Ad Context Protocol (AdCP)

Table of Contents

  1. Definition
    1. How AdCP relates to marketing
  2. How it works
  3. How to utilize AdCP
  4. How AdCP compares to adjacent protocols
  5. Best practices
  6. Future trends
  7. FAQs
  8. Related Terms
  9. Sources

Definition

The Ad Context Protocol (AdCP) is an open technical standard that lets AI agents communicate with advertising platforms, and increasingly with each other, using a shared structure for campaign data. It gives buyer-side agents, seller-side agents, creative tools, and data providers a common way to describe audiences, inventory, creative formats, and campaign objectives so that a media campaign can be planned and executed without a human clicking through each platform’s own dashboard.

AdCP runs on top of two transport layers: Anthropic’s Model Context Protocol (MCP), used when an AI assistant calls tools, and the Agent-to-Agent Protocol (A2A), used when agents collaborate directly. The same tasks and JSON schemas work across both. The protocol is governed by AgenticAdvertising.org, an industry organization rather than a single vendor, and it was announced on October 15, 2025 in New York by a consortium of ad tech companies.

A useful frame comes from Brian O’Kelley, the AppNexus founder and Prebid co-creator who now runs Scope3. He’s described AdCP as “the universal ads API” for the open web. The comparison that gets used most often, though, is OpenRTB: where OpenRTB standardized the millisecond auction that places a single impression, AdCP standardizes the layer above it, the negotiation and planning that happens before a buy and often outside the bidstream entirely.

Back to Top

How AdCP relates to marketing

For most marketers the friction AdCP targets is familiar. A campaign that runs across connected TV, display, online video, audio, and retail media usually means separate insertion orders, separate APIs, separate creative specs, and separate reporting screens for each channel. Adding a new channel means adding a new integration and training the team on another tool. AdCP’s pitch is that the same set of tasks works against every compliant seller, so adding inventory doesn’t mean adding headcount.

The timing matters because third-party identifiers keep losing reach, and buyers are shifting attention from broad demographic targeting toward intent and context. AdCP puts campaign intent and contextual signals at the center of how agents find inventory, which fits a privacy-constrained environment better than cookie-based addressability. It also sits next to a different problem: AI assistants are starting to recommend and surface products directly, and brands need a standard way to show up there. AdCP covers the advertising side of that shift, not the checkout.

Back to Top

How it works

AdCP organizes the campaign lifecycle into a set of protocol domains, each with named tasks. A buyer agent issues a task, a seller agent responds in a defined schema, and the two iterate.

Discovery starts with two machine-readable files. Publishers host adagents.json at a well-known path, declaring their properties and which agents are authorized to transact for them, roughly the way a site publishes robots.txt. Brands publish brand.json, which carries company identity, agent endpoints, and signing keys. A buyer’s agent reads both the same way a browser reads a config file, and a central registry run by AgenticAdvertising.org lets an agent search by category, channel, or capability, for example “CTV publishers with sports inventory.”

From there the main domains and a few of their tasks:

  • Media Buy — get_products sends one brief to every connected seller and gets back products in a single comparable format, with pricing, forecasts, and targeting. A “refine” mode lets the buyer adjust (“more CTV like this, up to $35 CPM; drop display”) without starting a new request. create_media_buy executes the campaign across sellers in one call, and update_media_buy handles mid-flight changes.
  • Creative — list_creative_formats returns each seller’s exact specs, build_creative generates assets from a single brief across multiple formats, and sync_creatives distributes finished assets to every seller at once.
  • Signals and Audiences — sync_audiences carries first-party segments (including suppression lists) with the campaign, while get_signals and activate_signal let a buyer discover and turn on third-party targeting data without a custom integration per platform.
  • Governance — check_governance runs before execution to validate budget limits, brand safety, and compliance. If a buy exceeds an agent’s authority, the governance agent escalates to a human, and get_plan_audit_logs records who proposed what and who approved it.
  • Trusted Match Protocol (TMP) — handles serve-time activation with a structural privacy split: a context match evaluates content signals, an identity match checks user eligibility through an opaque token, and the publisher joins the two locally so the buyer never sees identity and content together.
  • Brand Protocol, Accounts, and Catalogs — round out identity (get_brand_identity), commercial onboarding (sync_accounts), and product-feed sync (sync_catalogs).

