Blog · Protocol
Will AI agents replace OpenRTB? Why the bid stream is the stable layer
Every few weeks a new headline suggests AI agents are about to make real-time bidding obsolete. Agents negotiate deals in natural language, the argument goes, so who needs a microsecond auction protocol? The short answer is that the two things solve different problems, and both agentic stacks are being built directly on top of OpenRTB, not in place of it. Here is why the bid stream is the stable layer underneath the agent news.
The claim, stated fairly
The strong version of the argument is real, not a strawman. If a buyer's agent can describe an outcome to a seller's agent, negotiate terms, and settle a deal in conversation, then a lot of the manual campaign setup that DSP interfaces exist for goes away. The Ad Context Protocol and IAB Tech Lab's AAMP are both racing to standardize exactly that conversation. So it is fair to ask whether the auction protocol underneath survives the shift.
It does, for four concrete reasons.
1. Negotiation and execution are different clocks
Agents negotiate at planning time: minutes or seconds, a conversation between two services. An impression still has to be auctioned while a person waits for a page to load, in the low tens of milliseconds. Those are different problems on different clocks. An agreement reached by agents still has to be executed, per impression, in real time, and the mechanism for that is an auction over a compact wire format. Agents decide the terms; OpenRTB executes them. Replacing the negotiation UI does not replace the auction.
2. Both stacks are built on OpenRTB, by design
This is the part the headlines miss. IAB Tech Lab's explicit strategy is to extend OpenRTB, AdCOM, VAST, and GPP rather than introduce competing standards; its CEO has argued the industry should build on "an existing shared foundation, not introduce multiple new standards that create fragmentation." AdCP takes the other governance path but the same technical one: a negotiated AdCP buy executes as a deal ID in imp.pmp.deals, a programmatic guaranteed line, or a direct tag. Neither stack emits a new auction protocol. One extends the bid request; the other hands its output to the bid request. OpenRTB is the substrate they both assume.
3. Even the most aggressive design rewrites, not replaces
IAB's Agentic RTB Framework is the boldest bet in the space: it puts agent services inside the auction path, letting them enrich and modify a bid request mid-flight. And even there, the output is still an OpenRTB bid request. ARTF changes who may touch the request and adds a provenance question about which fields an agent rewrote. It does not change what the request is. The most auction-native agentic proposal on the table is a transformer of bid requests, not a successor to them.
4. The installed base does not blink
OpenRTB has been the interoperability layer between thousands of exchanges and bidders since 2010, and it ships ordinary improvements on a roughly monthly cadence; the 2.6-202606 snapshot added live-content fields and pricing macros while the agent news ran. A format that much infrastructure speaks, and that is still actively maintained, does not get displaced by a negotiation layer sitting above it. It gets a new client.
What actually changes
None of this means nothing changes. Three things genuinely shift, and they are worth preparing for:
- Who decides. More of the buying decision moves from a human in a UI to an agent reasoning over signals. The output is still a bid request, but it is now a generated bid request.
- Provenance. With ARTF-style agents in the path, you need to know which stage produced or altered which fields, and validate after the ones that can rewrite a request.
- Trust artifacts.
adagents.jsonjoins ads.txt, sellers.json, and schain as something buyers reconcile before honoring an agent-sourced deal.
Why validation matters more, not less
When a human built a campaign, an error in the request traced back to a config screen. When an agent assembles or rewrites the request, the OpenRTB is generated, and generated JSON drifts the way all generated JSON does: a plausible field in the wrong path, a consent string left in ext, an enum value that used to be valid. None of it throws. It just costs bids or breaks compliance. An agent that can build a bid request should be able to check it against the spec before it ships one, the same way a developer runs a linter before a commit.
That is the durable role for a validator. rtblint runs client-side in the tester, as a CLI for pipelines, and as an MCP server an agent can call as a tool. Whichever agentic stack wins, the transaction still resolves to OpenRTB on the wire, and the wire still has to be right. The bid stream is not the thing getting replaced. It is the thing everything else is being built to talk to.