AAMP Explained: IAB Tech Lab's Agentic Advertising Management Protocols

Quick answer:

• AAMP is IAB Tech Lab's framework for advertising agents, not a single finished protocol.
• It has three pillars: Agent Foundations, Agentic Protocols, and Trust and Transparency.
• The Agentic Protocols pillar maps agentic functions onto existing IAB standards.
• MCP is a general interface layer AAMP agents can speak. AdCP is a rival advertising framework. Both are different from AAMP.
• The latest milestone, AAMP 2.3, adds enterprise-ready capabilities, though its components version independently and mature at different rates.

This article is for advertisers, agency teams, and ad-tech builders who keep seeing "AAMP" and want a plain, accurate account of what it is and why it exists.

Drowning in Meta Ads?

Put your campaign on autopilot with Nova.

Read more

What is AAMP in advertising?

The AAMP advertising framework, short for Agentic Advertising Management Protocols, is IAB Tech Lab's open-source umbrella framework for consistent, transparent, interoperable AI-agent advertising. It coordinates the standards and reference code that let autonomous agents plan, buy, sell, and optimize advertising while staying accountable to the people who deploy them (IAB Tech Lab).

The short version worth quoting: AAMP is how buyer and seller ad agents transact with each other on shared terms. Instead of every vendor inventing its own way for an agent to request inventory, quote a price, or confirm a deal, AAMP gives them a common vocabulary built on standards the ad industry already runs on.

One clarification up front, because it drives most of the confusion: AAMP is not one monolithic specification with a single version number. It is a coordinated family of standards work and open-source components whose repositories can version independently (IABTechLab/AAMP on GitHub). Read "AAMP 2.3" as a release milestone across that family, not a single frozen document.

That coordination matters because agentic advertising is arriving faster than the rules that govern it. When two agents from two different companies try to transact, they need to agree on what a "deal" is, how a price is represented, and how each side proves it is who it claims to be. AAMP is IAB Tech Lab's answer to that problem.

Who created AAMP, and how has it evolved?

AAMP is a project of IAB Tech Lab, the standards body behind widely used advertising specifications such as OpenRTB and AdCOM. IAB Tech Lab's agentic advertising work predates the brand name: the umbrella was formally named AAMP on February 26, 2026, largely to end the naming confusion that had built up as separate agentic efforts multiplied (PPC Land).

Several components predate the umbrella name. ARTF, the real-time execution framework, went to public comment as v1.0 in late 2025, before the AAMP brand existed. After the February naming, the coordinated milestones came quickly: AAMP 2.0 arrived on April 23, 2026 with transaction-ready Buyer and Seller Agent SDKs (IAB Tech Lab), and AAMP 2.3, the current milestone, was announced on July 30, 2026 with a focus on enterprise deployment, privacy diligence, and pricing safeguards (IAB Tech Lab).

A caveat worth keeping in view: "AAMP 2.3" is an umbrella milestone announced in a press release. At the repository level, the components version independently and do not all carry a matching "2.3" tag, and independent analysts have noted that only a subset hold a published specification (No Fluff Advisory). Treat the release notes as current direction, and verify a specific component's version against its repo before building on it.

What problem does AAMP solve?

AAMP exists to make independently built ad agents interoperable and trustworthy. Three problems sit underneath that goal.

First, interoperability. Agentic buying and selling only works at scale if a buyer agent from one company can transact with a seller agent from another without a custom integration for every pairing. Shared schemas and transaction types remove that per-pairing work.

Second, trust. When software negotiates and spends money on its own, both sides need to know the counterparty is real, that a quoted price came from somewhere legitimate, and that the transaction can be audited later. AAMP builds identity, disclosure, and verification into the framework rather than leaving it to each vendor.

Third, clarity. Before February 2026 the market had several overlapping agentic efforts and no single name, which slowed adoption. Naming the umbrella AAMP was itself part of the fix.

The three pillars of AAMP

AAMP's architecture rests on three pillars: foundations for execution, protocols for transacting, and a trust layer that keeps agents accountable (IAB Tech Lab).

A note on Agentic Guardrails, because its status is easy to overstate. The February 2026 architecture described guardrails as "in development," covering sandboxing, cryptographic verification, and explicit intent declarations. AAMP 2.3 then introduced deterministic negotiation guardrails and server-side trust verification on price-moving steps. So guardrail behavior is partly operational in 2.3, while the standalone Agentic Guardrails component is still being built out. If governance is your reason for looking at AAMP, track that component specifically.

