OpenProposal explained: AAMP 3.0's RFP-to-buy format

OpenProposal is IAB Tech Lab’s draft format for the part of a direct deal that still runs on email and spreadsheets: the brief, the proposal and the back and forth before anyone signs. It is the core object in AAMP 3.0, it hands the agreed deal to OpenDirect, the Deals API or OpenRTB to execute, and it is not final. Public comment was due to close on 22 October 2026, but IAB Tech Lab has extended it to 10 November, so sellers can still shape it.

We compared the two agentic standards in AAMP and AdCP compared and argued that agents are going after the IO first in Agents aren’t coming for the auction. This post looks at OpenProposal itself: what is in it, where it stands, and what to prepare.

What does OpenProposal standardise?

It standardises the offer: what a seller is selling, described in a shape a buying agent can parse, compare and commit to without a person retyping it. IAB Tech Lab announced it on 22 September 2026 as part of AAMP 3.0, aimed at the stage between an RFP and a buy commitment. CEO Anthony Katsur said in the announcement that “OpenProposal fills a major gap between a buyer’s brief and a buy commitment.”

The draft defines two shapes of proposal:

Standard proposal. Published by the seller’s agent with no brief. In effect, a public shelf of packages.
Custom proposal. Built in reply to a buyer agent’s brief, which it points to with brief_ref.

A proposal carries identity, lifecycle state and the pitch: a prose description, best_for[], not_suitable_for[] and seasonality_notes. Under it sit line items. Each line item is one buyable unit in exactly one channel (display, video, audio, ctv, dooh or native). Two rules shape everything else:

No inheritance. A line item never takes a value from the proposal or from a sibling line item. Each one stands alone.
Subsets are allowed. A buyer may commit to some line items and not others, unless the proposal mandates linked execution.

Line items cover inventory, audiences, creative requirements, targeting, commercial terms, guarantees, eligibility, execution and settlement. With the two proposal-level groups, those are the 11 headers IAB Tech Lab walked through in its 8 October webinar. The press release describes the flow as seven stages: publish, discover, compare, qualify, negotiate, bind and execute, report.

Why is most of a proposal not a negotiation?

Every one of the draft’s 71 fields carries exactly one mutability marker, and that marker tells a buying agent what it can do alone.

Marker	Who acts	Fields
`immutable`	Nobody, once created	6
`seller-set`	Seller only	29
`selectable`	Buyer picks from options the seller declared, each with an optional price delta	12
`settable`	Buyer sets a value inside bounds the seller declared	5
`supplied`	Buyer provides data or assets	3
`requestable`	Buyer asks for something outside the envelope; seller must agree	3
`derived`	Computed from other fields	11

Only the three requestable fields need a round trip: materials_due, hold_status and committed_metrics[]. Everything else resolves against what the seller has already published. The spec puts it as “composition is constraint satisfaction, not negotiation.” If you declare that a premium audience adds $4 CPM and a 970×250 adds $3, the buyer agent can price its own combination.

Here is a trimmed piece of the draft’s display example. The rates are fictional:

audiences:
  available:
    - catalog_ref: "examplepub/audiences/smb-decision-makers@3"
    - { id: "ep:hnw-investors", provenance: modeled, addressable_scale: 1100000 }
  included:     ["ep:smb-decision-makers"]
  pricing:      { "ep:hnw-investors": { delta_cpm: 4.00 } }

formats:
  available:    ["display/300x250", "display/728x90", "display/970x250"]
  included:     ["display/300x250"]
  pricing:      { "display/970x250": { delta_cpm: 3.00 } }

pricing:
  - cost_method:       CPM
    gross_rate:        24.00
    seller_rate:       20.40
    floor:             21.00
    price_valid_until: "2026-11-15T23:59:59Z"
    currency:          USD

Price can still move. pricing[].floor is the lowest rate the seller will consider, which lets a counter be evaluated without a round trip, and negotiation_history[] keeps an append-only record of who proposed what. When a proposal reaches agreed, every catalogue reference is replaced with its resolved value, so the agreed record stands on its own.

How does OpenProposal fit with OpenDirect and the Deals API?

OpenProposal sits upstream of both and replaces neither. Each line item lands in the standard its transaction_mechanism maps to (spec section 1.1):

Direct buy: OpenDirect 2.1 Order and Line.
Programmatic guaranteed: OpenDirect 2.1 plus a Deals API deal_id.
PMP deal: Deals API plus an OpenRTB 2.6 Deal.
Open market: OpenRTB 2.6, no deal.

That split fills a real gap. Deals API v1.0, finalised on 6 February 2026, is a one-way push of deal terms from an origin system such as an SSP to a receiver such as a DSP. IAB Tech Lab’s own page says it “does NOT support proposals, revisions, or negotiations.” OpenDirect 2.1 is the booking contract: accounts, orders, lines and a line state machine that runs from Draft to Finished. Neither describes an offer a buyer can shop. OpenProposal does, then hands off.

Two details are worth noting. transaction_mechanism is itself selectable, so you can offer the same inventory as a direct IO, programmatic guaranteed or a preferred deal and let the buyer choose. And deal_id_issuance says the deal ID is minted at commitment, not before.

Has a final version shipped?

No. As of 29 October 2026:

