Come costruire uno sciame di agenti AI che dà la caccia all'alpha 24/7

Ti spiegherò come costruire lo sciame di agenti AI che sostituisce un intero team di ricerca quantitativa.

Andiamo dritti al punto.

Segna questo

- Sono Roan, uno sviluppatore backend che lavora su system design, esecuzione in stile HFT e sistemi di trading quantitativo. Il mio lavoro si concentra su come i mercati di previsione si comportano effettivamente sotto carico. Per suggerimenti, collaborazioni ponderate o partnership, i DM sono aperti.

Nel mio ultimo articolo ho detto che avrei seguito personalmente i primi 20 setup di chiunque stesse costruendo un sistema quantistico AI. Facevo sul serio.

Quattro sviluppatori sono già in fase avanzata del processo con me. Uno di loro sta eseguendo il ciclo completo del fondo hedge auto-migliorante mentre parliamo.

L'offerta è ancora valida.

Se stai costruendo un sistema di ricerca alpha, stai per iniziare, o ci stai solo pensando, rispondi a questo articolo o mandami un DM con il tuo setup attuale. Analizzerò personalmente la tua architettura e ti mostrerò il divario tra ciò che hai e uno sciame che caccia alpha da solo.

Se non rispondo, non eri tra i primi 20. Muoviti velocemente.

La maggior parte dei quant caccia ancora l'alpha come faceva un decennio fa.

Leggono un paper. Aprono un Jupyter notebook. Ingegnerizzano qualche feature. Eseguono un backtest. Strizzano l'occhio allo Sharpe ratio. Passano all'idea successiva.

Loro sono la pipeline.

Ogni fase della ricerca sono loro, seduti davanti a uno schermo, che testano un'ipotesi alla volta.

I costruttori quant più intelligenti del pianeta hanno smesso di farlo.

Costruiscono sciami. Ogni agente nello sciame possiede una fase della ricerca. Gli agenti lavorano in parallelo. Lo sciame funziona ininterrottamente. Nuovo alpha appare ogni mattina mentre loro dormono.

Boris Cherny, il capo di Claude Code in Anthropic, l'ha detto due settimane fa. "Non prompto più Claude. Ho loop in esecuzione che promptano Claude e capiscono cosa fare. Il mio lavoro è scrivere loop."

Quella singola frase ha ridefinito il modo in cui ogni costruttore serio sulla terra pensa all'AI.

Per la ricerca quantitativa cambia tutto.

Perché la ricerca alpha è già una pipeline. Leggi il paper. Estrai l'ipotesi. Ingegnerizza le feature. Fai il backtest su 20 anni di dati. Controlla la significatività. Controlla se il segnale sopravvive attraverso i regimi. Decomponi rispetto a ogni fattore noto.

Ogni fondo serio a Wall Street esegue quella stessa pipeline. Renaissance la esegue con 100 dottorandi. Two Sigma la esegue con 200. Citadel la esegue con ancora di più.

L'unica differenza è che loro hanno bisogno di centinaia di umani seduti all'interno della pipeline. Tu no.

Uno sciame di agenti AI può eseguire ogni fase di quella pipeline per te. Ogni agente specializzato. Ogni agente eseguito sul modello che si adatta alla sua complessità. Tutti in esecuzione 24/7 in parallelo.

Ho costruito questo sciame negli ultimi giorni.

Legge nuovi paper di ricerca durante la notte. Studia la matematica al loro interno. Estrae l'ipotesi esatta che viene rivendicata. Ingegnerizza le feature richieste. Fa il backtest del segnale contro 20 anni di storia. Esegue il rigore statistico. Controlla l'overfitting. Segnala qualsiasi cosa funzioni solo in un regime di mercato.

Alla fine di questo articolo conoscerai l'architettura esatta di uno sciame di ricerca alpha a sei agenti.

Conoscerai lo strumento che ti permette di costruirlo in un weekend senza scrivere da zero il tuo framework per agenti.

E conoscerai le cinque modalità di fallimento che uccidono il 90 percento dei tentativi retail.

Iniziamo.

Parte 1: Cos'è Realmente uno Sciame

Un prompt è una domanda. Chiedi, il modello risponde una volta e si ferma.

Un loop è un lavoro. L'agente continua a lavorare, controlla i propri progressi e continua finché il compito non è effettivamente completato.