The Agent Registry

The Trust and Transparency pillar is anchored by the Agent Registry, a free, open directory where agents are registered and verified so counterparties can confirm who they are dealing with (IAB Tech Lab). It launched in early March 2026 and is free and open to members and non-members alike, reachable through IAB Tech Lab's tools portal. Agents register through a REST API, and the registry's job is to make an agent's identity checkable, with stronger domain-ownership verification on its roadmap. That shared, checkable baseline is the point: trust becomes something a counterparty can confirm rather than assume.

The buyer-to-seller protocol flow

Here is the shape of an AAMP transaction, from the advertiser down to the publisher, with the trust and execution layers wrapped around it. This is the framework's most liftable picture.

   Advertiser / Agency                         Publisher / supply
            |                                          ^
            v                                          |
   +-----------------+   Agentic Protocols    +------------------+
   |   Buyer Agent   |<---------------------->|   Seller Agent   |
   |  (demand side)  |  Direct - Deals - Bid  |  (supply side)   |
   +-----------------+  Audiences - Ad Object +------------------+
            |            Mobile - and more              |
            v                                           v
     DSP / demand platforms                  SSP / supply platforms
            |                                           |
            +----------------- wrapped by --------------+
                                 |
        Agent Registry (identity + verification)
        Guardrails + approvals
        ARTF execution foundations
        Built on: OpenRTB - AdCOM - OpenDirect - Deals API
        Interfaces: MCP - A2A - REST

IAB Tech Lab's materials describe a Buyer Agent and a Seller Agent transacting with each other, with open-source reference implementations for ad buyer systems and ad seller systems. Treat the flow above as the relationships between those parts, and take exact component and agent naming from IAB's own architecture rather than any paraphrase.

The Agentic Protocols

The middle pillar does most of AAMP's practical work, and it does it by mapping agentic functions onto standards the industry already runs on rather than inventing new rails. An agent that already speaks OpenRTB or AdCOM is not starting from zero.

The roster is still evolving, and IAB's own overview currently foregrounds a subset of it, so treat the list below as the named components at the time of writing rather than a fixed, complete set. The components include:

These components do not all sit at the same level of maturity. Some are reference implementations, and some repositories have been reported as still in draft, so check the status and version of the specific component you plan to build against rather than assuming the whole list is equally final (No Fluff Advisory).

Alongside these, AAMP ships reference Buyer Agent and Seller Agent SDKs. The Buyer Agent covers demand-side decision logic and connects to demand platforms; the Seller Agent covers supply-side coordination and connects to publisher systems. Both expose multiple interfaces, including REST, MCP, and A2A (Agent2Agent), which is what lets agents from different vendors interoperate (IAB Tech Lab).

The agentic ad stack: where AAMP, MCP, and AdCP sit

Most of the confusion around AAMP comes from stacking it against things that live on different layers. It helps to name those layers. Call it the agentic ad stack, our framing of three layers that answer three different questions.

AAMP's original explanatory thesis, and the reason this stack is useful, is simple: AAMP coordinates advertising meaning and transactions, while MCP and A2A provide the interfaces through which agents communicate. They are related but not interchangeable. One more layer sits alongside these but outside AAMP's scope: agent payment rails such as x402, which handle how one agent actually pays another. AAMP and AdCP assume that settlement problem is solved elsewhere rather than defining it. Once the layers are separate, the two comparisons below stop being confusing.

AAMP vs MCP

AAMP is not MCP. They solve different problems and sit on different layers.

MCP (Model Context Protocol) was open-sourced by Anthropic in late 2024 and later contributed to the Linux Foundation's Agentic AI Foundation. It standardizes how an AI assistant discovers and calls external tools. When Meta launched its official Ads MCP connector at mcp.facebook.com/ads on April 29, 2026, giving assistants like Claude and ChatGPT a set of tools to read and act on a Meta ad account over OAuth, that was MCP doing its job: connecting an assistant to an account (PPC Land).

AAMP operates a layer up. It governs how advertising agents transact across the ecosystem, and it uses MCP as one of the interfaces its agents can speak.

The takeaway: MCP is how an agent reaches a tool. AAMP is how two advertising agents do business. They are complementary, and AAMP builds on MCP rather than replacing it.

