WTF Is a Protocol? And How Did We Get Here?

A short history of advertising protocols, what each one solved, what none of them could, and what AdCP was built for instead.

If you have spent any time around conversations about agentic advertising, you have heard the word "protocol" more times than you can count. AdCP is a protocol. OpenRTB is a protocol. The internet runs on protocols.

And if you are like most advertising professionals, not a computer scientist, not a software engineer, you may have nodded along while privately wondering what a protocol actually is and why everyone keeps insisting it matters so much.

Here's the history, and where we are today.

What a Protocol Actually Is

Open a browser and go to any website. In milliseconds, your browser sends a request to a server somewhere in the world, the server sends back a page, and your browser renders it. This works across billions of devices, millions of websites, and developers who have never met each other.

The reason it works is HTTP. HyperText Transfer Protocol. HTTP is the shared set of rules that tells every browser how to request a page and every server how to respond. No company owns it. A standards body published it. Everyone adopted it. And because everyone adopted it, the web became universal.

That is what a protocol is. Not software you install. Not a platform you license. A published specification, a shared agreement about what to say, how to say it, and what to expect in response. When enough participants adopt the same protocol, the system stops requiring custom integrations between every pair of participants. Interoperability becomes the default.

Every major breakthrough in advertising infrastructure has followed this pattern. Someone defined a common language for a specific problem. The industry adopted it. And each time, the resulting system optimized for the problem it was designed to solve, not necessarily the problem advertising actually needed solved. That gap is the thread running through this entire history.

The History: How We Got Here

Before 2000: Every Deal Was Custom

Before digital advertising, every transaction was negotiated individually. Agency calls publisher. Publisher pitches inventory. Humans haggle over placement, pricing, and creative specs. An insertion order gets signed. The ad runs.

This worked at the scale of mid-20th century media. There were hundreds of publishers, not millions. Inventory was scarce and premium. A skilled buyer could hold all the relationships in their head. Strategy, memory, and accountability lived in those relationships.

Then the internet happened, and the number of publishers, ad units, and potential impressions exploded by orders of magnitude. The old model collapsed under its own weight. A new shared language was needed.

The First Wave: Ad Servers and VAST (Early 2000s)

The first digital advertising protocols appeared as responses to specific, painful operational problems, not strategic ones.

VAST, the Video Ad Serving Template, was introduced by the IAB in 2008 to solve a maddening technical issue: every video player handled ads differently, and every ad server had to build a custom integration for each one. VAST gave publishers and advertisers a common format for video ad delivery. Any ad server that spoke VAST could reach any video player that spoke VAST. The online video advertising market could finally scale.

It was an elegant solution. It solved exactly what it was designed to solve: the mechanics of getting a video ad from a server to a player. What it could not solve, and did not try to solve, was whether that ad was running in the right context, for the right audience, in service of a strategy anyone had actually defined. The operational plumbing got standardized. The strategic layer remained entirely outside the system.

The Programmatic Revolution: OpenRTB (2010 onward)

The protocol that defined the last decade of advertising was OpenRTB, the Open Real-Time Bidding specification.

Before OpenRTB, every ad exchange had its own bidding format. Every DSP that wanted to connect to a new exchange had to build a custom integration. The programmatic ecosystem was technically possible but operationally fragmented.

OpenRTB changed that. It defined a standard structure for the bid request and the bid response. Suddenly, a DSP could connect to any exchange that spoke OpenRTB. An SSP could receive bids from any DSP. The programmatic ecosystem scaled to hundreds of billions of dollars in spend because the infrastructure was interoperable.

OpenRTB was a remarkable engineering achievement. But read what it was designed to do: answer the question "what is this impression worth right now?" at the transaction layer, in milliseconds, at scale. It answered that question extraordinarily well.

It was never designed to answer the questions that actually drive brand outcomes. Where should this budget go over time? What context surrounds this impression? What happened in the last campaign, and what should change? What does this brand stand for, and where will it refuse to appear? Those questions had no place in the protocol. They lived in spreadsheets, emails, and phone calls, and they never traveled with the buy. Every impression was a fresh start. No memory. No strategy. No accountability built into the architecture.

The Patchwork Era (2015 onward): Workarounds as Infrastructure

The industry's response to OpenRTB's structural limits was a decade of workarounds, each one solving a real problem, none of them changing the underlying architecture.

Programmatic Guaranteed created a path for guaranteed buys, but each platform implemented it differently. Brand safety classification emerged, but through third-party vendors bolted onto the auction after the fact. Private marketplaces let buyers negotiate with specific publishers, but through yet another layer of custom integrations. First-party data strategies emerged to address identity loss, but audience activation required different processes on every platform.

By the mid-2020s, the average media plan touched dozens of platforms, each with its own API, its own terminology, its own reporting format. Adding a new publisher meant building a new integration. Strategy still lived outside the system. Memory still reset with every campaign. Accountability was still distributed across a supply chain of intermediaries, none of whom owned the outcome.

The infrastructure had become the ceiling. And crucially, that ceiling was a governance ceiling as much as an operational one. The system could measure clicks. It could not remember intent.

The Missing Layer

Here is the thread that runs through all of it: every protocol built for advertising solved an operational problem. None of them were built to carry strategy, memory, or accountability.