Uno sciame è molti loop che girano in parallelo. Ogni loop è uno specialista. Ogni specialista possiede una fase della pipeline. L'output di uno alimenta l'input del successivo.

Questo è l'intero modello mentale.

Se hai usato Claude Code, Cursor o Codex, hai usato un loop senza saperlo. L'agente chiama un modello, il modello sceglie un'azione, l'azione viene eseguita, il risultato torna al modello e si ripete finché l'obiettivo non viene raggiunto.

Il loop è ciò che rende un agente un agente invece di una singola risposta.

Uno sciame è ciò che rende un team di ricerca un team di ricerca invece di un singolo ricercatore che digita.

Parte 2: Lo Strumento Che Fa Funzionare Lo Sciame

Potresti provare a costruirlo da solo con script Python che chiamano diverse API.

Ci ho provato. Si rompe nel momento in cui un agente deve aspettarne un altro. Si rompe nel momento in cui hai bisogno che lo stato persista tra i cicli. Si rompe nel momento in cui vuoi eseguire sei loop in parallelo su modelli diversi.

Finisci per costruire il tuo framework per agenti da zero invece di fare ricerca.

Poi ho trovato Slate.

Slate è un harness di codifica AI costruito da @wearerandomlabs. Gira nel tuo terminale. Distribuisce qualsiasi compito in uno sciame di sottoagenti attraverso il tuo codebase. Sceglie qualsiasi modello tu voglia in qualsiasi passaggio. La tua sottoscrizione esistente funziona.

Il motivo per cui lo uso per questo sciame è una funzionalità che hanno appena lanciato chiamata Programs.

Un Program è un loop scritto in JavaScript che Slate esegue per te.

Un prompt viene eseguito una volta e si ferma. Un Program è un loop ingegnerizzato. Gira ininterrottamente. Mantiene lo stato tra le esecuzioni. Continua finché il compito non è completato.

Decidi tu cosa succede in ogni passaggio. Quale modello gestisce quale passaggio. Cosa controlla il loop prima di continuare. Quando si ferma.

Non scrivi il Program da solo. Dici a Slate cosa vuoi e lui abbozza il loop con te, passo dopo passo. Salva il loop. Lo esegue. Continua a eseguirlo.

Poiché il loop è codice, può mantenere lo stato, interagire con il tuo codebase, chiamare API esterne, pubblicare su Slack e orchestrare più sottoagenti in parallelo su qualsiasi combinazione di modelli tu scelga. Modello open-weight economico per il lavoro facile. Modello frontier per il ragionamento complesso. Qualunque cosa si adatti al passaggio.

Per uno sciame di ricerca a sei agenti, questo è esattamente il livello che prima mancava.

Puoi trovare Slate su https://randomlabs.aihttps://randomlabs.ai/). È disponibile oggi.

Ora lascia che ti mostri lo sciame.

Parte 3: I Sei Agenti

Ogni fondo quant serio esegue le stesse sei fasi di ricerca.

Ecco lo sciame che le sostituisce.

Agente 1: Il Generatore di Idee.

Legge nuovi paper di ricerca da arXiv q-fin, SSRN e riviste finanziarie ogni notte.

Studia il modello matematico che ogni paper propone. Estrae l'ipotesi esatta che viene rivendicata, i dati richiesti e la direzione del segnale previsto.

Scrive ogni ipotesi come un ticket di ricerca strutturato che il prossimo agente può raccogliere.

Gira su un modello veloce ed economico perché il compito è un'estrazione strutturata ad alto volume.

Agente 2: L'Ingegnere delle Feature.

Prende un ticket di ipotesi. Recupera i dati richiesti dal database dei prezzi o dal database fondamentale.

Costruisce il vettore delle feature. Standardizza attraverso la sezione trasversale. Gestisce osservazioni mancanti, outlier oltre tre deviazioni standard e bias di look-ahead.

Output: un dataframe pulito pronto per il backtesting.

Agente 3: Il Backtester.

Prende il vettore delle feature. Costruisce le regole di costruzione del portafoglio. Esegue il backtest storico su 20 anni di dati con costi di transazione realistici, costi di borrowing sul lato corto e slippage.

Output: Sharpe ratio, massimo drawdown, turnover e stime di capacità.

