AdCP (Ad Context Protocol) and AAMP (Agentic Advertising Management Protocols) are the two emerging open standards governing how AI agents communicate across advertising systems. AdCP defines the campaign-layer language between buyers and sellers; AAMP extends real-time bidding infrastructure for agent use. Both solve for how agents talk to each other, but neither solves for how agents act within publishing platforms.

---

When AI agents plan, buy, and execute tasks for multichannel advertising campaigns, they need a way to communicate across systems that were never designed to talk to each other. Right now, the same term means different things depending on which platform you're on: a frequency cap in The Trade Desk isn’t configured the same way as one in Meta. Basically, even though the vocabulary overlaps, the implementations don't. 

Adding an AI agent to the mix by asking it to negotiate a multi-channel media plan and execute it without breaking a single campaign rule is impossible without resolving those differences into something agents can act on reliably. This is the exact challenge facing digital advertising today. AI agents are entering media buying, but ad tech systems were never built to talk to autonomous software, let alone each other. 

Plus, digital advertising has its own vocabulary. Generic AI models don't naturally understand industry-specific constraints like frequency caps, flighting schedules, or custom deal IDs. 

AdCP (Ad Context Protocol) and AAMP (Agentic Advertising Management Protocols) are open AI standards built to address these barriers to running agentic advertising. Think of AdCP and AAMP as the universal languages (or protocols) that the ad industry has collectively agreed to speak. 

These protocols allow a buying agent on one platform to negotiate, verify compliance, and pass structured instructions to a selling agent on another, all without falling back on ambiguous text notes or custom-coded API hacks. Without these protocols, you’d have to custom-build every agent-to-agent integration: a major roadblock to scalable agentic advertising operations.

While these protocols solve how agents talk to each other, they don’t solve how agents act inside complex, walled gardens like Meta or Google. Bridging the gap between open protocols and having agents reliably execute on-strategy tasks requires you to pair these communication standards with a deterministic, rule-based execution layer.

This article explains what AdCP and AAMP are, how they work together in agentic workflows, and where they differ. It also covers what to ask agentic advertising vendors about open standard support, governance enforcement, and whether their solution has actually run at scale.

What is AdCP (Ad Context Protocol)?

