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, como refatorar dezenas de arquivos, executar uma matriz ampla de testes ou comparar várias soluções ao mesmo tempo. Na prática, esse comportamento combina duas capacidades: esforço xhigh e mensagens de sistema no meio da conversa.

Experimente o Apidog hoje

Este guia mostra como os Fluxos de Trabalho Dinâmicos funcionam, quando usá-los e como reproduzir o mesmo padrão de orquestração usando a API. Para entender o modelo em si, veja o que é Claude Opus 4.8. Para mais contexto sobre arquitetura de agentes, leia também desvendando a arquitetura do harness de agentes Claude Code.

O que são Fluxos de Trabalho Dinâmicos

No Claude Code, os Fluxos de Trabalho Dinâmicos aparecem como o modo ultracode no menu de esforço.

O ponto importante: ultracode não é um novo nível de esforço da API. Ele combina duas capacidades já presentes no Opus 4.8:

1. Esforço xhigh
2. Mensagens de sistema no meio da conversa

Essa combinação permite que um agente principal:

• planeje uma tarefa grande;
• divida o trabalho em partes independentes;
• inicie subagentes paralelos;
• consolide os resultados na sessão principal.

Ou seja: o “fluxo dinâmico” não é mágica. É orquestração multiagente com mais orçamento de raciocínio e permissão para alterar instruções durante a execução.

Ingrediente 1: esforço xhigh

O parâmetro effort controla quantos tokens o Opus 4.8 pode gastar em uma resposta, incluindo chamadas de ferramentas.

O nível xhigh é recomendado pela Anthropic para codificação de longo prazo e trabalho agêntico. Ele foi pensado para execuções mais longas, inclusive tarefas que podem passar de 30 minutos e consumir grandes volumes de tokens.

Use xhigh no orquestrador quando ele precisar:

• analisar uma base de código grande;
• quebrar uma tarefa em várias subtarefas;
• decidir quais trabalhadores iniciar;
• coordenar resultados parciais;
• gerar um plano de execução consistente.

Exemplo de chamada inicial do orquestrador:

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": "Planeje uma refatoração do módulo de autenticação em todos os 14 serviços."
        }
    ],
)

Para esse tipo de uso, defina um max_tokens alto. Um ponto de partida prático é 64000, porque o orquestrador precisa de espaço para planejar, chamar ferramentas e consolidar respostas.

Ingrediente 2: mensagens de sistema no meio da conversa

Antes, uma mensagem de sistema ficava no início da conversa e permanecia fixa. Com o Opus 4.8, a API Messages permite inserir uma entrada de sistema no meio do array de messages.

Isso permite injetar novas instruções ou permissões durante a execução.

A Anthropic documenta esse comportamento em mensagens de sistema no meio da conversa.

Na prática, isso permite um fluxo como:

1. O usuário envia uma tarefa ampla.
2. O orquestrador analisa o problema.
3. A aplicação injeta uma mensagem de sistema autorizando a criação de trabalhadores.
4. O orquestrador passa a distribuir subtarefas.
5. Os resultados retornam para consolidação.

Exemplo conceitual de estrutura de mensagens:

messages = [
    {
        "role": "user",
        "content": "Analise os serviços e proponha uma refatoração segura."
    },
    {
        "role": "assistant",
        "content": "Encontrei 14 serviços afetados. Posso dividir por domínio."
    },
    {
        "role": "system",
        "content": "Você agora pode despachar trabalhadores paralelos. Cada trabalhador deve receber escopo limitado, arquivos relevantes e formato esperado de resposta."
    },
    {
        "role": "user",
        "content": "Prossiga com a distribuição das subtarefas."
    }
]

Essa mensagem de sistema intermediária é o que muda o modo de operação do agente durante a conversa.

Como ativar no Claude Code

No Claude Code, use a opção ultracode no menu de esforço.

Ao selecionar esse modo, a sessão passa a usar:

