Governance

How to Orchestrate Multiple AI Agents With Governance

· founder of ETCSEC · updated November 11, 2026 · 8 min
The short answer

Teams that already enforce file scope and review before merge still see conflicts, because the failure starts earlier: an unsplit brief, not the parallel agents themselves. The chain that actually prevents conflicts, duplicate work, and unreviewed merges runs brief to tickets, tickets to parallel agents with reserved file scope, agents to review by someone else, and review to integration that reruns the project's own checks, regardless of which MCP client runs each agent.

The failure starts before the first agent runs

A CTO who says running agents in parallel creates conflicts, duplicates, and unreviewed deliveries has usually already fixed half the problem: a dedicated worktree and branch per agent, a reserved file scope per ticket, and review before merge, the five practices a related guide on this blog already covers, illustrated there with Claude Code but not limited to it. What breaks the chain before any of that applies is earlier: a brief that never became a set of distinct, scoped tickets in the first place, and a review and integration step that has to hold regardless of which client ran which agent.

None of what follows repeats the worktree, scope, or review-before-merge practices already documented; it covers the two parts of the chain that sit on either side of them, turning a brief into tickets before parallel work starts, and coordinating review and integration once several deliveries land at the same time, built around the Model Context Protocol's own host-neutral architecture rather than one specific client.

Treating the five practices and this chain as the same thing is the mistake that leads a team to adopt file scope and review, still see conflicts, and conclude the practices do not work; the practices solve what happens once tickets exist, and a team that skips straight to parallel agents from an unsplit brief is still exposed to the failure mode those five practices were never meant to catch.

MCP's architecture is host-neutral, which is why the chain works with any client

The protocol's own architecture overview, version 2026-07-28, describes MCP as a client-server model where an MCP host, "an AI application like Claude Code or Claude Desktop," creates one MCP client for each server it connects to, with each client holding a dedicated connection to its server. The documentation gives a second, different host as its own example: when Visual Studio Code connects to the Sentry MCP server and then to a local filesystem server, the Visual Studio Code runtime instantiates a separate client object for each one.

That design is why a governance chain built on tickets, scope, and review does not have to be rewritten for every client: the host changes, Claude Code, Claude Desktop, VS Code, or any other application implementing the protocol, but the client-to-server connection model, and the tools, resources, and prompts a server exposes, stay the same underneath it. A ticket that names a file scope and an acceptance criterion constrains the agent regardless of which host happens to be running it that day.

The same overview specifies two transport mechanisms underneath that client-server model, a stdio transport for a local server talking to one client on the same machine, and a Streamable HTTP transport for a remote server serving many clients at once, each carrying the identical JSON-RPC message format regardless of which transport or which host is on the other end.

From brief to tickets: what has to be decided before parallel work starts

A brief, written for a person, usually bundles several changes that touch different parts of a codebase or a dataset under one description. Splitting it into tickets a set of agents can run in parallel means deciding, before any agent starts, which parts of that brief can be worked on without touching the same files, which ones depend on another ticket finishing first, and which single ticket should instead absorb a change too entangled to split safely.

Each resulting ticket still needs the two things a ticket-based governance model already requires: a file scope reserved before the agent launches, so two tickets in progress cannot claim the same files, and acceptance criteria written in advance, so the agent has a verifiable target and the reviewer has an objective test rather than the agent's own summary of what it did. Getting the split wrong here, overlapping scopes, or acceptance criteria copied verbatim from the original brief without being made specific to each ticket, is what produces the duplicate work and merge conflicts a CTO sees downstream, even when every other practice in the chain is followed correctly.

A brief that bundles a database migration with an unrelated UI change is the clearest case for splitting before assigning agents, since the two touch disjoint files and carry independent risk; a brief that changes one function's signature and every file that calls it is the clearest case for keeping as a single ticket, since splitting it would hand two agents overlapping scope on the same change.

The chain, stage by stage

The table below names the control at each stage of the chain, from brief to integration, and where that control already appears in more detail elsewhere on this blog rather than repeating it here.

StageWhat has to happenWhere it's covered
Brief to ticketsSplit into non-overlapping file scopes, each with its own acceptance criteriaThis article
Ticket to parallel agentWorktree and branch per agent, scope enforced before launchParallel Claude Code agents guide
Agent to deliveryTool list and available actions can change mid-run; agents resync via MCP notificationsMCP architecture overview
Delivery to reviewReviewed by someone other than the requester, on the actual diffAI agent governance guide
Review to integrationProject's own checks rerun at merge, not assumed from the review aloneAI agent governance guide

