Ask us which agentic protocol Alkimi is built on and the honest answer is: that's the wrong question. We get asked it a lot, usually phrased as "are you AAMP or AdCP," as if agentic advertising has two teams and every company has to pick one. It doesn't, and we haven't.

Here's the distinction that gets missed. AdCP, AAMP, A2A, these are all protocols for how agents talk to each other, the vocabulary and format of the conversation. They're useful, and they're also not the part of agentic advertising we build on top of. What we build is the layer above the conversation: can this agent be trusted with a budget, is this agreement recorded somewhere both sides can point to, did a human see this before it went live. That layer doesn't care which protocol the agents used to have the conversation in the first place.

Two products that prove the point

Take Concourse, our benchmark for AI buying agents. It runs an agent through a simulated market and grades how it negotiates, does it hold a floor, does it recognise bad terms, does it know when to walk away from a deal that looks finished but isn't. Concourse doesn't ask what protocol the agent speaks before it runs the test. It can't, because negotiation quality and protocol compliance are different things entirely. An agent can be fluent in AdCP and still negotiate badly, and Concourse is built to catch exactly that.

The Alkimi Gym, where agents get trained on the judgement Concourse exposes as missing, works the same way. It's not teaching an agent to speak a particular protocol better. It's teaching it what a bad deal looks like so it stops agreeing to one. That training transfers regardless of which protocol the agent uses to have the conversation that leads to the deal.

What this means in practice

If a buyer's stack already speaks AdCP, we integrate with that. If a publisher's agents are built around a different standard, we integrate with that too. We're not asking anyone to rip out their existing agent infrastructure to get a DealSheet, a human checkpoint, and an audit trail. Those three things sit above the protocol layer, not inside it, which is also why we don't describe what we do as "the exchange." An exchange implies you have to plug into our rails specifically. A trust layer means you keep your rails and we handle the part your rails were never built to handle: making sure what gets agreed is recorded, approved, and accountable.

This also means the marketplace works with or without a DSP in the loop. Some buyers want agents negotiating directly with publisher agents. Others want their existing DSP relationships intact and just want the deal governance wrapped around what's already happening. Both are the same product from our side, because the thing we're standardising isn't the media buying stack. It's the record of what two agents agreed to do.

Betting against a single winner, on purpose

RTB wasn't the last word in programmatic. Header bidding wasn't either. Whatever protocol currently has the most conference talks about it is not a safe long-term bet for a company whose job is deal governance, because the conversation layer is exactly the layer most likely to get replaced by something better in two years. What doesn't get replaced is the need for a human-approved, auditable record of what an agent agreed on your behalf, and that's the layer we've built the business on.

We'll keep integrating with whatever protocol agents are actually using. We're not going to be the company that bet everything on one of them turning out to be the standard, because by the time that question gets settled, it won't be the interesting problem left to solve.