• esforço xhigh;
• permissão para iniciar subagentes paralelos;
• mensagens de sistema no meio da conversa para viabilizar a orquestração.

Depois disso, descreva uma tarefa grande e deixe o orquestrador dividir o trabalho.

Exemplo de prompt útil:

Refatore o padrão de autenticação legado em todos os serviços.

Objetivos:
- localizar todos os usos do helper antigo;
- propor uma estratégia de migração por serviço;
- executar alterações independentes em paralelo;
- gerar testes para cada serviço alterado;
- consolidar um resumo final com riscos e arquivos modificados.

O Claude Code tende a executar automaticamente este padrão:

1. Planejar a tarefa.
2. Separar unidades de trabalho.
3. Iniciar trabalhadores paralelos.
4. Receber resultados.
5. Mesclar a saída na sessão principal.

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

Quando usar Fluxos de Trabalho Dinâmicos

Use quando o trabalho for amplo e paralelizável.

Bons casos de uso:

• refatorar um padrão em muitos arquivos;
• migrar vários módulos independentes;
• gerar e executar uma matriz grande de testes;
• comparar diferentes abordagens de implementação;
• analisar uma base de código grande por domínio ou serviço;
• revisar contratos de API em múltiplos endpoints.

Evite quando a tarefa for pequena ou estritamente sequencial.

Maus casos de uso:

• alterar uma única função;
• corrigir um bug isolado;
• escrever um arquivo pequeno;
• executar uma sequência em que cada passo depende diretamente do anterior.

O custo também importa. Centenas de subagentes com esforço alto podem consumir milhões de tokens. Use paralelismo apenas quando houver ganho real.

Como construir o mesmo padrão pela API

Você não precisa usar o Claude Code para implementar orquestração. A API Messages permite reproduzir o padrão com os mesmos dois ingredientes:

1. uma chamada de orquestrador com esforço xhigh;
2. mensagens de sistema no meio da conversa;
3. chamadas paralelas para trabalhadores;
4. consolidação final pelo orquestrador.

A Anthropic mostra esse padrão em construir um modo de orquestração.

Uma arquitetura simples fica assim:

Usuário
  ↓
Orquestrador xhigh
  ↓
Plano de subtarefas
  ↓
Trabalhador A ─┐
Trabalhador B ─┼→ Resultados
Trabalhador C ─┘
  ↓
Orquestrador
  ↓
Resposta final consolidada

1. Gere o plano com o orquestrador

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=64000,
    output_config={"effort": "xhigh"},
    thinking={"type": "adaptive"},
    messages=[
        {
            "role": "user",
            "content": """
            Planeje uma refatoração do módulo de autenticação em 14 serviços.

            Retorne:
            - lista de subtarefas independentes;
            - arquivos ou serviços afetados;
            - instruções para cada trabalhador;
            - formato esperado de resposta.
            """
        }
    ],
)

2. Execute trabalhadores com escopo limitado

Cada trabalhador deve receber apenas o necessário para sua subtarefa.

Exemplo de prompt para um trabalhador:

Você é responsável apenas pelo serviço billing-api.

Tarefa:
- localizar usos do helper de autenticação antigo;
- propor alterações mínimas;
- sugerir testes relevantes.

Não altere outros serviços.
Retorne a resposta no formato:

{
  "service": "...",
  "files_to_change": [],
  "proposed_changes": [],
  "tests": [],
  "risks": []
}

Você pode executar esses trabalhadores em paralelo e, quando a subtarefa for mais restrita, usar effort menor, como medium ou low.

worker = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=12000,
    output_config={"effort": "medium"},
    messages=[
        {
            "role": "user",
            "content": worker_prompt
        }
    ],
)

3. Consolide os resultados

Depois de coletar as respostas dos trabalhadores, envie tudo de volta ao orquestrador:

