AdCP, the Ad Context Protocol, has picked up a lot of attention this year, and most of the writing about it treats it as the answer to agentic advertising. It isn't. It's a very useful answer to one part of agentic advertising, and conflating the two is where most of the confusion in this space comes from.

Here's what AdCP actually is: a shared vocabulary that lets a buying agent and a selling agent exchange structured information, what inventory is available, what formats, what targeting, what price, without either side having to build a custom integration for every counterparty it talks to. That's genuinely useful. Before a common protocol, every agent-to-agent connection was a bespoke piece of engineering. AdCP turns that into something closer to a shared API spec.

What that covers, specifically

Two things, really. Discovery, an agent asking "what inventory do you have that matches these criteria" and getting back a structured answer instead of a PDF or a phone call. And proposal exchange, terms going back and forth in a format both sides' systems can parse automatically. That's the full scope. AdCP tells agents how to talk to each other. It says nothing about what happens once they've agreed something.

What it doesn't cover

Once two agents land on terms, somebody has to answer a handful of questions AdCP was never built to answer. Who has authority to agree this on the buyer's side, and what are the limits of that authority? Where does the agreed deal get recorded, in a form both parties can point to later if there's a dispute? At what point, if any, does a human need to see this before it goes live? And when the campaign runs, how does anyone check what was promised against what was delivered?

None of that is a protocol problem. It's a governance problem, and a protocol for exchanging messages isn't built to solve it, the same way email being a working protocol doesn't tell you whether the thing you agreed to in an email thread is enforceable.

Why this distinction actually matters

We see buyers treat "our agents speak AdCP" as equivalent to "our agentic buying is handled." It isn't, and the gap shows up exactly where you'd expect: in the deal record. Two agents can have a technically perfect AdCP exchange, agree terms cleanly, format everything correctly, and still produce a situation where neither side has an auditable account of what was actually agreed, because the protocol specifies the conversation, not the record of its outcome.

This is also why Concourse, our agent benchmark, doesn't test for protocol compliance. It tests for negotiation quality, does the agent hold a floor, does it recognise a bad deal, does it know when to walk. An agent can speak AdCP flawlessly and still negotiate itself into a weak deal, because fluency in the conversation and judgement about the content of the conversation are two different skills, and only one of them is what AdCP measures.

Where we sit on this

We integrate with AdCP. We're not betting the business on it being the only protocol that matters, because it almost certainly won't be, the way RTB wasn't the last word in programmatic and header bidding wasn't either. What stays constant across whichever protocol wins the conversation layer is the part AdCP doesn't touch: a record of what was agreed that both sides trust, a human checkpoint before anything consequential executes, and an audit trail when the campaign is done. That's the DealSheet, and it works the same whether the conversation underneath it happened over AdCP, A2A, or whatever comes after both of them.

The protocol gets agents talking to each other. It was never going to be the thing that makes the conversation worth trusting, and it isn't a gap in AdCP that it doesn't do that. It's just not what AdCP is for.