---
title: "AdCP vs AAMP, Part 2: AdCP Is Reading OpenProposal"
date: 2026-11-10
summary: "OpenProposal and AdCP now address the same step: turning a media brief into a proposal. I compare their models, trace four AdCP RFCs that cite the OpenProposal draft, and check what each standard has shipped, left open and put into use."
standfirst: "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. 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."
canonical: https://nofluffadvisory.com/writing/adcp-vs-aamp-part-2/
---

*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](https://github.com/adcontextprotocol/adcp/issues/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](/writing/adcp-vs-aamp/) 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](https://www.prnewswire.com/news-releases/iab-tech-lab-introduces-aamp-3-0-to-standardize-the-rfp-to-buy-process-for-agentic-advertising-302885348.html), built around a new draft object called [OpenProposal](https://github.com/IABTechLab/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](https://github.com/adcontextprotocol/adcp/releases/tag/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](https://github.com/IABTechLab/seller-agent/releases/tag/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](https://github.com/adcontextprotocol/adcp/pull/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](https://iabtechlab.com/clarifying-the-aamp-scope-why-so-many-aamp-vs-adcp-comparisons-miss-the-mark/). The [FAQ](https://github.com/adcontextprotocol/adcp/blob/main/docs/faq.mdx) 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](https://adcontextprotocol.org/api/registry/agents) 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](https://agenticadvertising.org/perspectives/agenticadvertisingorg-names-benjamin-masse-president-solidifies-founding-board-with-leaders-from-wpp-mult54ru) 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](https://agenticadvertising.org/governance) calls this "an appointed initial board." The repository's [charter](https://github.com/adcontextprotocol/adcp/blob/main/CHARTER.md) 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.

> [figure: The altitude map from part 1, redrawn for October 2026. Four bands from top to bottom: brief and planning, deal and campaign, impression and serve, outcomes. A dashed outline marks the July contested zone around the deal band only; a solid gold outline drawn on top now spans both the brief-and-planning band and the deal band. AdCP 3.3, on the left, is native in brief and planning with proposals and typed refinement, plus experimental hold policy and open opportunities; native in the deal band; experimental in serve through Trusted Match; native in outcomes. AAMP 3.0, on the right, shows OpenProposal as a draft on the wire in brief and planning, with no schema and no operations; native deal-stage negotiation over OpenDirect 2.1; native ARTF in the bidstream; and passthrough telemetry for outcomes.]

## 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](https://github.com/IABTechLab/OpenProposal/blob/v3.0-draft-1/spec/openproposal-3.0.md#3-field-mutability) 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](https://github.com/IABTechLab/OpenProposal) 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](https://iabtechlab.com/press-releases/iab-tech-lab-introduces-aamp-3-0-with-openproposal/), 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](https://github.com/adcontextprotocol/adcp/blob/main/docs/media-buy/product-discovery/proposal-negotiation.mdx) 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](https://github.com/adcontextprotocol/adcp/pull/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](https://github.com/adcontextprotocol/adcp/blob/main/docs/reference/whats-new-in-3-3.mdx) 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](https://github.com/adcontextprotocol/adcp/releases/tag/v3.3.0-beta.0) 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](https://github.com/adcontextprotocol/adcp/pull/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](https://github.com/adcontextprotocol/adcp/issues/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](https://github.com/IABTechLab/OpenProposal/commit/cd63a32914b8ab8876a59cb64751edb98d83dd69). 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](https://github.com/bokelley), and by far the AdCP repository's most prolific contributor: 4,927 commits against 259 for the next, on GitHub's [contributor count](https://github.com/adcontextprotocol/adcp/graphs/contributors) 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](https://github.com/adcontextprotocol/adcp/blob/main/docs/reference/specification-lifecycle.mdx) 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](https://agenticadvertising.org/working-groups) 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](https://github.com/adcontextprotocol/adcp/pull/7960) for definition pins, and [#8140](https://github.com/adcontextprotocol/adcp/pull/8140) and [#8097](https://github.com/adcontextprotocol/adcp/pull/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](https://github.com/adcontextprotocol/adcp/pull/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](https://github.com/adcontextprotocol/adcp/issues/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](https://github.com/adcontextprotocol/adcp/pull/8537)) and planned for 4.0.
- [#7661](https://github.com/adcontextprotocol/adcp/issues/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](https://github.com/adcontextprotocol/adcp/issues/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](https://github.com/adcontextprotocol/adcp/pull/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](https://github.com/adcontextprotocol/adcp/issues/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.

> [figure: Previous RFC]

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](https://github.com/adcontextprotocol/adcp/issues/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](https://github.com/IABTechLab/OpenProposal/issues/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](https://github.com/IABTechLab/OpenProposal/issues/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](https://iabtechlab.com/clarifying-the-aamp-scope-why-so-many-aamp-vs-adcp-comparisons-miss-the-mark/) 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.

> [figure: Timeline from 15 August to 10 November 2026. Above the axis, AdCP events: 15 August, a scan of AAMP's negotiation surface finds no shape changes needed; 23 August, the FAQ acknowledges overlap; 23 September, four RFCs cite the OpenProposal draft; 6 October, the definition-pins RFC closes; 14 October, the hold-policy RFC closes; 22 October, the 3.3 beta ships definition pins. Below the axis, Tech Lab and OpenProposal events: 20 September, the draft commit the RFCs later cite, still the latest commit when they were filed; 22 September, AAMP 3.0 and the OpenProposal draft announced; 24 October, Hypermindz (a third party) files issue 113 saying it would bind OpenProposal to AdCP today; 25 October, zero dispositions; 10 November, comments close. An arc jumps from the OpenProposal draft on 22 September to the four RFCs on 23 September.]

## 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.

> [figure: Previous step]

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](https://github.com/adcontextprotocol/adcp/issues/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](https://github.com/IABTechLab/OpenProposal/issues/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.

> [figure: Crosswalk table comparing OpenProposal 3.0 draft-1 on the left with AdCP 3.3 beta on the right, across eleven dimensions in the middle column. Offer unit; buyer customization; price by option, where AdCP shipped an experimental table borrowed from OpenProposal, now under review; the buyer's counter, which OpenProposal has no field for; history and versioning; holds, where AdCP borrowed hold-policy disclosure; third-party definitions, where AdCP borrowed definition pins and then withdrew them until 4.0; commitment; where the deal lands; operations, which OpenProposal does not define; and priced terms such as cancellation and exclusivity, where AdCP has an open RFC borrowed from OpenProposal. Four rows carry an arrow marking an idea borrowed from OpenProposal.]

| | 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](https://github.com/adcontextprotocol/adcp/issues/7659), citing §3.1, shipped in beta.1 and is under review |
| Buyer's counter | No field for a counter-price ([#30](https://github.com/IABTechLab/OpenProposal/issues/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](https://github.com/adcontextprotocol/adcp/issues/7661) |
| Third-party definitions | Seller-catalog references version-pinned (§2.2) | `definition_pins`, via [#7660](https://github.com/adcontextprotocol/adcp/issues/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](https://github.com/IABTechLab/OpenProposal/issues/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](https://github.com/adcontextprotocol/adcp/issues/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](https://github.com/IABTechLab/OpenProposal/issues/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](https://github.com/IABTechLab/OpenProposal/issues/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](https://github.com/IABTechLab/OpenProposal/issues/22)), creative assets not checked against selected formats ([#32](https://github.com/IABTechLab/OpenProposal/issues/32)), and `derived` values only the seller can compute ([#35](https://github.com/IABTechLab/OpenProposal/issues/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](https://github.com/IABTechLab/OpenProposal/issues/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](https://github.com/IABTechLab/OpenProposal/issues/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](https://github.com/IABTechLab/OpenProposal/issues/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](https://github.com/IABTechLab/OpenProposal/pull/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](https://github.com/adcontextprotocol/adcp/issues/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](https://github.com/adcontextprotocol/adcp/issues/6509), a typed declaration of which proposal dimensions a seller will revise, is still open, and so is [#7064](https://github.com/adcontextprotocol/adcp/issues/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](https://github.com/adcontextprotocol/adcp/issues/8086), on hold extension, ranking between competing holds and holds on specific installments, and [#8087](https://github.com/adcontextprotocol/adcp/issues/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](https://github.com/IABTechLab/OpenProposal/issues/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](https://github.com/IABTechLab/OpenProposal/issues/29) (October 8), with draft PR [#76](https://github.com/IABTechLab/OpenProposal/pull/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.

> [figure: Diagram of OpenProposal as an object without a protocol. A buyer agent on the left and a seller agent on the right. Between them floats an OpenProposal document. The channel between the agents is drawn as a broken dashed pipe labeled operations undefined, with ghosted chips for the operations issue 113 says the draft implies: fetch, request value, counter, accept, decline, withdraw, hold, commit and assent. Below, three candidate bridges draw in one after another: a static well-known manifest proposed in issue 29 and draft PR 76, which covers discovery only; the AAMP agent protocol or Agentic Direct, asked about in issue 113 with no Tech Lab answer yet; and AdCP's get_products, request_proposals and create_media_buy, which Hypermindz says it would bind to today.]

## 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](https://www.businesswire.com/news/home/20251215976339/en/PubMatic-and-ButlerTill-Launch-AdCP-Enabled-Agentic-AI-Campaign-Across-) |
| 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](https://swivel.ai/agenticholidaycasestudy) |
| 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](https://agenticadvertising.org/perspectives/what-marketers-want-to-know-about-agentic-buying-mv70smkx) (AAO's Board President; Chief Product Officer at Triton Digital and an EVP of the iHeart Technology Solutions Group, per AAO's [board announcement](https://agenticadvertising.org/perspectives/agenticadvertisingorg-names-benjamin-masse-president-solidifies-founding-board-with-leaders-from-wpp-mult54ru)) |
| 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](https://pubx.ai/live-agent-to-agent-media-buy-awny/). That post doesn't name AdCP; [pubX's Oct 6 post](https://pubx.ai/pubx-series-a-compliant-acquisition/) 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](https://iabtechlab.com/press-releases/pmg-integrates-iab-tech-lab-aamp-standards-into-alli-operating-system/) |
| 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](https://www.iabaustralia.com.au/local-agentic-advertising-sellers-pilot-faqs/) |
| Both | An in-app and CTV exchange selling "over AAMP and AdCP" | Self-described; employer unnamed | [OpenProposal #14](https://github.com/IABTechLab/OpenProposal/issues/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](https://adcontextprotocol.org/) 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](https://github.com/IABTechLab/seller-agent/pull/97), merged October 1, stopped "disclosing the seller's floor price in chat and on every counter-offer." Buyer-agent [PR #130](https://github.com/IABTechLab/buyer-agent/pull/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](https://github.com/adcontextprotocol/adcp/releases/tag/v3.2.9) (November 9), and 3.3 is at [v3.3.0-beta.5](https://github.com/adcontextprotocol/adcp/releases/tag/v3.3.0-beta.5) (November 7). AAMP's reference agents are at [v2.4.2](https://github.com/IABTechLab/seller-agent/releases/tag/v2.4.2) (August 18), with nothing tagged since. ARTF v1.0 is still [its only release](https://github.com/IABTechLab/agentic-real-time-framework/releases), and OpenProposal was tagged [v3.0-draft-1](https://github.com/IABTechLab/OpenProposal/releases/tag/v3.0-draft-1) on September 24.

**One date held.** [Part 1](/writing/adcp-vs-aamp/) 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](https://www.iabaustralia.com.au/local-agentic-advertising-sellers-pilot-faqs/) 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](https://github.com/IABTechLab/OpenProposal/issues) before comments close on November 10.

**If you buy media**, check commitment terms yourself before you accept. In AdCP, the [negotiation guide](https://github.com/adcontextprotocol/adcp/blob/main/docs/media-buy/product-discovery/proposal-negotiation.mdx) 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](https://github.com/IABTechLab/OpenProposal/blob/v3.0-draft-1/examples/line-item-ctv.yaml), 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](https://iabtechlab.com/press-releases/iab-tech-lab-introduces-aamp-3-0-with-openproposal/). 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](https://github.com/adcontextprotocol/adcp/issues/7659) and a fix for its finalize contradiction. AdCP 4.0, the breaking-change window, is [targeted for early 2027](https://github.com/adcontextprotocol/adcp/blob/main/docs/reference/roadmap.mdx) and has no tag. Same rule as July: judge both by what lands in the repository.

<style>
.dcsig { width: 100%; max-width: 760px; margin-inline: auto; height: auto; display: block; }
@media (prefers-reduced-motion: no-preference) {
  .dcsig.dcsig--reveal { opacity: 0; transform: translateY(12px); }
  .dcsig.dcsig--reveal.dcsig--in { opacity: 1; transform: translateY(0); transition: opacity 0.7s ease, transform 0.7s ease; }
}
.dcsig .dcsig-hot { cursor: help; }
.dcsig .dcsig-frame { transition: stroke 0.2s ease, stroke-width 0.2s ease; }
.dcsig .dcsig-hot:hover .dcsig-frame { stroke: var(--accent, #4a5a2e); stroke-width: 2.4; }
.p2st, .p2rf { margin: 2rem 0; font-family: var(--font-sans); }
.p2st-head, .p2rf-head { display: flex; flex-wrap: wrap; align-items: center; justify-content: space-between; gap: 0.6rem 1rem; margin-bottom: 0.8rem; }
.p2st-kicker { margin: 0; font-size: 0.68rem; font-weight: 700; letter-spacing: 0.14em; text-transform: uppercase; color: var(--ink-light); }
.p2st-nav, .p2rf-nav { display: flex; align-items: center; gap: 0.35rem; }
.p2st-nav[hidden], .p2rf-nav[hidden] { display: none; }
.p2st-btn, .p2st-dot { min-width: 2rem; height: 2rem; padding: 0 0.5rem; border: 1px solid var(--rule); border-radius: 999px; background: var(--paper); color: var(--ink); font: 600 0.8rem/1 var(--font-sans); cursor: pointer; }
.p2st-btn:hover, .p2st-dot:hover, .p2st-btn:focus-visible, .p2st-dot:focus-visible { border-color: var(--accent); color: var(--accent); }
.p2st-dot[aria-current="step"] { background: var(--accent); border-color: var(--accent); color: var(--paper); }
.p2st-btn:disabled { opacity: 0.35; cursor: default; }
.p2st-steps, .p2rf-track { list-style: none; margin: 0; padding: 0; }
.p2st-step { margin: 0 0 1.4rem; padding: 1rem 1.1rem 1.1rem; border: 1px solid var(--rule); border-radius: 10px; background: var(--paper-2); }
.p2st--js .p2st-step { display: none; margin: 0; }
.p2st--js .p2st-step.is-on { display: block; }
.p2st-title { display: flex; align-items: center; gap: 0.6rem; margin: 0 0 0.9rem; font-size: 1rem; font-weight: 700; color: var(--ink); }
.p2st-n { display: grid; place-items: center; width: 1.6rem; height: 1.6rem; border-radius: 50%; background: var(--ink); color: var(--paper); font-size: 0.78rem; }
.p2st-cols { display: grid; grid-template-columns: minmax(0, 1fr) minmax(0, 1fr); gap: 0.9rem; }
@media (max-width: 640px) { .p2st-cols { grid-template-columns: minmax(0, 1fr); } }
.p2st-col { min-width: 0; padding: 0.8rem 0.9rem; border-radius: 8px; background: var(--paper); border: 1px solid var(--rule); }
.p2st-col--op { border-top: 3px solid var(--warm); }
.p2st-col--ad { border-top: 3px solid var(--accent); }
.p2st-std { margin: 0 0 0.6rem; font-size: 0.74rem; font-weight: 800; letter-spacing: 0.06em; text-transform: uppercase; color: var(--ink); }
.p2st-std span { font-weight: 600; letter-spacing: 0.02em; text-transform: none; color: var(--ink-light); }
.p2st-vis { display: flex; flex-wrap: wrap; align-items: center; gap: 0.4rem; min-height: 3.6rem; margin-bottom: 0.6rem; }
.p2st-chip { display: inline-block; padding: 0.22rem 0.6rem; border: 1px solid var(--rule); border-radius: 999px; font-size: 0.78rem; font-weight: 600; color: var(--ink); background: var(--paper-2); }
.p2st-chip--on { border-color: var(--warm); background: color-mix(in srgb, var(--warm) 16%, var(--paper)); }
.p2st-chip--on::before { content: '✓ '; }
.p2st-chip--quiet { color: var(--ink-muted); border-style: dashed; }
.p2st-card { display: inline-flex; flex-direction: column; gap: 0.1rem; padding: 0.4rem 0.7rem; border: 1px solid var(--rule); border-radius: 7px; background: var(--paper-2); font-size: 0.8rem; color: var(--ink); }
.p2st-card b { font-weight: 700; }
.p2st-card i { font-style: normal; font-size: 0.74rem; color: var(--ink-muted); font-family: var(--font-mono, monospace); }
.p2st-card--ok { border-color: var(--accent); background: color-mix(in srgb, var(--accent) 9%, var(--paper)); }
.p2st-card--miss { border-color: var(--warm); border-style: dashed; background: color-mix(in srgb, var(--warm) 8%, var(--paper)); }
.p2st-call code { display: inline-block; padding: 0.3rem 0.55rem; border-radius: 6px; background: var(--ink); color: var(--paper); font-size: 0.74rem; }
.p2st-arrow { color: var(--ink-muted); font-weight: 700; }
.p2st-txt { margin: 0; font-size: 0.86rem; line-height: 1.55; color: var(--ink); }
.p2st-txt code { font-size: 0.8em; }
.p2st-live { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0 0 0 0); white-space: nowrap; }
@media (prefers-reduced-motion: no-preference) {
  .p2st--js .p2st-step.is-on .p2st-vis > * { animation: p2stIn 0.45s ease-out both; }
  .p2st--js .p2st-step.is-on .p2st-vis > :nth-child(2) { animation-delay: 0.08s; }
  .p2st--js .p2st-step.is-on .p2st-vis > :nth-child(3) { animation-delay: 0.16s; }
  .p2st--js .p2st-step.is-on .p2st-vis > :nth-child(4) { animation-delay: 0.24s; }
  @keyframes p2stIn { from { opacity: 0; transform: translateY(6px); } to { opacity: 1; transform: none; } }
}
.p2rf-track { display: grid; grid-auto-flow: column; grid-auto-columns: 100%; gap: 1rem; overflow-x: auto; scroll-snap-type: x mandatory; scroll-behavior: smooth; overscroll-behavior-x: contain; scrollbar-width: thin; padding-bottom: 0.4rem; }
.p2rf-slide { scroll-snap-align: start; min-width: 0; }
.p2rf-shot { display: block; border: 1px solid var(--rule); border-radius: 8px; overflow: hidden; background: #fff; }
.p2rf-shot img { display: block; width: 100%; height: auto; }
.p2rf-shot:hover, .p2rf-shot:focus-visible { border-color: var(--accent); }
.p2rf-cap { margin: 0.55rem 0 0; font-size: 0.86rem; line-height: 1.5; color: var(--ink); }
.p2rf-count { min-width: 3rem; text-align: center; font-size: 0.8rem; font-weight: 600; color: var(--ink-muted); }
@media print {
  .p2st-nav, .p2rf-nav { display: none !important; }
  .p2st--js .p2st-step { display: block !important; margin-bottom: 1rem; }
  .p2rf-track { display: block; overflow: visible; }
  .p2rf-slide { margin-bottom: 1rem; break-inside: avoid; }
}
</style>
<script is:inline>
(function () {
  if (window.__dcSigReveal) return;
  window.__dcSigReveal = true;
  if (!('IntersectionObserver' in window)) return;
  if (window.matchMedia && window.matchMedia('(prefers-reduced-motion: reduce)').matches) return;
  function init() {
    var sigs = document.querySelectorAll('.dcsig');
    if (!sigs.length) return;
    sigs.forEach(function (s) { s.classList.add('dcsig--reveal'); });
    var io = new IntersectionObserver(function (entries) {
      entries.forEach(function (e) { if (e.isIntersecting) { e.target.classList.add('dcsig--in'); io.unobserve(e.target); } });
    }, { threshold: 0.15 });
    sigs.forEach(function (s) { io.observe(s); });
  }
  if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', init);
  else init();
})();
</script>
<script is:inline>
(function () {
  function stepper(fig) {
    var steps = fig.querySelectorAll('.p2st-step'), dots = fig.querySelectorAll('[data-p2st-dot]');
    var prev = fig.querySelector('[data-p2st-prev]'), next = fig.querySelector('[data-p2st-next]'), live = fig.querySelector('[data-p2st-live]');
    var i = 0;
    function show(n, announce) {
      i = Math.max(0, Math.min(steps.length - 1, n));
      steps.forEach(function (s, k) { s.classList.toggle('is-on', k === i); });
      dots.forEach(function (d, k) { if (k === i) d.setAttribute('aria-current', 'step'); else d.removeAttribute('aria-current'); });
      prev.disabled = i === 0; next.disabled = i === steps.length - 1;
      if (announce) live.textContent = steps[i].getAttribute('aria-label');
    }
    fig.classList.add('p2st--js');
    fig.querySelector('[data-p2st-nav]').hidden = false;
    prev.addEventListener('click', function () { show(i - 1, true); });
    next.addEventListener('click', function () { show(i + 1, true); });
    dots.forEach(function (d, k) { d.addEventListener('click', function () { show(k, true); }); });
    fig.addEventListener('keydown', function (e) {
      if (e.key === 'ArrowRight') { show(i + 1, true); e.preventDefault(); }
      if (e.key === 'ArrowLeft') { show(i - 1, true); e.preventDefault(); }
    });
    show(0, false);
  }
  function carousel(fig) {
    var track = fig.querySelector('[data-p2rf-track]'), slides = track.children, count = fig.querySelector('[data-p2rf-count]');
    var prev = fig.querySelector('[data-p2rf-prev]'), next = fig.querySelector('[data-p2rf-next]');
    function at() { return Math.round(track.scrollLeft / Math.max(1, track.clientWidth)); }
    function sync() { var k = at(); count.textContent = (k + 1) + ' / ' + slides.length; prev.disabled = k === 0; next.disabled = k === slides.length - 1; }
    function go(k) { track.scrollTo({ left: Math.max(0, Math.min(slides.length - 1, k)) * track.clientWidth }); }
    fig.querySelector('[data-p2rf-nav]').hidden = false;
    prev.addEventListener('click', function () { go(at() - 1); });
    next.addEventListener('click', function () { go(at() + 1); });
    track.addEventListener('scroll', function () { window.requestAnimationFrame(sync); }, { passive: true });
    sync();
  }
  function init() {
    document.querySelectorAll('[data-p2st]').forEach(stepper);
    document.querySelectorAll('[data-p2rf]').forEach(carousel);
  }
  if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', init);
  else init();
})();
</script>