Agente 4: Il Validatore.

Qui è dove vive il rigore.

Prende il risultato del backtest. Esegue statistiche t aggiustate con Newey-West per correggere l'autocorrelazione nella serie dei rendimenti. Esegue il ricampionamento bootstrap con 10.000 iterazioni per verificare se lo Sharpe è reale o un artefatto del campione.

Segnala qualsiasi segnale che non supera le soglie di significatività. Uccide qualsiasi cosa con un degrado in-sample vs out-of-sample superiore al 30 percento, perché quello è overfitting.

Gira su un modello di ragionamento più forte. Il creatore non convalida mai il proprio lavoro. Mai.

Agente 5: Il Revisore dei Regimi.

Prende i segnali che hanno superato la validazione. Segmenta la storia di 20 anni per regime (identificato tramite un Hidden Markov Model su volatilità e rendimenti).

Ricalcola Sharpe, drawdown e hit rate all'interno di ogni regime. Uccide qualsiasi cosa funzioni solo in un regime, perché quello è regime timing travestito da alpha.

Agente 6: Il Decompositore di Fattori.

Prende i segnali robusti ai regimi. Li regredisce contro il modello a cinque fattori di Fama-French più il momentum di Carhart più un fattore low-vol.

Riporta l'alpha residuo (l'intercetta della regressione) e la sua statistica t.

Solo i segnali in cui l'alpha residuo sopravvive alla decomposizione dei fattori sono genuino nuovo alpha. Tutto il resto è momentum reimpacchettato o value reimpacchettato con passaggi extra.

Sei agenti. Ognuno possiede una fase. Passano i loro output lungo la catena.

un Program Slate. sei agenti specializzati. gira ogni 24 ore.

L'intero sciame gira su un Program Slate che si attiva ogni 24 ore.

Parte 4: Come Costruirlo Passo Dopo Passo

Ecco la build esatta. Segui e avrai lo sciame in funzione entro la fine della giornata.

Passo 1: Installa Slate

Apri il tuo terminale ed esegui:

1npm install -g @randomlabs/slate

Slate si installa come CLI globale in meno di 30 secondi.

Poi crea la directory del progetto:

1mkdir alpha-swarm
2cd alpha-swarm
3slate init

slate init scaffolda il progetto con le cartelle necessarie per stato, Programs e provider.

Passo 2: Connetti i Tuoi Modelli

Esegui:

1slate /providers

Questo apre la schermata di configurazione del provider all'interno della CLI di Slate. Connetti i modelli che vuoi usare.

Per questo sciame uso Sonnet sugli agenti veloci (generazione di idee, ingegneria delle feature, backtesting, revisione dei regimi) e Opus sugli agenti con carico di ragionamento pesante (validazione e decomposizione dei fattori).

Passo 3: Abbozza il Program

Avvia Slate:

1slate

Poi nella CLI di Slate digita:

abbozza un programma che esegue sei agenti di ricerca in sequenza: generatore di idee, ingegnere delle feature, backtester, validatore, revisore dei regimi, decompositore di fattori. eseguilo ogni 24 ore. usa sonnet per gli agenti veloci e opus per la validazione e la decomposizione dei fattori.

Slate abbozza il Program con te. Fa domande di chiarimento. Quale fonte dati. Quale finestra di backtest. Quale soglia Sharpe. Quale classificatore di regime. Rispondi in linguaggio naturale. Slate scrive il JavaScript.

Ecco come appare il loop una volta scritto:

