Plate 01 · Signature figure Agentic Advertising
THE PROPOSAL LAYER TECH LAB AgenticAdvertising.org OPENPROPOSAL 3.0 a seller's option space · draft-1, no schema ADCP 3.3 a chain of versioned snapshots · beta OpenProposal: the seller declares an option space, with optional price deltas per option, and the buyer composes inside it. Under the draft's field-resolution rules, requestable fields require a seller response. A public-comment draft. LINE ITEM · CTV properties +$2.00 audiences +$4.00 measurement +$1.50 cancellation +$3.00 requestable · seller responds AdCP: each successful refinement creates a new snapshot linked to its source, with a digest of its commercial terms. Finalize commits the terms; acceptance checks the digest. A protocol-first beta. draft soft avail sha256:… revised typed ask sha256:… committed terms · expires_at sha256:… Ideas crossing: AdCP RFCs that cite the OpenProposal draft. Two have shipped in the 3.3 beta; two are open. pins hold policy price deltas (open) The contested ground moved up: from the deal plane in July to the step between a brief and a commitment in October. BRIEF → COMMITMENT · THE NEW CONTESTED GROUND no published agreement between the bodies · ideas crossing anyway No published agreement between the bodies. Ideas are crossing anyway.
Agentic Advertising

AdCP vs AAMP, Part 2: AdCP Is Reading OpenProposal

The gist

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.

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.

THE ALTITUDE MAP, OCTOBER 2026 AdCP 3.3 beta AAMP 3.0 JULY 31 CONTESTED GROUND · OCTOBER 25 Brief and planning, now contested. AdCP proposal lifecycle (request_proposals, refine_proposals) and 3.3 additions; OpenProposal 3.0 draft-1. Details in the two sections that follow. BRIEF & PLANNING NATIVE Proposal snapshots on the wire request · refine · hold policy · open opportunities DRAFT OpenProposal 3.0 on the wire 71 fields · no schema · no operations yet Deal and campaign, contested since July. AdCP: finalize commits the terms and, by default, holds inventory until expires_at (terms-only sellers commit without a hold); accept_proposal checks the terms digest and creates the MediaBuy. AAMP: OpenDirect 2.1 avails and quotes, negotiation messages since seller-agent v2.1.1, booking into Deal IDs. DEAL & CAMPAIGN NATIVE finalize → accept terms committed · hold by default · digest-checked NATIVE OpenDirect 2.1 negotiate · book negotiation messages since v2.1.1 · Deal IDs out Impression and serve, unchanged since part 1's September addendum. AdCP: the Trusted Match profile targets sub-50ms end-to-end and is still experimental. AAMP: ARTF v1.0 containers inside the host platform, gRPC/protobuf interfaces carrying OpenRTB 2.6 data; still the only ARTF release. IMPRESSION & SERVE EXPERIMENTAL Trusted Match sub-50ms target · router · package match NATIVE ARTF v1.0 in the bidstream in-cluster · gRPC/protobuf · OpenRTB data Outcomes. AdCP specifies delivery reporting; the AAMP reference agents expose pacing, spend and platform reports. Neither establishes a validated attribution service. OUTCOMES NATIVE Reporting finality on-protocol delivery reporting · vendor-metric goals (3.3) PASSTHROUGH Telemetry + platform reports pacing & spend · platform reports In July they met at the deal. Now they meet one step earlier, at the proposal.
Part 1's altitude map, redrawn. The dashed outline is July's contested zone; the solid outline is October's. "Native" means specified, not adopted at scale; neither side's outcomes band establishes validated attribution; ARTF v1.0 is still ARTF's only release. Hover any band for detail.

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 keeps commercial_terms closed 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-rate specialism 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_policy and extend_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

  1. GitHub issue adcp #7660, RFC: pin referenced definitions inside accepted commercial terms, closed, opened by bokelley on September 23, 2026. Highlighted: The OpenProposal 3.0 draft requires seller-catalog refs to be version-pinned and immutable, then replaced by resolved values when the proposal becomes agreed, citing section 2.2.

    #7660 · definition pins cites §2.2. Closed October 6; shipped in beta.0 and beta.1 as definition_pins, then withdrawn to 4.0.

  2. GitHub issue adcp #7661, RFC: disclose proposal hold policy before finalization, closed, opened by bokelley on September 23. Highlighted: The OpenProposal 3.0 draft exposes hold_available, hold_duration, and hold scope before the hold is requested, citing section 5.6.2; AdCP should preserve its atomic proposal-level finalize semantics while making the expected window plannable.

    #7661 · hold-policy disclosure cites §5.6.2. Closed October 14; shipped as experimental hold_policy and extend_hold.

  3. GitHub issue adcp #7659, RFC: declare price adjustments for buyer-selectable product dimensions, open, opened by bokelley on September 23. Highlighted: IAB Tech Lab’s draft OpenProposal 3.0 uses the same general idea for every selectable field, a seller declares the available and included values plus an optional per-option price delta, citing section 3.1; it does not define how multiple adjustment types compose; AdCP should.

    #7659 · price adjustments cites §3.1. Shipped in beta.1 as experimental price_adjustments; reopened November 7.

  4. GitHub issue adcp #7662, RFC: offer priced alternatives for cancellation, exclusivity, measurement, and remedies, open, opened by bokelley on September 23. Highlighted: The OpenProposal 3.0 draft makes cancellation, exclusivity, measurement source, shortfall remedy, and reporting selectable terms, with pricing where applicable, citing sections 5.6 to 5.7.

    #7662 · priced alternatives cites §5.6–5.7. Open, moved to 4.0.

