Como construir um enxame de agentes de IA que busca Alpha 24/7

Vou detalhar como construir o enxame de agentes de IA que substitui uma equipe inteira de pesquisa quantitativa.

Vamos direto ao ponto.

Marque esta página

- Sou Roan, um desenvolvedor backend trabalhando com design de sistemas, execução estilo HFT e sistemas de trading quantitativo. Meu foco é entender como os mercados de previsão realmente se comportam sob carga. Para sugestões, colaborações ou parcerias, minha DM está aberta.

No meu último artigo, disse que iria pessoalmente revisar as primeiras 20 configurações de qualquer pessoa construindo um sistema de IA quantitativo. Eu estava falando sério.

Quatro desenvolvedores já estão no processo comigo. Um deles está executando o loop completo do fundo de hedge auto-melhorável enquanto falamos.

A oferta ainda está de pé.

Se você está construindo um sistema de pesquisa de alfa, prestes a começar, ou apenas pensando nisso, responda a este artigo ou me envie uma DM com sua configuração atual. Eu vou revisar pessoalmente sua arquitetura e mostrar a lacuna entre o que você tem e um enxame que caça alfa por conta própria.

Se eu não responder, você não estava entre os primeiros 20. Seja rápido.

A maioria dos quants ainda caça alfa da mesma forma que fazia uma década atrás.

Eles leem um artigo. Abrem um Jupyter notebook. Criam algumas features. Executam um backtest. Olham de soslaio para o índice Sharpe. Passam para a próxima ideia.

Eles são o pipeline.

Cada etapa da pesquisa é eles, sentados em frente a uma tela, testando uma hipótese de cada vez.

Os construtores de quant mais inteligentes do planeta pararam de fazer isso.

Eles constroem enxames. Cada agente no enxame é dono de uma etapa da pesquisa. Os agentes trabalham em paralelo. O enxame funciona continuamente. Novo alfa aparece todas as manhãs enquanto eles dormem.

Boris Cherny, chefe do Claude Code na Anthropic, disse isso há duas semanas. "Eu não dou mais prompts para o Claude. Tenho loops rodando que dão prompts para o Claude e descobrem o que fazer. Meu trabalho é escrever loops."

Essa única frase reformulou como todo construtor sério no planeta pensa sobre IA.

Para a pesquisa quantitativa, isso muda tudo.

Porque a pesquisa de alfa já é um pipeline. Leia o artigo. Extraia a hipótese. Crie as features. Faça o backtest em 20 anos de dados. Verifique a significância. Verifique se o sinal sobrevive em diferentes regimes. Decomponha contra todos os fatores conhecidos.

Todo fundo sério em Wall Street executa exatamente esse pipeline. A Renaissance o executa com 100 PhDs. A Two Sigma o executa com 200. A Citadel o executa com mais.

A única diferença é que eles precisam de centenas de humanos sentados dentro do pipeline. Você não precisa.

Um enxame de agentes de IA pode executar cada etapa desse pipeline para você. Cada agente especializado. Cada agente rodando no modelo que se adequa à sua complexidade. Todos rodando 24 horas por dia, 7 dias por semana, em paralelo.

Eu tenho construído este enxame nos últimos dias.

Ele lê novos artigos de pesquisa durante a noite. Estuda a matemática dentro deles. Extrai a hipótese exata que está sendo reivindicada. Cria as features necessárias. Testa o sinal contra 20 anos de história. Executa o rigor estatístico. Verifica overfitting. Sinaliza qualquer coisa que só funciona em um regime de mercado.

Ao final deste artigo, você conhecerá a arquitetura exata de um enxame de pesquisa de alfa com seis agentes.

Você conhecerá a ferramenta que permite construí-lo em um fim de semana sem precisar escrever seu próprio framework de agentes do zero.

E você conhecerá os cinco modos de falha que matam 90 por cento das tentativas de varejo.

Vamos nessa.

Parte 1: O Que Realmente é um Enxame

Um prompt é uma pergunta. Você pergunta, o modelo responde uma vez e para.