Running agents in parallel without losing the thread

Once several agents are running against their own reserved scopes, the coordination problem shifts from file conflicts to staying synchronized on what each agent is actually allowed to do. MCP's own notification system exists for exactly this: a server can tell connected clients when its available tools change, for example when a tool is added, modified, or temporarily disabled, and a client that subscribed to that notification refreshes its tool list rather than continuing to work from a stale one.

For a team running several agents against the same MCP servers, that means a scope or permission change made mid-run, a tool newly blocked by an administrator, a server taken offline for maintenance, propagates to every connected agent through the protocol itself, instead of depending on each agent being restarted to pick up the change.

This is an opt-in mechanism, not something a client gets automatically: the protocol's own documentation notes that change notifications are sent only to clients that subscribed to them, and that polling still has a role since delivery is best-effort rather than guaranteed, particularly across a reconnect.

Review has to happen once, by someone who didn't do the work

Running five tickets in parallel does not mean inventing five different review standards; it means the same rule, the person who asked for the work is not the one who approves it, applied to every delivery that lands, whether they arrive one at a time or all in the same afternoon. GitHub's own documentation on its Copilot coding agent states the same constraint for a comparable workflow: an approval from the person who assigned the work does not count toward a repository's required reviews.

What changes under parallel load is not the standard, it is the volume a reviewer has to absorb at once, which is the reason the same practices guide already caps simultaneous sessions to what review can actually keep up with, rather than treating review capacity as unlimited just because the agents themselves can run in parallel.

A cap on simultaneous sessions, already recommended elsewhere on this blog at three to five, is the practical form this takes: it is not a limit on how many agents a tool can run, it is a limit matched to how many deliveries one reviewer, or one review rotation, can actually read the diff for before approving.

Integration reruns the checks, it doesn't trust the review alone

A diff that passed review still merges into a shared history that every other in-progress ticket depends on, which is why the governance model this blog has already documented reruns the project's own checks at integration time, rather than relying solely on the review that preceded it. Under parallel work that step matters more, not less: two reviewed, approved tickets can still conflict with each other in ways neither reviewer saw in isolation, and integration is the point where that conflict actually surfaces.

Treating integration as a second, independent check rather than a formality after review is what keeps a merge conflict from becoming a production incident discovered after the fact instead of a blocked merge caught before it.

None of this requires a different tool for parallel work versus sequential work; the same rerun-at-integration step applies to a single ticket merging alone, it simply has more opportunities to catch something when several tickets land close together.

Building the chain into a team

The worktree, branch, and file-scope practices that make the parallel-agent stage of this chain work, cap included, are covered in full at atipol.ai/agentic-ai-blog/parallel-claude-code-agents. How the cost of running several agents in parallel is tracked per ticket rather than per month is covered at atipol.ai/agentic-ai-blog/ai-agent-costs, and the guided tour showing a ticket move from brief to parallel work to review to integration end to end is at atipol.ai/tour.

Frequently asked questions

Does a governed multi-agent orchestration chain work with AI clients other than Claude Code?

Yes. The Model Context Protocol's own architecture is host-neutral: its documentation describes Claude Code, Claude Desktop, and Visual Studio Code as examples of hosts that each create their own MCP client per server, with the same client-server connection model underneath. A chain built on tickets, file scope, and review constrains the agent regardless of which host is running it.

What has to be decided before splitting a brief into tickets for parallel agents?

Which parts of the brief touch different files and can run without overlap, which parts depend on another ticket finishing first, and which parts are too entangled to split safely and should stay as one ticket. Each resulting ticket still needs its own reserved file scope and acceptance criteria written before the agent launches.

Why rerun checks at integration if a delivery was already reviewed?

Because a review covers one diff in isolation, while integration is where that diff meets every other change merged since the review started. Two separately reviewed and approved tickets can still conflict with each other in ways neither reviewer saw, which is why rerunning the project's own checks at merge time catches what review alone cannot.

Sources

Try it on a real project

The public demo shows a fictional organization at work, no account needed. The free plan includes a project, three agents and an agent lead.