The four AdCP RFCs filed on September 23, each citing the OpenProposal draft at commit cd63a329 (highlight added). Captured from GitHub on October 27, 2026, so the status chips are as of that day. Select a frame to open the issue.

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.

IDEAS CROSSING, AUGUST TO NOVEMBER 2026 ADCP IAB TECH LAB · OPENPROPOSAL AUG 15 SEP 15 OCT 1 NOV 10 15 August 2026, adcp#6547 (merged): structures proposal-refinement negotiation; "A parallel scan of IAB Tech Lab's AAMP confirmed no shape changes are needed for future interop." AAMP scan: no shape changes #6547 23 August 2026, adcp#6801: retires the "agentic bidding vs agentic buying" framing after Tech Lab's scope clarification; the FAQ now acknowledges overlap. FAQ: overlap acknowledged #6801 22 September 2026: IAB Tech Lab announces AAMP 3.0 with the OpenProposal draft for public comment. The draft-1 tag follows on 24 September. AAMP 3.0 · OpenProposal draft Sep 22 20 September 2026: commit cd63a329 in the OpenProposal repository. The 23 September AdCP RFCs cite the draft at this commit, which was still the latest one when they were filed; the next commit landed 24 September. commit the RFCs cite Sep 20 23 September 2026, the day after Tech Lab's announcement: four AdCP RFCs (#7659, #7660, #7661, #7662) filed from Brian O'Kelley's account, each citing a section of the OpenProposal draft at a 20 September commit. 4 RFCs cite the draft #7659 · #7660 · #7661 · #7662 Sep 23, day after the launch 6 October 2026: #7660 (definition pins) closed as completed, implemented by PR #7960 (which also flags the guide's finalize contradiction for a separate fix). pins RFC closed Oct 6 14 October 2026: #7661 (hold-policy disclosure) closed as completed; hold_policy and extend_hold ship as experimental. hold-policy RFC closed Oct 14 22 October 2026: AdCP v3.3.0-beta.0 tagged. For callers negotiating 3.3, definition_pins are required for covered references in new-buy and amendment proposals. 3.3 beta ships pins Oct 22 24 October 2026: OpenProposal issue #113, filed by Hypermindz, asks for an operations table and a named binding, and says Hypermindz would otherwise carry OpenProposal over AdCP's operations. #113: "bind it to AdCP" Oct 24 · Hypermindz 25 October 2026: 101 OpenProposal issues, all open; the disposition log reads "No dispositions yet." The comment period runs to 10 November, so none are expected yet. Oct 25: 101 issues, 0 dispositions (period open) 10 November 2026: OpenProposal public comment now closes, extended from 22 October. comments close Nov 10 (was Oct 22) One day from announcement to citation. A month from citation to beta.
Every event on this timeline is a public issue, PR, commit, tag or release cited in the text. Its markers run to October 25, plus the November 10 close; definition pins were withdrawn from 3.3 on October 29. Hover a marker for details.

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

  1. 1The seller makes an offer

    OpenProposal 3.0 draft-1

    CTV line item$24 CPM baseA · includedB · +$2C · +$3floor $21

    The seller declares the option space up front: available[], included[] and a pricing delta for each extra option, plus an optional floor.

    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.

  2. 2The buyer adds option B

    OpenProposal 3.0 draft-1

    A · includedB · +$2C · +$3composed locally$24 + $2 = $26

    A selectable choice 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.

  3. 3The buyer pushes for $22

    OpenProposal 3.0 draft-1

    floor $21counter $22no field to write it in

    The 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 call

    A typed CPM ceiling. The seller answers with another successor, or declines.

  4. 4The buyer commits

    OpenProposal 3.0 draft-1

    commitmentidempotency_keyassentbuyer ✓ · seller ?signature: WS1, deferred

    The 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_at

    Finalize commits the terms and, by default, holds inventory until expires_at.

  5. 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 accept

    Accept must present the exact digest; only then does a media buy exist.