Um loop é um trabalho. O agente continua trabalhando, verifica seu próprio progresso e continua até que a tarefa esteja realmente concluída.

Um enxame são muitos loops rodando em paralelo. Cada loop é um especialista. Cada especialista é dono de uma etapa do pipeline. A saída de um alimenta a entrada do próximo.

Esse é o modelo mental completo.

Se você já usou Claude Code, Cursor ou Codex, você já usou um loop sem saber. O agente chama um modelo, o modelo escolhe uma ação, a ação é executada, o resultado volta para o modelo, e isso se repete até que o objetivo seja alcançado.

O loop é o que torna um agente um agente, em vez de uma única resposta.

Um enxame é o que torna uma equipe de pesquisa uma equipe de pesquisa, em vez de um pesquisador digitando.

Parte 2: A Ferramenta Que Executa o Enxame

Você poderia tentar construir isso sozinho com scripts Python que chamam diferentes APIs.

Eu tentei. Quebra no momento em que um agente precisa esperar por outro. Quebra no momento em que você precisa que o estado persista entre os ciclos. Quebra no momento em que você quer executar seis loops em paralelo em modelos diferentes.

Você acaba construindo seu próprio framework de agentes do zero em vez de fazer pesquisa.

Foi quando eu encontrei o Slate.

Slate é um harness de codificação de IA construído por @wearerandomlabs. Ele roda no seu terminal. Ele distribui qualquer tarefa em um enxame de subagentes em sua base de código. Ele escolhe qualquer modelo que você quiser em qualquer etapa. Sua assinatura existente funciona.

A razão pela qual eu o uso para este enxame é um recurso que eles acabaram de lançar chamado Programs.

Um Program é um loop escrito em JavaScript que o Slate executa para você.

Um prompt é executado uma vez e para. Um Program é um loop projetado. Ele roda continuamente. Ele mantém o estado entre as execuções. Ele continua até que a tarefa esteja concluída.

Você decide o que acontece em cada etapa. Qual modelo lida com qual etapa. O que o loop verifica antes de continuar. Quando ele para.

Você não escreve o Program sozinho. Você diz ao Slate o que quer e ele elabora o loop com você, passo a passo. Ele salva o loop. Ele o executa. Ele continua executando.

Como o loop é código, ele pode manter estado, interagir com sua base de código, acessar APIs externas, postar no Slack e orquestrar vários subagentes em paralelo em qualquer combinação de modelos que você escolher. Modelo de peso aberto barato para o trabalho fácil. Modelo de fronteira para o raciocínio difícil. O que se adequar à etapa.

Para um enxame de pesquisa de seis agentes, esta é exatamente a camada que costumava estar faltando.

Você pode encontrar o Slate em https://randomlabs.aihttps://randomlabs.ai/). Ele está disponível hoje.

Agora deixe-me mostrar o enxame.

Parte 3: Os Seis Agentes

Todo fundo quantitativo sério executa as mesmas seis etapas de pesquisa.

Aqui está o enxame que as substitui.

Agente 1: O Gerador de Ideias.

Lê novos artigos de pesquisa do arXiv q-fin, SSRN e periódicos financeiros todas as noites.

Estuda o modelo matemático que cada artigo está propondo. Extrai a hipótese exata que está sendo reivindicada, os dados necessários e a direção do sinal previsto.

Escreve cada hipótese como um ticket de pesquisa estruturado que o próximo agente pode pegar.

Roda em um modelo rápido e econômico porque a tarefa é extração estruturada de alto volume.

Agente 2: O Engenheiro de Features.

Pega um ticket de hipótese. Obtém os dados necessários do banco de dados de preços ou fundamentos.

Constrói o vetor de features. Padroniza em toda a seção transversal. Lida com observações ausentes, outliers além de três desvios padrão e viés de look-ahead.

Gera um dataframe limpo pronto para backtesting.

Agente 3: O Backtester.

Pega o vetor de features. Constrói regras de construção de portfólio. Executa o backtest histórico em 20 anos de dados com custos de transação realistas, custos de aluguel no lado vendido e slippage.