AAMP vs AdCP

The comparison that pits two like-for-like options against each other is AAMP against AdCP (Ad Context Protocol). Both are advertising transaction frameworks for agents, and buyers evaluating the space in 2026 tend to face a two-stack choice between them.

AdCP launched earlier, on October 15, 2025, founded by Yahoo, Optable, PubMatic, Scope3, Swivel, and Triton Digital under an MIT license, and it has grown a large membership. Its design center differs from AAMP's: AdCP defines a new campaign-lifecycle protocol and puts trust into the wire format, while AAMP retrofits agents onto standards the industry already uses. The two are closer than the branding suggests. Both use MCP as a core agent interface, and IAB Tech Lab's COO, Shailley Singh, has said the two overlap on roughly 13 functions (PPC Land).

For a buyer, the practical question is less "which one wins" and more "which one do the platforms and partners I already use support." Because both ride on MCP, committing to one does not fully lock you out of the other, though the transaction primitives differ, so they are not drop-in swaps. A full head-to-head between AAMP and AdCP is beyond this article's scope.

Why AAMP matters for advertisers and agencies

For most advertisers and agency teams, AAMP is infrastructure you will feel through the tools you buy rather than something you implement directly. Its importance is in what it standardizes: governed, interoperable agents with a verifiable identity registry and guardrails becoming the expected baseline rather than a vendor extra.

Two things are worth watching as adoption grows. One, the Agent Registry sets a precedent that a serious advertising agent should be verifiable, which is a reasonable bar to hold your own vendors to. Two, the pricing-provenance work in AAMP 2.3, which records where a quoted price came from so an agent cannot fabricate a CPM, points at the controls buyers will likely start expecting from any agent that spends on their behalf.

None of this means agentic buying is a finished, hands-off technology. The framework is young, its components version independently, and real adoption is early. Based on IAB Tech Lab's roadmap and member activity, AAMP looks like the direction the industry is standardizing toward, though that is an assessment rather than a guarantee about any single product's results.

Where products fit

A product can resemble AAMP's governed-agent model without implementing or conforming to AAMP. The pattern AAMP is codifying, an agent that decides and acts under human-set guardrails with an audit trail, already describes how a number of managed AI media buyers work.

AdAdvisor, an established Meta-ads specialist rather than a new entrant, is one example. Its Nova product is an approval-first Meta media buyer that operates inside user-defined guardrails and keeps an action record, and it is the kind of MCP-connected, approval-first agent the governed model describes. Those are useful governance characteristics, but they do not make Nova AAMP-certified or AAMP-compliant, and no such claim is being made here. The broader point stands on its own: whether or not a given tool ever formally adopts AAMP, verifiable identity, guardrails, and disclosure are a sound checklist for choosing an agent to trust with spend.

Frequently asked questions

Summary

AAMP (Agentic Advertising Management Protocols) is IAB Tech Lab's open-source umbrella framework for AI-agent advertising, named in February 2026 and updated in the AAMP 2.3 milestone announced in July 2026. It rests on three pillars: Agent Foundations for execution, Agentic Protocols that let buyer and seller agents transact on existing rails, and a Trust and Transparency layer anchored by the Agent Registry. AAMP is not MCP, which is a general interface its agents can speak, and it is not AdCP, the rival framework it overlaps with on roughly 13 functions. For advertisers, AAMP is the direction the industry is standardizing toward, with verifiable identity and guardrails becoming the baseline you can reasonably expect from any agent you trust with spend.

Sources

• IAB Tech Lab, AAMP standards overview
• IAB Tech Lab, "IAB Tech Lab Releases AAMP 2.3" (July 30, 2026)
• IAB Tech Lab, "AAMP 2.0 Release Brings Transaction-Ready Buyer and Seller Agent SDKs"
• IAB Tech Lab, "Introducing the IAB Tech Lab Agent Registry"
• IABTechLab/AAMP GitHub repository
• PPC Land, "IAB Tech Lab names its agentic ad initiative AAMP to end market confusion"
• PPC Land, "AAMP and AdCP overlap on 13 functions, IAB Tech Lab COO says"
• PPC Land, "Meta opens its ad system to Claude and ChatGPT with new AI connectors"
• No Fluff Advisory, "IAB Agentic Standards" (repo-level status of AAMP components)
• VideoWeek, AdCP launch coverage (Oct 15, 2025)