AdCP (the Ad Context Protocol) is an open standard that defines how AI agents discover, plan, buy, sell, and measure digital advertising across every channel. It is published by AgenticAdvertising.org (AAO), an independent industry organization, with 116+ member companies including Yahoo, PubMatic, Scope3, and Samba TV. The standard is built on MCP (Anthropic's Model Context Protocol) and supports Google's A2A (Agent-to-Agent) protocol as a second transport layer. 

By using AdCP, your company can give advertising-specific instructions that make sense to AI agents. Without this protocol, an agent likely wouldn’t understand how to perform a nuanced ask specific to digital advertising. That could (and very likely would) cause major issues for your campaigns. 

For example, AdCP makes it possible to ask an agent to apply a 5-impression weekly frequency cap to a direct campaign. AdCP enables the agent to understand how to encode and communicate that constraint as a structured deal term a seller's agent can read and enforce. Without AdCP, the agent would likely embed the constraint in a free-text note that every seller agent interprets (or ignores) differently. 

AdCP covers the full campaign lifecycle through a set of defined tasks, including: 

• publisher discovery via adagents.json, 
• commercial account setup (sync_accounts)
• inventory discovery and negotiation (get_products)
• campaign execution (create_media_buy, update_media_buy)
• creative generation and distribution (build_creative, sync_creatives)
• audience data activation (sync_audiences)
• signal sourcing (get_signals, activate_signal)
• governance (check_governance, get_plan_audit_logs)
• performance reporting (get_media_buy_delivery)

Plenty of advertising tech hints at what you can achieve with agentic advertising through hypothetical use cases or narrow, closed-loop demos. AdCP is proof that agent-to-agent digital advertising operations are viable: the first agent-to-agent media buy in history was executed under AdCP on October 16, 2025. This fully agentic media buy used real money and live inventory from LG Ads, not hypotheticals, and was executed without human intervention.

It’s also important to note that AdCP operates asynchronously. This means that human-in-the-loop approvals are architecturally supported, not bolted on later.

What is AAMP (Agentic Advertising Management Protocols)?

AAMP (the Agentic Advertising Management Protocols) is IAB Tech Lab's umbrella initiative for developing agentic advertising standards, with a strong emphasis on programmatic infrastructure. It’s an open-source initiative with public GitHub repositories. AAMP was formally published on March 16, 2026, and is organized across three pillars: Agentic Foundations, Agentic Protocols, and Trust and Transparency. 

• The Agentic Foundations pillar houses ARTF (the Agentic Real-Time Framework), which defines how AI agents operate inside real-time programmatic bidding environments. This pillar addresses a structural constraint in programmatic media buying: programmatic auctions require a response in milliseconds—significantly faster than a live LLM call can return. AAMP's agentic programmatic bidding solution relies on pre-decisioning. The LLM makes decisions in advance, caches them, and then executes the right decision as soon as the right auction conditions pop up, cutting latency by 80%. 
• The Agentic Protocols pillar defines schemas, SDKs (Software Development Kits), and reference implementations for buyer and seller agent interactions. Some of these interactions include inventory discovery, deal negotiation, and order execution. This pillar builds on the existing IAB Tech Lab standards already in widespread use today (such as OpenRTB, AdCOM, and OpenDirect) rather than replace them. 
• The Trust and Transparency pillar provides a neutral Agent Registry for identity verification across the ecosystem. AAMP is an open-source initiative with public GitHub repositories for Agentic Direct and reference Buyer and Seller Agent SDKs.

The biggest challenge that AAMP solves right now is the gap between LLM response times and the real-time demands of programmatic media buying. When a programmatic bid request fires, every node on the supply chain (DSPs, exchanges, SSPs) needs to respond within milliseconds. Even though LLM calls only take a matter of seconds, they’re way, way too long to be used within a live programmatic auction.

But there’s a bigger issue with using LLMs within live media buying auctions. LLMs are probabilistic. The exact same bid opportunity could produce two different responses from the LLM. Stretch that out over an agentic system processing billions of auctions a day, and you’ve got a major liability on your hands. 

AAMP’s pre-decisioning architecture ensures that an LLM’s reasoning gets called before the action, not during it. The LLM decides what to do, caches the right decision, then executes deterministically when the right auction conditions arise. In other words, you can still use an LLM to influence the right outcome, but its reasoning takes place outside the real-time constraints of programmatic buying. 

What's the difference between AdCP and AAMP?

AdCP and AAMP both tackle the challenge of getting AI agents to communicate and transact across advertising systems, but they operate at different layers of the advertising stack. 

AdCP governs the campaign management layer: how buyer and seller agents discover inventory, negotiate deals, execute buys, manage creative, and govern spend. AAMP primarily governs the programmatic infrastructure layer, particularly as it relates to how AI agents operate inside real-time bidding systems at sub-second execution speeds. 

This means advertisers can use AdCP and AAMP together in their agentic strategies. For instance, a single AdCP create_media_buy transaction can trigger thousands of impression-level events. These events can flow through an AAMP-aligned programmatic infrastructure so you can execute each impression-level event in real time, at auction speed.  

AdCP and AAMP are complementary, not competing, AI protocol standards

Sometimes AdCP and AAMP are positioned as competing standards fighting for the same ground. This isn’t the case. In fact, most production agentic advertising solutions rely on both AdCP and AAMP because these standards solve different problems within different layers.

As you evaluate agentic advertising tools, make sure to ask whether the vendor supports open standards (like AdCP and/or AAMP) or if they’re building a proprietary communication layer. Ideally, they’re using open standards built by an initiative like AdCP and which are shared by major players in the digital advertising ecosystem: publishers, DSPs, and even data providers like Yahoo, PubMatic, and Scope3.

Be wary of agentic advertising solutions that rely exclusively on proprietary layers: they can lock you into one vendor's interpretation of how agentic advertising should work. If the vendor’s interpretation starts drifting away from industry-established best practices, you may have to rebuild your entire agentic stack if you ever opt to switch vendors.

Why AdCP and AAMP don't solve your governance problem

AdCP and AAMP standardize how agents communicate and how transactions are structured, but neither protocol governs what an agent does when it acts on those messages. Essentially, agent communication and agent behavior are separate problems to solve.

The separation between "what an agent understands" and "how an agent acts" is why a buyer agent can correctly parse a seller's AdCP response and still implement a budget decision that violates your client's stated spend requirements.

Protocols can carry and follow governance rules, but they can’t create them. For example, AdCP includes a check_governance task that carries governance decisions between agents — but the rules themselves have to come from elsewhere.

Governance rules (and the system that enforces them consistently across platforms) have to come from and live somewhere else. These rules determine what agents can and can't do, plus when to involve a human. They’re also a must for agentic workflows. Governance keeps agents from exceeding set budget limits, targeting audiences outside approved demographic parameters, and serving ads in geographic markets outside the approved media plan. 

How do agencies enforce governance across multiple ad platforms?

It is critical to hard-code governance rules at the task execution layer to keep agents operating within your strategic bounds across ad platforms. Your agency needs a way to enforce your rules above the probabilistic AI layer so agents cannot circumvent them through inference.

In other words, feeding governance rules to an LLM via context or in individual prompts won’t cut it. (At this point, we've all seen AI drift from strict rules given to the model as instructions or requirements for a task.) 

This is particularly challenging for ad agencies because they need to enforce different client rules across every platform. Setting governance rules inside each individual platform doesn't solve the problem. A rule set inside Google Ads does nothing to enforce the same constraint on Meta. A brand safety requirement configured in your DSP doesn't carry over to TikTok. Each platform governs itself, and nothing governs the whole.

What agencies need is governance set at the client or account level. This means rules can follow the campaign across every platform automatically, without humans re-entering or re-verifying each one. That's only possible with a governance-maintained layer that sits above the platforms, not inside them.

Agentic advertising solutions like Fluency can help. For the last eight years, Fluency has helped advertisers manage cross-platform account-level governance at scale across all major channel types.

What AdCP and AAMP mean for agency and brand media teams right now

Practitioners close to AdCP and AAMP estimate that meaningful AdOps transaction volume through agentic workflows—real budget, at scale, across a typical client portfolio—is likely five or more years out. 

But that doesn't mean you should wait to start setting up the right infrastructure or documenting operating procedures within your agency.

Taking the time to verify and update your current campaign playbooks, decision trees, and human-managed operating procedures is a fantastic way to lay the groundwork for machine-readable governance infrastructure. Doing this up-front work means that, no matter what combination of platforms, protocols, and agentic tools emerge over the coming months, your agency will be ready to hit the ground running. 

Setting these rules up is worth doing before asking agents to make decisions at scale. But as AI agents evolve to operate across more of the stack, you’ll still need a way to keep governance tied to your accounts or campaigns instead of isolated platforms. 

How to evaluate agentic advertising vendors

The agencies best positioned for agentic advertising are the ones taking the time to evaluate their current documented processes and build governance rules now. Still, there’s a very good chance you’ll need a technology partner in the future to bring your agentic strategies to life. 

As you evaluate agentic advertising tech vendors, make sure to ask: 

• Do you support AdCP and/or AAMP open standards, or are you developing a proprietary agent communication standard?
• Is agent governance enforced at the channel level, account level, or campaign level? Some other way? 
• Has governance been in production at scale, or is it still a hypothetical use case? 

Integrating a solution like Fluency means you can enforce rules for your agents across walled gardens, DSPs, and the open web simultaneously. 

If you’re looking for advice on getting started with agentic advertising, check out our article on enforcing multichannel brand compliance or our 4-step framework for building scalable agentic advertising workflows.

Frequently asked questions

What does AdCP stand for?

AdCP stands for Ad Context Protocol. It is an open standard published by AgenticAdvertising.org that defines how AI agents discover, plan, buy, sell, and measure advertising across channels. Built on Anthropic's Model Context Protocol, AdCP operates at the campaign management layer, above real-time bidding infrastructure. 

What does AAMP stand for?

AAMP stands for Agentic Advertising Management Protocols. It is IAB Tech Lab's umbrella initiative for agentic advertising standards, formally published March 16, 2026. AAMP is organized across three pillars: Agentic Foundations, Agentic Protocols, and Trust and Transparency. This initiative builds upon IAB Tech Lab’s existing and widely used AI standards, including OpenRTB, AdCOM, and OpenDirect for agent use.

Are AdCP and AAMP competing standards?

No, AdCP and AAMP are complementary because operate at different layers of the advertising stack. AdCP governs campaign management (how agents discover inventory, negotiate deals, and execute buys), whereas AAMP governs programmatic infrastructure, especially how AI agents operate inside real-time bidding systems. For instance, a single AdCP media buy can trigger thousands of impression-level events handled through AAMP-aligned infrastructure. 

Do AdCP and AAMP handle AI agent governance?

AdCP and AAMP can carry out governance rules but the rules themselves must be defined and enforced by a separate system. Governance and communication are different layers within an agentic architecture. AdCP and AAMP are protocol languages that standardize how agents communicate and how transactions are structured, but they do not dictate how agents behave when they receive those messages.

Does AdCP replace OpenRTB?

No, AdCP operates at the campaign management layer, which sits above the real-time bidding infrastructure governed by OpenRTB. Both are used to deploy agentic advertising XXX. AAMP (not AdCP) is the framework that extends OpenRTB for agent use. AdCP handles inventory discovery, deal negotiation, creative management, and campaign governance; OpenRTB handles impression-level auction mechanics.