Most publishers are better served using a marketplace's or partner's sell-side agent at first, while keeping direct ownership of the three things that carry commercial judgement: the product catalogue, the pricing and approval rules, and the record of what was agreed. Building a sell-side agent makes sense for a publisher with engineering capacity, substantial direct demand and selling logic a shared agent cannot express. IAB Tech Lab's AAMP framework narrows the gap between the two options, because it publishes an open-source reference implementation of a seller agent that a publisher can study or build from. The choice turns less on code than on who controls the mandate.

TL;DR. A sell-side agent packages inventory into products, answers buyer agents, enforces floors and deal rules, and accepts, counters or declines proposals. Building one gives full control but leaves the publisher maintaining a production service against standards that are still moving. Using a marketplace's agent is faster but places the selling logic inside someone else's system. A hybrid works for most publishers: borrow the agent, own the products, rules and record, and keep them in formats that can move. The decisive questions are whose interests the agent represents, where the rules live, and whether the publisher can retrieve the deal record independently.

What does a sell-side agent actually do?

A sell-side agent acts for a publisher or inventory owner. It describes what is for sale, receives briefs or proposals from buyer agents, checks them against the publisher's rules, and accepts, counters, escalates or declines. When a deal is agreed, it passes the terms to whatever system activates the deal and records what was agreed.

Most of that work is commercial, not technical. Which products exist, what each one costs, which advertisers are blocked, and which offers need a person to approve them are all decisions a sales team already makes.

What does building on the AAMP reference seller agent involve?

IAB Tech Lab's AAMP, the Agentic Advertising Management Protocols, is published on GitHub as a set of separately versioned components. One of them, seller-agent, is a reference implementation of supply-side coordination and marketplace interaction. It sits alongside agentic-direct, the communication and orchestration layer, OpenProposal, the specification for how publishers define products and packages in RFP responses, and a registry example showing how agents are discovered and registered.

A reference implementation shows how the parts fit together. Turning it into a production service is the publisher's job. That means hosting, security, integration with the ad server and sales systems, monitoring, and someone to respond when it misbehaves.

Maintenance is the larger commitment. Because AAMP's components are versioned independently, a self-built agent has to track several moving specifications rather than one. A publisher that also wants to reach buyer agents using AdCP, the separate Ad Context Protocol from AgenticAdvertising.org, takes on a second set of tasks and schemas to support.

The return is control. A self-built agent can express selling logic that a shared agent may not: bespoke sponsorship packages, complex make-good rules, or pricing tied to first-party data the publisher would rather not send to a third party.

What does using a marketplace's sell-side agent involve?

Using a marketplace's agent removes most of the engineering. The marketplace runs the agent, keeps up with protocol versions, and handles the connections to buyer agents. The publisher configures products and rules rather than writing code.

The trade-offs sit elsewhere. The selling logic lives inside a system the publisher does not run, so the publisher depends on the marketplace exposing the rules it needs. The agent's behaviour is only as neutral as the marketplace operating it: a marketplace that also runs agents on behalf of buyers has interests the publisher should understand before handing over its floors. And if the marketplace holds the only copy of the deal record, the publisher's position in a dispute depends on the marketplace's records.

Which parts should a publisher own regardless of the choice?

Whichever route a publisher takes, three things should stay under its direct control. Call them the three retained assets.

The product catalogue. Products and packages described in a structured format, ideally following OpenProposal, so they can move between agents and marketplaces without rewriting.
The mandate. Floors by product and deal type, blocked categories, the measurement basis for each product, and the value above which a person must approve.
The record. A copy of agreed deal terms the publisher can retrieve on its own, matching the copy the buyer holds.

Authorisation belongs alongside these, and the principle is familiar: ads.txt, introduced in 2017, and sellers.json, introduced in 2019, gave publishers a way to state who may sell their inventory. Agentic standards carry the same idea forward. AdCP lets publishers declare which agents may sell their inventory in an adagents.json file on their own domain, and IAB Tech Lab runs an Agent Registry where companies list the agents they bring to market. The decision about which agents may represent a publisher should rest with the publisher, not with any single intermediary.

How should a publisher decide between building and borrowing?

Five questions settle most cases:

Engineering capacity. Can the publisher staff a production service, including out-of-hours support, for the life of the agent?
Selling complexity. Does the publisher sell products a configurable agent cannot represent?
Data sensitivity. Does pricing depend on data the publisher will not share with a third party?
Standards coverage. Which AAMP components, at which versions, and which other protocols does the publisher need to support?
Exit. If the publisher leaves a marketplace, can it take its catalogue, rules and deal history with it?

For example, consider two hypothetical publishers. The first runs a national news site with an in-house ad engineering team and a large share of revenue from bespoke sponsorships. Building on the AAMP reference seller agent fits: the custom logic justifies the maintenance. The second runs a group of specialist titles with a three-person sales team and standard display and video products. Borrowing a marketplace's agent fits, provided the products and rules are kept portable and the deal record is retrievable.

Is there a middle path?

Yes, and it suits most publishers. A publisher can start with a marketplace or partner agent, keep its product catalogue in an OpenProposal-shaped format, write its mandate as a document it owns rather than as settings inside one platform, and keep its own copy of every deal record. If volume, complexity or strategy later justify building, the publisher moves with its commercial assets intact and only the agent changes.

The point that decides whether borrowing is safe is the record. Alkimi, a neutral marketplace that works within IAB Tech Lab's AAMP framework and has its agent listed in the Agent Registry, checks that connecting agents are authorised by the publisher or buyer they represent, and writes agreed terms to a DealSheet that both parties hold and either side can retrieve independently.

Frequently asked questions

Does IAB Tech Lab publish a seller agent?

Yes. AAMP includes seller-agent, an open-source reference implementation of supply-side coordination and marketplace interaction, alongside a reference buyer agent.

Can a publisher run the AAMP reference seller agent as it is?

A reference implementation shows how the components fit together. Running it in production still requires hosting, security, integration with the publisher's systems, monitoring and ongoing updates as AAMP components change.

What should a publisher keep control of if it uses a marketplace's agent?

Its product catalogue, its pricing and approval rules, its decisions about which agents may sell its inventory, and an independently retrievable copy of every agreed deal.

Do publishers need to support both AAMP and AdCP?

That depends on which buyer agents they want to reach. The two are separate frameworks from different bodies, so a publisher should ask any marketplace or vendor which it supports, at which version.

Should Publishers Build Their Own Sell-Side Agent or Use a Marketplace's?