Vou traduzir o conteúdo do inglês para o português, seguindo todas as diretrizes fornecidas.
Vou traduzir o texto mantendo a formatação Markdown, tags HTML, blocos de código, URLs e termos técnicos, conforme as regras.
Aqui está a tradução:
I am going to break down exactly how to build a hedge fund grade multi-factor alpha model using graph engineering.
Let's get straight to it.
Marque isto
- Sou o Roan, desenvolvedor backend especializado em design de sistemas, execução estilo HFT e sistemas de trading quantitativo. Meu trabalho foca em como os mercados de previsão realmente se comportam sob carga. Para sugestões, colaborações ou parcerias, minhas DMs estão abertas.
No meu último artigo, disse que pessoalmente orientaria os primeiros 20 setups de qualquer pessoa construindo um sistema quant de IA, e eu estava falando sério.
Alguns builders já estão avançados no processo comigo. A oferta ainda está de pé.
Se você está construindo um sistema de graph engineering, prestes a começar ou apenas pensando nisso, responda a este artigo ou me envie uma DM com seu setup atual. Eu vou pessoalmente analisar sua arquitetura e mostrar a diferença entre o que você tem e um swarm que caça alpha por conta própria.
Se eu não responder, você não estava entre os primeiros 20. Seja rápido.O investimento multifatorial é como todos os hedge funds sérios de Wall Street geram retornos. Eles não negociam ideias isoladas. Eles empilham fatores.**Este é o mesmo processo que a AQR executa. O mesmo processo que a Two Sigma executa. O mesmo processo que a Bridgewater executa. E é a primeira vez que se torna executável por um builder solo.
O problema sempre foi que construir isso exigia uma equipe de pesquisa. Engenheiros de fatores. Estatísticos. Especialistas em construção de portfólio. Analistas de risco. Engenheiros de execução. Você precisa de pelo menos dez pessoas por família de fatores, e nenhum quant solo consegue montar essa equipe.
É por isso que quants de varejo ficam presos em estratégias únicas enquanto os hedge funds imprimem alpha.Até agora.
https://x.com/RohOnChain/status/2074134246784921977
Nos meus dois últimos artigos, abordei loop engineering e como construir um swarm de agentes de IA que caça alpha 24 horas por dia, 7 dias por semana.
Depois que você tem loops e swarms, a camada que os mantém unidos como um sistema funcional é um grafo.
Graph engineering é a prática de projetar essa camada. Você define os nós. Você define as arestas. O grafo se executa sozinho.
Ao final deste artigo, você não apenas entenderá graph engineering.
Você terá um modelo multifatorial de alpha autoexecutável, rodando a cada 24 horas no seu laptop.
Parte 1: O Que Graph Engineering Realmente É
Todo quant que trabalha com IA está em algum lugar da mesma progressão. Identificar onde você está torna óbvio para onde ir em seguida.
O Que Graph Engineering Realmente É
Estágio 1: Prompts.
Você digita um prompt. Você espera. Você lê a saída. Você digita o próximo. Você é o loop. Nada sobrevive quando você fecha o laptop.
Estágio 2: Loops.
Você escreve um script que envolve o prompt e o executa em um cronograma. O loop mantém o estado. Ele sobrevive depois que você fecha o laptop. Foi o que meu artigo sobre loop engineering ensinou. Um agente, uma tarefa, rodando para sempre.
Estágio 3: Swarms.
Você expande o loop em vários agentes com funções especializadas. Um gera sinais. Outro os valida. Outro executa. Foi o que o artigo sobre swarm de agentes de IA ensinou. Múltiplos agentes em paralelo, coordenados manualmente por código Python de colagem.
Estágio 4: Grafos.
Você descreve a estrutura de coordenação uma vez. Os nós são agentes. As arestas são transferências de dados. O grafo sabe quando paralelizar, quando esperar, quando tentar novamente, quando escalar. Você não toca no código de colagem novamente.
Graph engineering é a prática de projetar essa estrutura de coordenação.
Um grafo não é um script. Essa distinção é mais importante do que qualquer um lhe diz.
Um script quebra no momento em que um agente precisa esperar por outro. Um script quebra no momento em que o estado precisa persistir entre ciclos. Um script quebra no momento em que você quer seis loops em paralelo em modelos diferentes. Todo quant de varejo que já tentou construir um sistema multiagente já esbarrou nessas três paredes.
A parede da falha me quebrou. Quando meu agente de lucratividade foi bloqueado porque precisava analisar 500 balanços patrimoniais e atingiu limites de taxa, todo o pipeline morreu.
Eu voltava na manhã seguinte para um processo interrompido, sem sinal, e sem ideia de onde a falha havia se originado. Depurar significava ler um stack trace e adivinhar qual agente estava a montante da falha.
No segundo mês, eu já havia passado mais tempo depurando coordenação do que fazendo pesquisa. Eu estava prestes a arquivar todo o projeto.
Esse é o estado de falha que todo quant multiagente encontra. É também a razão pela qual os grafos existem.
Um grafo não tem esses modos de falha. Paralelo é nativo. O estado é persistente. A falha é delimitada ao nó, não ao pipeline. Quando um nó quebra, o resto do grafo continua funcionando, e você corrige o nó quebrado descrevendo a falha em inglês simples.
Essa é a promessa do graph engineering. Agora a questão é o que executa o grafo.
Parte 2: A Ferramenta Que Executa o Grafo
Grafos são diagramas arquiteturais. Eles não se executam sozinhos. Eles precisam de um runtime.
O runtime é o que a maioria das pessoas construindo sistemas multiagente erra.
Elas assumem que a parte difícil é projetar o grafo. Não é. A parte difícil é encontrar uma infraestrutura que realmente possa executá-lo.
Passei semanas testando diferentes runtimes antes de encontrar um que pudesse executar um grafo multifatorial de ponta a ponta.
O que eu uso se chama Slate. Construído por @wearerandomlabs. Roda no seu terminal. Pega suas assinaturas de modelo existentes e distribui o trabalho entre elas.
O que importa para este artigo é uma funcionalidade que eles lançaram recentemente chamada Programs. Um Program é um grafo escrito em JavaScript que o Slate executa para você continuamente.
Um prompt é executado uma vez e para. Um Program continua até que a tarefa seja concluída.
Você não escreve o Program sozinho. Você diz ao Slate o que quer em inglês simples. O Slate elabora o grafo.
O Slate então apresenta um diagrama para você. Você faz perguntas sobre o diagrama. Você altera nós. Você ajusta modelos. Somente quando estiver satisfeito, você diz ao Slate para salvar e executar.
Se algo quebrar, você conversa com o Slate sobre a falha. O Slate corrige o grafo.
Você pode encontrar o Slate em http://randomlabs.ai/rr. Ele está disponível hoje.
A melhor maneira de sentir o graph engineering antes de construir um é executar os dois Programs de exemplo que acompanham o Slate.
Eles são chamados
/goal
e
/deepresearch
.
/goal - Grafos Que Executam Até Serem Verificadamente Concluídos
Digite isso dentro do Slate:
1/goal implementar uma função de estatística t ajustada por Newey-West em Python e verificar se ela corresponde à implementação do statsmodels em dez séries de retorno aleatórias
O Slate não dispara um prompt em um modelo. Ele cria um grafo.
**Um nó escreve a função. Outro nó escreve o teste de verificação. Um terceiro executa ambos. Um quarto avalia se as saídas correspondem.**
Se elas não corresponderem, o grafo faz um loop de volta com a divergência específica como feedback. Ele continua até que um modelo avaliador menor e separado confirme que o objetivo foi concluído.
Este é o padrão maker-checker em um runtime. O maker nunca avalia o próprio trabalho do maker.
/deepresearch - Grafos Que Paralelizam a Pesquisa
Experimente isto dentro do Slate:
1/deepresearch o que a pesquisa acadêmica mais recente diz sobre o desempenho fora da amostra do modelo de cinco fatores de Fama-French em mercados emergentes de 2015 a 2026
O grafo que é criado aqui é diferente do /goal.
É uma ramificação de pesquisa paralela.
O Slate despacha vários agentes trabalhadores de uma só vez. Cada um é responsável por um ângulo diferente da pergunta.
Um lê artigos recentes. Outro verifica o arXiv q-fin. Outro extrai dados da biblioteca Kenneth French. Outro cruza referências de citações.
Todos eles reportam de volta a um orquestrador central que sintetiza as descobertas.A razão pela qual /deepresearch é importante para esta construção é que ele demonstra o padrão exato que você precisa para a construção de fatores.
Sete agentes de fatores. Cada um é responsável por um fator diferente. Todos rodando em paralelo. Todos reportando a um orquestrador central.
Esse é o grafo multifatorial, menos as tarefas específicas de quant.
Gaste 30 minutos executando /goal e /deepresearch em perguntas que realmente importam para você. É assim que a intuição de graph engineering acontece.
Parte 3: O Grafo de Alpha Multifatorial
O investimento multifatorial decompõe os retornos das ações em direcionadores sistemáticos mais um residual. A versão fundamental é o modelo de três fatores de Fama-French, publicado em 1993:
R_i é o retorno da ação i. R_f é a taxa livre de risco. R_m é o retorno do mercado. SMB é o prêmio de tamanho. HML é o prêmio de valor.
O alpha α é o que o modelo não consegue explicar. Esse residual é o que você está caçando.
Carhart adicionou momentum em 1997. Fama e French adicionaram lucratividade (RMW) e investimento (CMA) em 2015.
Os hedge funds modernos usam uma pilha de sete fatores. AQR, Two Sigma, Millennium, Bridgewater — todos usam variantes. Aqui estão os sete fatores que importam em 2026.
Fator 1: Beta de Mercado.
Regressão móvel de 60 meses do retorno excedente da ação contra o retorno excedente do mercado.
Fator 2: Tamanho (SMB).
Small caps superam large caps em uma base ajustada ao risco.
Fator 3: Valor (HML).
Alto book-to-market supera baixo book-to-market em horizontes longos.
Fator 4: Momentum (MOM).
Os vencedores dos últimos 12 meses continuam vencendo por 3 a 12 meses.
Fator 5: Lucratividade (RMW).
Operadores robustos superam operadores fracos.
Fator 6: Investimento (CMA).
Crescimento conservador de ativos supera expansão agressiva.
Fator 7: Baixa Volatilidade.
Ações de baixa volatilidade obtêm retornos ajustados ao risco mais altos do que a teoria prevê.
Todo fundo usa uma versão disso. Builders solo não conseguem porque precisam de uma equipe de pesquisa.
Graph engineering resolve isso. Cada fator se torna um nó.
Aqui está o grafo completo. Onze nós no total.
Nós de Construção de Fatores (rodam em paralelo)
Nó 1: Agente de Beta de Mercado.
Executa a regressão móvel de 60 meses. Gera um beta para cada ação.
Nó 2: Agente de Tamanho.
Ordena por capitalização de mercado. Calcula o spread small-big.
Nó 3: Agente de Valor.
Ordena por book-to-market. Calcula o spread high-low.
Nó 4: Agente de Momentum.
Calcula o momentum de 12 meses menos 1 mês. Constrói o MOM a partir do spread dos decis.
Nó 5: Agente de Lucratividade.
Calcula a lucratividade bruta. Constrói o RMW.
Nó 6: Agente de Investimento.
Calcula o crescimento anual de ativos. Constrói o CMA.
Nó 7: Agente de Baixa Volatilidade.
Calcula a volatilidade realizada dos últimos 60 dias. Constrói a baixa volatilidade a partir do spread dos decis.
Nós de Coordenação (rodam em sequência)
Nó 8: O Validador.
Executa estatísticas t ajustadas por Newey-West em cada fator. Reamostragem bootstrap com 10.000 iterações. Elimina qualquer fator com degradação dentro da amostra versus fora da amostra acima de 30 por cento.
Roda em um modelo de raciocínio mais forte. O maker nunca valida o próprio trabalho do maker.
Nó 9: O Auditor de Regime.
Segmenta o histórico de 20 anos em três regimes usando um Modelo Oculto de Markov (HMM) sobre volatilidade e retornos. Elimina qualquer coisa que funcione em apenas um regime.
Nó 10: O Construtor de Portfólio.
Combina os fatores sobreviventes em um portfólio long-short usando pesos de paridade de risco. Aplica neutralidade setorial, de beta e cambial (dólar).
Nó 11: O Decompositor de Risco.
Regride o portfólio contra os sete fatores mais fatores de estilo e macro. Relata o alpha residual e a estatística t.
Apenas sinais onde o alpha residual sobrevive à decomposição de fatores são alpha novo genuíno. Todo o resto é estilo reempacotado com etapas extras.
Onze nós. Cada um é responsável por uma tarefa. Eles passam suas saídas pelo grafo.
O modelo inteiro roda em um único Program do Slate que é executado a cada 24 horas.
Parte 4: Como Construir Passo a Passo
Aqui está a construção exata. Siga junto no seu terminal.
Passo 1: Instalar o Slate
Abra seu terminal e execute:
1npm i -g @randomlabs/slate
O Slate é um pacote npm global. A instalação leva cerca de 30 segundos.
Verifique com:
1slate --version
Passo 2: Criar o Diretório do Seu Projeto
A pesquisa multifatorial precisa de seu próprio espaço de trabalho. Arquivos de estado, testes históricos de fatores, snapshots de portfólio — tudo fica aqui.
1mkdir ~/projects/multifactor-alpha2cd ~/projects/multifactor-alpha
Não execute outros projetos do Slate a partir da mesma pasta. O namespace do estado é por espaço de trabalho.
Passo 3: Iniciar o Slate
Digite:
1slate
Passo 4: Conectar Seus Provedores
Dentro do Slate, digite:
1/providers
Isso abre a tela de configuração de provedores. A Random Labs é autenticada por padrão. Você também pode conectar o OpenAI Codex e o GitHub Copilot diretamente.
Navegue até o Codex com as teclas de seta e pressione enter para autenticar. Sua assinatura existente funciona.
Passo 5: Conectar Seus Modelos
Dentro do Slate, digite:
1/models
Você vê todos os modelos disponíveis em todos os provedores conectados. A Random Labs hospeda cerca de 90 modelos.
Você quer duas camadas de modelo.
Uma camada rápida para os sete agentes de construção de fatores. Claude Sonnet funciona.
Uma camada de raciocínio mais forte para o validador, auditor de regime e decompositor de risco. Claude Opus funciona.
Passo 6: Aquecer Com /goal E /deepresearch
Antes de criar seu próprio Program, gaste 30 minutos com os dois Programs de exemplo fornecidos.
É assim que o graph engineering deixa de ser um conceito e se torna intuição.
Experimente este comando /goal dentro do Slate:
1/goal escrever uma função Python que calcule coeficientes de regressão transversal de Fama-MacBeth e verificar se ela corresponde ao pacote empiricalfin em 20 anos de dados mensais de retorno
Observe como o grafo se ramifica. Observe o modelo avaliador verificar o trabalho do modelo escritor. Observe o que acontece quando a primeira tentativa falha.
Depois experimente este comando /deepresearch:
1/deepresearch o que a literatura acadêmica diz sobre o fator de lucratividade RMW versus o fator de qualidade conforme definido pela MSCI e como eles diferem empiricamente de 2015 a 2026
Observe a ramificação paralela de trabalhadores. Observe o orquestrador sintetizar.
Essas duas execuções lhe darão o modelo mental necessário antes de escrever seu próprio Program.
Passo 7: Criar o Program Multifatorial
Este é o passo mais importante. Você descreve o grafo em inglês simples e o Slate o cria com você.
Digite este prompt exato no Slate:
1crie para mim um program que execute sete agentes de pesquisa multifatorial em paralelo:2beta de mercado, tamanho, valor, momentum, lucratividade, investimento e baixa volatilidade.3Após todos os sete serem concluídos, execute um validador, um auditor de regime, um construtor4de portfólio e um decompositor de risco em sequência. Use Claude Sonnet para os sete5agentes de fator e Claude Opus para o validador, auditor de regime e decompositor de risco.6Execute todo o pipeline a cada 24 horas. Use o sistema de arquivos como memória. Defina um orçamento7de $30 por execução. Aplique estatística t ajustada por Newey-West acima de 2,5, bootstrap com 10.000 iterações,8e rejeite qualquer fator com degradação de Sharpe dentro da amostra versus fora da amostra9acima de 30 por cento.
O Slate não começa apenas a escrever código. Ele lê com atenção e faz perguntas esclarecedoras.
Qual fonte de dados. Qual janela de backtest. Qual universo. Qual classificador de regime. Se deve usar padrões substituíveis.
Você responde em inglês simples. O Slate escreve o JavaScript.
Passo 8: Revisar o Diagrama do Grafo
Assim que o Slate criar o Program, ele renderiza um diagrama do grafo.
Você não está lendo código para entender o que será executado. Você está olhando para a estrutura de coordenação.
Sete nós de fatores rodando em paralelo a partir do orquestrador. Um ponto de sincronização. Quatro nós de coordenação em sequência. Uma etapa de persistência. Um nó de espera. Um loop de volta ao topo.
Faça perguntas ao Slate sobre o diagrama antes de executar qualquer coisa:
- Por que o validador está rodando no Opus?
- O que acontece se o agente de momentum exceder o tempo limite?
- Qual estado é persistido entre os ciclos?
- O que faz o auditor de regime rejeitar um fator?
Se alguma resposta te surpreender, peça ao Slate para alterar o grafo.
Passo 9: Salvar E Executar
Assim que o diagrama corresponder ao que você deseja, diga ao Slate para salvar o Program em um arquivo. Depois execute:
1slate run multifactor-alpha.js
No momento em que você pressionar enter, o Slate inicia o grafo. Os sete agentes de fatores são disparados em paralelo.
A engenharia de recursos (feature engineering) é executada em paralelo. A validação é executada no modelo mais forte.
A primeira execução leva de 15 a 25 minutos. As execuções diárias subsequentes são mais rápidas porque o arquivo de estado já contém o histórico.
Passo 10: Definir Um Orçamento
Dentro do Slate, digite:
1/budget $30/execução
Isso limita o gasto total por execução. Se uma execução se aproximar do limite, o Slate escala antes de continuar.
Passo 11: Depurar Quando Algo Quebrar
Programs reais quebram. O meu quebrou três vezes nas primeiras duas semanas.
O agente de valor foi bloqueado porque não conseguia interpretar balanços patrimoniais não americanos. Eu disse ao Slate. O Slate corrigiu o agente de valor para incluir uma etapa de normalização cambial.
O agente de momentum ocasionalmente retornava zero sinais sobreviventes em regimes adversos ao momentum. Eu disse ao Slate. O Slate adicionou um fallback que amplia a janela de lookback do momentum durante esses regimes.
O construtor de portfólio às vezes violava a neutralidade setorial. Eu disse ao Slate. O Slate adicionou uma etapa de projeção para aplicar a neutralidade antes de escrever o portfólio.
Você não corre atrás de um stack trace. Você descreve o problema para o Slate. O Slate corrige o nó.
Parte 5: O Que Realmente Aconteceu Quando Eu Executei
Aqui está a parte que eu não esperava.
Eu descrevi o grafo para o Slate em um parágrafo. O Slate verificou primeiro os identificadores de modelo disponíveis, ativou a skill de modelos e escolheu claude-sonnet-4.6 para os agentes rápidos e claude-opus-4.5 para os estágios de coordenação.
Então, o Slate criou o Program inteiro em uma única passada. Não um rascunho. O JavaScript completo. Onze nós interligados. Construção de fatores paralela. Validação sequencial. Memória compartilhada no sistema de arquivos com diretórios de execução com timestamp. Alocações de orçamento. Tudo.
O Slate não apenas escreveu o código e desapareceu. Ele voltou com três decisões específicas que queria que eu confirmasse antes de executarmos.
Decisão 1: Modelo do construtor de portfólio. Meu prompt inicial especificava Opus para o validador, auditor de regime e decompositor de risco, mas eu não nomeei um modelo para o construtor de portfólio. O Slate o definiu como Opus por padrão, porque o estágio é um trabalho analítico pesado, mas sinalizou que poderia mudar se eu quisesse o Sonnet.
Decisão 2: Versões dos modelos. O Slate usou as versões estáveis atuais do Sonnet e Opus (4.6 e 4.5) e se ofereceu para atualizar para versões mais recentes se eu preferisse.
Decisão 3: Aplicação do orçamento. Esta me surpreendeu. O Slate me disse explicitamente que o limite de $30 por execução era consultivo, não um interruptor de desligamento forçado. Não há uma primitiva de medição de custo em tempo real, então o orçamento é aplicado como um limite declarado mais gastos autorreportados que são somados e sinalizados. Se eu quisesse uma interrupção forçada no meio da execução, o Slate se ofereceu para projetá-la explicitamente.
Essa terceira observação é por que confio nesta ferramenta. A maioria dos frameworks de agentes fingiria silenciosamente que o orçamento estava sendo aplicado. O Slate me disse exatamente qual camada de aplicação ele poderia realmente fornecer.
Confirmei todas as três opções padrão, renomeei o Program para multifactor-research-pipeline e disse ao Slate para salvá-lo.
Então executei.
Os sete agentes de fatores foram disparados imediatamente. Cada um apareceu no terminal com seu próprio ID de subagente e temporizador de status.
O Slate confirmou a execução em inglês simples:
"Está rodando em segundo plano como multifactor-pipeline, começando com os sete agentes de fatores em paralelo no Sonnet, depois a sequência validador → regime → portfólio → risco no Opus, com as configurações padrão (./research-memory, orçamento de $30, os três gates, loop perpétuo de 24 horas)."
Essa única linha captura por que grafos superam scripts.
Eu não escrevi código de coordenação. Não corri atrás de um stack trace. Não colei APIs. Descrevi o grafo em inglês simples, respondi a três perguntas de design, e o Slate o construiu.
Tudo é substituível na inicialização. Intervalo, orçamento, limites dos gates, modelos, localização da memória e um limite maxRuns se você não quiser que o grafo rode para sempre.
Aqui está o Program completo que o Slate escreveu para mim. Estude-o, mas não o copie literalmente. O seu será ligeiramente diferente dependendo das respostas que você deu às perguntas esclarecedoras do Slate.
Parte 6: O Que Acontece a Cada 24 Horas
Às 3h da manhã, no seu horário, o grafo acorda.
Os sete agentes de fatores são disparados em paralelo. Cada um extrai as últimas 24 horas de dados de preço e fundamentos. Atualiza sua série temporal de fatores. Passa para o validador.
O validador executa testes t de Newey-West. Faz bootstrap de 10.000 amostras. Elimina qualquer coisa que falhou fora da amostra.
Só esta etapa rejeita cerca de 80 por cento do que parece promissor em um primeiro backtest.
O auditor de regime pega o que sobreviveu. Segmenta o histórico usando o HMM. Recalcula o Sharpe por regime.
Um fator que só funciona em um regime não é alpha. É beta para aquele regime, disfarçado de alpha.
O construtor de portfólio pega os fatores sobreviventes. Constrói o portfólio long-short com as restrições de neutralidade aplicadas.
O decompositor de risco pega o portfólio. Regride contra o conjunto amplo de fatores de estilo e macro.
Se a estatística t do alpha residual estiver acima de 2,5, o sinal sobrevive. Se não, o dia é registrado como nenhum sinal e o grafo dorme até amanhã.
Todas as manhãs você acorda com uma mensagem no Slack. Ou você tem um sinal que pode negociar. Ou você tem evidência documentada de que hoje foi ruído.
Ambos os resultados são úteis. Nenhum exigiu que você estivesse no teclado.
É assim que um modelo de alpha multifatorial autoexecutável se parece em 2026.
O Modelo (Blueprint)
Se você não se lembrar de mais nada, lembre-se destes sete movimentos em ordem.
1. Entenda a progressão. Prompts se tornaram loops. Loops se tornaram swarms. Swarms se tornaram grafos.
2. Conheça seus fatores. Mercado, tamanho, valor, momentum, lucratividade, investimento, baixa volatilidade. Sete fatores. Cada um se torna um nó.
3. Projete onze nós. Sete agentes de fatores em paralelo. Quatro agentes de coordenação em sequência. Desenhe o gráfico antes de escrever uma linha de código.
4. Use modelos diferentes para nós diferentes. Sonnet para construção de fatores. Opus para validação e decomposição. O criador nunca valida o criador.
5. Imponha regras rígidas. Newey West t stat acima de 2,5. Bootstrap de 10.000 iterações. Robustez de regime em três estados HMM. Residual alpha t stat acima de 2,5.
6. Aqueça com /goal e /deepresearch. A intuição de engenharia de gráficos vem de observar gráficos, não de ler sobre eles.
7. Deixe acumular. Mês um é encontrar bugs. Mês dois é refinar fatores. No terceiro mês, seu gráfico produz sinais que você pode realmente negociar.
Agora vá construí-lo
Instale o Slate esta noite. Inicie-o. Execute /goal em uma questão quant real. Execute /deepresearch em um fator pelo qual você tem curiosidade.
Depois, elabore seu próprio Programa com o prompt exato do Passo 6. Revise o diagrama. Execute-o. Defina um orçamento de $30.
Na próxima semana a esta altura, você terá seu primeiro gráfico multifatorial rodando sozinho.
No próximo mês a esta altura, você terá seu primeiro sinal negociável sobrevivendo a todos os onze nós.
Essa é a troca. Um fim de semana de configuração para um sistema de pesquisa acumulativo que nunca dorme.
Agora vá construí-lo.
Se você travar em qualquer parte da construção, me envie uma DM aqui.
Você pode encontrar o Slate em http://randomlabs.ai/rr.
Siga @wearerandomlabs se quiser ver todas as capacidades que eles lançam. /goal e /deepresearch são os dois primeiros Programas. Não serão os últimos.