Comment is extended. The AAMP 3.0 press release now carries a banner extending public comment to Tuesday, 10 November 2026, “due to overwhelming feedback.” PPC Land reported that IAB Tech Lab announced the extension on LinkedIn on 23 October, a day after the original deadline. The GitHub README and the “Start here” issue still say 22 October, so go by the press release.
It is a draft. The only tag is v3.0-draft-1. The spec says it “MUST NOT” be treated as a ratified standard, and the README warns against building production systems that expect stability.
There is no schema yet. Machine-readable schemas “will follow the first revision”, after comment closes. The YAML examples are the best guide to shape until then.
The process is still being set up. The governance file still lists the working group, chairs and decision rule as TBD, and the disposition log is empty. When we checked, the repository had 113 issues, none of them closed. Open change requests include a static manifest at a well-known URL for standard proposals, per-market geo pricing, and commitments that carry the proposal version.
It is not in the SDKs yet. The press release said OpenProposal would be built into the Buyer and Seller Agent SDK reference implementations during comment. The seller SDK has a feat/openproposal-mapping branch, with commits from 16 to 19 October, that adds OpenProposal endpoints and maps Google Ad Manager line items to OpenProposal line items. It is not merged, and the latest tagged release of both SDKs is still v2.4.2 from August.
Seven questions are open. They include whether per-field mutability and catalogue references belong in 3.0 at all, and the fact that the format registry has no audio/, ctv/ or dooh/* entries yet.

Expect field names to change. Our reading is that the structure (a pitch, self-contained line items, declared option sets) is more settled than any single field, but IAB Tech Lab has not committed to that.

What should your sales team prepare now?

Most of the work is commercial, and it is useful whatever the final version looks like. Much of it also feeds an AdCP sales agent, as we covered in making inventory agent-ready for AdCP.

Pick your standard shelf. List the packages you would sell without a brief. Write a plain description of each, including who it suits and who it does not. A buying agent reads description and best_for[] to decide whether to look further.
Turn “it depends” into option sets. For each package, decide which audiences, properties, formats, measurement vendors and reporting feeds a buyer can pick, which are in the base rate, and the CPM or flat delta for each extra. For most teams this is the hardest step, because those prices live in a planner’s head.
Set the bounds. Write down the geo, device, daypart and frequency cap ranges a buyer can set without asking.
Write down your envelope. Floor rate per line item, minimum spend, minimum and maximum budget, and how long a posted rate holds.
Decide what you will guarantee. Viewability or completion ceilings, the measurement vendors you accept, and whether a shortfall means a makegood or a credit.
Separate gross from net. The draft has gross_rate (what the buyer pays) and seller_rate (what you receive), plus billing fields for who invoices. Agree the fee arithmetic internally first.

What should your sales agent be ready to do?

If you run or are building a sales agent, these are the behaviours draft 1 asks for:

Serve a summary representation for screening and a full one with every catalog_ref resolved.
Keep catalogue entries versioned and unchanged once referenced, as in examplepub/audiences/smb-decision-makers@3.
Recompute availability and addressable_scale against the buyer’s actual selection, not just the default package.
Treat commitment.idempotency_key strictly: a replay returns the original result and never creates a second commitment.
Run the hold states: none, requested, held, then expired, released or converted.
Freeze the record at agreed, issue the deal ID or OpenDirect order in the mapped standard, and carry one correlation_id across every system it touches.
Know your seller identity. seller_id is an IAB Tech Lab registry reference, and visibility can be registry_gated.

The seller SDK branch is a useful reference for mapping Google Ad Manager line items to OpenProposal, but do not ship production code against draft 1. Build the data model and the pricing now, and wire up the format after the revised draft.

BidCliq builds header bidding and agentic tools for publishers, and our sales agent is verified by AgenticAdvertising.org against AdCP 3.1.

What to do next

Read the draft spec and the display example with your head of sales, not just your engineers.
Comment before 10 November 2026. You need a GitHub account, not IAB Tech Lab membership, and the repo’s rules say implementation feedback outranks opinion.
Start the option-set pricing exercise for your top five packages.
Watch the repository for the revised draft, the disposition log and the first JSON Schema.

Frequently asked questions

What is OpenProposal?

OpenProposal is IAB Tech Lab's draft specification for describing an advertising offer in a format buying agents can parse, compare and commit to. It is the core object of AAMP 3.0, announced on 22 September 2026.

Has OpenProposal been finalised?

No. As of 29 October 2026 the only published version is 3.0 draft 1, which the spec says must not be treated as a ratified standard. IAB Tech Lab has extended public comment to 10 November 2026, and schemas will follow the first revision.

Does OpenProposal replace OpenDirect or the Deals API?

No. OpenProposal covers the offer and its agreement. Each agreed line item is executed through OpenDirect 2.1, the Deals API or OpenRTB 2.6, depending on whether it is a direct buy, programmatic guaranteed, a PMP deal or open market.

Do I need to be an IAB Tech Lab member to comment on OpenProposal?

No. Comments are filed as issues or pull requests on the IABTechLab/OpenProposal GitHub repository, and a GitHub account is enough.

What should a publisher prepare for OpenProposal now?

Define a shelf of standard packages, decide which options buyers can choose and what each one costs, and set floors, budget bounds, guarantees and hold rules. That catalogue work is needed whatever the final field names turn out to be.

About the author

Sharad Yadav

Founder, BidCliq

Sharad Yadav is the founder of BidCliq, a publisher-first ad monetization platform that helps publishers and ad ops teams run header bidding, Prebid and programmatic across display, video, app and CTV. Before BidCliq, he led AdTech and product at GeeksforGeeks, where he built an in-house ads product that doubled programmatic revenue within nine months and an anti-adblock solution that lifted ad yield by 10%. He is a founding member of AdCP.