1export default async function alphaSwarm(slate) {
2  while (true) {
3    // Stage 1: read papers, extract hypotheses
4    const hypotheses = await slate.agent('idea-generator', {
5      model: 'sonnet',
6      task: 'Read arXiv q-fin and SSRN from the last 24 hours. Extract 10 alpha hypotheses with claimed direction, required data, and paper reference.',
7      state: slate.state.get('tested-hypotheses')
8    });
9
10    // Stage 2: feature engineering, in parallel per hypothesis
11    const features = await Promise.all(
12      hypotheses.map(h => slate.agent('feature-engineer', {
13        model: 'sonnet',
14        task: `Build the feature vector for: ${h.claim}. Standardize cross-section. Handle look-ahead.`,
15        data: slate.tools.priceData()
16      }))
17    );
18
19    // Stage 3: 20-year backtest with realistic costs
20    const backtests = await Promise.all(
21      features.map(f => slate.agent('backtester', {
22        model: 'sonnet',
23        task: 'Run 20-year backtest. Include transaction costs of 5bps per trade and shorting costs.',
24        features: f
25      }))
26    );
27
28    // Stage 4: statistical validation on the reasoning model
29    const validated = await Promise.all(
30      backtests.map(b => slate.agent('validator', {
31        model: 'opus',
32        task: 'Newey-West t-stat above 2.5. Bootstrap 10k. Reject if IS/OOS Sharpe degrades more than 30 percent.',
33        backtest: b
34      }))
35    );
36
37    // Stage 5: regime segmentation via HMM
38    const regimeChecked = await Promise.all(
39      validated
40        .filter(v => v.passed)
41        .map(v => slate.agent('regime-auditor', {
42          model: 'sonnet',
43          task: 'Fit 3-state HMM on volatility and returns. Recompute Sharpe per regime. Reject if only one regime works.',
44          result: v
45        }))
46    );
47
48    // Stage 6: factor decomposition to isolate residual alpha
49    const finalSignals = await Promise.all(
50      regimeChecked
51        .filter(r => r.passed)
52        .map(r => slate.agent('factor-decomposer', {
53          model: 'opus',
54          task: 'Regress against Fama-French 5 + Carhart momentum + low-vol. Report residual alpha and t-stat.',
55          result: r
56        }))
57    );
58
59    // Persist, notify, sleep
60    await slate.state.set('final-signals', finalSignals);
61    await slate.state.append('tested-hypotheses', hypotheses);
62    await slate.notify.slack('research', `${finalSignals.length} new signals survived all six stages today.`);
63    await slate.sleep('24h');
64  }
65}

Questo è l'intero sciame. Un file. Sei agenti. Gira per sempre.

Passo 4: Esegui Lo Sciame

Salva il file ed esegui:

1slate run alpha-swarm.js

Nel momento in cui premi invio, Slate avvia il loop. I sei agenti si attivano in sequenza.

L'ingegneria delle feature viene eseguita in parallelo su ogni ipotesi. I backtest vengono eseguiti in parallelo. La validazione viene eseguita sul modello più forte.

Puoi guardare ogni agente al lavoro dalla CLI di Slate in tempo reale. Ogni agente mostra il suo stato, il suo compito corrente e i suoi progressi.

[Screenshot 4: Terminale che mostra lo sciame in esecuzione con più agenti attivi in parallelo, indicatori di progresso visibili per ogni fase.]

Il primo ciclo richiede da 20 a 40 minuti a seconda di quante ipotesi produce la fase uno.

Alla fine, Slate pubblica i sopravvissuti sul tuo canale Slack con i loro Sharpe ratio, drawdown e alpha residuo. Poi dorme fino a domani.

Passo 5: Itera

La prima versione del loop non è mai quella finale.

Il generatore di idee produrrà duplicati. Digita in Slate:

aggiungi un controllo contro la cronologia dello stato in modo che proponga solo ipotesi che non abbiamo testato negli ultimi 30 giorni.

Il validatore respingerà segnali che pensi dovrebbero passare. Digita:

allenta la soglia Sharpe a 1.2 ma stringi la soglia massima di drawdown all'8 percento.

Slate aggiorna il Program per te. Il ciclo successivo usa la nuova logica. Ogni miglioramento si accumula nel file di stato e, col tempo, lo sciame diventa più affilato perché ricorda tutto ciò che ha già testato e tutto ciò che ha già respinto.

Parte 5: Come Questo Sostituisce Realmente un Team di Ricerca

Tre modelli coprono ogni implementazione reale.

Modello 1: Scoperta notturna.

Lo sciame gira dalle 20:00 alle 8:00. Ogni mattina ti svegli con due o tre segnali che hanno superato tutte e sei le fasi.

Il tuo lavoro diventa rivedere i sopravvissuti invece di eseguire tu stesso la pipeline.

Modello 2: Modalità burst di ipotesi.

Nuovo paper pubblicato. Nuova fonte dati disponibile. Attivi lo sciame su richiesta e fai testare 100 ipotesi quel pomeriggio.

Un ricercatore umano ne testa due nello stesso tempo.

