À medida que os agentes assumem tarefas mais ambiciosas, eles enfrentam dificuldades com:
- Completar trabalhos de forma confiável em escala
- Gerenciar o próprio contexto
Temos experimentado como lidar com esses desafios na forma do que chamamos de subagentes dinâmicos: em vez de emitir tarefas de subagentes por meio de chamadas genéricas de ferramentas, o agente escreve um pequeno script que orienta a execução dos subagentes. Isso significa que os modelos podem contar com padrões de código que são bons em escrever (como loops, ramificações ou concorrência) para criar lógica de orquestração adequada à tarefa.
Por que subagentes dinâmicos?
O Deep Agents já oferece suporte a subagentes. Eles isolam o contexto, permitem que o agente principal delegue unidades de trabalho discretas e mantêm resultados intermediários fora da janela de contexto principal. Então, por que precisamos de subagentes dinâmicos?
Com subagentes normais, eles são chamados um de cada vez, pelo modelo principal os invocando diretamente. Isso funciona em pequena escala. Mas quebra quando você precisa gerar centenas de subagentes, ou quando a lógica de orquestração é condicional ou multifásica.
Os subagentes dinâmicos resolvem isso com orquestração programática. Em vez de fazer chamadas de ferramenta passo a passo, o agente escreve um pequeno script que orquestra e chama os subagentes, e o executa em um interpretador leve.
O exemplo canônico: um subagente por página de um documento de 300 páginas. Em vez de chamar a ferramenta de subagente 300 vezes, o agente escreve um loop:
1const results = await Promise.all(pages.map(page =>2 task({ description: `Summarize page ${page.number}`, subagentType: "summarizer" })3));
Isso desbloqueia duas coisas que a orquestração baseada em chamadas de ferramenta não consegue entregar de forma confiável:
Cobertura determinística em escala. Sem estrutura, os agentes fazem julgamentos subjetivos sobre o escopo, examinando 75 de 500 itens e considerando o trabalho concluído. Um loop de despacho não faz isso. A cobertura se torna uma garantia estrutural, não um problema de engenharia de prompt.
Orquestração complexa confiável. Escrever a orquestração como código é mais confiável do que fazer o modelo reproduzi-la como uma sequência de chamadas de ferramenta, especialmente para fan-out + síntese, pipelines multifásicos ou ramificações condicionais.
Esta é a mesma ideia por trás dos workflows no Claude Code e dos Modelos de Linguagem Recursivos (RLMs): um modelo escreve código, e esse código despacha mais agentes.
Início rápido
Os subagentes dinâmicos exigem duas coisas: subagentes para os quais despachar o trabalho, e um interpretador de código: um runtime seguro e leve onde o modelo escreve e executa código de orquestração. O Deep Agents inclui um interpretador de código opcional baseado no QuickJS. Para usá-lo, instale o pacote middleware QuickJS e, em seguida, passe o CodeInterpreterMiddleware via o argumento middleware no create_deep_agent.
1pip install -U "deepagents[quickjs]"
1from deepagents import create_deep_agent2from langchain_quickjs import CodeInterpreterMiddleware34agent = create_deep_agent(5 model="openai:gpt-5.5",6 middleware=[CodeInterpreterMiddleware()],7)
O Deep Agents já vem com um subagente de uso geral embutido, então já existe um perfil de subagente geral que pode ser usado em workflows. Para workflows especializados, configure subagentes personalizados com seus próprios nomes, descrições e prompts de sistema: os nomes e descrições são como o agente sabe qual papel usar.
Para acionar subagentes dinâmicos, dê um prompt ao seu agente com a palavra "workflow", assim:
1result = await agent.ainvoke({2 "messages": [{"role": "user", "content": "Run a workflow that reviews every file in src/routes/ and summarizes the top risks."}]3})
Uso com um agente de código
A maneira mais rápida de experimentar subagentes dinâmicos é com o dcode, nosso agente de código de terminal construído usando um Deep Agent. Ele já vem com o interpretador de código habilitado, então não há nada para configurar — os subagentes dinâmicos funcionam prontos para uso.
Instale
1curl -LsSf https://langch.in/dcode | bash
Execute
1dcode
Para acionar subagentes dinâmicos, basta pedir um "workflow". Em vez de executar o trabalho diretamente, ou tentar gerenciar a propagação de subagentes com sua ferramenta de tarefa nativa, o agente escreve um script de orquestração que chama a função global task() embutida e a executa no interpretador de código. Por exemplo: "execute um workflow para revisar todos os arquivos em src/ em busca de SQL injection."
À medida que os subagentes são gerados, o dcode os mostra em tempo real no painel de subagentes dinâmicos, agrupados em fases por despacho.
Você pode testar isso mais rapidamente com o dcode, mas também pode usá-lo na ferramenta de sua preferência via ACP (como Zed)
Como funciona
O agente recebe uma ferramenta eval. Ele escreve JavaScript que executa com segurança dentro do interpretador. Quando subagentes estão configurados, o interpretador expõe uma função global task() embutida que os despacha a partir do código. Com base na tarefa em questão, o modelo escreve código diferente — um loop, uma ramificação, um Promise.all — e o interpretador o executa deterministicamente.
task() recebe uma descrição, um subagentType e um responseSchema opcional — quando fornecido, o resultado já é um objeto tipado, pronto para ser filtrado ou passado para a próxima etapa.
1const result = await task({2 description: "Review src/auth/login.ts for security issues.",3 subagentType: "reviewer",4 responseSchema: {5 type: "object",6 properties: {7 severity: { type: "string", enum: ["high", "medium", "low"] },8 issues: { type: "array", items: { type: "string" } },9 },10 },11});1213const critical = result.severity === "high" ? result.issues : [];14critical; // model sees the last line
Para mais informações, consulte Subagentes programáticos e Interpretadores na documentação.
Padrões comuns de orquestração
Os workflows dinâmicos da Anthropic popularizaram um conjunto de padrões de orquestração para trabalho paralelo de agentes. Eles não são recursos que você ativa. São formas que emergem naturalmente do trabalho, e o agente se ajusta a uma diferente à medida que a tarefa muda. A tabela abaixo mapeia cada forma para o tipo de trabalho que melhor se adequa.
Abaixo, vamos nos aprofundar em como cada um funciona no Deep Agents, com rastreamentos ao vivo. Também preparamos um vídeo explicando esses seis padrões, que você pode conferir aqui.
Classificar e agir
Os itens são classificados primeiro e, em seguida, cada item é tratado por um subagente especializado com base em sua classificação. Isso permite processar entradas mistas onde diferentes itens precisam de diferentes expertises.
Casos de uso: Triagem de tickets de suporte, logs de erro, feedback de usuários ou qualquer lote de itens que precise de tratamento diferente dependendo do tipo.
Exemplo: triagem de um backlog de tickets de suporte. O agente lê os tickets e classifica cada um como bug, solicitação de funcionalidade ou dúvida. Bugs para um investigador de bugs, solicitações de funcionalidade para um analista de funcionalidades e dúvidas para um respondedor de suporte. O resultado é um resumo agrupado por categoria.
Veja o rastreamento aqui.
Fan-out e sintetizar
O agente despacha o mesmo tipo de trabalho para muitos itens em paralelo e, em seguida, combina os resultados.
Casos de uso: Revisão de código em um diretório, análise de um lote de documentos, processamento de arquivos de log, execução da mesma verificação em vários serviços.
Exemplo: uma revisão de segurança por arquivo em uma árvore de código-fonte. O agente descobre todos os arquivos TypeScript em src/ e despacha um revisor de segurança por arquivo em paralelo. Em seguida, mescla os resultados em um único relatório priorizado com classificações de gravidade e as linhas que precisam ser alteradas.
Veja o rastreamento aqui.
Verificação adversarial
Um padrão de duas passagens. A primeira passagem produz descobertas. A segunda passagem envia cada descoberta para verificadores independentes, e apenas as descobertas que sobrevivem ao acordo são mantidas. Isso reduz falsos positivos quando a confiança é mais importante que a velocidade.
Casos de uso: Auditorias de segurança onde falsos positivos são caros, verificações de conformidade, qualquer revisão onde você precisa de alta confiança nas descobertas.
Exemplo: uma auditoria de segurança onde falsos positivos são inaceitáveis. Um auditor lança uma rede ampla em busca de vulnerabilidades potenciais e, em seguida, cada descoberta é entregue a um verificador independente que lê o código do zero e retorna um veredito CONFIRMADO ou REFUTADO. Apenas as descobertas confirmadas sobrevivem no relatório final.
Veja o rastreamento aqui.
Gerar e filtrar
Vários subagentes geram soluções independentes para o mesmo problema. O agente compara, pontua e filtra os resultados no código, mantendo apenas os melhores.
Casos de uso: Propostas de arquitetura, estratégias de refatoração, variações de conteúdo, qualquer tarefa onde explorar múltiplas opções antes de decidir produz um resultado melhor.
Exemplo: redesigns concorrentes de um limitador de taxa, ranqueados. O agente tem um arquiteto para produzir vários redesigns independentes de rate-limiter.ts, cada um escrito em seu próprio arquivo para que não se sobrescrevam. Em seguida, pontua-os com base em correção sob pico, suporte a múltiplas instâncias e complexidade. O mais forte vence, com uma justificativa do porquê.
Veja o rastreamento aqui.
Torneio
As variações são comparadas frente a frente por um subagente juiz, com os vencedores avançando por rodadas de eliminação.
Casos de uso: Otimização sob critérios subjetivos, seleção de estilo, escolha entre implementações concorrentes.
Exemplo: uma chaveamento em pares sobre reescritas de um handler createOrder bagunçado. Vários escritores produzem cada um uma reescrita candidata com diferentes prioridades, então um juiz as compara frente a frente, avançando os vencedores rodada por rodada até que um campeão se destaque. Ele retorna com a justificativa do juiz.
Veja o rastreamento aqui.
Loop até concluir
O agente executa um loop de descoberta, desduplicando contra o que já encontrou, até que nenhum novo resultado apareça. Útil quando o escopo do trabalho não é conhecido antecipadamente.
Casos de uso: Busca exaustiva, detecção de código morto, auditorias de dependência, qualquer varredura onde você queira completeza em vez de um número fixo de resultados.
Exemplo: uma varredura de segurança baseada em passagens. O agente executa uma passagem de varredura, inspeciona o que encontrou no código e só inicia outra passagem se a anterior revelou novos problemas. Ele para quando uma passagem não encontra nada novo. Ele relata as descobertas consolidadas e quantas passagens foram necessárias.
Veja o rastreamento aqui.
Conclusão
Subagentes dinâmicos são como você dá aos agentes mais autonomia e maior confiabilidade. O código lida com a cobertura e o contexto intermediário, e o modelo ainda faz o trabalho pesado de julgamento. Os padrões acima são um ponto de partida. Na prática, os agentes os compõem e misturam com base no que a tarefa exige.
Esta é a ideia do Modelo de Linguagem Recursivo em sua forma mais simples. Um agente que escreve código, e esse código despacha mais agentes. É um agente chamando a si mesmo recursivamente e não é limitado por uma janela de contexto nem engessado em um workflow fixo. Um agente pode decompor o problema o quanto for necessário e remontar as peças na forma que melhor se ajustar. Os padrões de orquestração destacados acima são vislumbres iniciais do que é possível, mas o teto continuará a subir à medida que os modelos ficam melhores em escrever código.
Subagentes dinâmicos são como o Deep Agents coloca isso em suas mãos hoje. Comece adicionando um interpretador de código ao seu agente, ou recorra ao dcode onde os subagentes dinâmicos funcionam prontos para uso.
Agradecimentos
Coautorado por @colifran_ e @huntlovell. Agradecimentos a @hwchase17, @masondrxy e @chester_curme pela revisão atenciosa.