Gera estimativas de índice Sharpe, drawdown máximo, turnover e capacidade.

Agente 4: O Validador.

É aqui que o rigor reside.

Pega o resultado do backtest. Executa estatísticas t ajustadas por Newey-West para corrigir a autocorrelação na série de retornos. Executa reamostragem bootstrap com 10.000 iterações para verificar se o Sharpe é real ou um artefato da amostra.

Sinaliza qualquer sinal que falhe nos limites de significância. Elimina qualquer coisa com uma degradação in-sample vs out-of-sample maior que 30 por cento, porque isso é overfitting.

Roda em um modelo de raciocínio mais forte. O criador nunca valida o próprio trabalho. Nunca.

Agente 5: O Auditor de Regime.

Pega os sinais que passaram na validação. Segmenta o histórico de 20 anos por regime (identificado via um Modelo Oculto de Markov em volatilidade e retornos).

Recalcula Sharpe, drawdown e taxa de acerto dentro de cada regime. Elimina qualquer coisa que só funciona em um regime, porque isso é timing de regime disfarçado de alfa.

Agente 6: O Decompositor de Fatores.

Pega os sinais robustos a regimes. Faz a regressão deles contra o modelo de cinco fatores de Fama-French mais o momentum de Carhart mais um fator de baixa volatilidade.

Relata o alfa residual (o intercepto da regressão) e sua estatística t.

Apenas sinais onde o alfa residual sobrevive à decomposição de fatores são alfa novo genuíno. Todo o resto é momentum reembalado ou valor reembalado com etapas extras.

Seis agentes. Cada um é dono de uma etapa. Eles passam suas saídas para baixo na cadeia.

um Slate Program. seis agentes especializados. roda a cada 24 horas.

Todo o enxame roda em um Slate Program que é acionado a cada 24 horas.

Parte 4: Como Construí-lo Passo a Passo

Aqui está a construção exata. Siga e você terá o enxame rodando até o final do dia.

Passo 1: Instale o Slate

Abra seu terminal e execute:

1npm install -g @randomlabs/slate

O Slate é instalado como uma CLI global em menos de 30 segundos.

Em seguida, crie o diretório do projeto:

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

slate init cria a estrutura do projeto com as pastas necessárias para estado, Programs e provedores.

Passo 2: Conecte Seus Modelos

Execute:

1slate /providers

Isso abre a tela de configuração do provedor dentro da CLI do Slate. Conecte os modelos que você deseja usar.

Para este enxame, eu uso Sonnet nos agentes rápidos (geração de ideias, engenharia de features, backtesting, auditoria de regime) e Opus nos agentes pesados de raciocínio (validação e decomposição de fatores).

Passo 3: Elabore o Program

Inicie o Slate:

1slate

Em seguida, na CLI do Slate digite:

elabore um program que execute seis agentes de pesquisa em sequência: gerador de ideias, engenheiro de features, backtester, validador, auditor de regime, decompositor de fatores. execute a cada 24 horas. use sonnet para os agentes rápidos e opus para validação e decomposição de fatores.

O Slate elabora o Program com você. Ele faz perguntas esclarecedoras. Qual fonte de dados. Qual janela de backtest. Qual limite de Sharpe. Qual classificador de regime. Você responde em linguagem natural. O Slate escreve o JavaScript.

Aqui está a aparência do loop depois de escrito:

1export default async function alphaSwarm(slate) {
2  while (true) {
3    // Estágio 1: ler artigos, extrair hipóteses
4    const hypotheses = await slate.agent('idea-generator', {
5      model: 'sonnet',
6      task: 'Leia arXiv q-fin e SSRN das últimas 24 horas. Extraia 10 hipóteses de alfa com direção reivindicada, dados necessários e referência do artigo.',
7      state: slate.state.get('tested-hypotheses')
8    });
9
10    // Estágio 2: engenharia de features, em paralelo por hipótese
11    const features = await Promise.all(
12      hypotheses.map(h => slate.agent('feature-engineer', {
13        model: 'sonnet',
14        task: `Construa o vetor de features para: ${h.claim}. Padronize na seção transversal. Lide com look-ahead.`,
15        data: slate.tools.priceData()
16      }))
17    );
18
19    // Estágio 3: backtest de 20 anos com custos realistas
20    const backtests = await Promise.all(
21      features.map(f => slate.agent('backtester', {
22        model: 'sonnet',
23        task: 'Execute backtest de 20 anos. Inclua custos de transação de 5 bps por trade e custos de venda a descoberto.',
24        features: f
25      }))
26    );
27
28    // Estágio 4: validação estatística no modelo de raciocínio
29    const validated = await Promise.all(
30      backtests.map(b => slate.agent('validator', {
31        model: 'opus',
32        task: 'Estatística t ajustada por Newey-West acima de 2.5. Bootstrap 10k. Rejeite se o Sharpe IS/OOS degradar mais de 30 por cento.',
33        backtest: b
34      }))
35    );
36
37    // Estágio 5: segmentação de regime 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: 'Ajuste HMM de 3 estados em volatilidade e retornos. Recalcule Sharpe por regime. Rejeite se apenas um regime funcionar.',
44          result: v
45        }))
46    );
47
48    // Estágio 6: decomposição de fatores para isolar alfa residual
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: 'Faça regressão contra Fama-French 5 + momentum Carhart + baixa volatilidade. Relate alfa residual e estatística t.',
55          result: r
56        }))
57    );
58
59    // Persistir, notificar, dormir
60    await slate.state.set('final-signals', finalSignals);
61    await slate.state.append('tested-hypotheses', hypotheses);
62    await slate.notify.slack('research', `${finalSignals.length} novos sinais sobreviveram a todos os seis estágios hoje.`);
63    await slate.sleep('24h');
64  }
65}

Esse é o enxame inteiro. Um arquivo. Seis agentes. Roda para sempre.

Passo 4: Execute o Enxame

Salve o arquivo e execute:

1slate run alpha-swarm.js

No momento em que você apertar enter, o Slate inicia o loop. Os seis agentes disparam em sequência.

A engenharia de features roda em paralelo para cada hipótese. Os backtests rodam em paralelo. A validação roda no modelo mais forte.

Você pode observar cada agente trabalhando em tempo real pela CLI do Slate. Cada agente mostra seu estado, sua tarefa atual e seu progresso.

[Screenshot 4: Terminal mostrando o enxame rodando com múltiplos agentes ativos em paralelo, indicadores de progresso visíveis para cada estágio.]

O primeiro ciclo leva de 20 a 40 minutos, dependendo de quantas hipóteses o estágio um produz.

No final, o Slate posta os sobreviventes no seu canal do Slack com seus índices Sharpe, drawdowns e alfa residual. Depois, dorme até amanhã.

Passo 5: Itere

A primeira versão do loop nunca é a final.

O gerador de ideias produzirá duplicatas. Digite no Slate:

adicione uma verificação contra o histórico de estado para que ele só proponha hipóteses que não testamos nos últimos 30 dias.

O validador rejeitará sinais que você acha que deveriam ter passado. Digite:

afrouxe o limite de Sharpe para 1.2 mas aperte o limite de drawdown máximo para 8 por cento.

O Slate atualiza o Program para você. O próximo ciclo usa a nova lógica. Cada melhoria se acumula no arquivo de estado e, com o tempo, o enxame fica mais afiado porque ele se lembra de tudo que já testou e de tudo que já rejeitou.

Parte 5: Como Isso Realmente Substitui Uma Equipe de Pesquisa

Três padrões cobrem toda implantação real.

Padrão 1: Descoberta noturna.

O enxame roda das 20h às 8h. Toda manhã você acorda com dois ou três sinais que sobreviveram a todos os seis estágios.

Seu trabalho se torna revisar os sobreviventes em vez de executar o pipeline você mesmo.

Padrão 2: Modo de explosão de hipóteses.

