Vou detalhar exatamente como construir um modelo alfa multifatorial de nível hedge fund usando engenharia de grafos.
Vamos direto ao ponto.
Guarde isto
- Sou Roan, desenvolvedor backend trabalhando com 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 iria pessoalmente revisar os primeiros 20 setups de quem estivesse construindo um sistema quant com IA, e eu estava falando sério.
Alguns construtores já estão avançando no processo comigo. A oferta ainda está de pé.
Se você está construindo um sistema de engenharia de grafos, ou prestes a começar, ou mesmo apenas pensando nisso, responda a este artigo ou me mande uma DM com seu setup atual. Vou pessoalmente analisar sua arquitetura e mostrar a diferença 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. O investimento multifatorial é como todo hedge fund sério em Wall Street gera retornos. Eles não negociam ideias isoladas. Eles empilham fatores.
Esse é 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 construtor 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 a estratégias únicas enquanto os hedge funds imprimem alfa. Até agora.
https://x.com/RohOnChain/status/2074134246784921977
Nos meus dois últimos artigos, abordei engenharia de loops e como construir um enxame de agentes de IA que caça alfa 24/7.
Depois que você tem loops e enxames, a camada que os mantém unidos como um sistema funcional é um grafo.
Engenharia de grafos é a prática de projetar essa camada. Você define os nós. Você define as arestas. O grafo funciona sozinho.
Ao final deste artigo, você não apenas entenderá engenharia de grafos.
Você terá um modelo alfa multifatorial autoexecutável rodando a cada 24 horas no seu laptop.
Parte 1: O Que a Engenharia de Grafos Realmente É
Todo quant trabalhando com IA está em algum ponto da mesma progressão. Identificar onde você está torna óbvio para onde ir em seguida.
O Que a Engenharia de Grafos Realmente É
Estágio 1: Prompts.
Você digita um prompt. Espera. Lê a saída. 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 dispara em um cronograma. O loop mantém estado. Ele sobrevive depois que você fecha o laptop. Foi isso que meu artigo sobre engenharia de loops ensinou. Um agente, uma tarefa, rodando para sempre.
Estágio 3: Enxames.
Você expande o loop em muitos agentes com papéis especializados. Um gera sinais. Outro valida. Outro executa. Foi isso que o artigo sobre enxames de agentes de IA ensinou. Múltiplos agentes em paralelo, coordenados manualmente por código Python de cola.
Estágio 4: Grafos.
Você descreve a estrutura de coordenação uma vez. Nós são agentes. 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 cola novamente.
Engenharia de grafos é 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 te conta.
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 tentou construir um sistema multiagente já esbarrou nessas três paredes.
A parede da falha me quebrou. Quando meu agente de rentabilidade ficou bloqueado porque precisava analisar 500 balanços patrimoniais e atingiu os limites de taxa, todo o pipeline morreu.
Eu voltava na manhã seguinte para um processo parado, sem sinal, e sem ideia de onde a falha se originou. Depurar significava ler um stack trace e adivinhar qual agente estava a montante da falha.
No segundo mês, eu já tinha 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. Estado é persistente. A falha é limitada ao nó, não ao pipeline. Quando um nó quebra, o resto do grafo continua rodando, e você corrige o nó quebrado descrevendo a falha em inglês simples.
Essa é a promessa da engenharia de grafos. 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. Precisam de um runtime.
O runtime é o que a maioria das pessoas construindo sistemas multiagente erra.
Eles assumem que a parte difícil é projetar o grafo. Não é. A parte difícil é encontrar uma infraestrutura que realmente consiga executá-lo.
Passei semanas testando diferentes runtimes antes de encontrar um que conseguisse executar um grafo multifatorial de ponta a ponta.
O que eu uso se chama Slate. Criado 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 continuamente para você.
Um prompt roda uma vez e para. Um Program continua até a tarefa ser concluída.
Você não escreve o Program sozinho. Você diz ao Slate o que quer em inglês simples. O Slate rascunha o grafo.
O Slate então te apresenta um diagrama. Você faz perguntas sobre o diagrama. Você altera nós. Você ajusta modelos. Só quando estiver satisfeito você diz ao Slate para salvar e executar.
Se quebrar, você conversa com o Slate sobre a falha. O Slate corrige o grafo.
Você pode encontrar o Slate em http://randomlabs.ai/rr. Está disponível hoje.
A melhor maneira de sentir a engenharia de grafos antes de construir um é executar os dois Programs de exemplo que vêm com o Slate.
Eles se chamam
/goal
e
/deepresearch
.
/goal – Grafos Que Rodam Até Serem Verificadamente Concluídos
Digite isto 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 não corresponderem, o grafo volta com a diferença específica como feedback. Ele continua até que um modelo avaliador pequeno 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.
/deepresearch – Grafos Que Paralelizam 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 de trabalho de uma vez. Cada um assume uma perspectiva diferente da pergunta.
Um lê artigos recentes. Outro verifica o arXiv q-fin. Outro puxa dados da biblioteca Kenneth French. Outro faz referência cruzada de citações.
Todos reportam de volta a um orquestrador central que sintetiza as descobertas. A razão pela qual /deepresearch importa 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 engenharia de grafos acontece.
Parte 3: O Grafo Alfa Multifatorial
O investimento multifatorial decompõe os retornos das ações em drivers sistemáticos mais um resíduo. 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 alfa α é o que o modelo não consegue explicar. Esse resíduo é o que você está caçando.
Carhart adicionou momentum em 1997. Fama e French adicionaram rentabilidade (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: Rentabilidade (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. Construtores solo não conseguem porque precisam de uma equipe de pesquisa.
A engenharia de grafos 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 momentum de 12 menos 1 mês. Constrói MOM a partir do spread dos decis.
Nó 5: Agente de Rentabilidade.
Calcula rentabilidade bruta. Constrói RMW.
Nó 6: Agente de Investimento.
Calcula crescimento anual de ativos. Constrói CMA.
Nó 7: Agente de Baixa Volatilidade.
Calcula a volatilidade realizada dos últimos 60 dias. Constrói o fator de 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 de 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.
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. Impõe neutralidade setorial, beta e cambial.
Nó 11: O Decompositor de Risco.
Regride o portfólio contra os sete fatores mais fatores de estilo e macroeconômicos. Relata o alfa residual e a estatística t.
Apenas sinais onde o alfa residual sobrevive à decomposição de fatores são alfa genuíno e novo. Todo o resto é estilo reembalado com etapas extras.
Onze nós. Cada um tem uma função. Eles passam suas saídas adiante no grafo.
O modelo completo roda em um único Program do Slate que dispara 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 Seu Diretório de 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 na 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 setas do teclado 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 a engenharia de grafos 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 conferir 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 rentabilidade 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 fornecem o modelo mental que você precisa 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 um program que execute sete agentes de pesquisa multifatorial em paralelo:2beta de mercado, tamanho, valor, momentum, rentabilidade, 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 fatores 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. Imponha estatística t ajustada por Newey-West acima de 2,5, bootstrap de 10.000 iterações,8e rejeite qualquer fator com degradação do 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 atingir 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 disparam em paralelo.
A engenharia de características (feature engineering) roda em paralelo. A validação roda 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/run
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 Quebrar
Programs reais quebram. O meu quebrou três vezes nas primeiras duas semanas.
O agente de valor ficou 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 hostis ao momentum. Eu disse ao Slate. O Slate adicionou uma alternativa 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 impor a neutralidade antes de escrever o portfólio.
Você não corre atrás de um stack trace. Você descreve o problema ao 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 ao 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 as etapas 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 conectados. Construção de fatores em paralelo. Validação sequencial. Memória compartilhada via 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 a etapa é 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: Imposição do orçamento. Essa me surpreendeu. O Slate me disse explicitamente que o limite de $30 por execução era consultivo, não uma chave de desligamento forçado. Não há uma primitiva de medição de custo em tempo real, então o orçamento é imposto como um limite declarado mais gastos auto-reportados 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 é a razão pela qual confio nesta ferramenta. A maioria dos frameworks de agentes fingiria silenciosamente que o orçamento estava sendo imposto. O Slate me disse exatamente qual camada de imposiçã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 apertei executar.
Os sete agentes de fatores dispararam imediatamente. Cada um apareceu no terminal com seu próprio ID de subagente e timer 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 os padrões (./research-memory, orçamento de $30, as três portas, loop perpétuo de 24 horas)."
Essa única linha captura por que grafos vencem scripts.
Eu não escrevi código de coordenação. Não corri atrás de 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 das portas, 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 fuso horário, o grafo acorda.
Os sete agentes de fatores disparam em paralelo. Cada um puxa as últimas 24 horas de dados de preço e fundamentos. Atualiza sua série temporal de fator. Passa a mão 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 é alfa. É beta para aquele regime, disfarçado de alfa.
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 alfa residual estiver acima de 2,5, o sinal sobrevive. Se não, o dia é registrado como sem 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 alfa multifatorial autoexecutável se parece em 2026.
O Modelo
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 enxames. Enxames se tornaram grafos.
2. Conheça seus fatores. Mercado, tamanho, valor, momento, 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. Maker nunca valida maker.
5. Aplique regras rígidas. Estatística t de Newey West acima de 2,5. Bootstrap com 10.000 iterações. Robustez de regime em três estados de HMM. Estatística t do alfa residual acima de 2,5.
6. Aqueca com /goal e /deepresearch. A intuição sobre engenharia de grafos vem de observar grafos, não de ler sobre eles.
7. Deixe que se acumule. O primeiro mês é para encontrar bugs. O segundo mês é para refinar fatores. No terceiro mês, seu grafo produz sinais que você pode realmente negociar.
Agora vá construí-lo
Instale o Slate hoje mesmo. 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, você terá seu primeiro grafo multifatorial em execução.
No próximo mês, 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 em regime de capitalização que nunca dorme.
Agora vá construí-lo.
Se você travar em qualquer parte da construção, me mande uma DM aqui.
Você pode encontrar o Slate em http://randomlabs.ai/rr.
Siga @wearerandomlabs se quiser ver todos os recursos que eles lançam. /goal e /deepresearch são os dois primeiros Programas. Eles não serão os últimos.
