Publishers will know which AI agent they are dealing with the same way buyers learned which seller they were buying from: through public, machine-readable declarations that the other side can check. ads.txt, introduced in 2017, lets a publisher declare who may sell its inventory. sellers.json, introduced in 2019, lets an exchange or SSP declare who it pays. For agents, comparable pieces now exist: IAB Tech Lab's Agent Registry records which companies operate which agents, and AdCP defines an adagents.json file in which a publisher declares the agents allowed to sell its inventory. None of these, on its own, proves that a particular agent is authorised for a particular deal.

TL;DR. ads.txt and sellers.json identify accounts and sellers in the bid stream, not software negotiating on someone's behalf. Agent identity has at least three layers: which company operates the agent, which principal the agent represents, and whether it holds authority for the deal in front of it. IAB Tech Lab's Agent Registry addresses the first layer by tying each registering company to its GPP ID and reviewing entries. AdCP's adagents.json borrows the ads.txt model of a publisher-hosted declaration. Publishers still need to confirm the principal and keep a shared record of what each agent agreed.

What problem did ads.txt solve?

ads.txt, published by IAB Tech Lab in 2017, is a plain text file that a publisher hosts on its own domain listing the advertising systems and account IDs authorised to sell its inventory, and whether each relationship is direct or resold. Buyers crawl the file and compare it with the seller details in each bid request. If a seller account claiming to sell a publisher's inventory is not in that publisher's ads.txt, the buyer has grounds to treat the impression as unauthorised.

The design choice that made ads.txt work was location. Because the file sits on the publisher's own domain, only someone who controls the domain can change it. Domain control stands in for identity, and the declaration is free to read.

What problem did sellers.json solve?

sellers.json, introduced by IAB Tech Lab in 2019, is the mirror image. An exchange or SSP publishes a file listing the seller accounts it represents, with each seller's name, domain and whether it is a publisher, an intermediary or both. A buyer can take a seller ID from a bid request, look it up in the exchange's sellers.json and see which business is behind it.

Read together, the two files let a buyer trace authorisation from both ends: the publisher says which accounts may sell, and the exchange says who owns those accounts. Neither file says anything about who is negotiating, because in the auction model nobody negotiates. A bid request is priced and cleared in milliseconds.

Why don't ads.txt and sellers.json identify AI agents?

ads.txt and sellers.json identify accounts and sellers at the point of an auction. An AI agent negotiating a deal raises different questions. A publisher facing a buying agent needs to know which company operates the agent, which advertiser or agency the agent acts for, and whether that principal has authorised this deal at this value. A buyer facing a selling agent needs the same answers in reverse, plus confirmation that the publisher has authorised that agent to sell its inventory.

Existing supply chain files cover none of these directly. They still describe the seller accounts through which an agent-agreed deal delivers, but they do not tell a publisher whether the software across the table is entitled to commit someone's budget.

What does IAB Tech Lab's Agent Registry add?

The IAB Tech Lab Agent Registry, part of its Tools Portal, is where companies register the MCP and A2A agents they bring to market, categorise them and state their purpose and maturity. Each registering company is tied to its GPP ID, and IAB Tech Lab reviews entries for the required validation information. The registry is free for members and non-members.

The registry answers the operator question: a named company stands behind this agent and has put it on public record. Within AAMP, IAB Tech Lab's open-source framework for agentic advertising, a separate registry-agent-example component demonstrates agent discovery, registration and coordination. A registry listing does not by itself say which principal an agent represents in a given negotiation.

What is adagents.json in AdCP?

AdCP, the Ad Context Protocol, is published by AgenticAdvertising.org, a separate body from IAB Tech Lab. According to the AdCP documentation, publishers declare which agents may sell their inventory in an adagents.json file hosted on their own domain, read the same way a browser reads robots.txt. AgenticAdvertising.org also runs a registry that lets buyer agents search for seller agents by channel or capability.

The lineage from ads.txt is clear: a declaration on the publisher's domain, under the publisher's control, readable by anyone. The AdCP documentation also describes buyer agents signing their requests with HTTP Message Signatures (RFC 9421), which sellers verify against keys the buyer publishes, and idempotency keys that stop a retried request from creating a second buy. Those mechanisms address whether a request really came from the agent it claims to come from.

How can a publisher tell which agent it is dealing with today?

In practice, a publisher answers the identity question in layers. A hypothetical example shows how. A buying agent approaches a news publisher with a proposal for a £30,000 private marketplace deal on behalf of a retail advertiser.

Operator: is the agent's operator listed in the IAB Tech Lab Agent Registry, and does the listing match the company the agent claims to belong to?
Request authenticity: if the protocol in use supports signed requests, does the signature verify against the operator's published keys?
Principal: does the retail advertiser, or its agency, confirm through an existing contact that this agent acts for it?
Authority: does the agent's stated budget ceiling and approval threshold cover a £30,000 commitment, and who signs off if not?
Record: once terms are agreed, do both parties hold the same record of them?

ads.txt and sellers.json still answer a sixth question once the deal runs: whether impressions were sold through authorised accounts.

What should publishers do now?

Publishers should keep ads.txt and sellers.json entries accurate, because agent-negotiated deals still deliver through seller accounts. A publisher running its own sell-side agent should register it in the Agent Registry, so buyers can check the operator, and should publish whatever authorisation file the protocol it supports requires. For incoming buying agents, the publisher should require a named principal before sharing pricing, and confirm that principal through a channel the agent does not control.

Alkimi, a neutral agentic advertising marketplace whose own agent is listed in the IAB Tech Lab Agent Registry, works within IAB Tech Lab's AAMP framework and checks that every connecting agent is authorised by the buyer or publisher it represents; the terms those agents agree are then written to a DealSheet that both parties hold.

Frequently asked questions

What is ads.txt?

ads.txt is a text file, introduced by IAB Tech Lab in 2017, that a publisher hosts on its domain to list the advertising systems and account IDs authorised to sell its inventory.

What is sellers.json?

sellers.json, introduced by IAB Tech Lab in 2019, is a file published by an exchange or SSP listing the seller accounts it represents and whether each is a publisher, an intermediary or both.

Is there an ads.txt for AI agents?

AdCP, from AgenticAdvertising.org, defines adagents.json, a publisher-hosted file declaring which agents may sell the publisher's inventory. IAB Tech Lab's approach to agent identity centres on its Agent Registry.

Does an Agent Registry listing prove an agent is authorised?

No. It shows that a named company registered the agent and that IAB Tech Lab reviewed the entry. Whether the agent is authorised by a given advertiser or publisher for a given deal has to be confirmed separately.

Do ads.txt and sellers.json still matter for agent-negotiated deals?

Yes. Where an agent-agreed deal delivers through existing programmatic systems, impressions still pass through seller accounts that ads.txt and sellers.json describe.

ads.txt, sellers.json and Agent Identity: How Will Publishers Know Which Agent They Are Dealing With?