Underneath, trust is enforced cryptographically rather than by convention. Requests are signed using RFC 9421 HTTP Message Signatures and verified against published JWKS keys, idempotency keys make a retried call safe instead of double-charging, and governance approvals travel as signed tokens so no agent in the chain can forge a sign-off.

Back to Top

How to utilize AdCP

There’s no single way to “use” AdCP, because the protocol is implemented by software rather than operated by a person. In practice, three groups touch it.

Platforms and publishers implement an AdCP agent that exposes their capabilities as tasks over MCP or A2A, then publish their adagents.json or brand.json records and test the implementation. A DSP, SSP, publisher, data platform, or creative tool each implements the domains relevant to its business, so a publisher focuses on Media Buy while a data provider focuses on Signals.

Advertisers and agencies work through an AdCP-enabled agent that connects to their media partners. Common cases: running one brief across every partner instead of four dashboards, distributing creative to all sellers from a single asset set, layering CRM and third-party data onto a buy without per-platform integration work, and pulling aggregated delivery into one report. Official client libraries exist for JavaScript/TypeScript (@adcp/sdk), Python (adcp), and Go (adcp-go).

Tool builders and vendors slot specialized agents into a workflow — a media-buying agent, a creative agent, a signals agent, a governance agent — coordinated by an orchestrator that makes sure a human approves what matters. The protocol ships compliance storyboards a test runner can execute against an agent, so a vendor’s claim that it supports a given flow is verifiable rather than asserted.

Back to Top

How AdCP compares to adjacent protocols

AdCP is easy to confuse with the commerce and bidding protocols announced around the same time. They operate at different layers and, for the most part, compose rather than compete.

ProtocolWho’s behind itWhat it standardizesLayer
AdCP (Ad Context Protocol)AgenticAdvertising.org consortiumHow agents discover inventory, negotiate, buy media, and reportCampaign / advertising
OpenRTBIAB Tech LabThe real-time auction that places a single impressionImpression (sub-200ms)
ARTF / AAMPIAB Tech LabUpdating RTB infrastructure so agents transact inside existing SSP/DSP environmentsImpression
ACP (Agentic Commerce Protocol)OpenAI and StripeProduct feeds, checkout sessions, payment handoffCommerce / checkout
UCP (Universal Commerce Protocol)Google and ShopifyThe full shopping lifecycle from discovery to post-purchaseCommerce
MCP (Model Context Protocol)AnthropicHow an AI model calls tools and reads contextTransport

The clearest dividing line is between AdCP and the commerce protocols. AdCP owns the path up to the handoff — surfacing the right offer, engaging the user, sending attribution back. ACP and UCP own the transaction itself. A platform that does both runs AdCP for “show the right ad and start the conversation” and ACP or UCP for “take the payment.” Neither replaces the other.

The line with OpenRTB and the IAB Tech Lab’s agentic work (ARTF and the broader AAMP effort, introduced in late 2025) is one of altitude. Those sit at the impression layer, inside the single auction. AdCP sits above, at the campaign layer, where a single create_media_buy can spin off thousands of impression-level events. A platform can implement both, and the standards bodies haven’t yet published a formal technical comparison because the IAB work is still stabilizing.

Back to Top