One buyer change, step by step, in each standard. Prices and digests are illustrative; field and call names are from OpenProposal 3.0 draft-1 and AdCP 3.2 and 3.3. Use the arrows or the numbers to step through.

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.

TWO PROPOSAL MODELS, FIELD BY FIELD OPENPROPOSAL 3.0 · draft-1 ADCP 3.3 · betas Offer unit. OpenProposal §2, §5; AdCP proposal snapshot. Proposal + self-contained line items, one channel each OFFER UNIT Snapshot; purchases[] = product + pricing option Customizing. OpenProposal Appendix B; AdCP refine_proposals. 20 fields resolve locally against declared bounds CUSTOMIZING Typed constraints + ask → seller returns new snapshot Price by option. OpenProposal §3.1; AdCP RFC #7659. Per-option price deltas on any selectable field PRICE BY OPTION Exp. table in beta.1 (#7659); under review Buyer's counter. OpenProposal §5.6 and issue #30; AdCP refine_proposals constraints. No field for a counter-price (#30 open) BUYER'S COUNTER constraints.cpm ceiling, or the ask History. OpenProposal §4.1; AdCP negotiation guide. One object: version + append-only history HISTORY Successor snapshots, parent link, terms digest Holds. OpenProposal §5.6.2; AdCP refine_proposals hold policy, via RFC #7661. hold_status: requestable, with a state machine HOLDS Finalize commits; hold by default; hold_policy (exp.) Definitions. OpenProposal §2.2; AdCP definition pins, via RFC #7660, in beta.0 and beta.1, withdrawn until 4.0. catalog_ref, version-pinned (§2.2) DEFINITIONS definition_pins in beta.0–1; withdrawn to 4.0 Commitment. OpenProposal §4.1, §5.6.1; AdCP accept_proposal. commitment + idempotency_key; assent scheme TBD COMMITMENT accept_proposal + exact digest → MediaBuy Lands in. OpenProposal §1.1; AdCP media-buy lifecycle. OpenDirect 2.1 · Deals API · OpenRTB 2.6 LANDS IN AdCP's own MediaBuy lifecycle Operations. OpenProposal issue #113; AdCP task reference. Not defined (#113) OPERATIONS request · refine · accept · list over MCP / A2A Priced terms. OpenProposal §5.6–5.7; AdCP RFC #7662. Cancellation, exclusivity, measurement: priced PRICED TERMS RFC #7662, open (4.0) → idea borrowed from the OpenProposal draft (cited in the AdCP RFC)
The two proposal models side by side, updated November 9. Highlighted text marks a gap; arrows mark an idea AdCP took from the OpenProposal draft. The same comparison follows as a table; hover any row for section numbers.
OpenProposal 3.0 draft-1AdCP 3.3 betas
Offer unitProposal plus self-contained line items, one channel each (§2, §5)Proposal snapshot whose commercial_terms.purchases[] name a product and a pricing option
Customizing20 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 optionPer-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 counterNo field for a counter-price (#30, open)A constraints.cpm ceiling, or the ask
HistoryOne object: integer version plus append-only negotiation_history[] (§4.1)Successor snapshots linked by parent_proposal_id; terms_digest over commercial terms
Holdshold_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 definitionsSeller-catalog references version-pinned (§2.2)definition_pins, via #7660, in beta.0 and beta.1; withdrawn until 4.0
Commitmentcommitment 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 inOpenDirect 2.1, Deals API or OpenRTB 2.6 (§1.1)AdCP’s own media-buy lifecycle
OperationsNot defined (#113)request_proposals, refine_proposals, accept_proposal, list_proposals over MCP and A2A
Priced termsCancellation, 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:

  1. 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.json for 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.
  2. 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.
  3. 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.

AN OBJECT WITHOUT A PROTOCOL Buyer agent: under OpenProposal 3.0 draft-1, it can parse and compose an offer, but the draft does not say which call fetches a proposal, sends a counter, requests a hold or records assent. buyer agent Seller agent: publishes standard proposals or answers briefs with custom ones. A search of the AAMP seller-agent repository finds no reference to OpenProposal as of 25 October 2026. seller agent The OpenProposal object: proposal plus line items, 71 fields with mutability markers, a status lifecycle and an append-only negotiation history. The states are defined; the transitions between them are not tied to any call. OpenProposal states defined · calls not OPERATIONS THE DRAFT IMPLIES BUT NEVER NAMES (#113) fetch request counter accept decline withdraw hold commit assent THREE WAYS IT COULD BE FILLED Candidate 1: a static manifest at /.well-known/openproposal.json, then fetching shortlisted proposals. Proposed by a Tech Lab staff member in issue #29 (8 October) with draft PR #76 (22 October), which awaits a working-group disposition. Covers discovery only, not counters, holds or assent. Static manifest /.well-known/openproposal.json #29 · draft PR #76 discovery only Candidate 2: the AAMP buyer and seller agent protocol, or Agentic Direct, the AAMP orchestration repository. Postindustria asked on #113 which repository will carry the operations; no Tech Lab reply had appeared by 25 October 2026. AAMP agents / Agentic Direct the binding Tech Lab hasn't named asked on #113 no answer yet Candidate 3: AdCP's existing operations. Hypermindz, a buy-side planning platform, wrote on #113 (24 October 2026) that without a named binding it would carry OpenProposal over AdCP's get_products, request_proposals and create_media_buy, and expects others to do the same. AdCP operations get_products · request_proposals create_media_buy "bind it to AdCP today" Two implementations can agree on every field and still not interoperate.
What OpenProposal defines, what it leaves out, and the three ways the gap could be filled. Hover each candidate for the source.

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.

StandardWhatHow far it gotSource
AdCPPubMatic and Butler/Till, a CTV campaign for Geloso’s Clubtails; brief entered through Claude, executed through PubMatic’s Activate platformLaunched, reported livePubMatic release, Dec 15, 2025
AdCPPurePlay’s buyer agent with Swivel’s seller agent, a premium CTV holiday campaign for a “major eyewear retailer”Ran December 2025Swivel case study
AdCPLyft’s Citi Bike audio buy with iHeartMedia, $5,000, “approved and booked in iHeart’s ad server”Booked; no delivery reportedBenjamin 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 eventLive event activation; spend and repeat use not reportedpubX, Oct 7. That post doesn’t name AdCP; pubX’s Oct 6 post says its stack is “built on AdCP”
AAMPPMG’s Alli integrated with the AAMP buyer agent architecture and agent registryIntegration reported; no campaign or spend namedTech Lab release, Apr 7
AAMPIAB Australia’s sellers pilot, pinned to AAMP 2.3 and seller-agent v2.4.2Sandbox: “no live spend,” synthetic dataIAB Australia FAQ, Sep 23
BothAn in-app and CTV exchange selling “over AAMP and AdCP”Self-described; employer unnamedOpenProposal #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.

Evgeny Popov
Evgeny Popov · FounderNew York
About the author

Evgeny Popov

Builder at heart, global operator by experience. 25+ years scaling AdTech, MarTech, and data businesses across five regions. Three exits. AdCP Founding Member, former IAB leader, DMEXCO columnist. Currently Global Head of Enterprise at Samba TV and founder of No Fluff Advisory.

Ad · served by our AdCP stack