🔀 Fluxos Dinâmicos

Dynamic Workflows é um recurso do Claude Code lançado junto do Opus 4.8 (research preview). O modelo planeja o trabalho e dispara muitos subagentes em paralelo numa única sessão.

É a forma mais "larga" de paralelismo no Claude Code — e a mais cara. Saber o que é evita confundir com skills, subagents e agent teams.

Lançado com o 4.8; com o 4.8 os agentes rodam por mais tempo; saídas são verificadas.

Um workflow pode subir até ~1.000 agentes, que trabalham sozinhos (sem se falar) e têm os resultados mesclados ao final, devolvidos para a sessão principal.

Como rodam em paralelo, terminam rápido — mas cada agente é uma chamada completa do Claude, então o custo escala junto.

Largura, não conversa; resultados mesclados; latência baixa, custo alto.

No Claude normal, o plano inteiro fica "na cabeça" do modelo, junto com o contexto. No workflow, o plano vive fora — em código — e o Claude só vê o resultado.

Tirar o plano do contexto é o que mantém a sessão principal limpa em jobs gigantes.

Contexto enche em jobs grandes; o workflow descarrega o plano para fora da sessão.

O Claude escreve um arquivo JavaScript que descreve o pipeline; um runtime executa esse script em segundo plano e orquestra os agentes.

Porque o plano é código, ele pode ser inspecionado, salvo e re-executado depois.

Script JS; roda em background; determinístico (loops, condicionais, fan-out).

Você descreve o objetivo final; o Claude desenha o pipeline e o roda. É como um n8n/Make que constrói o próprio fluxograma a partir do que você pediu.

A analogia ajuda quem vem de automação no-code a entender o conceito em um segundo.

Você dá o objetivo; ele cria a topologia; "self-building canvas".

O Claude sempre confirma antes de disparar um workflow — você aprova, ou pode ver o script bruto primeiro. Digitar "workflow" por acaso não dispara nada.

Tira o medo do recurso: ele não "foge" sozinho a não ser que você ligue o UltraCode (módulo 4.5).

Confirmação explícita; ver o script antes; leia o escopo, depois aprove.

Uma receita reutilizável que o Claude segue. Zero agentes extras — o mesmo agente lê e executa.

É o "como" de uma tarefa, e pode rodar dentro de qualquer um dos outros.

Receita; sem agente extra; aninhável.

Um agente com contexto próprio, enviado para uma tarefa lateral. Reporta de volta uma vez e some.

Mantém a sessão principal limpa; não fala com outros subagents, só com a sessão.

1 agente; contexto isolado; reporta e encerra.

Uma pequena equipe com papéis nomeados que trocam mensagens entre si e compartilham uma lista de tarefas.

É a opção quando os agentes precisam debater/colaborar (war room, conselho).

Poucos agentes; conversam; papéis e ferramentas próprias.

O Claude escreve código que sobe muitos agentes (até ~1.000). Eles trabalham sozinhos; os resultados se mesclam no fim.

É força bruta paralela — diferente da conversa de uma team.

Até 1.000; não conversam; merge final.

Agent Team = um grupo de chat: os membros se passam o bastão e reagem entre si. Workflow = pistas solo: os agentes nunca se veem.

É o critério que mais decide qual usar: precisa colaborar → team; precisa paralelismo bruto → workflow.

Team conversa; workflow isola; o resto é custo.

Os agentes de um workflow podem ler e usar suas skills, MCPs e chaves de API. A skill é o "como"; o workflow é o "quantos".

Você reaproveita o que já construiu (skills/MCP) dentro de um job massivo.

Skill = how; workflow = how-many; MCP ao lado de qualquer um.

Da base ao topo: só perguntar → skill → subagent → agent team → workflow. Cada degrau adiciona complexidade e poder.

A escada é um mapa de decisão: você sobe conforme o problema cresce.

5 degraus; mais alto = mais poder + mais risco/custo.

Cada degrau custa mais: "só perguntar" é barato; workflow é o mais caro de todos.

Subir sem necessidade é pagar a mais pela mesma resposta.

Poder ∝ custo; topo da escada = topo da conta.

A resposta padrão deve ser o degrau mais baixo que resolve. Só suba quando o de baixo "ficar sem espaço".

Evita a tentação de usar workflow para tudo só porque é novo.

Menor degrau suficiente; subir é exceção.

Revisar todos os arquivos de um codebase, uma migração de 400 arquivos, pesquisa profunda em muitas fontes, stress-test de uma decisão grande.

São jobs que quebram em muitas peças independentes — o caso ideal.

Muitas peças paralelas; risco alto; vale a compute.

Uma única edição, uma pergunta rápida, conversa normal de ida-e-volta, ou qualquer coisa que você precise pilotar passo a passo.

Nesses casos, o workflow só custa mais pela mesma resposta.

Tarefa única; precisa de direção; um agente já segura.

"Isto se quebra em muitas peças que rodam ao mesmo tempo?" Se sim → tente um workflow. Se um agente segura tudo, não.

É o teste de uma frase que resolve a maioria das decisões.

Paralelizável → workflow; sequencial/único → não.

/goal é um loop: um agente segue tentando, turno após turno, até "done = true". Pode rodar por horas.

É a ferramenta para um objetivo com critério de parada claro.