Best practices

  • Treat discovery files as production infrastructure. A stale or missing adagents.json or brand.json makes a publisher or brand invisible to buyer agents, so keep agent endpoints, capabilities, and signing keys current.
  • Implement only the domains you transact in. A data provider doesn’t need the full Media Buy surface, and a publisher doesn’t need the Signals provider flow. Scope the implementation to the business.
  • Wire governance in before granting autonomy. The escalation path and audit log are what let a team hand an agent more spending authority over time. Set the auto-approval thresholds and conditions first, then loosen them as the audit trail proves out.
  • Don’t skip signature verification. The RFC 9421 signing and JWKS verification are the difference between an open standard and an open door. Idempotency keys belong on every write so a dropped response and a retry don’t create a duplicate buy.
  • Validate against the compliance storyboards. Running the protocol’s test runner against your agent turns “we support media buy” into a checkable claim, which matters when other agents decide whether to transact with you.
Back to Top

The protocol launched with a small set of domains and was designed to expand, so expect the task surface to keep growing as agent-to-agent buying matures. Investment is following the same curve: AdsGency raised a $12 million seed round to build agentic cross-platform ad buying that lines up with AdCP’s AI-to-AI model, and founding backers including PubMatic, Yahoo, and Triton Digital are putting resources behind the organization.

Three things worth watching. First, whether AdCP and the IAB Tech Lab’s impression-layer work settle into a clean two-layer stack or compete for the same ground. Second, how the handoff to commerce protocols develops, since attribution from a sponsored AI conversation back through ACP or UCP checkout is still being worked out. Third, adoption breadth — the protocol is governed by a neutral working group and open to any implementer, but its value scales with how many publishers and platforms actually expose AdCP agents. Analysts have started fitting it into broader framings, such as Everest Group’s “4P” characterization (Policy, Protocol, Prediction, Performance), though that’s an outside lens rather than part of the specification.

Back to Top

FAQs

Is AdCP the same as the Agentic Commerce Protocol (ACP)? No. ACP, from OpenAI and Stripe, handles product feeds, checkout, and payment inside AI assistants. AdCP handles the advertising layer that comes before the purchase. They meet at the handoff, and a platform can run both.

Is AdCP replacing OpenRTB? No. OpenRTB runs the millisecond auction for a single impression. AdCP works at the campaign layer above that, where negotiation and planning happen. A single AdCP media buy can generate thousands of OpenRTB-style impression events.

Who owns AdCP? No single company. It’s a project of AgenticAdvertising.org, a neutral working group with publishers, platforms, agencies, and ad tech providers. Co-founding members include Yahoo, Optable, PubMatic, Scope3, Swivel, and Triton Digital.

What does AdCP run on? It’s built on Anthropic’s Model Context Protocol (MCP) for AI-assistant tool calls and the Agent-to-Agent Protocol (A2A) for agent collaboration. The same tasks and schemas work over either transport.

Do I need to be a developer to use it? The protocol is implemented in software, so day-to-day buyers interact with it through an agent, not by writing code. There are official SDKs for JavaScript, Python, and Go for teams that want to build their own agent, plus a hosted assistant for testing.

How does AdCP keep AI agents from spending money they shouldn’t? Through its governance domain. check_governance validates a buy against budget caps, brand safety, and compliance before it runs, and anything over an agent’s authority escalates to a human. Every decision lands in an audit log.

How is identity handled at serve time without leaking user data? The Trusted Match Protocol splits the match into two operations. One evaluates content, the other checks user eligibility through an opaque token, and the publisher joins them locally so the buyer never sees identity and content together.

Can publishers and platforms start implementing it now? Yes. The protocol is available for any company to implement, with discovery files (adagents.json, brand.json), client SDKs, and a compliance test suite published openly.

Back to Top
  • Model Context Protocol (MCP)
  • Agent-to-Agent Protocol (A2A)
  • OpenRTB
  • Agentic Commerce Protocol (ACP)
  • Universal Commerce Protocol (UCP)
  • Agentic Advertising Standards (IAB Tech Lab)
  • Programmatic Advertising
  • Commerce Media Network (CMN)
  • Conversational Advertising
  • MCP Server
Back to Top

Sources

Back to Top

Was this helpful?

Next

Agent Card