HTTP made websites universally accessible. VAST made video ads technically deliverable. OpenRTB made impression-level allocation fast and liquid. Each was the right solution for the problem it was designed to solve.

But advertising is not just a logistics problem. It is a relationship problem. A brand problem. A governance problem. The infrastructure built over twenty years was extraordinary at moving money efficiently. It was never designed to move intent.

That is the gap AdCP was built to fill. Not incrementally, on top of what existed, but as a new foundation designed for a different objective from the start.

AdCP: The Protocol Built for a Different Question

AdCP, the Ad Context Protocol, is the open standard for agentic advertising. It is the common language that allows AI agents across the entire advertising value chain to discover inventory, plan campaigns, execute buys, generate creative, govern decisions, and report results across any platform, any format, any channel. Without a shared language, every integration is custom, every new partner is a new project, and agents from different platforms cannot collaborate because they cannot communicate.

But AdCP is not just a more modern version of OpenRTB. It answers a fundamentally different question. Where OpenRTB asked "what is this impression worth right now?", AdCP asks "where should this brand invest over time?" One optimizes a transaction. The other coordinates decisions, with human judgment embedded in the architecture from the start.

AdCP is built and maintained by AgenticAdvertising.org (AAO), a global nonprofit organization of more than 150 members and 2,000+ certified practitioners spanning brands, agencies, publishers, and technology platforms. The cross-industry makeup is deliberate: the members writing the standards are the same ones whose agents run on them. No single interest writes the rules for everyone else.

AdCP 3.0: Expanding the Foundation

AdCP launched in late 2025. Six months later, AdCP 3.0 marked the protocol's first major structural expansion, moving beyond media execution into the full advertising lifecycle.

The significance of 3.0 was not any single feature. It was the scope of what became standardized for the first time. Brand identity, which had always lived in PDFs and brand books requiring human interpretation at every step, became machine-readable through brand.json. Any authorized agent — a creative tool, a buying platform, an AI assistant — could read a brand's identity directly and apply it immediately. No manual handoff. No interpretation errors. A brand's values, visual guidelines, and constraints traveling with the campaign rather than being left behind at the brief stage.

Governance, which had always been a patch applied after the auction, became architectural. AdCP 3.0's governance protocol means that before any campaign executes, budget authority, brand safety, and regulatory compliance are validated automatically. If an action exceeds a human's pre-approved authority, the system escalates and the agent cannot proceed until a human approves. The audit trail that accountability requires is generated by design, not reconstructed after the fact.

Creative production, which had required separate workflows, separate specs, and separate asset management for every channel, became a single workflow. One brief. Every format. Every seller. Simultaneously.

And the channel universe expanded from 9 to 20, including linear TV, streaming audio, gaming, influencer, and sponsored intelligence inside AI assistants, all transactable through the same protocol as digital display.

What 3.0 established was a foundation where strategy, governance, and brand identity are not features layered on top of the transaction. They are the condition of every transaction.

AdCP 3.1: From Foundation to Production Infrastructure

If 3.0 proved the model could work end to end, 3.1 is what comes from actually running it at real volume with real agents making real buys.

AdCP 3.1 is now generally available. The headline is production-hardening: closing the gaps that appear not in design documents but in the moments where a real campaign breaks down into manual intervention.

The most meaningful improvements address the operational realities of running at scale. When something breaks mid-campaign — a creative gets pulled or an audience is suspended — 3.1 makes the degraded state queryable. The buy tells you which dependency went offline, which packages it affects, and what to do next, eliminating the support tickets and delayed discovery that characterized the old model.

Brand verification moved from assertion to proof. In 3.1, brand verification responses must be cryptographically signed, closing the gap between an agent claiming to act for a brand and that brand having actually authorized it.

Version negotiation became explicit. Sellers now advertise which versions they support. Buyers declare which version they are built against. The compatibility handshake is stated, not assumed.

The floor for what "working at scale" means has raised significantly.

What to Expect Going Forward

AdCP follows a structured release cadence. Major releases introduce structural expansions. Minor releases add capabilities while maintaining full compatibility. Patch releases address conformance and documentation without touching the wire format.

The standard is public. The documentation is open. The limitations page tells you exactly what is not covered yet, because the credibility of a standard is measured by its gap list as much as its feature list. And the people who decide what gets built next are AAO members, through working groups, an elected board, and an open RFC process.

The Throughline

Every protocol in this history solved the problem it was designed for. HTTP gave every device access to every website. VAST gave every ad server access to every video player. OpenRTB gave every buyer access to every auction.

What none of them were designed for: strategy, governance, memory, accountability. The things advertising has needed for twenty years and kept trying to patch in after the fact.

AdCP is the first protocol designed for those things from the start. Not because the operational problems are solved, but because the operational problems were never the hard part. The hard part was building infrastructure that could carry intent, enforce accountability, and remember what it decided and why.

That infrastructure exists now. It is running. And the global community of AAO builders shaping where it goes next is growing every week.

Go deeper:

📄 AdCP documentation — https://docs.adcontextprotocol.org/docs/intro

📋 AdCP 3.1 Release — What's New in 3.1

🎓 Get certified — https://agenticadvertising.org/certification

🤝 Become a member — https://agenticadvertising.org/membership