On October 22, 2026 AgenticAdvertising.org closed its October Town Hall with AdCP 3.2 generally available: platform activation, reporting in the protocol, and tighter trust attestations on top of the MCP task surface buyers already wire into Claude, Cursor, and Prebid Sales Agent stacks. A week earlier, Mediahuis and Draft Digital ran what they describe as the first agent-to-agent campaign without a programmatic intermediary in the middle. Their post-mortem line is blunt: an agent can only sell what has been clearly defined. That definition lives in AdCP messages. Revenue still lives in OpenRTB bid requests and VAST documents nobody graded when the MCP tool returned 200.
What AdCP actually negotiates
The Ad Context Protocol is not a replacement auction wire. It is a task protocol between buyer and seller agents, usually over Model Context Protocol, with Agent2Agent as an alternate transport. Discovery starts with get_adcp_capabilities, which tells you which protocol families the seller implements and which AdCP version it speaks. Inventory discovery uses product and placement tasks such as get_products. Commitment uses create_media_buy, which returns a manifest: deal identifiers, pricing, format constraints, and hooks for creative sync.
Creative work sits in a parallel family. sync_creatives registers assets against the buy: hosted markup, VAST URLs, duration claims, and governance metadata. Governance tasks (content standards, calibration, delivery verification) can pass while the downstream tag is still wrong for SSAI or CTV players. None of these JSON payloads are bid requests. None of them are <VAST> documents. They are contracts between agents.
Authorization at the publisher edge is also part of the story. Sellers publish adagents.json at /.well-known/adagents.json to declare which sales agents may represent which properties. That file answers a question ads.txt never asked: is this agent allowed to negotiate for this inventory? It does not populate imp objects or fetch creative XML.
Where the negotiation lands on the wire
When programmatic inventory executes, the agreement has to collapse into objects exchanges and DSPs already parse. The field-level mapping guide is the handoff document: AdCP names become OpenRTB integers and deal objects.
Placement intent is the cleanest example. AdCP video_placement_types uses readable names (instream, accompanying_content, interstitial, standalone) defined against OpenRTB 2.6 video.plcmt. A buy negotiated as instream must execute as plcmt: 1 on the impression. Emitting only the deprecated video.placement field loses the constraint even when every AdCP message said instream. Audio follows the same pattern via audio_distribution_types mapped to audio.feed.
Commercial terms become PMP structures. The media buy’s deal id lands in imp.pmp.deals[].id. Floors, currency, auction type, seat allow lists, and guaranteed flags each have OpenRTB homes. A bid that names a deal id absent from the request is dropped (OpenRTB loss reason 4). A guaranteed buy emitted as an open auction impression is a different product than the one agents signed.
Creative constraints must reappear on the impression object: duration, mimes, protocols, sizes. AdCP may accept a format at sync_creatives time that violates the emitted imp.video constraints. The auction filters it anyway (loss reasons 203 and 204). The MCP layer never sees that loss code.
Trust at serve time still runs through the supply chain on the bid. source.schain reconciled against ads.txt and sellers.json answers whether the intermediaries on this impression are authorized. Agent authorization in adagents.json and seller authorization in schain are complements. Verifying only the negotiation file leaves you with an auditable agreement attached to an unauditable impression.
Video and CTV buys add a second wire format. After the deal clears, the player requests a VAST URL or unwraps a wrapper chain. Duration, mezzanine files, HTTPS media, and UniversalAdId on that tag determine whether the spot serves on stitched CTV inventory. AdCP can mark a creative synced while the tag fails player gates. The four readiness gates writeup is about that gap, not about MCP schema errors.
How you catch it
An LLM implementing AdCP can hallucinate a mapped field, drop a deal id, or attach a VAST URL that 404s. The seller agent can still respond with a well-formed JSON success object. The fix is to treat protocol conformance and payload conformance as two different tests.
For the OpenRTB side, run the emitted bid request through rtblint (cargo install rtblint, npm install rtblint-core, MCP rtblint-mcp). Validate against the dated OpenRTB snapshot your exchange actually runs, not the version string in your agent README. Discovery helpers such as get_adcp_capabilities on the MCP server tell you what AdCP families exist; they do not replace validate_bid_request on the object about to hit /openrtb2/auction.
For the creative side, fetch the terminal tag and run vastlint. The VAST tag tester accepts a live URL or pasted XML for preview, tracking, and click URLs. The VAST inspector walks wrapper hops until an InLine appears or the chain breaks. Wire those checks after sync_creatives or before you treat a buy as cleared for launch.
These packages are deterministic checks on the wire objects. They are independent of IAB Tech Lab and of AgenticAdvertising.org; the specs do not require them, and nothing in an MCP success response substitutes for them.
Where to go next
If you are parsing incoming agentic demand today, start with AdCP versus OpenRTB in practice: same pipes, different upstream handshake. When you build the emitter, keep the AdCP to OpenRTB mapping open beside your task handlers so every narrowed constraint reappears on imp. For trust, read the AdCP explainer on rtblint.org alongside the supply-chain doc and reconcile four files, not one.
Agentic buying will keep closing deals in minutes. Exchanges and players will keep speaking the formats they spoke before. The useful engineering work is making sure every closed deal still produces a bid request and a VAST tag that survive the same validators you used before agents joined the workflow.
Top comments (1)
The negotiated-to-openRTB path always feels like it should be simpler than it is. Curious how you handle the VAST wrapper conflicts when the buy-side and sell-side both think they own the fallback.