À medida que os agentes assumem tarefas mais ambiciosas, eles enfrentam dificuldades para:
- Concluir trabalhos de forma confiável em escala
- Gerenciar o próprio contexto
Nós temos experimentado como lidar com esses desafios na forma do que estamos chamando de subagentes dinâmicos: em vez de emitir tarefas de subagentes através de chamadas genéricas de ferramentas, o agente escreve um pequeno script que controla a execução do subagente. 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 uma 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 os 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 ferramentas passo a passo, o agente escreve um pequeno script que orquestra e chama 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: `Resumir página ${page.number}`, subagentType: "summarizer" })3));
Isso desbloqueia duas coisas que a orquestração baseada em chamadas de ferramentas não consegue entregar de forma confiável:
Cobertura determinística em escala. Sem estrutura, os agentes fazem julgamentos de escopo, analisando 75 de 500 itens e considerando 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 e 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 ferramentas, especialmente para dispersão + 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.
Guia de Início Rápido
Subagentes dinâmicos requerem duas coisas: subagentes para 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 em QuickJS. Para usá-lo, instale o pacote middleware QuickJS e, em seguida, passe o CodeInterpreterMiddleware através do 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 função usar.
Para acionar subagentes dinâmicos, instrua seu agente com a palavra "workflow", assim:
1result = await agent.ainvoke({2 "messages": [{"role": "user", "content": "Execute um workflow que revise cada arquivo em src/routes/ e resuma os principais riscos."}]3})
Uso com um agente de código
A maneira mais rápida de testar 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 — subagentes dinâmicos funcionam prontamente.
Instalação
1curl -LsSf https://langch.in/dcode | bash
Execução
1dcode
Para acionar subagentes dinâmicos, basta pedir um "workflow". Em vez de executar o trabalho sozinho, ou tentar gerenciar a dispersã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 cada arquivo em src/ em busca de injeção de SQL."
À medida que os subagentes são gerados, o dcode os mostra ao vivo 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 em sua ferramenta de escolha 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() aceita uma description, 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: "Revisar src/auth/login.ts em busca de problemas de segurança.",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; // o modelo vê a última linha
Para mais informações, consulte Subagentes programáticos e Interpretadores na documentação.
Padrões Comuns de Orquestração
A Anthropic, com seus workflows dinâmicos, popularizou 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 naturalmente emergem do trabalho, e o agente adota 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 então cada item é tratado por um subagente especializado com base em sua classificação. Isso permite processar entradas mistas onde diferentes itens precisam de diferentes especializações.
Casos de uso: Triagem de tickets de suporte, logs de erro, feedback de usuários ou qualquer lote de itens que precisam de tratamento diferente dependendo do seu 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 vão 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.
Dispersão e síntese
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 cada arquivo 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 custosos, 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. Em seguida, cada descoberta é entregue a um verificador independente que lê o código fresco e retorna um veredito CONFIRMADO ou REFUTADO. Apenas as descobertas confirmadas sobrevivem para o 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: redesenho competitivo de um limitador de taxa, ranqueado. O agente tem um arquiteto para produzir vários redesenho independentes de rate-limiter.ts, cada um escrito em seu próprio arquivo para que não se sobrescrevam. Em seguida, ele os pontua 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
Variações são comparadas frente a frente por um subagente juiz, com os vencedores avançando através de 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 manipulador createOrder bagunçado. Vários escritores produzem candidatos a reescrita com diferentes prioridades. Em seguida, um juiz os 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, deduplicando 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ê deseja completude 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 de novo. Ele reporta as descobertas consolidadas e quantas passagens foram necessárias.
Veja o rastreamento aqui.
Conclusão
Subagentes dinâmicos são como você dá mais autonomia e maior confiabilidade aos agentes. O código cuida da cobertura e do 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 ou 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 encaixar. Os padrões de orquestração destacados acima são vislumbres iniciais do que é possível, mas o teto só continuará subindo à medida que os modelos ficarem 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 use o dcode onde subagentes dinâmicos funcionam prontamente.
Agradecimentos
Coautoria de @colifran_ e @huntlovell. Agradecimentos a @hwchase17, @masondrxy e @chester_curme pela revisão cuidadosa.
