AdCP Explained: What Brian O'Kelley's 'Universal Ads API' Means for AI-Chat Publishers

There’s a new acronym worth knowing: AdCP, the Ad Context Protocol. It’s an open standard for how AI agents talk to each other across the ad supply chain — how a buyer’s agent finds inventory, states what it wants, negotiates terms, executes a buy, and gets results back, all in a common machine language. If that sounds like plumbing, it is. Good plumbing usually does.

We’ve argued for a while that the buyers and sellers of AI-era inventory would be software, not humans on phones — we wrote that agentic buying was coming last fall. AdCP is the most serious attempt yet to give those agents a shared dialect.

Why the name on the door matters

The protocol is being championed by Brian O’Kelley, and that’s not a footnote. O’Kelley is the closest thing ad tech has to a founding architect. He was CTO of Right Media, which Yahoo bought in 2007. He co-founded AppNexus that same year and ran it as CEO through its roughly $1.6B sale to AT&T in 2018, where it became the spine of Xandr. He is the person most often credited with popularizing programmatic advertising and the online ad exchange.

In 2021 he co-founded Scope3 with Anne Coghlan, originally to measure advertising’s carbon footprint, since pivoted into an agentic advertising platform. He’s CEO. So when O’Kelley says that AI agents — not human traders — will buy and sell media, he’s not speculating from the sidelines. He built the auction infrastructure the last generation of traders used, then watched it ossify. He’s calling AdCP “the universal ads API” and “the OpenRTB for the AI era.” Coming from him, that comparison is a claim about lineage, not marketing.

How AdCP actually works

The clever part is that AdCP doesn’t try to be a transport. It rides on ones that already exist.

• It runs over MCP and A2A. AdCP defines advertising-specific tasks and schemas that sit on top of Anthropic’s Model Context Protocol and the Agent-to-Agent protocol as transports. O’Kelley’s framing is precise: “MCP is a self-describing API — you (or your agent) can ask an MCP server ‘what can you do’ and it will tell you.” AdCP layers the advertising semantics on top of that self-description.
• A buyer agent drives the loop. The agent discovers a seller’s inventory, expresses requirements, negotiates terms, executes the media buy, and reports results — the same sequence a media planner runs by email and spreadsheet today, compressed into a machine conversation.
• It’s modular. Three pieces do the work: a Signals Activation Protocol for audiences and signals, a Media Buy Protocol for the transaction itself, and a Creative Protocol for the assets.
• Humans stay in the loop by design. The async structure exists so a person can approve consequential decisions before money moves. That’s a deliberate choice, not an afterthought, and it’s encoded as a core principle the governance body calls “Embedded Human Judgment.”

The problem AdCP is aimed at is real. Today a brand picks one of two bad options. Programmatic gives you scale — vast commoditized inventory, but opaque fees and a supply chain five hops long. Direct and native buying gives you control and quality, but it doesn’t scale and it runs on human labor. AdCP’s bet is that agents can negotiate on audiences, outcomes, and engagement — not just per-impression auctions — and get standardization and publisher-native control at the same time.

It doesn’t replace OpenRTB — it sits beside it

This is the point most coverage gets muddled, so be clear about it: AdCP is complementary to the real-time bidding stack, not a successor.

OpenRTB standardized the bidstream — the millisecond auction that happens as a page loads. AdCP standardizes the negotiation around the buy: the planning and pre-buy conversations that happen outside the bidstream entirely. The two can run at the same time. An agent can negotiate terms and guarantees through AdCP, then let those terms execute through an RTB auction underneath. AdCP’s async, human-approvable design is exactly what the bidstream can’t offer, because a 100ms auction has no room for a human to say yes.

If you’ve read our take on what RTB has to become on a streaming surface, this is the layer above it. RTB decides the clearing price in real time. AdCP decides what the deal is in the first place.

The state of play

AdCP moved fast, and the membership list is the tell.

• The launch. Roughly twenty companies collaborated privately for a couple of months, then launched publicly on October 15, 2025, with code live on GitHub at v2.0.0. O’Kelley published “The Universal Ads API” on his Substack the same day. Digiday, AdExchanger, and AdWeek covered it.
• The founders. Six co-founding members each committed resources and around $10k a year: Optable, PubMatic, Scope3, Swivel, Triton Digital, and Yahoo. By 2026 membership had grown past 100 — AccuWeather, LG Ads, Raptive, Samba TV, Kargo, and Magnite among them.
• The governance. It’s run by AgenticAdvertising.org, a Delaware 501(c)(6) nonprofit. Interim leadership includes Randall Rothenberg, the former IAB CEO, and Matthew Egol.
• The momentum. In January 2026, Prebid.org announced the Prebid Sales Agent, an open-source AdCP-based seller agent that lets buyer agents from Claude, ChatGPT, and Gemini discover inventory and buy it. On June 18, 2026, AdCP shipped v3.1.0, the current version, adding creative retention, lifecycle webhooks, billing authority, audience sync, and governance signing.

Two caveats worth stating plainly. There’s a parallel standards track: IAB Tech Lab released a User Context Protocol in early November 2025 and an Agentic RTB Framework a week later, since branded AAMP. That effort is separate from AdCP — Rothenberg advises AgenticAdvertising.org personally, but the IAB Tech Lab work is not the same thing. And AdCP’s own site says the first agent-to-agent media buy — real money, real inventory from LG Ads — happened on October 16, 2025. That’s self-reported by adcontextprotocol.org, so treat it as their claim rather than settled fact.

The part no transaction protocol owns

Here’s the honest gap, and it’s the one that matters most for anyone monetizing an AI chat product.

AdCP standardizes the transaction. It does not decide what the ad looks like or where it renders inside an AI chat answer. Once an agent has discovered inventory, negotiated terms, and executed a buy, something still has to read the live conversation, match it to an offer, filter for brand safety, and render the result as a message a user will actually accept in the thread. None of the transaction protocols own that serving layer. It’s the unsolved piece — and it’s the hard piece, because it’s where the ad either belongs in the answer or ruins it.

This is the seam AdCP leaves open, and it maps onto our work cleanly:

• AdCP transacts on outcomes and audiences, not just impressions. That’s the same shift we’ve argued for — that on these surfaces, intent beats audience, because the user’s prompt is a richer signal than any cookie-derived profile.
• Agent buyers need agent-readable native inventory to buy. A negotiated deal still needs a placement that exists as a native in-thread message, not a rectangle bolted onto a chat window.
• “OpenRTB for the AI era” needs a serving surface to clear against — which is the case we made for RTB on streaming responses.

Where Elo fits

Elo is the adserver for AI chat. It reads live conversation context, matches it to an advertiser offer, runs brand-safety filtering, and delivers the ad server-side as a native message inside the thread — across web, iOS, and Android, model-agnostic, on CPM, CPC, or CPA. It’s the supply surface where AdCP demand lands.

That’s the clean division of labor. AdCP is how an agent buys the moment. Elo is the surface where the moment renders natively, in the user’s reading context, as something they accept rather than tune out. The transaction standard and the serving layer are different problems, and solving one doesn’t solve the other. If you’re building an AI chat product and wondering how any of this turns into revenue, that’s the question we walk through in how to monetize your AI chat app — and if the vocabulary here is new, the conversational advertising glossary covers the terms.

AdCP is genuinely good news. A standard for agentic negotiation is overdue, and O’Kelley is the right person to push it. It just settles how the deal gets done. It doesn’t settle where the ad lives. That part is still up for grabs — which is exactly where we’ve planted our flag.