Um novo artigo é publicado. Uma nova fonte de dados se torna disponível. Você dispara o enxame sob demanda e tem 100 hipóteses testadas naquela tarde.

Um pesquisador humano testa duas no mesmo tempo.

Padrão 3: Monitoramento de decaimento de alfa.

O enxame reexecuta sinais validados toda semana com dados novos. No momento em que o Sharpe de um sinal cai abaixo do limite, ele sinaliza o decaimento.

Você corta a exposição antes que o drawdown se acumule.

Cada padrão substitui uma função específica que costumava exigir um PhD. Juntos, eles substituem a maior parte do que uma equipe de pesquisa realmente faz no dia a dia.

Parte 6: Cinco Modos de Falha Que Matam 90 Por Cento Das Tentativas de Varejo

Falha 1: Pular o validador.

Você terá 100 sinais com belos índices Sharpe e nenhum rigor. Cada um é data snooping disfarçado.

O validador é inegociável. Use seu modelo mais forte. Defina limites rígidos de rejeição. Nunca deixe o criador validar seu próprio trabalho.

Falha 2: Sem persistência de estado.

Um enxame sem memória testa a mesma hipótese falha todos os dias.

Cada sinal rejeitado deve ser registrado com a razão exata da rejeição para que nenhum agente desperdice tokens no mesmo erro duas vezes.

Falha 3: Sem separação criador-verificador.

O agente que gerou a hipótese é o pior juiz possível de saber se ela é alfa real.

Separe o criador e o verificador em agentes diferentes em modelos diferentes. A Renaissance faz isso. A Two Sigma faz isso. A Citadel faz isso. Seu enxame também deveria.

Falha 4: Um agente fazendo tudo.

No momento em que você tenta fazer um agente gerar, criar features, testar e validar, a qualidade desmorona.

A especialização é o que faz o enxame funcionar. Cada agente faz uma coisa perfeitamente.

Falha 5: Sem condição de parada no loop.

Um loop sem uma parada real falha silenciosamente. O agente emite um sinal de conclusão acreditando que o trabalho está feito. Resultados ruins ficam sem correção.

Cada condição de parada deve ser verificável por algo diferente da própria afirmação do agente. "Sharpe acima de 1.5 nas últimas 30 negociações fora da amostra." "Drawdown abaixo de 5 por cento." Nunca "o agente diz que está pronto."

Respeite esses cinco e o enxame produzirá resultados de pesquisa de nível institucional.

Resumo

A pesquisa de alfa já é um pipeline. Seis estágios. Leia artigos. Crie features. Faça backtest. Valide. Verifique regimes. Decomponha contra fatores.

Todo fundo sério o executa com 100 PhDs.

Um enxame de seis agentes de IA especializados executa cada estágio para você. Cada agente escolhe o modelo que se adequa à sua complexidade. O enxame inteiro roda em um Slate Program que é acionado a cada 24 horas.

Programs do Slate é a camada que torna isso realmente implantável em um fim de semana em vez de seis meses.

Ele elabora o loop com você. Ele salva o loop. Ele executa o loop. Ele o executa para sempre.

Você deixa de ser o pipeline. Você se torna o arquiteto.

O fosso de infraestrutura é real. O fosso de pesquisa está morto.

Esse é o ponto.

Se você quiser testar, cadastre-se em

https://randomlabs.ai e siga

@wearerandomlabs para o lançamento.

No meu artigo anterior sobre engenharia de loops, detalhei como a mesma arquitetura se conecta a um sistema de trading auto-melhorável completo que executa negociações por conta própria. Se você ainda não o leu, leia logo após este.

Este enxame é a metade de pesquisa desse sistema.

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

Os fundos que construírem isso primeiro irão se beneficiar pelo crescimento composto na próxima década.

Os que ainda estão testando uma hipótese de cada vez ficarão para trás.

Então aqui está a pergunta para refletir.

Você é o pesquisador ainda testando uma hipótese por semana, ou é o arquiteto que construiu o enxame que testa cem todas as noites enquanto você dorme?

Não há resposta errada. Mas há respostas muito reveladoras.