Claude Code Workflows Dinâmicos: Executando Centenas de Subagentes Paralelos com Opus 4.8

Claude Opus 4.8 foi lançado com um recurso de destaque para o Claude Code: Fluxos de Trabalho Dinâmicos. Em uma única sessão, um agente orquestrador pode iniciar centenas de subagentes paralelos para atacar uma tarefa grande e ramificada: refatorar dezenas de arquivos, executar uma ampla matriz de testes ou explorar várias soluções simultaneamente. Parece mágica no terminal. Nos bastidores, são duas peças concretas trabalhando juntas.

Este guia detalha como os Fluxos de Trabalho Dinâmicos realmente funcionam, quando usá-los e como construir o mesmo padrão de orquestração através da API bruta. Para o modelo em si, veja o que é Claude Opus 4.8. Para um contexto sobre a arquitetura de agentes, nosso desvendando a arquitetura do harness de agentes Claude Code é a leitura complementar.

O que são Fluxos de Trabalho Dinâmicos, na verdade

No Claude Code, os Fluxos de Trabalho Dinâmicos aparecem como um modo chamado ultracode no menu de esforço. Aqui está a parte que vale a pena entender: ultracode não é um novo nível de esforço da API. É uma combinação de duas coisas que já existem no Opus 4.8:

1. O nível de esforço xhigh
2. Mensagens de sistema no meio da conversa

Juntos, eles dão a um agente orquestrador tanto a profundidade de raciocínio para planejar uma tarefa grande quanto a permissão permanente para iniciar agentes trabalhadores conforme a tarefa se desenvolve. Esse é todo o segredo. Todo o resto é a fiação do Claude Code.

Ingrediente 1: esforço xhigh

O parâmetro effort controla quantos tokens o Opus 4.8 gasta em uma resposta, incluindo chamadas de ferramentas. xhigh é o nível que a Anthropic recomenda para codificação de longo prazo e trabalho agêntico; ele é ajustado para execuções que se estendem por mais de 30 minutos com orçamentos de tokens na casa dos milhões.

Para um Fluxo de Trabalho Dinâmico, essa profundidade importa porque o orquestrador precisa fazer um planejamento real: dividir a tarefa em unidades independentes, decidir quantos trabalhadores iniciar e mesclar seus resultados. Níveis de esforço mais baixos restringem o trabalho e fazem menos chamadas de ferramentas, o que é o oposto do que um orquestrador precisa. Ao executar xhigh, defina um max_tokens grande (64K é um bom ponto de partida) para que o modelo tenha espaço para pensar e coordenar.

Ingrediente 2: mensagens de sistema no meio da conversa

Esta é a nova capacidade da API Messages que torna tudo isso possível. Antes do Opus 4.8, um prompt de sistema ficava no início de uma conversa e permanecia fixo. Agora você pode colocar uma entrada de sistema no meio do array de messages, injetando novas instruções ou permissões no meio da tarefa.

É isso que concede a um orquestrador permissão permanente para lançar fluxos de trabalho multiagente após o início da conversa, em vez de negociá-la antecipadamente. A Anthropic documenta o mecanismo em mensagens de sistema no meio da conversa. É uma pequena mudança na API com uma grande consequência: os agentes agora podem adquirir capacidades no meio de uma execução com base no que descobrem.

Ativando no Claude Code

No Claude Code, os Fluxos de Trabalho Dinâmicos ficam por trás da opção ultracode no menu de esforço. Selecioná-lo define o esforço xhigh e concede à sessão permissão para gerar subagentes paralelos através de mensagens de sistema no meio da conversa. A partir daí, você descreve uma tarefa grande e deixa o orquestrador distribuí-la.

Algumas coisas acontecem automaticamente:

• Claude planeja a tarefa e decide como dividi-la
• Ele inicia trabalhadores em paralelo, cada um com escopo para uma parte do trabalho
• Os resultados são transmitidos de volta e mesclados na sessão principal

Se você configurou o Claude Code com um plano, nosso guia de configuração do SDK do Agente Claude com plano Claude cobre a configuração circundante.

Quando usar Fluxos de Trabalho Dinâmicos (e quando não usar)

Os Fluxos de Trabalho Dinâmicos se destacam em trabalhos amplos e paralelizados:

• Refatorar um padrão em muitos arquivos simultaneamente
• Gerar e executar uma grande matriz de testes
• Explorar várias abordagens de implementação em paralelo e depois comparar
• Análise de base de código em larga escala onde cada trabalhador assume um módulo

Eles são a ferramenta errada para tarefas estreitas e sequenciais. Gerar centenas de subagentes para uma mudança em um único arquivo consome tokens sem benefício, e trabalhadores paralelos não podem ajudar quando cada etapa depende da anterior. O custo é real: centenas de subagentes xhigh significam milhões de tokens. Ajuste o padrão ao formato do trabalho.

Construindo o mesmo através da API

