A2A hit v1.0 and 150+ supporters by April 2026; this cheat sheet maps bidding, allocation, MCP, and AP2 patterns for engineers. Full breakdown.
Why agents need a negotiation layer
When one agent asks another to do work, both sides need a shared vocabulary for what is being requested, what it costs, and who commits to what. Without that, every integration becomes a bespoke API contract and agents cannot discover or transact with services they have never seen before. Negotiation protocols standardize the handshake: how an agent advertises a capability, how a peer expresses demand, and how the two settle on terms.
Agent2Agent (A2A) reaching v1.0 with 150+ supporters by April 2026 signals that this handshake is stabilizing into something you can build against rather than reinvent. The practical payoff is interoperability — an agent you write can talk to one you did not, provided both speak the same protocol.
Bidding and allocation patterns
Most multi-agent coordination reduces to two questions: how do agents state what they want, and how does the system decide who gets it. Bidding covers the first — an agent submits an offer describing a task, constraints, and what it will pay in tokens, compute, or priority. Allocation covers the second — a mechanism matches bids to available capacity and resolves contention when several agents want the same resource.
- Single-winner allocation: one bid wins a task; simplest to reason about, good default for discrete jobs.
- Auction-style bidding: agents compete on a declared value; useful when a resource is scarce and you want it to go to the highest-value use.
- Batch allocation: collect bids over a window, then solve the assignment as a set rather than first-come-first-served, which avoids greedy misallocation.
Choose the pattern by how expensive the work is and how much contention you expect. Cheap, plentiful tasks rarely justify an auction; scarce or costly ones do.
Where MCP and AP2 fit
A2A governs agent-to-agent conversation, but an agent still needs to reach tools and data, and it still needs to settle payment. MCP (Model Context Protocol) handles the tool and context side: it standardizes how an agent connects to external resources, so a capability an agent bids on can actually be executed against real systems. Think of MCP as the layer that turns a promise into an action.
AP2 addresses payment and authorization — the settlement half of a negotiation. Once two agents agree on terms, something has to record the commitment and move value or grant access. Keeping negotiation, execution, and settlement as separate protocols lets you swap or upgrade one without rewriting the others.
Practical guidance for engineers
Start by deciding which layer your problem actually needs. If agents only need to call tools, MCP alone may be enough; add A2A when independent agents must coordinate, and AP2 when money or metered access changes hands. Design your bids to be explicit — encode constraints and cost up front so allocation logic never has to guess.
Treat every negotiation as potentially failing: peers time out, bids get rejected, and settlements can be declined. Build idempotent request handling and clear fallback paths so a stalled negotiation degrades gracefully instead of leaving orphaned commitments. Because these protocols are converging rather than finished, keep the boundaries between negotiation, execution, and payment clean in your own code — that separation is what will let you adopt new versions without a rewrite.