AdCP vs AAMP: Which Standard to Implement

Back AdCP. If you have one integration budget for the next two quarters, spend it there and keep AAMP as a watch item with a named owner and no engineers attached.

AdCP publishes one number for the whole specification in a file you can fetch: dist/schemas/latest.json reads 3.1.13 stable, and that release carries 64 operations across 10 areas. Freeze the directory, run a conformance suite against it, re-run the same suite next quarter against a byte-identical artifact. AAMP is eight repositories versioning independently, and the one holding the buyer-to-seller wire contract, iab-agentic-primitives, calls itself a pre-release whose “APIs, schemas, and package layout may still change between releases until a 1.0 IAB Tech Lab standardization”. A supply contract needs a conformance clause, and that sentence will not carry one.

The umbrella version does not close the gap. IAB Tech Lab announced AAMP 2.3 on 30 July 2026 and the number matches no tag, no release and no version field in any of the eight repositories; the hub had zero tags on the day of the announcement and has zero tags now.

A counterparty that publishes only an AAMP agent card flips the call, because you implement what they serve. So does serve-time work. ARTF lets a third-party agent patch the bid object while the auction clock is running, inside somebody else’s OpenRTB auction under tmax, and AdCP has nothing at that layer to compete with it. That work goes to your general counsel before it reaches an engineer: the Go implementation is AGPL-3.0 under Index Exchange copyright.

Your first move, by side

If you sell inventory, publish two static documents this week. adagents.json and brand.json at /.well-known/ make you discoverable to a buying agent before you implement a single operation, and no protocol decision blocks them. The AAMP equivalent is an agent card plus a registry entry to resolve it, which costs more and reaches fewer buyers today.

If you buy, run one HTTP request per counterparty domain before the protocol argument starts. Does the domain serve /.well-known/adagents.json, or hand you an agent card and a registry to resolve against? The responses decide your order of work, and the discovery file guide covers what comes back. If nothing resolves across your top twenty partners, you are early: put a date in the calendar and spend the budget elsewhere.

The two stacks, job by job

AAMP has no single surface to cite, so its column names repositories: naming operations would imply a coherence that is not there.

AdCP has no priced negotiation. AAMP has no creative operation, no governance operation and no measurement object in its wire contract, which is three blanks against one. Two groups made different bets about which part of a media transaction is the hard part. How a machine buys media traces one purchase at the wire level; AAMP Explorer breaks the right-hand column out repo by repo.

The object models do not compose

The transports compose. The object models do not: an AdCP media_buy and an AAMP Deal are unrelated types with unrelated lifecycles, so an agent that already speaks MCP is adding a vocabulary, while a buyer who wants both stacks is buying two integrations and two conformance suites.

Negotiation is where that costs money. AdCP negotiates in sentences: a buyer who wants a cheaper plan sends refine with ask: "reduce total by 10%" and lets the seller re-price. AAMP negotiates in numbers, bounded by an access tier the seller assigns to your API key rather than one you claim. The caps are percentages of the seller’s own opening price: public gets three rounds, 3% per round and 8% cumulative; advertiser six rounds, 6% and 20% (AAMP Explorer reproduces the table). AdCP’s model is more expressive and much harder to test, and on price I want the numbers.

NegotiationMessage makes idempotency_key required and the seller agent’s handler never reads it, so a retried request counts as a fresh round. On the public tier that is one of your three rounds and 3 of your 8 cumulative points gone to a timeout nobody logged.

AAMP’s registry issues its five trust states and they cap the prices a buyer is shown. AdCP’s five are computed by the consumer from two self-published documents, advisory by design, and they touch no price at any point. The trust status entry has both enums side by side.

AdCP’s own FAQ files the rivalry away in one line: “Put simply: AAMP is agentic bidding; AdCP is agentic buying.” ARTF fits that sentence. The rest of AAMP does not, because its wire contract exposes /products, /api/v1/quotes, /api/v1/deals, /api/v1/change-requests and /api/v1/negotiations/messages over OpenDirect 2.1, which is quote, negotiate, book and amend, the campaign layer AdCP occupies. The same table, stamped “As of April 2026”, calls AAMP’s public schemas “Being defined”; there are 48.

Anthony Katsur is right that “standards proliferation is a real cost to the industry”, and right that “when you remodel the kitchen, you don’t burn down the house” — AAMP is built on OpenDirect 2.1, AdCOM and OpenRTB, all IAB Tech Lab work. What the metaphor hides is that his remodel shipped as eight rooms with eight release schedules and no plan covering the house. Andrew Casale calls the category “a soup of confusion” and the evidence backs him, though the soup is thickest inside AAMP: eight repositories, four with no tag at all, a press-release version that matches none of them, and one component that nobody can route around shipped under a licence that reaches its host’s users.

Craig Tuck’s objection, that “the biggest risk we see with an innovation like AdCP is decreasing transparency and control”, and Paul Bannister’s claim that agentic trading “puts the buyer directly in touch with the publisher’s ad server and removes other middlemen”, are both true, of different planes. The campaign path is buyer to publisher, with a record of who agreed what. The auction path is a mutation applied to somebody else’s bid inside somebody else’s auction under a timeout. Which path you buy on decides which of the two you get.

Governance, licensing and the AGPL problem

