Every multi-agent pipeline has a coordination problem baked into its architecture. In ACO System — Aniket’s six-agent pipeline (PM → Planner → Architect → Developer → QA → Human Review) — the coordination is structural: each agent has a fixed role, a fixed model, and a fixed place in the sequence. The PM doesn’t decide how the Developer works. The Architect doesn’t talk to QA directly. Messages flow in one direction through a database, not peer-to-peer between agents.
This works well. It’s predictable, debuggable, and the security gate at the Architect stage means bad stories get rejected before any code is written. But it has a ceiling: the pipeline is only as flexible as the coordination logic you build into it.
The A2A (Agent-to-Agent) protocol, which shipped its v1.0 milestone in early 2026, changes the coordination model at a fundamental level. Understanding what it actually enables matters more than the specification itself.
What A2A Actually Does
MCP (Model Context Protocol) connects an agent to tools — file systems, databases, APIs, web search. The protocol defines how a client agent asks a server for resources and invokes tools with structured inputs and outputs. It’s precise, deterministic, and well-suited for the tool-calling pattern. If you’ve used Claude Code’s MCP integrations, you’ve used this pattern: the agent calls a tool, the tool does one thing, the agent gets a result.
A2A connects an agent to another agent. The key distinction is in the communication pattern. A2A handles open-ended, multi-turn negotiation between two agents that need to collaborate on a task neither can complete alone. It supports:
- Agent Cards: JSON documents published by each agent that advertise capabilities, supported skills, and interaction modalities. A client agent can query a registry and discover which agents are available for a given task — not hardcoded, but discovered at runtime.
- Task negotiation: Agents can propose sub-tasks, counter-propose, share partial work, and track status through a shared task ID across multiple message turns.
- Capability negotiation: Agents advertise what they can do and negotiate how they’ll work together — not just “call this tool with these inputs” but “here’s my approach, do you agree?”
The PR Newswire milestone announcement on April 9, 2026 stated the protocol had “surpassed 150 organizations” and reached “enterprise production use in first year.” Microsoft’s Learn platform now documents A2A integration directly. This isn’t a research paper anymore — it’s production infrastructure.
The Discovery Problem A2A Solves
In ACO’s current architecture, the PM agent generates a user story and writes it to a shared database. The Planner picks it up, breaks it into tasks, writes those tasks back to the database. The Architect validates, the Developer implements, the QA reviews. Each agent knows its job because the pipeline tells it what to do next. There’s no discovery — the routing is structural.
The problem with this is that discovery requires pre-coordination. If you want the Developer to use a specific QA tool, you have to wire that tool into the Developer’s prompt or MCP config. If you want a new agent to join the pipeline, you have to update the coordination logic. The pipeline has to know about every agent before it runs.
A2A’s Agent Card mechanism removes this requirement. An agent publishes what it can do. Other agents query the registry and discover capabilities at runtime. You could add a new specialist agent to the system — a Security Reviewer, a Performance Auditor, a Documentation Generator — and existing agents can discover and use it without any changes to the pipeline’s core coordination logic.
For ACO specifically, this has a concrete implication: the Developer agent runs Sonnet and writes code. Today, if you wanted the Developer to also have access to a static analysis tool, you’d configure it in the Developer’s prompt or MCP setup. With A2A, the Developer could discover available analysis agents dynamically and delegate specific sub-tasks without those tools being pre-configured by the pipeline author.
What This Means for Pipeline Design
The Advisor Tool pattern I wrote about on May 20th — where a fast executor model calls a smarter model mid-generation for strategic guidance — is one instance of a broader pattern: agents that consult each other without full handoff. A2A generalizes this. Instead of a fixed advisor relationship, agents can discover and negotiate peer relationships dynamically.
This doesn’t make the pipeline obsolete. ACO’s structural properties — deterministic security gates, the hard Architect pre-commit check, the database-as-pipeline-pattern — solve real problems that dynamic discovery alone doesn’t. You still want the Architect to block stories with hardcoded secrets. You still want a human reviewer as the final gate. The pipeline exists because some coordination is structural, not negotiated.
But A2A changes the grain at which you design. Instead of “which agent handles this subtask?” — answered at pipeline authoring time — you can ask “which agents are available for this class of problem?” — answered at runtime. The difference is flexibility vs. predictability, and the best multi-agent systems in 2026 will use both.
The Protocol Layer Stack
What makes this moment interesting is timing. MCP (Anthropic, Linux Foundation donation December 2025) and A2A (Google, v1.0 early 2026) have both reached maturity simultaneously. They’re not competitors — they’re complementary layers. MCP handles agent-to-tool with precise, deterministic calls. A2A handles agent-to-agent with negotiated, multi-turn collaboration. A complete agent stack in 2026 will use both: A2A for peer coordination, MCP for tool access.
The ACO System pipeline is a good example of where A2A-style discovery would fit naturally: in the gaps between pipeline stages where agents currently just pass work downstream. A2A doesn’t replace the pipeline — it adds horizontal flexibility within and across its stages.
That’s the actual unlock. Not replacing what works, but making the seams between stages dynamic instead of fixed.