Como orquestrar vários agentes de IA com governança
As equipas que já aplicam um perímetro de ficheiros e uma revisão antes da fusão continuam a ver conflitos, porque a falha começa antes: um brief não dividido, não os agentes em paralelo em si. A cadeia que realmente evita os conflitos, o trabalho duplicado, e as fusões não revistas vai do brief aos tickets, dos tickets a agentes em paralelo com perímetro de ficheiros reservado, dos agentes à revisão por outra pessoa, e da revisão à integração que reexecuta os próprios controlos do projeto, independentemente de qual cliente MCP executa cada agente.
A falha começa antes de o primeiro agente ser executado
Um CTO que diz que executar agentes em paralelo cria conflitos, duplicados, e entregas não revistas normalmente já resolveu metade do problema: um worktree e um branch dedicados por agente, um perímetro de ficheiros reservado por ticket, e revisão antes da fusão, as cinco práticas que um guia relacionado deste blogue já cobre, ilustradas aí com o Claude Code mas sem se limitarem a ele. O que quebra a cadeia antes mesmo de tudo isso se aplicar ocorre mais cedo: um brief que nunca se tornou um conjunto de tickets distintos e delimitados à partida, e uma etapa de revisão e integração que tem de se manter independentemente de qual cliente executou qual agente.
Nada do que se segue repete as práticas de worktree, perímetro, ou revisão antes da fusão já documentadas; cobre as duas partes da cadeia que se situam de ambos os lados, transformar um brief em tickets antes de começar o trabalho em paralelo, e coordenar a revisão e a integração assim que várias entregas chegam ao mesmo tempo, construído em torno da arquitetura neutra em relação ao host própria do Model Context Protocol em vez de em torno de um cliente específico.
Tratar as cinco práticas e esta cadeia como a mesma coisa é o erro que leva uma equipa a adotar o perímetro de ficheiros e a revisão, continuar a ver conflitos, e concluir que as práticas não funcionam; as práticas resolvem o que acontece depois de os tickets existirem, e uma equipa que passa diretamente para agentes em paralelo a partir de um brief não dividido continua exposta ao modo de falha que essas cinco práticas nunca foram pensadas para intercetar.
A arquitetura do MCP é neutra em relação ao host, por isso a cadeia funciona com qualquer cliente
A própria visão geral da arquitetura do protocolo, versão 2026-07-28, descreve o MCP como um modelo cliente-servidor em que um host MCP, «uma aplicação de IA como o Claude Code ou o Claude Desktop», cria um cliente MCP para cada servidor a que se liga, sendo que cada cliente mantém uma ligação dedicada ao seu servidor. A documentação dá um segundo host, diferente, como exemplo próprio: quando o Visual Studio Code se liga ao servidor MCP do Sentry e depois a um servidor de sistema de ficheiros local, o runtime do Visual Studio Code cria um objeto cliente separado para cada um.
Esse desenho explica por que uma cadeia de governança construída sobre tickets, perímetro, e revisão não precisa de ser reescrita para cada cliente: o host muda, Claude Code, Claude Desktop, VS Code, ou qualquer outra aplicação que implemente o protocolo, mas o modelo de ligação cliente-servidor, e as ferramentas, recursos, e prompts que um servidor expõe, permanecem os mesmos por baixo. Um ticket que nomeia um perímetro de ficheiros e um critério de aceitação restringe o agente independentemente de qual host o está a executar nesse dia.
A mesma visão geral especifica dois mecanismos de transporte sob esse modelo cliente-servidor, um transporte stdio para um servidor local que fala com um único cliente na mesma máquina, e um transporte Streamable HTTP para um servidor remoto que serve muitos clientes ao mesmo tempo, cada um transportando o mesmo formato de mensagem JSON-RPC independentemente de qual transporte ou host está do outro lado.
Do brief aos tickets: o que tem de ser decidido antes de começar o trabalho em paralelo
Um brief, escrito para uma pessoa, normalmente agrupa várias alterações que tocam partes diferentes de uma base de código ou de um conjunto de dados sob uma só descrição. Dividi-lo em tickets que um conjunto de agentes possa executar em paralelo significa decidir, antes de qualquer agente arrancar, quais as partes desse brief que podem ser trabalhadas sem tocar nos mesmos ficheiros, quais dependem de outro ticket terminar primeiro, e qual deveria antes permanecer como um único ticket que absorve uma alteração demasiado entrelaçada para ser dividida com segurança.
Cada ticket resultante continua a precisar das duas coisas que um modelo de governança baseado em tickets já exige: um perímetro de ficheiros reservado antes do lançamento do agente, para que dois tickets em curso não possam reivindicar os mesmos ficheiros, e critérios de aceitação escritos antecipadamente, para que o agente tenha um objetivo verificável e o revisor tenha um teste objetivo em vez do próprio resumo do agente sobre o que fez. Fazer mal esta divisão, perímetros sobrepostos, ou critérios de aceitação copiados literalmente do brief original sem serem tornados específicos para cada ticket, é o que produz o trabalho duplicado e os conflitos de fusão que um CTO vê a jusante, mesmo quando todas as outras práticas da cadeia são seguidas corretamente.
Um brief que agrupa uma migração de base de dados com uma alteração de interface sem relação é o caso mais claro para dividir antes de atribuir agentes, já que ambos tocam ficheiros disjuntos e carregam risco independente; um brief que altera a assinatura de uma função e todos os ficheiros que a chamam é o caso mais claro para manter como um único ticket, já que dividi-lo daria a dois agentes um perímetro sobreposto sobre a mesma alteração.
A cadeia, etapa por etapa
A tabela abaixo nomeia o controlo em cada etapa da cadeia, do brief à integração, e onde esse controlo já aparece com mais detalhe noutro lugar deste blogue em vez de o repetir aqui.
| Etapa | O que tem de acontecer | Onde está coberto |
|---|---|---|
| Do brief aos tickets | Divisão em perímetros de ficheiros não sobrepostos, cada um com os seus próprios critérios de aceitação | Este artigo |
| Do ticket ao agente em paralelo | Worktree e branch por agente, perímetro aplicado antes do lançamento | Guia de agentes Claude Code em paralelo |
| Do agente à entrega | A lista de ferramentas e as ações disponíveis podem mudar a meio da execução; os agentes ressincronizam-se através de notificações MCP | Visão geral da arquitetura MCP |
| Da entrega à revisão | Revisto por alguém diferente de quem pediu, sobre o diff real | Guia de governança de agentes de IA |
| Da revisão à integração | Os próprios controlos do projeto reexecutados na fusão, não assumidos apenas pela revisão | Guia de governança de agentes de IA |
Executar agentes em paralelo sem perder o fio
Assim que vários agentes estão a correr contra os seus próprios perímetros reservados, o problema de coordenação passa dos conflitos de ficheiros para se manter sincronizado sobre o que cada agente está realmente autorizado a fazer. O próprio sistema de notificações do MCP existe exatamente para isto: um servidor pode dizer aos clientes ligados quando as suas ferramentas disponíveis mudam, por exemplo quando uma ferramenta é adicionada, modificada, ou temporariamente desativada, e um cliente subscrito a essa notificação atualiza a sua lista de ferramentas em vez de continuar a trabalhar a partir de uma lista desatualizada.
Para uma equipa que executa vários agentes contra os mesmos servidores MCP, isso significa que uma alteração de perímetro ou de permissão feita a meio da execução, uma ferramenta recém-bloqueada por um administrador, um servidor colocado offline para manutenção, propaga-se a cada agente ligado através do próprio protocolo, em vez de depender de reiniciar cada agente para captar a alteração.
Este é um mecanismo de adesão voluntária, não algo que um cliente obtém automaticamente: a própria documentação do protocolo nota que as notificações de alteração só são enviadas a clientes que a elas se subscreveram, e que o polling continua a ter um papel já que a entrega é «best-effort» em vez de garantida, particularmente numa reconexão.
A revisão tem de acontecer uma vez, por alguém que não fez o trabalho
Executar cinco tickets em paralelo não significa inventar cinco padrões de revisão diferentes; significa aplicar a mesma regra, a pessoa que pediu o trabalho não é a que o aprova, a cada entrega que chega, quer cheguem uma de cada vez ou todas na mesma tarde. A própria documentação do GitHub sobre o seu agente de codificação Copilot estabelece a mesma restrição para um fluxo de trabalho comparável: uma aprovação da pessoa que atribuiu o trabalho não conta para as revisões exigidas de um repositório.
O que muda sob carga paralela não é o padrão, é o volume que um revisor tem de absorver de uma só vez, razão pela qual o mesmo guia de práticas já limita as sessões simultâneas ao que a revisão pode realmente acompanhar, em vez de tratar a capacidade de revisão como ilimitada só porque os próprios agentes podem correr em paralelo.
Um limite nas sessões simultâneas, já recomendado noutro lugar deste blogue entre três e cinco, é a forma prática que isto assume: não é um limite de quantos agentes uma ferramenta pode executar, é um limite ajustado a quantas entregas um revisor, ou uma rotação de revisão, consegue realmente ler o diff antes de aprovar.
A integração reexecuta os controlos, não confia apenas na revisão
Um diff que passou na revisão funde-se na mesma numa história partilhada de que depende cada outro ticket em curso, razão pela qual o modelo de governança que este blogue já documentou reexecuta os próprios controlos do projeto no momento da integração, em vez de depender apenas da revisão que o precedeu. Sob trabalho em paralelo, essa etapa importa mais, não menos: dois tickets revistos e aprovados podem na mesma entrar em conflito um com o outro de formas que nenhum dos dois revisores viu isoladamente, e a integração é o momento em que esse conflito realmente emerge.
Tratar a integração como um segundo controlo independente em vez de uma formalidade após a revisão é o que impede um conflito de fusão de se tornar um incidente de produção descoberto depois do facto em vez de uma fusão bloqueada intercetada antes.
Nada disto exige uma ferramenta diferente para o trabalho em paralelo em comparação com o trabalho sequencial; a mesma etapa de reexecução na integração aplica-se a um único ticket que se funde sozinho, simplesmente tem mais oportunidades de detetar algo quando vários tickets chegam próximos no tempo.
Construir a cadeia dentro de uma equipa
As práticas de worktree, branch, e perímetro de ficheiros que fazem funcionar a etapa de agentes em paralelo desta cadeia, limite incluído, são cobertas na íntegra em atipol.ai/agentic-ai-blog/parallel-claude-code-agents. Como o custo de executar vários agentes em paralelo é seguido por ticket em vez de por mês é coberto em atipol.ai/agentic-ai-blog/ai-agent-costs, e a visita guiada que mostra um ticket a passar do brief ao trabalho em paralelo à revisão e à integração de ponta a ponta está em atipol.ai/tour.
Perguntas frequentes
Uma cadeia de orquestração multi-agente governada funciona com clientes de IA diferentes do Claude Code?
Sim. A própria arquitetura do Model Context Protocol é neutra em relação ao host: a sua documentação descreve o Claude Code, o Claude Desktop, e o Visual Studio Code como exemplos de hosts que cada um cria o seu próprio cliente MCP por servidor, com o mesmo modelo de ligação cliente-servidor por baixo. Uma cadeia construída sobre tickets, perímetro de ficheiros, e revisão restringe o agente independentemente de qual host o está a executar.
O que tem de ser decidido antes de dividir um brief em tickets para agentes em paralelo?
Que partes do brief tocam ficheiros diferentes e podem correr sem sobreposição, quais dependem de outro ticket terminar primeiro, e quais estão demasiado entrelaçadas para serem divididas com segurança e deveriam permanecer como um único ticket. Cada ticket resultante continua a precisar do seu próprio perímetro de ficheiros reservado e de critérios de aceitação escritos antes do lançamento do agente.
Por que reexecutar os controlos na integração se uma entrega já foi revista?
Porque uma revisão cobre um diff isoladamente, enquanto a integração é onde esse diff encontra cada outra alteração fundida desde que a revisão começou. Dois tickets revistos e aprovados separadamente podem na mesma entrar em conflito um com o outro de formas que nenhum revisor viu, razão pela qual reexecutar os próprios controlos do projeto no momento da fusão deteta o que a revisão por si só não consegue.
Fontes
- Model Context Protocol, visão geral da arquitetura (versão do protocolo 2026-07-28), consultado em 11/11/2026
- GitHub Docs, Reviewing a pull request created by Copilot, consultado em 11/11/2026
- NIST, AI Risk Management Framework (AI RMF 1.0), publicado em 26/01/2023
A demo pública mostra uma organização fictícia em funcionamento, sem conta. O plano gratuito inclui um projeto, três agentes e um agent lead.
