Ad Context Protocol (AdCP) is being sold as a magic bullet. But let’s be honest: Your first AdCP project is probably going to fail.
It won’t fail because the protocol is bad; it will fail because you’ve been sold a simplistic dream – a “universal API” for ad tech – and that’s what you’re budgeting for.
But AdCP isn’t a simple API upgrade. Hidden inside the promise of agentic automation is a massive, complex, asynchronous, stateful, multi-tenant engineering problem.
You’re budgeting for a new integration. You should be budgeting for a new distributed system.
The “hard mode” of action protocols
The demo of AdCP looks easy: An agent – or an MCP Host – makes a tools/call for create_media_buy.
But the response you get back isn’t completed. It’s status: submitted. That buy now sits in a pending_approval state for hours, or even days, until a human on the other end clicks a button and the server (eventually) sends your system a webhook.
Your agent just became a server.
The first thing your engineering team will discover is that they aren’t just calling an API; they are being asked to build a full-blown orchestration engine. This engine requires the following capabilities:
AdExchanger Daily
Get our editors’ roundup delivered to your inbox every weekday.
Daily Roundup
- Persist state: It needs a robust job queue and state machine to track that a task is in_progress for the next 72 hours.
- Handle asynchrony: It must be a durable, server-side process that can gracefully handle restarts, manage webhook ingestion and resume workflows right where they left off.
- Manage failure: It needs complex retry logic (with exponential backoff), idempotency keys (so a failed call that gets retried doesn’t accidentally buy a campaign twice) and circuit breakers for when a partner’s server inevitably goes down.
This brings us to another hard truth: The AdCP “hub” is not optional. A point-to-point MCP connection to one publisher is a nice pilot. But your business runs on 50 partners and the walled gardens.
If you want shared budget control or unified analytics, you’ve already committed to a hub. That hub becomes the product: an MCP Host that manages many MCP Servers and serves as the stateful brain for data harmonization, spend fan-out and failure containment.
So why bother?
If using AdCP is this hard, why walk into the trap?
Because the alternative is worse: a future where we’re still just shipping static data and indulging in “bespoke chaos.”
A shared ontology lets our data move. But an action protocol like AdCP, running on MCP, lets our work move.
However, engineering complexity is the cost of entry for true automation. That most stakeholders aren’t ready for this complexity isn’t a failure of the protocol; it’s a failure of the pitch.
For the first time, AdCP provides a portable way for agents to act across sovereign systems. This is how you turn a strategic goal – “Launch a Q4 CTV push” – into a set of repeatable, auditable, automated steps without hand-coding 20 different vendor integrations.
AdCP doesn’t replace OpenRTB; it works alongside it. It’s like adding a second door to the same house.
- OpenRTB is the high-frequency auction layer (sub-second transactions).
- AdCP/MCP is the low-frequency workflow layer (planning, setup and reporting that takes hours or days).
You will use AdCP to negotiate the PMP deal and set up the campaign. You will use OpenRTB to execute the bids against that deal ID. This shift moves the entire competitive frontier. We will finally stop competing on who has the most brittle integrations and start competing on who has the smartest orchestration strategy.
Making agentic a reality
Here is a pragmatic road map for implementation.
Start with a zero-risk, read-only minimum viable product. Connect to one or two partners to build a unified, schema-validated dashboard that proves the plumbing works.
Next, conduct a “write pilot” with one partner and a tiny budget, focusing on validating the full asynchronous loop and webhook processing, not on ROI.
Before scaling, build governance first by implementing an explicit “human-in-the-loop” approval workflow with an immutable audit trail.
Finally, once the model and governance are proven, build the core hub architecture with state machines and canonical data models, which enables adding new AdCP-compliant partners with minimal integration effort. MCP may eventually let you subscribe to that capability. Until then, act like you have to own it.
AdCP won’t save you from hard engineering. It will save you from bespoke chaos. It moves the complexity out of a thousand brittle scripts and into one controllable, strategic and auditable orchestration layer.
Stop budgeting for an API. Start budgeting for the hub.
“Data-Driven Thinking” is written by members of the media community and contains fresh ideas on the digital revolution in media.
Follow Hypermindz.ai and AdExchanger on LinkedIn.