Loop; critério de parada; profundidade no tempo.

Workflow é largura: muitos agentes executam um plano fixo em paralelo e os resultados se mesclam num só.

Não há loop "até ser verdade" — é executar o plano e devolver.

Plano fixo; paralelo; 1 resultado.

"Seguir até ser verdade?" → /goal. "Grande demais para um passo?" → workflow.

Confundir os dois leva a loops infinitos ou paralelismo sem critério.

Profundidade × largura; critério × volume.

/deep-research dispara um workflow embutido: vários agentes pesquisam em paralelo, votam em cada alegação e devolvem um relatório com fontes.

É o jeito mais fácil de experimentar um workflow sem escrever nada.

Busca paralela; votação por alegação; relatório citado.

Em vez de confiar numa única saída, vários agentes checam a mesma alegação e votam — o que sobrevive entra no relatório.

É o padrão que aumenta a confiança das descobertas em jobs grandes.

Votação; checagem independente; menos alucinação.

Dá para aninhar um workflow dentro de um /goal — largura dentro de profundidade. Muito poderoso, e muito fácil de queimar dinheiro.

Saber que existe — e o cuidado que exige — evita autonomia descontrolada.

Aninhamento; autonomia alta; cautela com custo.

O custo depende do tamanho do job que você aponta. Cada agente é uma chamada completa do Claude, com contexto próprio, e muitos rodam de uma vez.

Um único prompt mal-escopado pode consumir metade de um plano mensal em ~30 min.

Custo ∝ escopo; input ≫ output normalmente; cuidado com varreduras amplas.

1) Limite o escopo. 2) Nomeie o entregável. 3) Ponha o trabalho repetitivo no Haiku. Vago → conta alta; escopado → centavos.

As três regras transformam um workflow caro num barato sem perder qualidade.

"Cheque src/routes por auth faltando, 1 Haiku por arquivo, devolva tabela."

Enquanto roda, /workflows mostra todos os agentes ativos: modelo (ex.: Haiku), tokens usados, ferramentas e tempo. Dá para parar.

É o painel de controle — você vê o custo crescer em tempo real.

Lista de agentes; tokens/tempo; botão de parada.

Um run é descartável por padrão. Em /workflows, escolha o run e salve (tecla s) — ele vai para .claude/workflows/ e passa a rodar como /seu-nome.

Você transforma um job repetido (ex.: auditoria de skills) num comando reutilizável.

Salvar; .claude/workflows/; re-rodar; /deep-research é um embutido.

No /effort, UltraCode = raciocínio X-High + workflows ligados por padrão. Ele orquestra sozinho, sem precisar da palavra "workflow".

É o modo mais caro: para de perguntar e orquestra. Ligue quando qualidade vale mais que a conta.

X-High + workflows; menos confirmações; muito mais tokens.

Coisa rápida → pergunte. Coisa repetida → Skill. Tarefa lateral → Subagent. Crew que conversa → Agent Team. Até ser verdade → /goal. Job paralelo gigante → Workflow.

É o resumo de decisão que você leva para o dia a dia.

MCP/CLIs/APIs conectam-se a qualquer um dos degraus.

Cenários reais para você decidir o degrau certo da escada.

Treina o reflexo de não usar workflow para tudo.

Gabarito comentado na página completa.

Pegue prompts amplos e aplique as 3 regras (escopo, deliverable, Haiku).

É a habilidade que mais economiza dinheiro na prática.

Antes/depois com estimativa de custo.

Decida, em cada caso, se cabe loop até "done=true" ou paralelismo de uma passada.

Consolida o conceito mais escorregadio da trilha.

Critério de parada × volume paralelo.

Escreva o objetivo e esboce as fases (fan-out → merge) para um job real seu.

Tira o conceito do abstrato e leva ao seu contexto.

Fases; verificação; deliverable nomeado.

Rode um /deep-research com escopo apertado e observe o fan-out e a votação.

Vê na prática como agentes paralelos viram um relatório citado.

Escopo apertado; observar /workflows.

Aplique "isto quebra em peças paralelas?" a uma lista de tarefas suas.

Vira hábito de decisão rápido e barato.

Sim → workflow; não → degrau mais baixo.

Prompt que varre uma pasta específica com um agente Haiku por arquivo e devolve uma tabela.

Escopo + deliverable + Haiku no mesmo prompt.

Texto pronto na página completa.

Prompt para transformar muitos arquivos com isolamento por worktree e verificação.

O caso clássico de "400 arquivos".

Descobrir → transformar → verificar.

Modelo de pergunta de pesquisa bem-delimitada para o /deep-research.

Pergunta apertada = relatório melhor e mais barato.

Escopo, fontes, formato de saída.

O prompt do vídeo: ler cada skill, 1 Haiku por skill, pontuar e ranquear pior→melhor num scorecard.

Exemplo real de fan-out + síntese.

Score por agente; síntese final em Opus.

Instrução para salvar o workflow em .claude/workflows/ e re-executar como /nome.

Transforma um run pontual num comando do projeto.

Salvar no projeto, não no global.

Frases prontas para limitar nº de agentes, modelo e escopo antes de aprovar o run.

Evita o "metade do plano em 30 min".

Teto de agentes; Haiku; ver script antes.