Blog · Agentic

OpenProposal scores CTV line items with ctv/* format ids, but the draft registry those ids point at is still empty.

October 24, 2026 · RTBlint

On October 23, 2026 IAB Tech Lab extended public comment on AAMP 3.0 and OpenProposal from October 22 to November 10, citing overwhelming feedback on the draft that standardizes RFP-to-buy objects for agentic advertising. PPC Land reported the extension the same day. The draft is not idle paperwork: buyer and seller agent SDKs already book media through OpenDirect, the Deals API, and OpenRTB. OpenProposal is the layer that is supposed to let agents compare seller shelves at machine speed before those rails fire. The CTV example in the repository is already concrete. The format registry the example depends on is not.

Planning success is not auction shape

OpenProposal v3.0-draft-1 describes itself as the descriptive specification for what is being bought and sold, engineered so a buying agent can parse and evaluate it at machine speed. The appendix counts 71 fields across proposal and line item, with 23 touched by the buyer through selectable, settable, supplied, and requestable markers. Only three requestable fields require a round trip. The design claim is constraint satisfaction: sellers declare option sets and price deltas up front, and buyer agents pick within those bounds without negotiating every dimension.

Section 1.1 is explicit that OpenProposal does not replace execution standards. Each line item lands in the downstream path its transaction_mechanism maps to: direct buys through OpenDirect 2.1, programmatic guaranteed through OpenDirect plus a deal_id, private marketplace through the Deals API and OpenRTB 2.6, open market through OpenRTB with no deal. That table is the handoff contract. Everything above it is comparison. Everything below it is the bid request your exchange already validates, or rejects with a silent no-bid.

That split matters because agentic pilots are measured on planning metrics first: how many proposals screened, how fast a brief matched, whether price provenance looked sane after AAMP 2.3. Execution metrics still live in the same fill and loss reports you used before agents arrived. A green agent trace does not prove the forwarded imp object still carries the pod duration, placement semantics, or deal object the comparison assumed when it scored the line item.

What the CTV example actually declares

The normative draft points to a runnable CTV line item in examples/line-item-ctv.yaml. That file is not abstract. It sets channel: ctv, locks environments to CTV, offers ctv/instream-15s and ctv/instream-30s under formats, declares creative_delivery with protocol: vast_4_2 and secure_required: true, caps frequency at household basis, commits a completion-rate guarantee, and selects PRIVATE_AUCTION as the included transaction_mechanism. serving_mode is ssai. buying_route is SSP_PLATFORM.

Read that as a merchandising object and it is legible. A buyer agent can see CTV instream lengths, SSAI delivery, a private auction path, and a seller-reported completion metric. Read it as a promise about the next hop on the wire and the draft immediately asks what ctv/instream-15s means in OpenRTB terms: which video.plcmt and pod fields apply, whether the deal is already minted at commitment time through deal_id_issuance, and how SSAI mode should appear on the supply object if your bidder keys off it.

OpenProposal answers the merchandising questions in YAML. It delegates channel-specific creative shape to a format registry: section 5.4 says specs are as defined by the referenced registry entry, and that OpenProposal does not hardcode a shape per channel. Section 7 repeats the same division: channel support cost one new field and committed-metric tuples, while the format registry carries what is channel-specific about creative shape. That is a reasonable split until the registry is empty for the channel you are selling.

Open question four is the CTV footgun

Section 8 lists seven open questions the working group wants answered during comment. Question four is blunt: the format registry has no entries for audio/*, ctv/*, or dooh/*, while specs delegates to a registry that cannot currently answer for half the declared channels. GitHub issue #5 in the OpenProposal repository tracks the same point. This is not a footnote about future work. It is an admission that the CTV example's format ids are namespaced strings without normative registry rows behind them in this draft.

PPC Land's October 24 AAMP overview notes that machine-readable schemas were intentionally withheld from the first draft because comment was still deciding questions that shape them, and that seven open questions remained on October 24, including missing audio, CTV, and out-of-home registry entries. Extending comment to November 10 gives more time to file dispositions; it does not fill the registry. Until it does, two teams can implement the same YAML example and ship incompatible OpenRTB templates tied to the same format id string.

The failure mode is familiar from pre-plcmt migrations, just faster because agents do not pause to ask a trafficker. A buying agent scores the CTV line item on duration and completion guarantees, commits through the SDK, and hands execution to a forwarder that still emits a generic imp.video block copied from display paths. The deal id may match. The auction type may match. The placement semantics that made the line item a CTV instream fifteen do not survive, and OpenRTB still has no field that says which OpenProposal line item won, as we covered in the parallel version-negotiation gap between agentic protocols and dated OpenRTB snapshots.

From PRIVATE_AUCTION to the bid request

When transaction_mechanism resolves to PRIVATE_AUCTION, the draft maps execution to the Deals API plus OpenRTB 2.6. That is the path most SSP integrations already understand: a deal object on the impression, seat allow lists, floor semantics, and the rest of the PMP machinery your adapters test in staging. The OpenProposal line item also carries buyer_requirements with mixed mutability: seller-set seat requirements and supplied dsp_seat_id values once the buyer commits.

OpenProposal (CTV example, excerpt):
  channel: ctv
  formats.included: ["ctv/instream-15s"]
  transaction_mechanism.included: ["PRIVATE_AUCTION"]
  serving_mode: ssai
  commitment.flight_start / flight_end: buyer-set flight

OpenRTB 2.6 handoff (what your forwarder must still build):
  imp.pmp.deals[].id     ← from Deals API / deal_id_issuance
  imp.video.plcmt        ← not spelled out by ctv/instream-15s in draft registry
  imp.video.podid / rqddurs / poddur  ← pod semantics if the buy is podded
  source.ext.schain      ← unchanged supply-chain expectations

Nothing in the excerpt guarantees those video fields appear. The comparison step can be correct while the auction object is incomplete. Your bidder may answer with nbr 2 invalid request, or it may bid with defaults that mislabel SSAI instream as generic video and then wonder why post-auction creative checks fail on the VAST side. RTBlint catches malformed or inconsistent OpenRTB payloads, not agent reasoning. It is still the check that tells you the handoff broke before money moved.

Programmatic guaranteed and preferred deal mechanisms add OpenDirect and Deals API steps before the bid stream sees traffic. The same registry gap hurts there too: an order line can reference format ids that never mapped to AdCOM placement objects your DSP expects when it finally builds the impression. Agents compress calendar time between proposal acceptance and first bid; they do not automatically compress adapter QA.

What to verify before you trust agent output

Treat OpenProposal JSON and the forwarded bid request as two contracts. Pin the OpenRTB dated snapshot your exchange runs in config, independent of agent releases, the same way AdCP pins adcp_version on every message while OpenRTB still agrees version out of band. When a CTV line item clears, cross-check imp.video.plcmt, duration bounds, and pod fields against what the line item's formats and serving mode implied, even if the registry row does not exist yet.

Log correlation_id from the committed line item next to exchange request ids. OpenProposal derives that field so one identity should cross OMS, deal issuance, and reporting. If your forwarder cannot carry it into OpenRTB extensions today, record the gap explicitly in runbooks instead of assuming support because the agent SDK succeeded.

Run agent-produced requests through the same bid request tester pipeline you use for human trafficking changes. Add a regression fixture built from line-item-ctv.yaml once you decide how ctv/instream-15s maps in your stack. Until IAB Tech Lab publishes registry entries for ctv/*, that mapping is vendor-specific, and two compliant agent integrations can still diverge on the wire.

If the buy also clears to VAST, validate tags separately. OpenProposal declares creative_delivery.protocol; it does not prove the SSAI stitch served a conforming document. The delivery-side write-up on AAMP versus AdCP at the VAST envelope is the sibling check once the auction object looks fine but playback still fails.