Modello 3: Monitoraggio del decadimento dell'alpha.

Lo sciame riesegue i segnali validati ogni settimana su dati freschi. Nel momento in cui lo Sharpe di un segnale scende sotto la soglia, segnala il decadimento.

Riduci l'esposizione prima che il drawdown si accumuli.

Ogni modello sostituisce una funzione specifica che prima richiedeva un dottorato. Insieme sostituiscono la maggior parte di ciò che un team di ricerca fa effettivamente giorno per giorno.

Parte 6: Cinque Modalità di Fallimento Che Uccidono il 90 Percento dei Tentativi Retail

Fallimento 1: Saltare il validatore.

Otterrai 100 segnali con bellissimi Sharpe ratio e nessun rigore. Ognuno è data snooping travestito.

Il validatore non è negoziabile. Usa il tuo modello più forte. Imposta soglie di rifiuto dure. Non lasciare mai che il creatore convalidi il proprio lavoro.

Fallimento 2: Nessuna persistenza dello stato.

Uno sciame senza memoria testa la stessa ipotesi fallita ogni giorno.

Ogni segnale respinto deve essere registrato con il motivo esatto del rifiuto in modo che nessun agente sprechi mai token sullo stesso fallimento due volte.

Fallimento 3: Nessuna separazione creatore-verificatore.

L'agente che ha generato l'ipotesi è il peggior giudice possibile per stabilire se sia alpha reale.

Separa creatore e verificatore tra diversi agenti su diversi modelli. Renaissance lo fa. Two Sigma lo fa. Citadel lo fa. Anche il tuo sciame dovrebbe farlo.

Fallimento 4: Un agente che fa tutto.

Nel momento in cui provi a far generare, ingegnerizzare, testare e validare un singolo agente, la qualità crolla.

La specializzazione è ciò che fa funzionare lo sciame. Ogni agente fa una cosa perfettamente.

Fallimento 5: Nessuna condizione di arresto sul loop.

Un loop senza un vero arresto fallisce silenziosamente. L'agente emette un segnale di completamento credendo che il lavoro sia finito. I risultati scadenti rimangono non corretti.

Ogni condizione di arresto deve essere verificabile da qualcosa di diverso dalla semplice affermazione dell'agente. "Sharpe superiore a 1.5 negli ultimi 30 scambi out-of-sample." "Drawdown inferiore al 5 percento." Mai "l'agente dice che è finito."

Rispetta queste cinque e lo sciame produrrà output di ricerca di livello istituzionale.

Riepilogo

La ricerca alpha è già una pipeline. Sei fasi. Leggi paper. Ingegnerizza feature. Fai backtest. Valida. Controlla i regimi. Decomponi rispetto ai fattori.

Ogni fondo serio la esegue con 100 dottorandi.

Uno sciame di sei agenti AI specializzati esegue ogni fase per te. Ogni agente sceglie il modello che si adatta alla sua complessità. L'intero sciame gira su un Program Slate che si attiva ogni 24 ore.

I Programs di Slate sono il livello che rende questo effettivamente distribuibile in un weekend invece che in sei mesi.

Abbozza il loop con te. Salva il loop. Esegue il loop. Lo esegue per sempre.

Smetti di essere la pipeline. Diventi l'architetto.

Il fossato dell'infrastruttura è reale. Il fossato della ricerca è morto.

Questo è il punto.

Se vuoi provarlo, registrati su

https://randomlabs.ai e segui

@wearerandomlabs per il lancio.

Nel mio articolo precedente sull'ingegneria dei loop ho spiegato come la stessa architettura si collega a un sistema di trading auto-migliorante completo che esegue operazioni da solo. Se non l'hai ancora letto, leggilo subito dopo questo.

Questo sciame è la metà di ricerca di quel sistema.

https://x.com/RohOnChain/status/2069056530960490835

I fondi che costruiranno questo per primi si accumuleranno per il prossimo decennio.

Quelli che ancora testano un'ipotesi alla volta verranno lasciati indietro.

Quindi ecco la domanda su cui riflettere.

Sei il ricercatore che testa ancora un'ipotesi a settimana, o sei l'architetto che ha costruito lo sciame che ne testa cento ogni notte mentre dormi?

Non c'è una risposta sbagliata. Ma ce ne sono di molto rivelatrici.