Você não precisa do Claude Code para construir orquestração. Os mesmos dois ingredientes estão disponíveis na API bruta de Mensagens, e a Anthropic fornece um exemplo prático em construir um modo de orquestração. O formato é:

1. Execute uma chamada de orquestrador com esforço xhigh que planeja a tarefa
2. Use mensagens de sistema no meio da conversa para conceder ao orquestrador permissão para despachar trabalhadores
3. Distribua as chamadas de trabalhadores em paralelo, cada uma com escopo para uma unidade de trabalho
4. Colete os resultados e os envie de volta ao orquestrador para mesclar

import anthropic

client = anthropic.Anthropic()

orchestrator = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=64000,
    output_config={"effort": "xhigh"},
    thinking={"type": "adaptive"},
    messages=[
        {"role": "user", "content": "Plan a refactor of the auth module across all 14 services."},
    ],
)

Cada trabalhador é uma chamada separada da API Messages que você pode executar simultaneamente, frequentemente em um nível de esforço mais baixo, já que sua tarefa é restrita. Se você está avaliando isso em relação à infraestrutura de agentes hospedados da Anthropic, o guia agentes gerenciados vs. SDK de Agentes apresenta as compensações.

Custo e controle

Subagentes paralelos multiplicam rapidamente o gasto de tokens. Um Fluxo de Trabalho Dinâmico que inicia 200 trabalhadores, cada um gastando dezenas de milhares de tokens em xhigh, se traduz em dinheiro real. Três hábitos o mantêm sensato:

• Restrinja os trabalhadores rigorosamente e execute-os em esforço medium ou low onde a subtarefa permitir
• Defina um limite para max_tokens por trabalhador para que um agente descontrolado não esgote seu orçamento
• Armazene em cache o contexto compartilhado para que o prompt de sistema repetido não seja cobrado na taxa total em cada trabalhador

A análise de preços do Opus 4.8 detalha os níveis de esforço e o cache. A versão resumida: a orquestração é poderosa, mas a conta escala com o número de agentes, então trate o paralelismo como uma escolha deliberada.

Testando sua orquestração com Apidog

Ao construir a orquestração através da API, a parte difícil de depurar é a distribuição (fan-out): os trabalhadores estão recebendo o contexto de escopo correto, suas respostas têm o formato que sua etapa de mesclagem espera e sua mensagem de sistema no meio da conversa chega corretamente? Você não quer descobrir um bug após 200 chamadas de trabalhadores ao vivo.

Apidog permite testar as peças isoladamente:

• Salve a requisição do orquestrador e inspecione a divisão da tarefa planejada antes de despachar qualquer coisa
• Simule o endpoint do trabalhador para que você possa testar sua lógica de distribuição e mesclagem sem gastar tokens em centenas de chamadas reais
• Adicione asserções sobre o formato da resposta do trabalhador para que um payload inconsistente falhe de forma evidente
• Repita uma única chamada de trabalhador em diferentes níveis de effort para ajustar o custo por trabalhador

Baixe o Apidog, construa as requisições do orquestrador e do trabalhador contra https://api.anthropic.com/v1/messages, e valide o ciclo em simulações primeiro. O guia da API do Opus 4.8 tem a requisição base para começar. Uma vez que a lógica esteja sólida em simulações, mude para o endpoint ao vivo.

FAQ

O que são Fluxos de Trabalho Dinâmicos no Claude Code? Um recurso que permite a uma sessão iniciar centenas de subagentes paralelos para lidar com tarefas grandes e ramificadas. É alimentado pelo esforço xhigh mais mensagens de sistema no meio da conversa no Opus 4.8.

Ultracode é um nível de esforço separado? Não. Ultracode é o nome do Claude Code para o esforço xhigh combinado com permissão permanente para iniciar fluxos de trabalho multiagente. Os níveis de esforço da API ainda são low, medium, high, xhigh e max.

O que são mensagens de sistema no meio da conversa? Uma mudança na API Messages no Opus 4.8 que permite colocar uma entrada de sistema no meio da conversa, injetando novas instruções ou permissões no meio da tarefa. É o que permite a um orquestrador gerar trabalhadores após o início de uma execução.

Posso construir Fluxos de Trabalho Dinâmicos sem o Claude Code? Sim. Use o esforço xhigh mais mensagens de sistema no meio da conversa na API bruta de Mensagens. A Anthropic publica um exemplo de orquestração prático em sua documentação.

Fluxos de Trabalho Dinâmicos custam muito? Podem custar. Centenas de subagentes xhigh somam milhões de tokens. Restrinja os trabalhadores rigorosamente, diminua o esforço deles onde puder e armazene o contexto compartilhado em cache para controlar os gastos.

Quando devo evitar Fluxos de Trabalho Dinâmicos? Em tarefas estreitas ou estritamente sequenciais. Trabalhadores paralelos não agregam valor quando cada etapa depende da anterior, e eles desperdiçam tokens em trabalhos pequenos.