👑 Líder de Equipe
O Modo Exército do Claude Code funciona com um coordenador central — o Líder de Equipe. Ele orquestra trabalhadores especializados, roteia permissões entre eles e envia tarefas via sistema de mailbox. O líder nunca executa trabalho diretamente: sua função é planejar, distribuir e supervisionar.
Como o Líder Coordena
Planejamento centralizado — o líder recebe a tarefa principal e a decompõe em subtarefas atômicas
Roteamento de permissões — cada trabalhador recebe apenas as permissões necessárias para sua subtarefa
Supervisão contínua — o líder monitora o progresso e pode realocar tarefas se um trabalhador falhar
Distribuição via mailbox — comunicação assíncrona estruturada entre líder e trabalhadores
💡 Dica: Maximize a Eficiência do Líder
O líder é mais eficiente quando recebe tarefas bem definidas e decomponíveis. Evite tarefas vagas como "melhore o projeto" — prefira "refatore os 5 módulos de autenticação para usar o novo padrão de middleware". Quanto mais claro o objetivo, melhor a decomposição em subtarefas e mais eficiente a distribuição entre trabalhadores.
📬 Sistema de Mailbox
A comunicação entre líder e trabalhadores acontece via mensagens estruturadas — o sistema de mailbox. Cada trabalhador tem sua caixa de entrada e pode enviar mensagens de volta ao líder. Quando um trabalhador precisa de uma permissão que não possui, ele solicita ao líder via mailbox, que decide se concede ou não.
Anatomia de uma Mensagem
Tarefa (líder → trabalhador) — contém descrição, arquivos alvo, permissões concedidas e critérios de sucesso
Status (trabalhador → líder) — reporta progresso, resultados parciais ou conclusão da subtarefa
Pedido de permissão (trabalhador → líder) — quando o trabalhador precisa de acesso que não foi concedido inicialmente
Assíncrono por design — trabalhadores não ficam bloqueados esperando resposta; continuam o que podem
📊 Fluxo de Comunicação
Latência média: mensagens entre líder e trabalhador são processadas em milissegundos dentro do mesmo host
Formato estruturado: JSON com campos padronizados — tipo, origem, destino, payload e timestamp
Fila persistente: mensagens não se perdem se um trabalhador estiver ocupado — ficam na fila até serem consumidas
Escalabilidade: o sistema suporta dezenas de trabalhadores simultâneos sem degradação
🖥️ Painéis tmux/iTerm2
Cada trabalhador do exército roda em seu próprio painel isolado — seja tmux ou iTerm2. Isso garante isolamento total de processos: um trabalhador travado não afeta os outros. Cada painel tem seu próprio stdout, stderr e estado de execução.
tmux vs iTerm2
tmux (Linux/macOS) — multiplexador de terminal. Cada trabalhador em um pane separado. Funciona em servidores remotos sem GUI.
iTerm2 (macOS apenas) — terminal nativo com tabs. Integração mais visual, mas limitado ao macOS local.
Isolamento de processo — cada painel é um processo independente com seu próprio PID e árvore de processos
Fallback automático — se iTerm2 não estiver disponível, o sistema automaticamente usa tmux
💡 Monitorando Trabalhadores
Use tmux com painéis nomeados para acompanhar cada trabalhador em tempo real. O comando tmux list-panes mostra todos os painéis ativos. Configure layouts automáticos com tmux select-layout tiled para visualizar todos os trabalhadores simultaneamente. No iTerm2, use a funcionalidade de broadcast para enviar comandos a todos os painéis de uma vez.
⚡ Agentes In-Process
Nem todo trabalhador precisa de um processo separado. Agentes in-process usam fork dentro do mesmo processo Node/Bun, com AsyncLocalStorage para isolamento de contexto. São mais leves, iniciam instantaneamente e compartilham cache — ideais para tarefas curtas e paralelas.
Fork In-Process com AsyncLocalStorage
Mesmo processo, contextos isolados — AsyncLocalStorage cria escopos independentes dentro do mesmo event loop
Inicialização instantânea — sem overhead de criação de processo ou alocação de painel tmux
Cache compartilhado — agentes in-process aproveitam o cache de prompt do processo pai automaticamente
Propagação automática — o contexto segue através de callbacks, Promises e chains assíncronas sem vazamento
📊 Performance Comparada
Tempo de criação: in-process ~1ms vs tmux/iTerm2 ~200-500ms — diferença de 200x
Uso de memória: in-process compartilha heap do processo pai vs processo separado aloca ~50-100MB novo
Cache de prompt: in-process herda 100% do cache vs processo separado começa do zero
Trade-off: menos isolamento (crash afeta o processo pai) mas muito mais eficiente para tarefas curtas
☁️ UltraPlan
O UltraPlan é o teletransporte do Claude Code para a nuvem. Você envia um prompt, um agente remoto projeta o plano completo, você aprova pelo browser, e a execução volta para o ambiente local. É a ponte entre planejamento escalável na nuvem e execução segura na sua máquina.
Fluxo Completo do UltraPlan
1. Envio do prompt — você descreve a tarefa localmente; o Claude Code empacota contexto e envia para a nuvem
2. Planejamento remoto — um agente na nuvem analisa o contexto e projeta um plano detalhado com subtarefas
3. Aprovação no browser — o plano é apresentado em uma interface web para revisão e aprovação humana
4. Execução local — após aprovação, o plano volta para a máquina local e é executado pelo exército de agentes
💡 Quando Usar UltraPlan
UltraPlan brilha em tarefas complexas que exigem planejamento profundo — refatorações grandes, migrações de framework, ou reestruturações de arquitetura. O planejamento na nuvem tem acesso a mais compute e tempo de raciocínio do que o ambiente local, resultando em planos mais detalhados e menos erros de execução. Use-o quando a tarefa é grande demais para planejar em uma única sessão local.
📦 Git Bundles
Para que o agente remoto do UltraPlan tenha contexto do seu projeto, o Claude Code usa Git Bundles para semear o ambiente na nuvem. O processo tem múltiplos fallbacks para garantir que o código chegue lá, independentemente do tamanho do repositório ou estado do working directory.
Estratégia de Fallback dos Bundles
Tentativa 1 — Histórico completo — envia o repositório inteiro como bundle, incluindo todo o histórico de commits
Tentativa 2 — Apenas HEAD — se o histórico for grande demais, envia apenas o commit atual (shallow clone)
Tentativa 3 — Squash — comprime todos os commits em um único commit e envia como bundle mínimo
Captura de stash — alterações não commitadas são preservadas via stash e incluídas no bundle
Fazer
- ✓ Commitar alterações importantes antes de usar UltraPlan
- ✓ Manter o repositório limpo para bundles menores e mais rápidos
- ✓ Usar .gitignore para excluir arquivos pesados do bundle
- ✓ Revisar o plano no browser antes de aprovar a execução
Evitar
- ✗ Enviar repositórios com binários grandes sem .gitignore
- ✗ Aprovar planos sem revisão — sempre verifique as subtarefas
- ✗ Incluir credenciais ou secrets no bundle (use .gitignore)
- ✗ Usar UltraPlan para tarefas simples que um agente local resolve
📋 Resumo do Módulo
Próximo Módulo:
3.2 - 🌉 A Ponte