merge = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=64000,
    output_config={"effort": "xhigh"},
    thinking={"type": "adaptive"},
    messages=[
        {
            "role": "user",
            "content": f"""
            Consolide os resultados dos trabalhadores abaixo.

            Objetivos:
            - identificar conflitos;
            - remover duplicações;
            - montar plano final de refatoração;
            - listar riscos;
            - sugerir ordem de execução.

            Resultados:
            {worker_results}
            """
        }
    ],
)

Se você está comparando esse modelo com infraestrutura de agentes hospedados, veja agentes gerenciados vs. SDK de Agentes.

Controle de custo

Subagentes paralelos multiplicam rapidamente o consumo de tokens.

Para manter controle:

• use xhigh no orquestrador, não necessariamente em todos os trabalhadores;
• limite max_tokens por trabalhador;
• restrinja o escopo de cada chamada;
• evite enviar a base inteira para todos os agentes;
• reutilize contexto compartilhado com cache quando aplicável;
• valide o formato das respostas antes da etapa de merge.

Exemplo de configuração mais econômica para trabalhadores:

worker = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=8000,
    output_config={"effort": "low"},
    messages=[
        {
            "role": "user",
            "content": "Analise apenas este arquivo e retorne riscos de migração."
        }
    ],
)

A análise de preços do Opus 4.8 detalha níveis de esforço e cache. A regra prática é simples: paralelismo é poderoso, mas deve ser uma decisão explícita de arquitetura.

Testando sua orquestração com Apidog

Ao construir orquestração via API, a parte mais arriscada é o fan-out:

• cada trabalhador recebeu o escopo correto?
• o payload tem o formato esperado?
• a mensagem de sistema intermediária foi enviada corretamente?
• a etapa de merge consegue consumir todos os resultados?
• o custo por trabalhador está aceitável?

Você não quer descobrir esses problemas depois de iniciar 200 chamadas reais.

Com Apidog, você pode testar as partes isoladamente:

• salvar a requisição do orquestrador;
• inspecionar o plano antes de despachar trabalhadores;
• simular endpoints de trabalhadores;
• validar o formato das respostas;
• repetir uma chamada com diferentes níveis de effort;
• testar a etapa de consolidação antes de usar o endpoint real.

Fluxo recomendado:

1. Crie a requisição do orquestrador para https://api.anthropic.com/v1/messages.
2. Valide o plano retornado.
3. Modele o payload esperado para cada trabalhador.
4. Simule respostas de trabalhadores.
5. Teste a etapa de merge.
6. Só depois execute o fan-out real.

O guia da API do Opus 4.8 tem a requisição base para começar.

FAQ

O que são Fluxos de Trabalho Dinâmicos no Claude Code?

São fluxos em que uma sessão pode iniciar múltiplos subagentes paralelos para lidar com tarefas grandes e ramificadas. Eles combinam esforço xhigh com mensagens de sistema no meio da conversa no Opus 4.8.

Ultracode é um novo nível de esforço da API?

Não. ultracode é o nome usado no Claude Code para a combinação de esforço xhigh com permissão para iniciar fluxos multiagente. Os níveis da API continuam sendo low, medium, high, xhigh e max.

O que são mensagens de sistema no meio da conversa?

São mensagens system inseridas no meio do histórico da conversa. Elas permitem adicionar novas instruções ou permissões durante a execução da tarefa.

Posso construir Fluxos de Trabalho Dinâmicos sem Claude Code?

Sim. Use a API Messages com esforço xhigh, mensagens de sistema no meio da conversa e chamadas paralelas para trabalhadores.

Fluxos de Trabalho Dinâmicos custam caro?

Podem custar. Centenas de subagentes podem consumir milhões de tokens. Limite escopo, reduza esforço nos trabalhadores quando possível e use cache de contexto compartilhado.

Quando devo evitar Fluxos de Trabalho Dinâmicos?

Evite em tarefas pequenas, lineares ou estritamente sequenciais. Se não houver paralelismo real, subagentes apenas aumentam custo e complexidade.