By IAB Tech Lab formally named its umbrella agentic advertising initiative AAMP, the Agentic Advertising Management Protocols, on February 26, 2026. Kochava opened its StationOne platform to public beta on March 25, making AAMP the first agentic advertising spec you can actually run code against in a sandbox environment. If you build or maintain ad tech infrastructure, this is the guide to what the spec covers, what works today, and whether it deserves a spot on your roadmap.
What AAMP is and why it exists
AAMP is not a single protocol. It is an umbrella initiative that brings together several IAB Tech Lab workstreams under one name. According to IAB Tech Lab's official page, the organization created the unified brand because practitioners kept conflating individual components, particularly ARTF and the Agentic Audiences framework, with the entire program.
The core problem AAMP addresses: as LLMs and autonomous agents enter programmatic advertising, there is no shared language for how a buyer agent talks to a seller agent, how either verifies the other's identity, or how an agent operates safely inside a real-time bidding environment where decisions complete in under 100 milliseconds.
Existing protocols like OpenRTB handle machine-to-machine transactions, but they assume the machines are deterministic systems running fixed logic. Agents are different. They generate plans, negotiate terms, and make judgment calls. AAMP provides the schemas, execution infrastructure, and trust layer so those agents can operate within the existing ad tech ecosystem rather than inventing a parallel one.
Anthony Katsur, IAB Tech Lab CEO, described the philosophy in a Digiday interview: "AAMP is built to support AI-driven workflows on open, trusted standards."
How it differs from OpenRTB and existing protocols
AAMP does not replace OpenRTB. It extends it.
According to IAB UK's overview of the initiative, AAMP builds on established programmatic infrastructure, extending protocols like OpenRTB, AdCOM, VAST, GPP, and TCF rather than replacing them. The IAB Tech Lab's position is that these standards represent compressed industry knowledge refined through billions of transactions.
Here is where the architecture diverges from what you are used to:
OpenRTB defines the bid request/response format between exchanges and bidders. It is synchronous, schema-driven, and assumes both sides are running predefined logic. The bid request arrives, your code evaluates it against targeting rules, and you return a bid or no-bid. There is no negotiation phase.
AAMP's Agentic Protocols layer adds a management layer on top. Buyer and seller agents can discover each other, negotiate deal terms, exchange audience signals, and complete setup tasks before any bid ever fires. The Agentic Direct SDK, already released as open source, uses the OpenDirect specification to enable automated buying and selling with publisher ad server integration.
ARTF (the Agentic Real-Time Framework) sits below the protocol layer and solves the performance problem. Agents running inside RTB environments need to operate within auction latency constraints. ARTF uses gRPC with protobuf serialization instead of JSON, runs agents in OCI-compliant containers, and according to IAB Tech Lab's documentation, reduces latency compared to standard ad serving response times. The ARTF GitHub repo exposes an MCP server with an extend_rtb tool that accepts OpenRTB bid requests and returns proposed mutations.
The key mental model: OpenRTB is the transaction format. AAMP is the framework that lets agents plan, negotiate, execute, and verify transactions using that format.
What the spec covers (with specifics)
AAMP is organized into three pillars. Each one addresses a distinct engineering problem.
Pillar 1: Agentic Foundations (ARTF)
This is the execution infrastructure. ARTF defines how agent services operate inside a host platform. The spec mandates OCI-compliant containers manageable through Kubernetes, Docker Compose, or cloud container services like Amazon ECS. Security architecture prohibits external network access entirely; all ingress and egress is limited to service communications with the orchestrating entity. Each agent must declare specific intents and any auction modifications, allowing the host to accept or reject changes before they take effect.
The MCP interface is built directly into the specification. The Container Project Working Group that developed ARTF included participants from Amazon Ads, Index Exchange, OpenX, The Trade Desk, Netflix, Yahoo, and Paramount, according to PPC Land's coverage of the ARTF release.
Pillar 2: Agentic Protocols
This is the management and communication layer. It includes several sub-specifications:
- Agentic Direct: automated buying/selling via the OpenDirect specification. Reference SDK is open source on GitHub.
- Agentic Audiences: originally donated by LiveRamp as the User Context Protocol in November 2025, this defines how agents exchange identity, contextual, and reinforcement signals.
- Agentic Mobile: donated by CloudX, supporting agentic workflows within mobile app ecosystems.
- Agentic Ad Object: derived from AdCOM, the existing advertising common object model used by OpenRTB.
- Buyer and Seller reference agents: open-source reference implementations available on GitHub (buyer, seller).
The protocols support four transaction modes: direct transactions via OpenDirect, programmatic deals via the Deals API, private marketplace setups, and open bidding through standard OpenRTB.
Pillar 3: Trust and Transparency (Agent Registry)
The Agent Registry is a neutral directory where companies register their AI agents. As of March 2026, the registry contains 10 active entries, all operating under MCP, with participants including Amazon, Optable, Dstillery, Burt Intelligence, and HyperMindZ.ai, according to PPC Land's registry coverage. Each company is validated against its IAB Tech Lab GPP and TCF ID. The registry classifies agents into three deployment types: Remote (cloud/SaaS), Local (downloadable), and Private (on-premise/VPC).
Registration is free and open to non-members.
What is production-ready vs. draft
Be specific about what you can ship against today and what is still forming:
Available now (open source, testable):
- ARTF v1.0: released for public comment November 2025, reference implementation on GitHub
- Agentic Direct SDK: uses OpenDirect 2.1, open source
- Buyer Agent and Seller Agent reference implementations: open source on GitHub
- Agent Registry: live, accepting registrations, 10 active entries
- StationOne workspace: open beta as of March 25, 2026, with 19 skills across 8 functional areas running the official IAB Tech Lab reference MCP server
Still in development:
- Agentic Guardrails (sandboxing, cryptographic verification, intent declarations): listed in AAMP architecture diagrams but described as still in development
- A2A (Agent-to-Agent) protocol support: the registry currently shows zero A2A entries; all 10 agents are MCP servers
- Agentic Mobile: donated by CloudX but integration status is unclear from public documentation
- Linear TV, radio, and out-of-home extensions: IAB Tech Lab says they are working on these internally
The honest gap: AAMP has reference implementations and a sandbox, but zero reported production deployments processing real ad spend. The StationOne workspace explicitly lets you "experiment with agentic workflows without executing real transactions," per Kochava CEO Charles Manning's announcement. If you need production case studies before committing engineering resources, they do not exist yet.
Decision framework: integrate now, wait, or monitor?
Your answer depends on where you sit in the stack.
Integrate now if you are an SSP, DSP, or exchange that participated in the ARTF working group (Amazon Ads, Index Exchange, OpenX, The Trade Desk, etc.). You helped write the spec. Your competitors are testing it. Getting ARTF container support into your infrastructure gives you a head start on hosting third-party agent services.
Build a prototype if you are an agency or brand-side engineering team that manages programmatic buying. Clone the buyer-agent repo, spin up StationOne, and run through the Agentic Direct workflow. The 19-skill workspace covers the full campaign lifecycle from brief creation through DSP activation. You will learn more about the spec's maturity in two days of hands-on testing than in two months of reading about it.
Monitor if you are a smaller ad tech vendor or publisher with limited engineering bandwidth. The spec is moving fast, with ARTF releasing in November 2025, the AAMP name landing in February 2026, and Kochava's open beta arriving in March 2026. Waiting for one more quarter will give you production deployment data and a clearer picture of which pillars stabilize first. Register your agent in the registry (it is free) to signal participation without committing to a build.
The contrarian case: if your current stack is built on OpenRTB and standard deal mechanics and you are not experiencing pain that agents would solve, the honest answer is that AAMP does not solve a problem you have today. It solves a problem you might have in 12 to 18 months when your competitors' agents start negotiating deals with publisher agents and you are still doing it manually.
What integration looks like in practice
If you decide to prototype, here is what the path looks like:
Step 1: Get oriented with the repos. The AAMP hub on GitHub links to all child repositories. Each uses independent semantic versioning. Start with agentic-direct and the buyer-agent reference implementation.
Step 2: Stand up StationOne. Kochava's platform is now open beta with no invitation code required. The IAB Tech Lab workspace exposes 19 skills organized across Foundation & Setup, Planning & Strategy, Inventory Discovery, Campaign Execution, Creative Management, DSP Activation, Performance & Optimization, and Change Management. All skills run through the official IAB Tech Lab reference MCP server.
Step 3: Run the Agentic Direct workflow. The documented demo flow creates a media plan from a brief, negotiates with the seller agent, confirms the transaction, and pushes it to Google Ad Manager. This uses OpenDirect, AdCOM, and the Content, Audience, and Privacy taxonomies.
Step 4: Evaluate ARTF if you run exchange infrastructure. The ARTF agent runs as an OCI container. The MCP server accepts OpenRTB bid requests via the extend_rtb tool and returns proposed bid request mutations. You can test this against your existing bid stream without modifying your auction logic by treating agent outputs as proposals that your system accepts or rejects.
Step 5: Register in the Agent Registry. Even if you are only monitoring, registration is free and gives your agent a verified identity in the ecosystem. You will need your IAB Tech Lab GPP/TCF ID, your domain, and your legal entity details.
For teams evaluating how AAMP fits into organizational workflows, our guide on preparing your media ops team for autonomous campaign buying covers the operational readiness side. And if you are thinking about governance, who owns the AI agent that just bought $200K of media addresses the accountability questions that the spec intentionally does not answer.
When NOT to implement AAMP
Do not build against AAMP if:
Your ad tech stack is not yours. If you are a brand or agency using managed DSP/SSP services and do not control the underlying infrastructure, AAMP integration is your vendor's job, not yours. Ask The Trade Desk, DV360, or your SSP partner when they plan to support AAMP agent hosting. Do not build middleware to bridge a gap your vendor should close.
You are looking for a plug-and-play solution. AAMP is a set of protocols and reference implementations, not a product. The reference agents are starting points for building your own, not turnkey software. If your team does not have engineers comfortable with gRPC, protobuf, MCP, and container orchestration, the learning curve will eat your timeline.
You conflate "agentic" with "automated." If your actual need is better automation of existing workflows, like automated bid rules or templated campaign setup, you do not need agent-to-agent communication protocols. You need better scripts. AAMP is designed for scenarios where AI agents make judgment calls and negotiate with other AI agents. If your workflows are deterministic, OpenRTB and your existing APIs are fine.
Your compliance team has not weighed in. Autonomous agents making media buying decisions raises questions about accountability, audit trails, and spending authority that AAMP's trust layer only partially addresses. The Agent Registry verifies identity, but it does not define who is liable when an agent overspends or buys inventory that violates brand safety policies. Get your legal and compliance teams aligned before writing code.
What we do not know yet
- Whether any company will run AAMP-based agents against live ad spend in 2026, or if production deployments remain 12+ months away
- How the Agentic Guardrails specification will handle the edge cases that emerge when agents make real purchasing decisions at scale
- Whether MCP will remain the dominant transport or if Google's A2A protocol will gain traction in the registry (currently zero A2A entries)
- How existing DSP and SSP vendors will position AAMP relative to their own proprietary automation features
Sage Thornton covers developer tools and technical infrastructure for The Daily Vibe.
