AdCP vs AAMP, Part 2: AdCP Is Reading OpenProposal
IAB Tech Lab's OpenProposal draft and AdCP now address the same step of a media buy: turning a brief into a proposal. The day after the draft appeared, four AdCP RFCs cited it; three of the borrowed ideas shipped in AdCP's 3.3 betas, and one has since been withdrawn until 4.0.
Full gist
Part 2 compares the two proposal models, follows the borrowing through the public record, and checks what each standard has shipped, left open and put into use as OpenProposal's comment period closes on November 10.
In English, please
Part 1 compared two rulebooks for letting AI agents buy ads: AAMP, from the ad industry's standards body IAB Tech Lab, and AdCP, from AgenticAdvertising.org. Since then both have moved onto the same step of a media buy: turning a buyer's brief into a seller's proposal, the offer that says what is for sale and at what price.
Tech Lab's new piece is OpenProposal, a draft format for that offer, open for public comment until November 10. Its big idea is that the seller lists up front which parts of the offer the buyer may change and what each option costs, so a buyer's agent can put a deal together without back-and-forth, like ordering from a menu with a price printed next to every extra. It is still a draft: there is no machine-readable version yet, Tech Lab's reference agents don't use it yet, and it doesn't say how two agents should actually send it to each other. One buyer-side company has suggested carrying it over AdCP's operations.
AdCP handles the same step as a conversation. The buyer asks, the seller answers with a new version of the proposal, and each version carries a fingerprint of its price terms so both sides can check that nothing changed. Its latest test release, a beta not meant for production, adds more features at this step.
The surprise: the day after Tech Lab published its draft, four proposals to change AdCP were filed, each citing it. Each borrows one idea, such as showing a seller's hold rules before the buyer commits, and reshapes it to fit AdCP. Two shipped in AdCP's beta a month later and a third soon after, though AdCP has since taken one back out until its next major version and is re-deciding what the final release keeps. One person, Brian O'Kelley, AdCP's most active author, filed all four and wrote and merged the changes that shipped. There is no published agreement between the two bodies, and AgenticAdvertising.org's president says there are no plans to merge the standards or the organisations.
Neither side is finished. Commenters have found holes in OpenProposal's model, such as no place for a buyer to write a counter-offer price, and AdCP's own guide contradicts itself on whether locking in a proposal can change its price. Neither has public, audited figures for how much real money runs through it. The practical advice: map one real proposal into both formats, check the committed terms yourself, and if the draft doesn't fit your business, say so before comments close on November 10.
- published
- reading
- 35 min read
- topics
On this page
Disclosure first: I co-lead AgenticAdvertising.org’s Signals & Measurement working group, and my signals agent and my sales agent are both in the AdCP registry counted below. The role is unpaid, no money is involved, and I have no ties to Brian O’Kelley, AppNexus or Scope3 (now Apostra), all of whom come up below. The working-group role may still make AdCP’s choices easier for me to read charitably, so I’ve tried to hold it to the same bar. As of November 9 I had authored 93 issues and 10 pull requests in AdCP’s specification repository and 24 issues in its SDK repository, and I have pushed against it before: in adcp#8199 I argued that one of AdCP’s own conformance tests couldn’t be passed honestly, and in this essay I report a contradiction in its negotiation guide. I’ve also filed implementation feedback on the OpenProposal draft during its comment period (four issues and twelve comments, between October 27 and November 5); this essay doesn’t cite them. AAO’s president, Benjamin Masse, read a draft; where I quote him, it says so. I link key claims to primary sources and flag accounts from interested parties.
On July 31 I published AdCP vs AAMP: The Retrofit and the Greenfield and closed it with a rule: judge both standards by what lands in the repository, not what lands in the feed. On September 22, IAB Tech Lab announced AAMP 3.0, built around a new draft object called OpenProposal for the stretch of a media buy between the buyer’s brief and the commitment to spend. On October 22, the Ad Context Protocol tagged v3.3.0-beta.0, and its headline additions sit in the same stretch.
Part 1 found the two standards colliding only at the deal plane. They now overlap one step earlier too, at the proposal. Something happened there that the “standards war” framing doesn’t predict. On September 23, the day after Tech Lab announced the draft, four AdCP RFCs were filed that each cite it. Each takes a specific mechanism from the draft and reshapes it to fit AdCP’s own model. Two of them shipped in the 3.3 beta a month later, one of them (hold policy) as an experimental feature, and a third followed in the next beta. On the public record, one person carried them: AdCP’s most active author, Brian O’Kelley, filed the RFCs, wrote and merged the changes, and merged the releases that shipped them. Since then AdCP has withdrawn one of the three until its next major version, and its working group is re-deciding what 3.3 keeps. I found no published agreement between the two bodies. AdCP is taking ideas from OpenProposal anyway. Traffic the other way is so far a single proposal: one buy-side platform on OpenProposal’s tracker suggests carrying the object over AdCP’s operations, because the draft defines none of its own.
What changed since part 1
In short: AAMP’s scope on the wire moved onto the proposal step, both bodies dropped the idea that the two standards sit on separate layers, and one part 1 claim, about demand, was too strong. Smaller version updates are at the end.
AAMP’s scope moved. Part 1’s altitude map labeled AAMP’s brief-and-planning band “inside the agent, not on the wire.” That was accurate in July. AAMP’s buyer agent took briefs and planned, and since seller-agent v2.1.1 on July 21 its proposals have crossed the wire at the deal stage (“Proposals persist on submission” through POST /api/v1/negotiations/messages), but no planning-stage object did. OpenProposal is that object: its custom proposal is “built in response to a buyer’s agent brief.” So AAMP’s wire-level scope moved onto the step where AdCP’s proposals already were. How to describe that depends on who you ask. Tech Lab’s scope clarification argues AAMP always spanned the full lifecycle, planning included; the AdCP side sees AAMP arriving on ground it was already on. Both readings fit the repositories. What changed is the wire, and the map below now marks OpenProposal as a draft there.
AdCP’s own framing. Part 1 quoted AdCP’s FAQ filing AAMP as an effort that appears to “operate at different layers of the stack and can coexist.” That line is gone. On August 23, adcp#6801 retired the old “AAMP is agentic bidding; AdCP is agentic buying” framing, which, in the PR’s words, Tech Lab “publicly rebutted” in its AAMP scope clarification. The FAQ now says the two bodies’ work is “neither identical nor cleanly divided into non-overlapping layers,” and that AAMP “is not wire-compatible with AdCP.” Tech Lab’s clarification concedes the overlap from its side while rejecting the idea that the frameworks are complementary; both halves are quoted below. Part 1 argued that the layer story was half wrong. Both bodies now say so too.
“One buying agent” as a demand proxy. The AdCP registry has grown from 21 agents to 35 across 26 member listings as of November 9: 28 sales, 4 signals, 1 creative, 1 buying and 1 untyped. Part 1 read the single buying agent as a thin demand side. That was too strong, and the alternative isn’t better: the registry undercounts buyers, and the named transactions in the ledger below are self-reported. Demand on both sides is unmeasured.
AAO’s election. Part 1 said AAO’s elections were pending. AAO announced a founding board on September 28, 2026: 21 director seats across marketers and agencies, publishers and technology providers, plus Board President Benjamin Masse of Triton Digital. Its governance page calls this “an appointed initial board.” The repository’s charter still says an elected board replaces the interim one at a first annual general meeting “scheduled for May 6, 2026.” I’m not alleging a missed election: I found no record either way, and the charter describes itself as a discoverability document that follows the underlying governance. It is stale against AAO’s own website. Masse told me on Slack on October 27 that the charter is out of date and the copy will be fixed, and gave a date on the record: “New elections will happen before the end of Q2 2027.”
The redrawn map below uses three labels. “Native” means a surface is specified in the standard’s own documents or reference code, which says nothing about adoption. “Draft” means published for comment and not ratified. “Experimental” means the standard itself says the shape may change. AdCP’s column mixes stable 3.2 surfaces with 3.3 additions, and those additions are a beta, mostly experimental. In the outcomes band, AdCP specifies delivery reporting and AAMP’s reference agents pass through platform reports; neither establishes a validated attribution service.
What OpenProposal is
OpenProposal describes what a seller is offering in a shape a buying agent can parse and act on. A proposal carries identity, an offer window, a lifecycle status and the sales pitch. Beneath it sit line items, each self-contained and in exactly one channel. A seller can publish a “standard proposal” with no brief, or build a “custom proposal” in answer to one.
The draft’s distinctive idea is mutability: which values each side may change. It defines seven basic markers and assigns one to each field, with two composite fields marked mixed. A selectable field lists the options a seller offers, which are included in the base rate, and an optional price delta for each extra option. A settable field gives the buyer a range to choose inside. A requestable field lets the buyer ask for something outside the declared space, and only those need the seller to answer. The draft’s appendix counts 71 fields, 23 touched by the buyer, of which 3 require a round trip. Its README states the design claim: “Composition is constraint satisfaction, not negotiation.”
The draft is explicit about where a deal goes next. Each line item lands in an existing Tech Lab standard according to its transaction_mechanism. Direct buys go to OpenDirect 2.1. Programmatic guaranteed deals add the Deals API. Private marketplace deals use the Deals API with OpenRTB 2.6, and the open auction uses OpenRTB alone. That is part 1’s retrofit thesis, stated by the spec itself.
OpenProposal is a public-comment draft. The repository says “Nothing here is a ratified IAB Tech Lab standard.” There is no machine-readable schema; one “will follow the first revision.” The governance file lists the working group, chairs, editors and decision rule as TBD. Comments opened September 22 and Tech Lab has extended the period to November 10, citing “overwhelming feedback.” As of November 9 the tracker holds 118 issues from 26 accounts, all open. No dispositions, the published decisions on comments, have appeared yet, which is expected while the period runs. Commenters have started drafting the text themselves: Postindustria has opened 20 pull requests against the draft, 17 of them on November 4 and 5. None has merged, and the specification itself hasn’t changed since September 24. The release said OpenProposal “will be built into the Buyer and Seller Agent SDK reference implementations.” Searches of the buyer-agent and seller-agent repositories find no reference to it yet. The AAMP hub’s README now lists it as an AAMP repository.
What AdCP did at the same step
AdCP’s proposal model, stable since 3.2, works through successive versions. The negotiation guide calls it “an immutable-snapshot workflow.” A buyer opens with request_proposals, which takes a brief and structured criteria. It then pushes back through refine_proposals, using typed constraints (budget, CPM ceiling, impression floor, flight dates, product changes) and a free-text ask. Each successful refinement returns a new snapshot linked to its source, with a terms_digest: a hash that lets either side check the commercial terms haven’t changed. It covers the commercial terms only, not the whole proposal or its negotiation history. A draft is a soft avail, a preliminary availability estimate that reserves nothing.
Finalizing commits the terms. By default it also reserves inventory until expires_at; a seller that declares terms-only semantics commits the terms without a hold, and the expiry is then just the acceptance window. Accepting must present the exact digest, and only then does a media buy exist. For published offers AdCP has a separate path, list_products and buy_products, which its docs describe as reading “a wholesale offer feed” and buying “without proposal negotiation.”
One part of this is unsettled in AdCP’s own docs. The guide’s overview says “a finalize returning different pricing or forecast values than its source draft showed is correct behavior, not an error.” Its normative section says compact finalize “copies the draft’s complete commercial_terms unchanged into a committed snapshot.” PR #7960, the same PR that shipped definition pins, names this as the guide’s “finalize re-prices” contradiction and leaves it for a separate fix. In my reading, the normative rule is the one that binds: compact finalize preserves the terms. The overview sentence conflicts with it and is still waiting for its fix.
The 3.3 beta deepens this model:
- Definition pins, for two betas. In beta.0 and beta.1, sellers had to pin the covered third-party definitions their new-buy and amendment proposals reference, such as a publisher’s format option, placement or collection, or a data provider’s signal, and a covered definition that changed after commitment failed acceptance with
REFERENCE_DEFINITION_CHANGED. AdCP then withdrew pins from 3.3 and planned them for 4.0, because it keepscommercial_termsclosed within 3.x: otherwise a 3.2 buyer could accept a term it silently ignored. - Holds you can plan. Products and proposals can disclose a hold policy before the buyer finalizes, and a hold can be extended. Both are experimental.
- Open opportunities. A buyer can keep an opportunity open and let sellers send later proposals (experimental).
- Expected confirmation time on submitted buys, and a new
sales-fixed-ratespecialism for sellers who publish a fixed price without reserving inventory.
The beta release notes say it is for “development and staging, not production” and that “SDK support follows this cut.” Most of the new surfaces are experimental, which in AdCP means their shapes may change between 3.x releases. In short, OpenProposal is a public-comment draft without a schema or SDK integration, and AdCP 3.3 is a beta whose SDK support followed the protocol. Five more betas followed through November 7, and a maintainer has targeted a release candidate for November 16.
AdCP is reading OpenProposal
On August 15, AdCP merged #6547, which structured its proposal-refinement negotiation and noted: “A parallel scan of IAB Tech Lab’s AAMP confirmed no shape changes are needed for future interop,” because AAMP’s negotiation surface typed a single price dimension. On August 13, two days before that merge and more than a month before the OpenProposal draft appeared, O’Kelley had opened #6509, an RFC for a typed way to declare which dimensions of a proposal the seller will revise. In my reading that is close to OpenProposal’s mutability idea, so some of the convergence is independent. It is not one of the four September RFCs (definition pins, hold policy, price adjustments and priced alternatives), and none of them cites it.
On September 22, Tech Lab announced the OpenProposal draft. On September 23, four AdCP RFCs were filed from Brian O’Kelley’s GitHub account, each citing a section of the draft at commit cd63a329. That commit is dated September 20, but it was still the repository’s latest commit when the RFCs were filed; the next one landed September 24. So the RFCs cite the draft as published. A commit date records when the commit was made, not when the repository became visible, and I found nothing suggesting earlier access.
O’Kelley is CEO and co-founder of Scope3, per his GitHub profile, and by far the AdCP repository’s most prolific contributor: 4,927 commits against 259 for the next, on GitHub’s contributor count as of November 9. So the borrowing starts with the person who writes most of AdCP.
Commit counts show activity, not authority, so who decides what ships? AdCP’s specification lifecycle requires an approved RFC for a material change. It gives Draft-stage decisions to the domain working-group lead and graduation from experimental to stable to an “architecture committee.” The working-group charter that sets voting and quorum is, in the doc’s words, “under active development.” AAO’s working-groups page does name leads: the group that covers discovery and proposals, Campaign Lifecycle, lists O’Kelley as its only lead, and I found no architecture committee among the 30 committees it lists.
What happened in these cases is on GitHub. O’Kelley filed all four RFCs and closed the two that shipped first. He authored and merged the implementing pull requests: #7960 for definition pins, and #8140 and #8097 for hold policy and hold extension. The only other review on those three is a comment from an account named aao-secretariat; none carries another person’s approval. The beta itself shipped through #7897, a release PR opened by AdCP’s release bot, which O’Kelley approved and merged. Of the two features, hold policy is experimental and hasn’t been through graduation; definition pins shipped as a regular 3.3 surface, inside a beta. So on the public record this is one author’s choice, carried through AdCP’s release tooling into a tagged beta. Any review that happened elsewhere, in working-group calls or Slack, isn’t visible in the repository.
What the four RFCs took
- #7660, definition pins. Takes OpenProposal’s version-pinned catalog references (§2.2). Changes the scope: OpenProposal pins the seller’s own catalog entries, while AdCP pins third-party definitions such as a publisher’s format option or a data provider’s signal, and explicitly doesn’t pin the seller’s own data. Closed as completed October 6; shipped in beta.0 and beta.1 as
definition_pins, then withdrawn from 3.3 on October 29 (#8537) and planned for 4.0. - #7661, hold-policy disclosure. Takes the idea of exposing hold availability and duration before a hold is requested (§5.6.2). Declines OpenProposal’s per-line-item hold state machine: the RFC says AdCP “should preserve its atomic proposal-level finalize semantics.” Closed as completed October 14; shipped as experimental
hold_policyandextend_hold. - #7659, price adjustments for buyer-selectable dimensions. Takes per-option price deltas (§3.1). Adds what the RFC says the draft lacks: rules for how several adjustments combine. O’Kelley recorded a decision on working-group input on October 24, and #7955 shipped it in beta.1 as experimental
price_adjustments. He closed the RFC October 31 and reopened it November 7, writing that the field won’t ship in 3.3.0 in that form; a November 9 working-group decision put that withdrawal back under review. - #7662, priced alternatives for commercial terms. Takes OpenProposal’s selectable, priced cancellation, exclusivity, measurement and remedy terms (§5.6–5.7). Narrows them to a bounded slice, explicitly “not a generic option framework for every contract field,” and leaves open whether exclusivity can be selectable at all. Open; moved to 3.4 in October and to 4.0 on November 8.
The receipts: four RFCs, one day after the draft
So this is adoption with adaptation, not copying: each RFC takes one mechanism and fits it to AdCP’s snapshot model, and one explicitly declines the part that doesn’t fit. It says the OpenProposal draft contained things AdCP didn’t have, which is a point for Tech Lab’s working group. It also says one person can move an idea from a rival’s draft into AdCP’s beta within a month. That’s fast. It’s also a governance fact: on this record, the speed came from one author’s pace, not from a multi-party process.
The record since late October shows more process, and less permanence. O’Kelley’s October 24 decision to ship price adjustments cites input from three groups, Masse’s among them, and set an objection deadline of October 30; none came. The withdrawals followed a different rule. Definition pins came out after beta.1 because commercial_terms stays closed within 3.x, and AdCP’s 3.3 notes tie that rule to adcp#8501, an issue about closed schemas that Postindustria’s Mirin, the most prolific commenter on OpenProposal’s tracker, filed on October 26. Further withdrawals wait on consent windows, and on November 9 the working group changed course, deciding to reopen 3.x schemas that were meant to be open and to re-triage what 3.3 keeps. The changes that shipped or came out were still written and merged from O’Kelley’s account, but the decisions now cite a group.
Masse read a draft and asked that the piece not be read as a case for convergence. “To be clear: we have no plans to merge the standards or the organisations,” he wrote on Slack. “We won’t ignore good ideas, and we won’t add friction for implementers who run both. But our scope and roadmap are independent.” He added that AAMP’s move into this space “doesn’t change who sets AdCP’s direction or how representative that process is.” That last point is the one the GitHub record above tests. In the first two cases the direction came from one author; in the later ones it came from the same author citing group input. The working-group charter that would make the process representative is still being written.
I can’t yet measure traffic in the other direction. The comment period closes on November 10, and with no dispositions published and none of the proposed changes merged, no contributor proposal can be treated as adopted. AdCP does come up in the tracker. An in-app and CTV exchange commenting on #14 describes selling “over AAMP and AdCP; we run the seller side of both today.” And on October 24, the buy-side planning platform Hypermindz filed #113, which I come back to below. Hypermindz has a stake in the answer: it says it would build on AdCP today.
None of this is a joint effort. Tech Lab’s scope clarification holds both halves of its position in one piece. It concedes “The object names and abstractions differ, but the business functions overlap,” and it rejects the bridge: “Shared MCP support does not make the frameworks complementary” and “No normative AdCP-to-AAMP decomposition or interoperability contract establishes this relationship.” AdCP’s FAQ says AAMP isn’t wire-compatible. I found no published joint statement, liaison or interoperability agreement. Part 1 said the war was between the bodies and the companies were hedging. Three months later there is still no public bridge between the bodies. AdCP’s most active author is openly borrowing from the other side. One of those ideas, hold policy, is in AdCP’s current beta; the other three are in 4.0’s queue or under review.
Two ways to handle a change
Both standards support published offers and responses to briefs, so the useful comparison is how each handles a change. In OpenProposal, the buyer changes things by choosing inside a declared offer: the seller states the option space and its prices up front, and the buyer’s agent composes. The draft’s first open question asks whether sellers can work that way: “Does per-field mutability belong in 3.0?” In AdCP, the seller issues a successor proposal: the buyer asks, with typed constraints and prose, and the seller answers with a new version.
One change, two ways
-
1The seller makes an offer
OpenProposal 3.0 draft-1
CTV line item$24 CPM baseA · includedB · +$2C · +$3floor $21The seller declares the option space up front:
available[],included[]and apricingdelta for each extra option, plus an optionalfloor.AdCP 3.2 · 3.3 beta
request_proposalsdraft v1$24 CPMterms_digest a1f…A brief goes in and a draft snapshot comes back. A draft is a soft avail: it reserves nothing.
-
2The buyer adds option B
OpenProposal 3.0 draft-1
A · includedB · +$2C · +$3composed locally$24 + $2 = $26A
selectablechoice resolves without seller assent, so the buyer’s agent prices it itself. No round trip.AdCP 3.2 · 3.3 beta
refine_proposals · askv2 · parent v1$26 CPMterms_digest 7c2…3.2 has no general price table for options, and 3.3's experimental one is under review, so the change is an ask, and the seller answers with a successor snapshot.
-
3The buyer pushes for $22
OpenProposal 3.0 draft-1
floor $21counter $22no field to write it inThe floor says the seller would consider $21, but the buyer has nowhere in the object to write $22 (issue #30).
AdCP 3.2 · 3.3 beta
refine_proposals · constraints.cpm ≤ 22v3 or declinedthe seller’s callA typed CPM ceiling. The seller answers with another successor, or declines.
-
4The buyer commits
OpenProposal 3.0 draft-1
commitmentidempotency_keyassentbuyer ✓ · seller ?signature: WS1, deferredThe buyer sets
commitment. Postindustria argues a resolved commitment “is an offer until the seller accepts” (#67), and the assent signature scheme is deferred.AdCP 3.2 · 3.3 beta
refine_proposals · finalizecommittedterms lockedinventory held to expires_atFinalize commits the terms and, by default, holds inventory until
expires_at. -
5The deal closes
OpenProposal 3.0 draft-1
lands by transaction_mechanismOpenDirect 2.1 · Deals API · OpenRTB 2.6the calls that carry itnot defined (#113)Each line item lands in an existing Tech Lab standard. The draft defines no operation that carries the commitment or the assent between agents.
AdCP 3.2 · 3.3 beta
accept_proposal · exact terms_digestmedia buycreated on acceptAccept must present the exact digest; only then does a media buy exist.
Each model has a gap the other fills, which fits the direction the borrowing has taken so far. AdCP has no general table for saying “this option costs $2 more.” Selectable signal options already carry prices, and a seller can split inventory into separately priced products, but #7659 says that modeling each price-bearing value as another product or another discovery round trip “makes otherwise selectable dimensions expensive to use.” OpenProposal’s gap runs the other way. It keeps history as an append-only log inside a single mutable object, and #45 shows the consequence: a seller revision can change a billable term with no history entry. Its assent record uses a signature scheme the draft assigns to “WS1,” a workstream yet to report.
| OpenProposal 3.0 draft-1 | AdCP 3.3 betas | |
|---|---|---|
| Offer unit | Proposal plus self-contained line items, one channel each (§2, §5) | Proposal snapshot whose commercial_terms.purchases[] name a product and a pricing option |
| Customizing | 20 of 23 buyer-touched fields resolve against declared bounds; 3 are requestable (Appendix B) | Typed constraints and a free-text ask in refine_proposals; the seller returns a successor snapshot |
| Price by option | Per-option deltas on any selectable field (§3.1) | No general adjustment table in 3.2; an experimental one from RFC #7659, citing §3.1, shipped in beta.1 and is under review |
| Buyer’s counter | No field for a counter-price (#30, open) | A constraints.cpm ceiling, or the ask |
| History | One object: integer version plus append-only negotiation_history[] (§4.1) | Successor snapshots linked by parent_proposal_id; terms_digest over commercial terms |
| Holds | hold_status is requestable, with a state machine (§5.6.2) | Finalize commits terms and holds inventory by default; experimental hold_policy, via #7661 |
| Third-party definitions | Seller-catalog references version-pinned (§2.2) | definition_pins, via #7660, in beta.0 and beta.1; withdrawn until 4.0 |
| Commitment | commitment with an idempotency_key; assent signature scheme deferred to WS1 (§4.1, §5.6.1) | accept_proposal with the exact digest and an idempotency_key |
| Lands in | OpenDirect 2.1, Deals API or OpenRTB 2.6 (§1.1) | AdCP’s own media-buy lifecycle |
| Operations | Not defined (#113) | request_proposals, refine_proposals, accept_proposal, list_proposals over MCP and A2A |
| Priced terms | Cancellation, exclusivity, measurement, remedy and reporting are selectable and priced (§5.6–5.7) | RFC #7662 open, moved to 4.0 |
What the round-trip claim leaves open
The draft’s README asks readers to test its headline ratio: “That ratio is the design claim the draft is asking you to test.” So far the tracker contains worked counterexamples and limited implementation tests, including desk tests that IAB Australia posted on November 9 against the open pull requests. I found no end-to-end benchmark of buyer–seller traffic.
Two caveats before the critiques. First, the comparison isn’t like for like: a draft in open comment collects its defects in public all at once, while a beta’s are spread across RFCs, many already closed. Second, the criticism is concentrated. Five accounts filed 80 of the 118 issues, and Constantine Mirin of Postindustria, whose filings describe it as an IAB Tech Lab member, filed 32 alone. Concentration doesn’t weaken a worked counterexample, though: #30 and #2 stand or fall on their own examples. The other 38 issues look different in kind: most ask for specific fields, such as typed geo codes, app identity, content language, and privacy or verification attestations. A few make model-level points, such as #45, which notes that a seller revision can change a billable term with no history entry. AdCP’s history is concentrated too, around O’Kelley’s account.
The sharpest challenge is about price. The draft gives every price key a seller-set or derived marker, and describes the seller’s floor as a field that “Enables a requestable counter to be evaluated without a round trip.” As #30 points out, “The counter it refers to has no field.” A buyer told the seller will consider anything down to $21 has nowhere in the object to write $22. The commenter describes four extra exchanges in one worked scenario. Related issues flag a missing key for the buyer’s selection (#22), creative assets not checked against selected formats (#32), and derived values only the seller can compute (#35).
Two challenges go to the model itself. A choice can be valid on its own but fail in combination. In one example on #2, both audiences and both activation routes are allowed, yet one pairing can’t be delivered: “The per-field model needs a rule for combinations of choices.” Postindustria’s #67 argues that a resolved commitment “is an offer until the seller accepts.” Postindustria also reports building a deterministic extractor to turn the draft into a schema (#121): every table parsed, but “33 points can’t be derived and have to be guessed.”
The proposed fixes are being tested too. A suggested counter-price formula in #30 started from the buyer’s $30 offer and added the option charges again, landing at $38.50 against a composed rate of $32.50; another commenter caught it. A draft pull request, #117, ships 60 fixed calculation vectors for price selection and fees. It states that a successful calculation does not “establish seller acceptance, reserve inventory or authorize a commitment,” and a reviewer has already challenged its coverage of minimum-spend cases.
AdCP’s tracker has open problems at the same layer, though they are mostly missing features rather than defects in what has shipped, so this still isn’t like for like. Mirin also filed adcp#7403, arguing that get_products “cannot be implemented as a compatibility facade over the 3.2 compact tools” that the proposal lifecycle uses; it is still open, and it is a defect claim. The rest are RFCs. #6509, a typed declaration of which proposal dimensions a seller will revise, is still open, and so is #7064, the epic for everything after acceptance: payment terms, settlement, disputes, credits and makegoods. Two others closed on October 31 after experimental versions shipped in the 3.3 betas: #8086, on hold extension, ranking between competing holds and holds on specific installments, and #8087, on letting a seller propose changes to a signed buy, such as a reschedule or a delivery remedy, part of which moved to 4.0.
My read, on both: OpenProposal aims for local composition, but the counterexamples still need resolving, and the draft hasn’t settled what happens at commitment: it marks commitment as settable while separately requiring assent records, and Postindustria argues that local resolution must be separated from seller acceptance. AdCP specifies its commitment path, but its overview contradicts its own finalize rule, a compatibility defect claim is open against its proposal tools, and most of the post-acceptance lifecycle is still RFC work.
An object without a protocol
The most important gap in OpenProposal isn’t a field. The draft defines what an offer is and which states it moves through, but not the calls that move it, or which protocol carries them. #113 puts it this way: “two implementations can agree on every field and still not interoperate.” It lists the operations the draft implies without naming: fetch a summary or the full proposal, request a value, counter, accept, decline, withdraw, request and release a hold, commit, and assent. It doesn’t ask the draft to define a wire protocol. It asks for an operations table and one sentence naming where the binding lives, and it says what happens otherwise: “We would bind it to AdCP’s get_products / request_proposals / create_media_buy today, and so would others. That is the fragmentation AAMP set out to avoid.”
Three candidates are on the table:
- A Tech Lab staff member’s change request, #29 (October 8), with draft PR #76 (October 22), proposes a static manifest at
/.well-known/openproposal.jsonfor discovering standard proposals. The PR is marked “Do not merge until the working group confirms the disposition of #29.” It covers discovery but not negotiation. - The AAMP agents themselves, or Agentic Direct, the orchestration repository, could carry the operations. Postindustria asked on #113 which repository will, and no Tech Lab reply had appeared by November 9.
- Implementers could do what #113 predicts.
Part 1 noted that nobody had built a bridge between the two stacks. This is the first public proposal to use one standard to carry the other’s object, and it comes from an implementer, not from either body.
Who is actually transacting
Part 1 used the registry as a demand proxy. Here instead is the public record of named activity, sorted by how far each item got. None of it has audited spend figures, and the sources are the participants or AAO.
| Standard | What | How far it got | Source |
|---|---|---|---|
| AdCP | PubMatic and Butler/Till, a CTV campaign for Geloso’s Clubtails; brief entered through Claude, executed through PubMatic’s Activate platform | Launched, reported live | PubMatic release, Dec 15, 2025 |
| AdCP | PurePlay’s buyer agent with Swivel’s seller agent, a premium CTV holiday campaign for a “major eyewear retailer” | Ran December 2025 | Swivel case study |
| AdCP | Lyft’s Citi Bike audio buy with iHeartMedia, $5,000, “approved and booked in iHeart’s ad server” | Booked; no delivery reported | Benjamin Masse, Oct 13 (AAO’s Board President; Chief Product Officer at Triton Digital and an EVP of the iHeart Technology Solutions Group, per AAO’s board announcement) |
| AdCP (per pubX) | pubX with Reckitt’s Mucinex and three publishers, “from brief to live placement” at an Advertising Week event | Live event activation; spend and repeat use not reported | pubX, Oct 7. That post doesn’t name AdCP; pubX’s Oct 6 post says its stack is “built on AdCP” |
| AAMP | PMG’s Alli integrated with the AAMP buyer agent architecture and agent registry | Integration reported; no campaign or spend named | Tech Lab release, Apr 7 |
| AAMP | IAB Australia’s sellers pilot, pinned to AAMP 2.3 and seller-agent v2.4.2 | Sandbox: “no live spend,” synthetic data | IAB Australia FAQ, Sep 23 |
| Both | An in-app and CTV exchange selling “over AAMP and AdCP” | Self-described; employer unnamed | OpenProposal #14 |
On this record, AdCP has more named campaigns and AAMP has a reported platform integration and a sandbox pilot. The AdCP rows come from four sources: PubMatic’s release, Swivel’s case study, pubX’s two posts and one post by AAO’s board president. I found them through web searches and a research pass, not a survey of AdCP vendors, and half date from December 2025. The AAMP search was narrower, which by itself would surface fewer rows, so the row counts don’t compare. Neither has a public, audited production volume. I didn’t find a named campaign with production spend through the AAMP reference agents; that search covered Tech Lab’s and PMG’s announcements, the SDK release notes and the Australian pilot documents.
Separately, the AdCP homepage claims 159+ members and its registry lists 35 agents. Neither count measures live buying.
The AAMP SDKs did keep hardening after their last tag, as the 3.0 release said they would “continue to further harden deterministic guardrails.” These cut both ways: each is a fix, and each fixes a leak. Seller-agent PR #97, merged October 1, stopped “disclosing the seller’s floor price in chat and on every counter-offer.” Buyer-agent PR #130, merged September 17, closed “the latent LLM-booking loophole in research crews.” The clean-up is ongoing, and it was needed. Neither change is in a tagged release yet.
Smaller updates since July
Versions. AdCP 3.2 is generally available and, as of November 9, the latest stable release is v3.2.9 (November 9), and 3.3 is at v3.3.0-beta.5 (November 7). AAMP’s reference agents are at v2.4.2 (August 18), with nothing tagged since. ARTF v1.0 is still its only release, and OpenProposal was tagged v3.0-draft-1 on September 24.
One date held. Part 1 recorded IAB Tech Lab CEO Anthony Katsur putting AAMP’s next release in September. AAMP 3.0 was announced on September 22, though as a draft object plus promised SDK work. IAB Australia’s pilot FAQ said so the next day: “There is no runnable AAMP 3.0 agent software to test yet.”
What to do with this
If you sell media, map one real proposal into both shapes before you commit integration budget. Both models support published offers and responses to briefs, so test seller-declared options, brief-specific prices and live availability in both. If OpenProposal’s model doesn’t fit your inventory, say so on its tracker before comments close on November 10.
If you buy media, check commitment terms yourself before you accept. In AdCP, the negotiation guide tells buyers to recompute the digest and “Compare the recomputed digest byte-for-byte with terms_digest.” That proves the committed terms match their own digest, not that they match the draft you approved, so also diff the finalized commercial_terms against the last draft you reviewed. The guide also warns that “A matching terms_digest proves the terms are unchanged, not that the third-party definitions they name are”; definition pins, which closed that gap in the first two 3.3 betas, were withdrawn until 4.0, so check those definitions yourself. In OpenProposal, don’t treat a resolved commitment as binding until the seller’s assent record exists, and note that you can’t verify that record cryptographically yet, because the draft defers its signature scheme to workstream WS1. Treat “no round trip” as a claim about composing an offer, not closing one. If any of this blocks you, the OpenProposal tracker is open until November 10.
If you build agents, run one translation test this quarter. Take one of OpenProposal’s worked examples, such as its CTV line item, express it as an AdCP request_proposals and refine_proposals exchange, and record every field that doesn’t map. That is the question #113 raises, answered with evidence, and it is a useful comment to file before November 10. If Tech Lab’s next draft names a binding, OpenProposal gets an agreed way to move between agents; if it doesn’t, #113 expects implementers to carry the object over whatever they already speak.
What to watch next: OpenProposal’s comment period closes November 10. Its documented process promises written dispositions, and its schema follows the first revision; dates for both are unpublished. A named binding is what #113 asks for, not something Tech Lab has promised. AdCP’s maintainers have targeted a 3.3 release candidate for November 16, after a re-triage that decides which withdrawn additions return; AdCP still owes a decision on #7659 and a fix for its finalize contradiction. AdCP 4.0, the breaking-change window, is targeted for early 2027 and has no tag. Same rule as July: judge both by what lands in the repository.



