Ti spiego esattamente come costruire un modello alpha multifattoriale di livello hedge fund usando l'ingegneria dei grafi.
Iniziamo subito.
Segna questo
- Sono Roan, uno sviluppatore backend che lavora su progettazione di sistemi, esecuzione in stile HFT e sistemi di trading quantitativo. Il mio lavoro si concentra su come si comportano realmente i mercati di previsione sotto carico. Per qualsiasi suggerimento, collaborazioni ponderate, partnership, i DM sono aperti.
Nel mio ultimo articolo ho detto che avrei guidato personalmente le prime 20 configurazioni di chiunque stesse costruendo un sistema quantistico AI, e facevo sul serio.
Alcuni sviluppatori sono già in fase avanzata con me. L'offerta è ancora valida.
Se stai costruendo un sistema di ingegneria dei grafi o stai per iniziare, o stai solo pensando di farlo, rispondi a questo articolo o mandami un DM con la tua configurazione attuale. Analizzerò personalmente la tua architettura e ti mostrerò il divario tra ciò che hai e uno sciame che caccia alpha in autonomia.
Se non rispondo, non eri tra i primi 20. Muoviti in fretta.
L'investimento multifattoriale è il modo in cui ogni hedge fund serio a Wall Street genera rendimenti. Non fanno trading su singole idee. Accumulano fattori.
Questo è lo stesso processo che usa AQR. Lo stesso processo che usa Two Sigma. Lo stesso processo che usa Bridgewater. Ed è la prima volta che è eseguibile da un singolo sviluppatore.
Il problema è sempre stato che costruire questo richiedeva un team di ricerca. Ingegneri dei fattori. Statistici. Specialisti nella costruzione di portafogli. Analisti del rischio. Ingegneri dell'esecuzione. Servono almeno dieci persone per famiglia di fattori, e nessun quant singolo può costruire quel team.
Ecco perché i quant al dettaglio si limitano a strategie singole e gli hedge fund stampano alpha.
Fino ad ora.
https://x.com/RohOnChain/status/2074134246784921977
Nei miei ultimi due articoli ho parlato di ingegneria dei loop e di come costruire uno sciame di agenti AI che caccia alpha 24/7.
Una volta che hai loop e sciami, il livello che li tiene insieme come un unico sistema funzionante è un grafo.
L'ingegneria dei grafi è la pratica di progettare quel livello. Definisci i nodi. Definisci gli archi. Il grafo funziona da solo.
Alla fine di questo articolo non solo capirai l'ingegneria dei grafi.
Avrai un modello alpha multifattoriale auto-eseguibile che si attiva ogni 24 ore sul tuo laptop.
Parte 1: Cosa è Realmente l'Ingegneria dei Grafi
Ogni quant che lavora con l'AI si trova da qualche parte sullo stesso percorso. Identificare dove ti trovi rende ovvio dove andare dopo.
Cosa è Realmente l'Ingegneria dei Grafi
Fase 1: Prompt.
Scrivi un prompt. Aspetti. Leggi l'output. Scrivi il successivo. Tu sei il loop. Niente sopravvive quando chiudi il laptop.
Fase 2: Loop.
Scrivi uno script che avvolge il prompt e si attiva secondo una pianificazione. Il loop mantiene lo stato. Sopravvive dopo che hai chiuso il laptop. Questo è ciò che insegnava il mio articolo sull'ingegneria dei loop. Un agente, un lavoro, in esecuzione per sempre.
Fase 3: Sciami.
Espandi il loop in molti agenti con ruoli specializzati. Uno genera segnali. Uno li convalida. Uno esegue. Questo è ciò che insegnava l'articolo sullo sciame di agenti AI. Agenti multipli in parallelo, coordinati manualmente tramite codice di collante Python.
Fase 4: Grafi.
Descrivi la struttura di coordinamento una volta. I nodi sono agenti. Gli archi sono passaggi di dati. Il grafo sa quando parallelizzare, quando aspettare, quando riprovare, quando escalation. Non tocchi più il codice di collante.
L'ingegneria dei grafi è la pratica di progettare quella struttura di coordinamento.
Un grafo non è uno script. Questa distinzione è più importante di quanto ti venga detto.
Uno script si rompe nel momento in cui un agente deve aspettarne un altro. Uno script si rompe nel momento in cui lo stato deve persistere attraverso i cicli. Uno script si rompe nel momento in cui vuoi sei loop in parallelo su modelli diversi. Ogni quant al dettaglio che ha provato a costruire un sistema multi-agente si è scontrato con questi tre muri.
Il muro del fallimento ha rotto me. Quando il mio agente di redditività si bloccava perché doveva analizzare 500 bilanci e raggiungeva i limiti di richiesta, l'intera pipeline moriva.
Tornavo la mattina dopo a un processo fermo, nessun segnale e nessuna idea di dove fosse nato il fallimento. Fare debug significava leggere una traccia dello stack e indovinare quale agente era a monte del crash.
Al secondo mese passavo più tempo a fare debug del coordinamento che a fare ricerca. Ero sul punto di accantonare l'intero progetto.
Questo è lo stato di fallimento che ogni quant multi-agente incontra. Ed è anche la ragione per cui esistono i grafi.
Un grafo non ha quelle modalità di fallimento. Il parallelo è nativo. Lo stato è persistente. Il fallimento è limitato al nodo, non alla pipeline. Quando un nodo si rompe, il resto del grafo continua a funzionare e tu aggiusti il nodo rotto descrivendo il fallimento in inglese semplice.
Questa è la promessa dell'ingegneria dei grafi. Ora la domanda è cosa fa funzionare il grafo.
Parte 2: Lo Strumento Che Fa Funzionare Il Grafo
I grafi sono diagrammi architetturali. Non funzionano da soli. Hanno bisogno di un runtime.
Il runtime è ciò che la maggior parte delle persone che costruisce sistemi multi-agente sbaglia.
Presumono che la parte difficile sia progettare il grafo. Non lo è. La parte difficile è trovare un'infrastruttura che possa effettivamente eseguirlo.
Ho passato settimane a provare diversi runtime prima di trovarne uno che potesse eseguire un grafo multifattoriale dall'inizio alla fine.
Quello che uso si chiama Slate. Costruito da @wearerandomlabs. Funziona nel tuo terminale. Raccoglie i tuoi abbonamenti ai modelli esistenti e distribuisce il lavoro tra di loro.
Ciò che conta per questo articolo è una funzionalità che hanno rilasciato di recente chiamata Programmi. Un Programma è un grafo scritto in JavaScript che Slate esegue per te in modo continuativo.
Un prompt viene eseguito una volta e si ferma. Un Programma continua finché l'attività non è completata.
Non scrivi il Programma da solo. Dici a Slate ciò che vuoi in inglese semplice. Slate abbozza il grafo.
Slate ti presenta quindi un diagramma. Fai domande sul diagramma. Cambi nodi. Regoli i modelli. Solo quando sei soddisfatto dici a Slate di salvare ed eseguire.
Se si rompe, chatti con Slate del fallimento. Slate corregge il grafo.
Puoi trovare Slate su http://randomlabs.ai/rr. È disponibile oggi.
Il modo migliore per percepire l'ingegneria dei grafi prima di costruirne uno è eseguire i due Programmi di esempio forniti con Slate.
Si chiamano
/goal
e
/deepresearch
.
/goal - Grafi Che Eseguono Finché Non Sono Verificati Come Completati
Digita questo all'interno di Slate:
1/goal implementa una funzione t-statistica corretta Newey-West in Python e verifica che corrisponda all'implementazione di statsmodels su dieci serie di rendimenti casuali
Slate non invia un singolo prompt a un modello. Avvia un grafo.
**Un nodo scrive la funzione. Un altro scrive il test di verifica. Un terzo esegue entrambi. Un quarto valuta se gli output corrispondono.**
Se non corrispondono, il grafo torna indietro con la specifica discrepanza come feedback. Continua finché un modello di valutazione separato e piccolo conferma che l'obiettivo è stato raggiunto.
Questo è il modello maker-checker in un runtime. Il maker non valuta mai il proprio lavoro.
/deepresearch - Grafi Che Parallelizzano la Ricerca
Prova questo all'interno di Slate:
1/deepresearch cosa dice la più recente ricerca accademica sulla performance fuori campione del modello a cinque fattori Fama-French nei mercati emergenti dal 2015 al 2026
Il grafo che si avvia qui è diverso da /goal.
È una diramazione di ricerca parallela.
Slate invia più agenti di lavoro contemporaneamente. Ognuno possiede una diversa angolazione della domanda.
Uno legge articoli recenti. Un altro controlla arXiv q-fin. Un altro estrae dati dalla libreria Kenneth French. Un altro incrocia le citazioni.
Tutti riferiscono a un orchestratore centrale che sintetizza i risultati.
La ragione per cui /deepresearch è importante per questa costruzione è che dimostra lo schema esatto di cui hai bisogno per la costruzione dei fattori.
Sette agenti dei fattori. Ognuno possiede un fattore diverso. Tutti in esecuzione in parallelo. Tutti che riferiscono a un orchestratore centrale.
Questo è il grafo multifattoriale, meno i compiti specifici del quant.
Dedica 30 minuti a eseguire /goal e /deepresearch su domande che ti interessano davvero. È così che si sviluppa l'intuizione sull'ingegneria dei grafi.
Parte 3: Il Grafo Alpha Multifattoriale
L'investimento multifattoriale scompone i rendimenti azionari in driver sistematici più un residuo. La versione fondamentale è il modello a tre fattori Fama-French, pubblicato nel 1993:
R_i è il rendimento del titolo i. R_f è il tasso privo di rischio. R_m è il rendimento di mercato. SMB è il premio per la dimensione. HML è il premio per il valore.
L'alpha α è ciò che il modello non può spiegare. Quel residuo è ciò che stai cercando.
Carhart ha aggiunto il momentum nel 1997. Fama e French hanno aggiunto la redditività (RMW) e l'investimento (CMA) nel 2015.
Gli hedge fund moderni utilizzano uno stack a sette fattori. AQR, Two Sigma, Millennium, Bridgewater utilizzano tutti varianti. Ecco i sette fattori che contano nel 2026.
Fattore 1: Beta di Mercato.
Regressione mobile a 60 mesi del rendimento in eccesso del titolo rispetto al rendimento in eccesso del mercato.
Fattore 2: Dimensione (SMB).
Le small cap superano le large cap su base corretta per il rischio.
Fattore 3: Valore (HML).
Un alto book-to-market supera un basso book-to-market su orizzonti temporali lunghi.
Fattore 4: Momentum (MOM).
I vincitori degli ultimi 12 mesi continuano a vincere per 3-12 mesi.
Fattore 5: Redditività (RMW).
Gli operatori robusti superano gli operatori deboli.
Fattore 6: Investimento (CMA).
La crescita conservativa degli asset supera l'espansione aggressiva.
Fattore 7: Bassa Volatilità.
I titoli a bassa volatilità ottengono rendimenti corretti per il rischio più alti di quanto previsto dalla teoria.
Ogni fondo esegue una versione di questo. I costruttori solitari non possono perché serve un team di ricerca.
L'ingegneria dei grafi risolve questo problema. Ogni fattore diventa un nodo.
Ecco il grafo completo. Undici nodi in totale.
Nodi di Costruzione dei Fattori (eseguiti in parallelo)
Nodo 1: Agente Beta di Mercato.
Esegue la regressione mobile a 60 mesi. Produce un beta per ogni titolo.
Nodo 2: Agente Dimensione.
Ordina per capitalizzazione di mercato. Calcola lo spread small-big.
Nodo 3: Agente Valore.
Ordina per book-to-market. Calcola lo spread high-low.
Nodo 4: Agente Momentum.
Calcola il momentum a 12 meno 1 mese. Costruisce MOM dallo spread dei decili.
Nodo 5: Agente Redditività.
Calcola la redditività lorda. Costruisce RMW.
Nodo 6: Agente Investimento.
Calcola la crescita annuale degli asset. Costruisce CMA.
Nodo 7: Agente Bassa Volatilità.
Calcola la volatilità realizzata mobile a 60 giorni. Costruisce il fattore bassa volatilità dallo spread dei decili.
Nodi di Coordinamento (eseguiti in sequenza)
Nodo 8: Il Validatore.
Esegue statistiche t corrette Newey-West su ogni fattore. Ricampiona bootstrap con 10.000 iterazioni. Elimina qualsiasi fattore con un degrado nel Sharpe in-sample rispetto a out-of-sample superiore al 30 percento.
Funziona su un modello di ragionamento più forte. Il maker non convalida mai il proprio lavoro.
Nodo 9: Il Revisore del Regime.
Segmenta la storia ventennale in tre regimi utilizzando un Modello di Markov Nascosto su volatilità e rendimenti. Elimina qualsiasi cosa funzioni in un solo regime.
Nodo 10: Il Costruttore di Portafoglio.
Combina i fattori sopravvissuti in un portafoglio long-short utilizzando pesi di risk parity. Impone la neutralità settoriale, di beta e valutaria.
Nodo 11: Il Decompositore di Rischio.
Regredisce il portafoglio rispetto ai sette fattori più fattori di stile e macro. Riporta l'alpha residuo e la statistica t.
Solo i segnali in cui l'alpha residuo sopravvive alla scomposizione fattoriale sono genuino nuovo alpha. Tutto il resto è stile ri-confezionato con passaggi extra.
Undici nodi. Ognuno possiede un lavoro. Passano i loro output lungo il grafo.
L'intero modello funziona su un singolo Programma Slate che si attiva ogni 24 ore.
Parte 4: Come Costruirlo Passo Dopo Passo
Ecco la costruzione esatta. Segui nel tuo terminale.
Passo 1: Installa Slate
Apri il tuo terminale ed esegui:
1npm i -g @randomlabs/slate
Slate è un pacchetto npm globale. L'installazione richiede circa 30 secondi.
Verifica con:
1slate --version
Passo 2: Crea la Tua Directory di Progetto
La ricerca multifattoriale ha bisogno del proprio spazio di lavoro. I file di stato, i test storici dei fattori, gli snapshot del portafoglio vivono tutti qui.
1mkdir ~/projects/multifactor-alpha2cd ~/projects/multifactor-alpha
Non eseguire altri progetti Slate dalla stessa cartella. Il namespace dello stato è per area di lavoro.
Passo 3: Avvia Slate
Digita:
1slate
Passo 4: Connetti I Tuoi Provider
All'interno di Slate, digita:
1/providers
Questo apre la schermata di configurazione del provider. Random Labs autentica per impostazione predefinita. Puoi anche connettere direttamente OpenAI Codex e GitHub Copilot.
Naviga su Codex con i tasti freccia e premi invio per autenticarti. Il tuo abbonamento esistente funziona.
Passo 5: Connetti I Tuoi Modelli
All'interno di Slate, digita:
1/models
Vedi ogni modello disponibile tra tutti i provider connessi. Random Labs ospita circa 90 modelli.
Ti servono due livelli di modello.
Un livello veloce per i sette agenti di costruzione dei fattori. Claude Sonnet funziona.
Un livello di ragionamento più forte per il validatore, il revisore del regime e il decompositore di rischio. Claude Opus funziona.
Passo 6: Riscaldati Con /goal E /deepresearch
Prima di abbozzare il tuo Programma, dedica 30 minuti ai due Programmi di esempio forniti.
È così che l'ingegneria dei grafi smette di essere un concetto e inizia a essere intuizione.
Prova questo comando /goal all'interno di Slate:
1/goal scrivi una funzione Python che calcoli i coefficienti di regressione cross-sezionale Fama-MacBeth e verifica che corrisponda al pacchetto empiricalfin su 20 anni di dati di rendimenti mensili
Guarda come il grafo si dirama. Guarda il modello di valutazione controllare il lavoro del modello scrittore. Guarda cosa succede quando il primo tentativo fallisce.
Poi prova questo comando /deepresearch:
1/deepresearch cosa dice la letteratura accademica sul fattore di redditività RMW rispetto al fattore qualità come definito da MSCI e in cosa differiscono empiricamente dal 2015 al 2026
Guarda la diramazione parallela dei lavoratori. Guarda l'orchestratore che sintetizza.
Queste due esecuzioni ti danno il modello mentale di cui hai bisogno prima di scrivere il tuo Programma.
Passo 7: Abbozza Il Programma Multifattoriale
Questo è il passo più importante. Descrivi il grafo in inglese semplice e Slate lo abbozza con te.
Digita questo prompt esatto in Slate:
1abbozzami un programma che esegue sette agenti di ricerca multifattoriale in parallelo: beta di mercato, dimensione, valore, momentum, redditività, investimento e bassa volatilità. Dopo che tutti e sette sono completati, esegui in sequenza un validatore, un revisore del regime, un costruttore di portafoglio e un decompositore di rischio. Usa Claude Sonnet per i sette agenti dei fattori e Claude Opus per validatore, revisore del regime e decompositore di rischio. Esegui l'intera pipeline ogni 24 ore. Usa il file system come memoria. Imposta un budget di $30 per esecuzione. Applica una t-statistica Newey-West superiore a 2.5, bootstrap con 10.000 iterazioni e rifiuta qualsiasi fattore con un degrado dello Sharpe in-sample rispetto a out-of-sample superiore al 30 percento.
Slate non si limita a iniziare a scrivere codice. Legge attentamente e fa domande chiarificatrici.
Quale fonte dati. Quale finestra di backtest. Quale universo. Quale classificatore di regime. Se utilizzare valori predefiniti sovrascrivibili.
Rispondi in inglese semplice. Slate scrive il JavaScript.
Passo 8: Rivedi Il Diagramma Del Grafo
Una volta che Slate ha abbozzato il Programma, restituisce un diagramma del grafo.
Non stai leggendo il codice per capire cosa verrà eseguito. Stai guardando la struttura di coordinamento.
Sette nodi dei fattori in esecuzione in parallelo dall'orchestratore. Un punto di sincronizzazione. Quattro nodi di coordinamento in sequenza. Un passo di persistenza. Un nodo di sospensione. Un ciclo di ritorno all'inizio.
Fai domande a Slate sul diagramma prima di eseguire qualsiasi cosa:
- Perché il validatore funziona su Opus?
- Cosa succede se l'agente momentum va in timeout?
- Quale stato viene persistito tra i cicli?
- Cosa attiva il revisore del regime per rifiutare un fattore?
Se una qualsiasi risposta ti sorprende, chiedi a Slate di modificare il grafo.
Passo 9: Salva Ed Esegui
Una volta che il diagramma corrisponde a ciò che desideri, dì a Slate di impegnare il Programma in un file. Poi esegui:
1slate run multifactor-alpha.js
Nel momento in cui premi invio, Slate avvia il grafo. I sette agenti dei fattori si attivano in parallelo.
L'ingegneria delle caratteristiche viene eseguita in parallelo. La convalida viene eseguita sul modello più forte.
La prima esecuzione richiede dai 15 ai 25 minuti. Le successive esecuzioni giornaliere sono più veloci perché il file di stato contiene già la cronologia.
Passo 10: Imposta Un Budget
All'interno di Slate, digita:
1/budget $30/esecuzione
Questo limita la spesa totale per esecuzione. Se un'esecuzione si avvicina al limite, Slate fa escalation prima di continuare.
Passo 11: Fai Debug Quando Si Rompe
I veri Programmi si rompono. Il mio si è rotto tre volte nelle prime due settimane.
L'agente di valore si è bloccato perché non riusciva a interpretare i bilanci non statunitensi. L'ho detto a Slate. Slate ha corretto l'agente di valore per includere un passo di normalizzazione valutaria.
L'agente momentum occasionalmente restituiva zero segnali sopravvissuti in regimi ostili al momentum. L'ho detto a Slate. Slate ha aggiunto un fallback che allarga la finestra di lookback del momentum durante quei regimi.
Il costruttore di portafoglio a volte violava la neutralità settoriale. L'ho detto a Slate. Slate ha aggiunto un passo di proiezione per imporre la neutralità prima di scrivere il portafoglio.
Non insegui una traccia dello stack. Descrivi il problema a Slate. Slate corregge il nodo.
Parte 5: Cosa è Successo Davvero Quando L'Ho Eseguito
Ecco la parte che non mi aspettavo.
Ho descritto il grafo a Slate in un paragrafo. Slate ha prima controllato gli identificatori dei modelli disponibili, ha attivato la competenza dei modelli e ha scelto claude-sonnet-4.6 per gli agenti veloci e claude-opus-4.5 per le fasi di coordinamento.
Poi Slate ha abbozzato l'intero Programma in un colpo solo. Non una bozza approssimativa. Il JavaScript completo. Undici nodi collegati insieme. Costruzione dei fattori parallela. Convalida sequenziale. Memoria condivisa del filesystem con directory di esecuzione con timestamp. Allocazioni di budget. Il tutto.
Slate non si è limitato a scrivere codice e sparire. È tornato con tre decisioni specifiche che voleva che confermassi prima di eseguire.
Decisione 1: Modello del costruttore di portafoglio. Il mio prompt iniziale specificava Opus per validatore, revisore del regime e decompositore di rischio, ma non ho nominato un modello per il costruttore di portafoglio. Slate lo ha impostato su Opus per impostazione predefinita perché la fase è un lavoro analitico pesante, ma lo ha segnalato come un'opzione se volevo Sonnet.
Decisione 2: Versioni dei modelli. Slate ha utilizzato le versioni stabili correnti di Sonnet e Opus (4.6 e 4.5) e si è offerto di passare a versioni più recenti se preferivo.
Decisione 3: Applicazione del budget. Questa mi ha sorpreso. Slate mi ha detto esplicitamente che il limite di $30 per esecuzione era consultivo, non un interruttore di interruzione definitivo. Non esiste un primitivo di misurazione dei costi in tempo reale, quindi il budget viene applicato come un limite dichiarato più la spesa auto-riportata che viene sommata e segnalata. Se volevo un'interruzione forzata a metà esecuzione, Slate si è offerto di progettarlo esplicitamente.
Quella terza specifica è il motivo per cui mi fido di questo strumento. La maggior parte dei framework per agenti fingerebbe silenziosamente che il budget fosse applicato. Slate mi ha detto esattamente quale livello di applicazione poteva effettivamente fornire.
Ho confermato tutte e tre le impostazioni predefinite, ho rinominato il Programma in multifactor-research-pipeline e ho detto a Slate di impegnarlo.
Poi ho premuto esegui.
I sette agenti dei fattori si sono attivati immediatamente. Ognuno è apparso nel terminale con il proprio ID sotto-agente e timer di stato.
Slate ha confermato l'esecuzione in inglese semplice:
"È in esecuzione in background come multifactor-pipeline, iniziando con i sette agenti dei fattori in parallelo su Sonnet, poi la sequenza validatore → regime → portafoglio → rischio su Opus, con le impostazioni predefinite (./research-memory, budget $30, i tre cancelli, ciclo perpetuo di 24 ore)."
Quella singola riga cattura il motivo per cui i grafi battono gli script.
Non ho scritto codice di coordinamento. Non ho inseguito una traccia dello stack. Non ho incollato API insieme. Ho descritto il grafo in inglese semplice, ho risposto a tre domande di progettazione e Slate lo ha costruito.
Tutto è sovrascrivibile all'avvio. Intervallo, budget, soglie dei cancelli, modelli, posizione della memoria e un limite maxRuns se non vuoi che il grafo funzioni per sempre.
Ecco il Programma completo che Slate ha scritto per me. Studialo, ma non copiarlo alla lettera. Il tuo sarà leggermente diverso a seconda delle risposte che hai dato alle domande chiarificatrici di Slate.
Parte 6: Cosa Succede Ogni 24 Ore
Alle 3 del mattino, il grafo si risveglia.
I sette agenti dei fattori si attivano in parallelo. Ognuno estrae le ultime 24 ore di dati di prezzo e fondamentali. Aggiorna la propria serie temporale del fattore. Passa al validatore.
Il validatore esegue test t di Newey-West. Effettua bootstrap su 10.000 campioni. Elimina qualsiasi cosa abbia fallito fuori campione.
Questo solo passo rifiuta circa l'80 percento di ciò che sembra promettente in un primo backtest.
Il revisore del regime prende ciò che è sopravvissuto. Segmenta la storia usando l'HMM. Ricalcola lo Sharpe per regime.
Un fattore che funziona in un solo regime non è alpha. È beta di quel regime, travestito da alpha.
Il costruttore di portafoglio prende i fattori sopravvissuti. Costruisce il portafoglio long-short con i vincoli di neutralità applicati.
Il decompositore di rischio prende il portafoglio. Lo regredisce rispetto all'insieme degli ampi fattori di stile e macro.
Se la statistica t dell'alpha residuo è superiore a 2.5, il segnale sopravvive. In caso contrario, la giornata viene registrata come nessun segnale e il grafo dorme fino al giorno successivo.
Ogni mattina ti svegli con un messaggio Slack. O hai un segnale che puoi scambiare. O hai la prova documentata che oggi era rumore.
Entrambi i risultati sono utili. Nessuno dei due richiedeva che tu fossi alla tastiera.
Questo è l'aspetto di un modello alpha multifattoriale auto-eseguibile nel 2026.
Il Progetto
Se non ricordi altro, ricorda queste sette mosse in ordine.
1. Comprendi la progressione. I prompt sono diventati loop. I loop sono diventati sciami. Gli sciami sono diventati grafi.
2. Conosci i tuoi fattori. Mercato, dimensione, valore, momentum, redditività, investimento, bassa volatilità. Sette fattori. Ognuno diventa un nodo.
3. Progetta undici nodi. Sette agenti fattoriali in parallelo. Quattro agenti di coordinamento in sequenza. Disegna il grafo prima di scrivere una riga di codice.
4. Usa modelli diversi per nodi diversi. Sonnet per la costruzione dei fattori. Opus per la validazione e la scomposizione. Maker non convalida mai Maker.
5. Applica regole rigide. Statistica t di Newey West superiore a 2,5. Bootstrap con 10.000 iterazioni. Robustezza del regime attraverso tre stati HMM. Statistica t dell'alpha residuo superiore a 2,5.
6. Riscaldati con /goal e /deepresearch. L'intuizione sull'ingegneria dei grafi viene dall'osservarli, non dal leggere articoli su di essi.
7. Lascia che si accumuli. Il primo mese serve a trovare bug. Il secondo mese a perfezionare i fattori. Entro il terzo mese, il tuo grafo produrrà segnali che puoi effettivamente tradare.
Ora costruiscilo
Installa Slate stasera. Avvialo. Esegui /goal su una domanda quant reale. Esegui /deepresearch su un fattore che ti incuriosisce.
Poi abbozza il tuo Programma usando esattamente il prompt del Passo 6. Esamina il diagramma. Eseguilo. Imposta un budget di $30.
Entro la prossima settimana a quest'ora avrai il tuo primo grafo multifattoriale auto-eseguibile.
Entro il prossimo mese a quest'ora avrai il tuo primo segnale tradabile che sopravvive a tutti gli undici nodi.
Questo è lo scambio. Un weekend di configurazione per un sistema di ricerca che si accumula e non dorme mai.
Ora costruiscilo.
Se ti blocchi in qualsiasi punto della costruzione, contattami qui.
Puoi trovare Slate su http://randomlabs.ai/rr.
Segui @wearerandomlabs se vuoi vedere ogni funzionalità che rilasciano. /goal e /deepresearch sono i primi due Programmi. Non saranno gli ultimi.