“AAMP is Apache-2.0” is a reasonable assumption and it is false. ARTF’s LICENSE file is the GNU AGPL v3 text, and the README spells it out: copyright Index Exchange Inc., AGPL-3.0. Vendor that Go implementation into a hosted exchange and section 13 puts your users in scope, reaching every buyer that hits your endpoint. That belongs in the first vendor call.

AAO’s interim board is half one vendor and its own FAQ says so: four interim directors, two of them Scope3-affiliated, and a first Annual General Meeting dated 6 May 2026. That is more than a body still calling its own incorporation pending has to publish. I price that concentration in and take the disclosure, because a published imbalance is one you can write a contract clause against. IAB Tech Lab wrote OpenRTB, AdCOM, OpenDirect and GPP, and both stacks stand on those. Neither fact shows up in a schema diff, and both matter more to a five-year bet than any operation count.

The press release version number is worth pinning down, because the hub is where a buyer would look for one. Its stated job is to reference stable releases for ecosystem clarity, and it has zero tags and zero releases, its last commit predates the AAMP 2.3 announcement by three and a half months, and its README still omits the wire contract that both reference agents pin in their pyproject.toml. Here is what the tags said on the day of the announcement, and what they say now.

The closest things to 2.3 are the buyer agent’s v2.3.0, already out for eight days when the announcement landed, and the seller agent’s v2.3.3. Both are one team’s application tag, and both are gone. Three independent releases followed within twelve days, and no number covers any two of them. The per-repository breakdown has the rest.

AdCP will cost a person’s attention every month, permanently. It published four patch releases in the first eleven days of August and it dates its removals in advance: format_ids deprecated in 3.2 and removed in 4.0, package bid_price deprecated in 3.2 in favour of bidding. One release, 3.1.3, is marked “Withdrawn. Do not use.” with the reason attached and still sitting in the tree. I would take that trade every time, and I would put the owner’s name on it before the first integration ships.

AdCP is stale about itself too. docs/reference/versions.mdx names 3.1.12 as current stable, dist/schemas/ in the same checkout carries 3.1.13, and the AAMP comparison table in docs/faq.mdx still calls AdCP “3.0 GA (released April 2026)”. Both projects drift from their own code in their own prose. The difference is that one of them publishes an oracle you can fetch and diff the prose against.

Where each stack thins

AdCP’s full surface is public and needs no membership. An engineer integrating against it can answer “what does this field mean, and what happens if I omit it” without booking a call with a working group.

AAMP’s control plane carries a warning label with real work underneath it: 13 operations and 48 JSON Schema files in iab-agentic-primitives, a large OpenAPI surface and an MCP tool set on each reference agent, a 534-line ARTF specification with a protobuf contract. Most of that is one team’s application, and it moves on the next minor release.

registry-agent-example is a 22-line agent.ts. Six files in agentic-audiences are zero bytes, including the schema that would join the embedding format to either agent, specs/v1.0/schema/agent_interface.schema.json, and the specification that does have content titles itself “Draft v0.1” from inside a directory named v1.0. The client that would make registry-mediated discovery work is called “the legacy stub retained as the default” in the seller agent’s own source. Discovery is where AAMP is least finished; the AAMP page has the repo-level verdicts.

iab-agentic-primitives also ships a standards gap report whose stated rule is the best sentence in either corpus: “‘We model a field named after a standard’ is never treated as ‘we verified conformance against the published standard’.” AdCP’s conformance suite is bigger and points inward, testing AdCP against AdCP. And ConsentContext gives a GPP or TCF string somewhere to sit on the wire, where AdCP’s limitations page says it “does not carry a normative consent tag”.

Neither stack standardises measurement or attribution. AdCP carries exposure records and outcome signals “but it does not specify an attribution model”, and says it “is not MRC-accredited and does not seek accreditation”; AAMP’s wire contract has no measurement object at all. Amy Porter’s worry that agents “could obscure critical decision-making if advertisers rely too much on AI” lands on exactly that seam: on the question a CFO asks first, both stacks hand the problem back and reporting stays a per-vendor integration. What neither stack standardises has the rest.

None of that volume measures deployed traffic, and neither corpus carries an adoption figure. What is measurable from outside is thin and real: of the 23 agents in AdCP’s public registry on 12 August, 13 completed an anonymous MCP handshake and three sales agents returned a product catalogue to a caller with no credentials (the full sweep).

Three sales agents handing a product catalogue to an unauthenticated caller is a security finding as much as an adoption one. Early deployments are running open, which is itself an argument for moving now, while the norms about who gets to see a rate card are still being set. Every named agentic buy that has run in public so far ran on AdCP or on raw MCP, and none of it is large (the deployment ledger).

What would change this analysis

Each of these is a file change, checkable without waiting for a press release.

1. iab-agentic-primitives tags at 1.0 or above. That moves AAMP from implementations-with-an-emerging-contract to contract-with-implementations, and it is the trigger to watch.
2. A first tag on the hub. The umbrella carries no tags at all, which is what the whole pinning argument above rests on.
3. A non-empty agentic-audiences/specs/v1.0/schema/agent_interface.schema.json, the join between AAMP’s data plane and everything else.
4. seller-agent’s AAMPRegistryClient stops being the legacy stub, which registry-mediated discovery needs before a buyer can rely on it.
5. Either corpus references the other. The first adcp string in an IAB Tech Lab repository would be the first sign that anyone intends the two to interoperate.

If you would rather not watch them yourself, that is the work I sell.