AdCP / Advertising Context Protocol.
A practical guide to the open protocol layer for agentic advertising workflows: discovery, planning, buying, creative, signals, governance, accounts, and measurement.
AdCP gives advertising agents a shared task and schema layer. It helps buyers, sellers, platforms, data providers, and creative systems communicate through standardized advertising actions rather than bespoke dashboard workflows and one-off integrations.
AdCP is not a replacement for OpenRTB, clean rooms, or human judgment. It is a protocol layer for making advertising work discoverable, executable, governable, and auditable by agents.
- AdCP 3.0 GA · v3.0.16
- AdCP 3.1 RC.14
- v2 deprecates Aug 1, 2026
- Sponsored Intelligence experimental
Fast read
- What it is
- An open agentic advertising protocol that defines domain-specific tasks and schemas for advertising agents.
- What it does
- Helps agents discover inventory, set up accounts, buy media, manage creative, activate signals, apply governance, and report results through standardized calls.
- What it is not
- Not a media exchange, identity graph, DSP, SSP, clean room, or replacement for OpenRTB.
- Why it matters
- Agentic workflows need repeatable, machine-readable actions. Without a shared protocol, every agent has to learn every platform separately.
- Current state
- AdCP 3.0 has reached general availability (current patch v3.0.16); 3.1 is in release-candidate validation (currently v3.1.0-rc.14). Validate implementation details against current official docs.
- Best next step
- Understand the domains, then decide which workflow your company should expose or consume first.
What AdCP is.
AdCP is a shared advertising task layer for AI agents. It defines what agents can ask for, what systems should return, and how actions move through the advertising workflow.
| Layer | Job | Example |
|---|---|---|
| Transport | Carries messages | MCP / A2A |
| AdCP | Defines advertising tasks and schemas | get_products, create_media_buy, get_signals, activate_signal |
| Execution system | Performs the action | publisher, SSP, DSP, creative system, data provider |
| Governance | Controls authority and audit | approvals, signatures, idempotency, audit logs |
| Existing ad standards | Power underlying objects and transactions | OpenRTB, AdCOM, OpenDirect, Deals API |
Why AdCP exists.
Fragmented workflows
Media buying, creative, data activation, accounts, and reporting still live across disconnected systems and dashboards.
Agents need actions, not screens
An agent cannot scale by clicking through every platform UI. It needs task-level interfaces.
Common schemas reduce ambiguity
Natural-language briefs need to resolve into structured, auditable requests.
Human oversight needs architecture
Agentic buying requires approvals, limits, audit logs, and accountability built into the flow.
Platform participation needs standards
Publishers, data providers, creative systems, and ad platforms need a shared way to expose what agents are allowed to do.
AdCP 3.1 RC watchlist.
3.0 is the current general-availability line; 3.1 is in release-candidate validation. Separate what is confirmed from what to validate and what to watch.
Confirmed from official docs
- AdCP 3.0 has reached general availability — current patch v3.0.16 (June 14, 2026); v2 is fully deprecated on August 1, 2026 (UTC).
- v3.0.16 backports compliance-storyboard fixes and adds a required seller_agent_url field on context_match_request.
- AdCP 3.1 is in release-candidate validation — current pre-release v3.1.0-rc.14, described as additive over 3.0.
- A required idempotency_key on every mutating request; RFC 9421 HTTP Message Signatures (optional in 3.0, required for AdCP Verified).
- One stated 3.1 breaking change: typed enums + ISO 3166-1 country codes for trademark fields.
Validate before implementation
- Schema version and exact task names
- Protocol domain changes and MCP / A2A transport assumptions
- Security / signing and governance-task requirements
- Registry / discovery and signals-protocol changes
- Compatibility with 3.0; deprecations or breaking changes; certification implications
Watch next
- 3.1 GA date and final scope; wire-version transition from "3.1-rc.14" to "3.1"
- AdCP Verified independent auditing (self-attested in 3.0)
- Signals-protocol maturity, registry adoption, and creative-generation workflows
- Measurement / event reporting, SDKs, and reference implementations
- Curation — listed as "coming soon," not yet a protocol domain
Contributions to the protocol.
This page is written from inside the work: No Fluff Advisory builds and operates a live AdCP signals agent (listed in the AAO registry) with all-pass runs on the 3.0 GA and 3.1.0 release-candidate storyboard suites, and contributes upstream in the Signals & Measurement working group.
Merged into the protocol & tooling
- last_updated on signal-definition — schema field for verifiable signal-record freshness (#5248 → PR #5249, in the 3.1.0 line since rc.7).
- Compliance-grader fix — all-pass single-protocol runs rendered “Degraded” by a rollup regression; root-caused to the introducing commit, filed (#5429, triaged P0) and fixed (PR #5444, merged).
- RFC 9421 webhook-signing default — the inventory (#4270) and draft PRs (#4273/#4275, closed in favor of the maintainer implementation) that drove the 3.0.9 realignment away from the deprecated HMAC framing.
Conformance suite, hardened
- Signals-only agents now skip non-applicable media-buy gating and gained dedicated error-handling / schema-validation storyboards (#2916, #3350, #4009 — fixed in the 3.1.0 suite; earlier #2535, #3999, #4065).
- Shaped in review — the signal-definition epistemic / provenance layer (#5017, maintainer-authored): contributed the implementer wire-size data (88 KB for 5 signals vs the 64 KB probe ceiling) that drove the progressive-disclosure design, plus field-level schema review.
Open proposals
- Runtime attestations RFC — verifier-signed signal-quality evidence on check_governance (#5418; issue titled for 3.1, the posted RFC proposes it as a 3.2 candidate).
- revoke_activation revocation primitive (#4203) · Measurement Feedback Signal (#4296).
- RFC 9421 migration coordination (#4205) · JWKS adoption baseline (#4206).
Contribution statuses validated June 2026 against the public AdCP repository; open proposals are point-in-time and may merge, change, or close. Maintainer-authored work is credited as review influence, not authorship.
Protocol domains.
AdCP organizes work into domain-specific tasks and schemas. Task names below are drawn from current official documentation.
-
Media Buy
Inventory discovery, campaign creation, delivery reporting.
get_products · create_media_buy · get_media_buy_delivery -
Creative
Creative format discovery, building, preview, distribution.
build_creative · preview_creative · list_creative_formats -
Signals
Audience and contextual data discovery and activation.
get_signals · activate_signal -
Accounts
Commercial identity, billing, and usage reporting.
list_accounts · sync_accounts · report_usage -
Governance
Brand suitability, approval, policy, audit, content standards.
create_content_standards · calibrate_content -
Brand
Machine-readable brand identity and authorized agents via brand.json.
brand.json discovery -
Sponsored Intelligence
Conversational brand experiences on AI platforms.
Experimental surface in AdCP 3.0 -
Curation
Media inventory curation.
Listed "coming soon" — not a current domain
From brief to governed execution.
- Discover authorized agents — adagents.json, brand.json, registry
- Set up account context — commercial identity, billing, advertiser / operator relationship
- Discover inventory and products — natural-language brief into structured product responses
- Build or sync creative — formats, assets, brand identity, approvals
- Add signals — audiences, suppression, contextual signals, signal activation
- Check governance — budget, brand safety, targeting rules, approvals
- Execute, report, and audit — media buy, delivery, events, audit logs
Discovery starts from two machine-readable files — a publisher's adagents.json (who may sell its inventory) and a brand's brand.json (who may act for the brand, and how):
{
"publisher": "example-publisher.com",
"authorized_agents": [
{
"url": "https://sales-agent.example-ssp.com",
"role": "seller",
"properties": ["news", "sports"]
}
],
"signing_keys": [
{ "kid": "2026-key-1", "alg": "Ed25519" }
]
}{
"brand": "example-brand.com",
"display_name": "Example Brand",
"authorized_agents": [
{ "url": "https://agent.example-buyer.com", "role": "buyer" }
],
"identity": {
"logos": ["/brand/logo.svg"],
"colors": ["#1a1a1a", "#4a5a2e"],
"tone": "confident, plain-spoken"
},
"policy": { "restricted_categories": ["gambling", "politics"] }
}Signals: where AdCP meets signal containerization.
The signals layer is where AdCP becomes especially important for agentic advertising. Agents need to discover signals, understand what they mean, check provenance and policy, activate them, and monitor status. That is the same operating problem behind signal containerization — turning audience logic into a governed, executable object.
Discover
What signals exist and what do they mean?
Inspect
Where did the signal come from, how fresh is it, and what policy applies?
Activate
Where can the signal run: seller, platform, identity path, contextual path, or measurement layer?
Monitor
What is the activation status and what outcome did it improve?
An agent discovers signals with a natural-language brief, then activates the chosen signal to a destination — a single get_signals call rather than a taxonomy lookup:
{
"tool": "get_signals",
"arguments": {
"brief": "in-market for premium CTV, US households, privacy-safe",
"deliver_to": { "platform": "dsp", "account": "acct_123" },
"max_results": 10
}
}Governance is the trust layer.
Agentic advertising only works if actions are accountable. A protocol needs to know who called a tool, what authority they had, what was approved, what conditions applied, and what actually ran.
- Human-in-the-loop approvals (a three-party separation of duties)
- Idempotency keys on every mutating request
- Request signing (RFC 9421 HTTP Message Signatures)
- Correlated audit logs
- Governance checks and signed governance tokens
- Brand-safety and content-standard enforcement
- Budget thresholds and authority / role boundaries
The principle
Human judgment is embedded in the system design, not bolted on afterward — the human stays the locus of accountability.
Where AdCP fits with IAB Tech Lab standards.
AdCP is best understood as an agentic management and workflow layer. IAB Tech Lab's AAMP work extends existing standards with agentic foundations, protocols, and trust infrastructure; ARTF focuses on containerized real-time execution; Agentic Audiences on embedding-based signal exchange. These layers can be complementary with clear boundaries. See the IAB Agentic Standards guide.
| Initiative | Role | Best question |
|---|---|---|
| AdCP | Agent task / workflow language | What should the agent ask or do? |
| AAMP | IAB Tech Lab umbrella for agentic advertising standards | How do agentic foundations, protocols, and trust fit into existing standards? |
| ARTF | Containerized real-time execution framework | How can service agents run inside host infrastructure with low latency and controlled mutation? |
| Agentic Audiences | Embedding-based signal exchange | How do agents exchange identity, contextual, and reinforcement signals? |
| OpenRTB / AdCOM / Deals API / OpenDirect | Existing transaction and object standards | What underlying objects and transaction models should agentic systems reference? |
Implementation lens by company type.
Pick your company type to see what to expose or consume — and the AdCP domains it touches first.
Authorized agents, inventory products, packages, account setup, governance, reporting.
Partner discovery, product discovery, creative formats, media buy, governance, reporting.
Signal catalog, provenance, activation paths, pricing, policy, status.
Seller agents, deals, signals, governance, a real-time execution bridge, reporting.
Buyer agents, media buys, creative, signal activation, governance, measurement.
Formats, asset generation, preview, brand identity, approval workflow.
Delivery, event logging, attribution, audit, lift, governed outputs.
A protocol defines the task. It does not replace judgment.
The industry should avoid treating AdCP as a magic layer that makes agents safe by default. The protocol can define the task. It cannot replace commercial judgment, governance design, data rights, measurement discipline, or operating ownership.
- Start with one workflow, not every workflow.
- Expose the safest useful task first.
- Design governance before spend movement.
- Treat signals as governed objects, not just segment IDs.
- Build audit and status from day one.
- Connect protocol work to business outcomes, not demos.
Where this fits in the full standards stack.
The layer map
AdCP defines the agent workflow layer. It still needs transaction rails, privacy constraints, measurement trust, and evidence discipline around it.
Building around AdCP or agentic advertising standards?
Use the playbooks to map the workflow, governance, signal model, implementation path, and commercial productization before building against the spec.