In early October 2026, IAB Tech Lab's programmatic supply-chain leadership pushed back on the idea that adagents.json should replace ads.txt, sellers.json, and the OpenRTB SupplyChain object. The argument, echoed in trade coverage of Hillary Slattery's rebuttal, is that the IAB files already answer who may sell inventory and how a bid request moved. AgenticAdvertising.org's answer is different: it names which sales agents a publisher authorized for agentic negotiation. Those are not the same question, and the auction payload still only embeds one of them.
If you are wiring AdCP, a Prebid Sales Agent, or a buyer-side agent that reads well-known JSON, you need both mental models on the desk. Picking one file and calling supply path "done" is how authorized agents and authorized sellers diverge without anyone getting an error.
adagents.json: who may represent the publisher to an agent
adagents.json lives at /.well-known/adagents.json. It is an AAO artifact tied to the Ad Context Protocol family. The document lists authorized_agents: agent URLs, property or placement scope, delegation type, optional exclusivity, and time bounds. The buyer agent is supposed to fetch this file before it treats an agent as allowed to sell a slice of inventory.
The unit of trust is the agent relationship, not the advertising system id on a schain node. A row can authorize https://sales-agent.example/ for one property id while saying nothing about the SSP seller account that will eventually emit OpenRTB. AdCP discovery tools can validate the JSON shape and pinned schema version; they do not, by themselves, prove that the live bid request was produced inside the scoped authorization.
Example inside the grammar: exclusive: true on an authorized agent row is meaningful in adagents.json. It does not delete a RESELLER line in ads.txt. Publishers can publish both files, get HTTP 200 on each, and still disagree about whether resale is allowed depending on which file the buyer's SPO product read last.
ads.txt, sellers.json, and schain: who may sell and who touched this impression
The IAB programmatic supply-chain stack predates agentic buying and still carries most programmatic traffic.
ads.txt (and app-ads.txt) is a publisher-hosted flat file. Each line binds a seller account id to an advertising system domain with DIRECT or RESELLER. OWNERDOMAIN and subdomain delegation extend that to property ownership. The question is authorization to sell inventory under that publisher id.
sellers.json sits on the SSP or exchange. It maps seller ids to company names, domains, and seller types so buyers can interpret ads.txt lines in context.
source.schain rides on the OpenRTB bid request. It is a per-impression chain of nodes (asi, sid, hp, and related fields) describing which systems took custody of this request. SupplyChain 1.1, in public comment through 2026, adds hp=0 nodes for entities that take technical custody without being payment-flow sellers. That is still schain semantics; it is not an adagents.json agent URL.
The three IAB artifacts cross-check in mature buyer workflows: crawl ads.txt, map ids through sellers.json, reconcile nodes on the wire against authorized sellers. A structural schain defect still fails even when authorization files look fine. For instance, complete: 1 with a chain that omits an expected hop triggers checks documented under openrtb.schain.incomplete. Under 1.1 expectations, an unexpected hp value on a node is a different class of bug, as in openrtb.schain.node.hp_unexpected.
Two stacks on one impression
Put the sides next to each other:
| Question | adagents.json | ads.txt + sellers.json + schain |
|---|---|---|
| What is being authorized? | Agent URL and scope for agentic sales | Seller account and resell relationship |
| Where does it live? | Publisher well-known JSON | Publisher ads.txt, exchange sellers.json, bid request schain |
| What rides on OpenRTB? | Nothing normative today |
source.schain (and related supply extensions) |
| Typical failure | Agent negotiated a buy outside publisher scope | Seller id or hop not authorized for this domain |
Neither column substitutes for the other. An agent listed in adagents.json can be absent from schain while schain stays syntactically valid. A schain node can match ads.txt while the agent that closed the AdCP package never appeared in the publisher's authorized_agents list. OpenRTB 2.6 has no first-class field that says "this impression was produced by agent X under authorization Y."
That gap is why industry debate this fall (IAB defending the existing trio versus AAO's agent file) matters for implementation, not press releases alone. Buyers evaluating "98% of bid streams validate directness" are measuring the IAB stack. Agentic paths add a parallel authorization fetch the bid stream does not automatically enforce.
Network and channel supply paths that attach eids under schain have their own OpenRTB 2.6 rules; see openrtb-2-6-network_channel_supplychain_eids when your inventory is not a plain publisher domain story. The agent file still does not replace that object.
How you catch it
Manual reconciliation remains the honest first step: for each registrable domain you buy, fetch adagents.json and ads.txt, resolve agent URLs and seller ids, and compare them to source.schain on a live or logged bid request. Policy belongs in your stack; the wire objects will not merge the files for you.
For the OpenRTB payload, paste the request into the OpenRTB tester or run rtblint validate against the dated snapshot you pinned. An LLM implementing AdCP, ARTF, or agent tools can emit plausible schain and still miss incomplete chains, wrong ver, or dialect mismatches that only show up on the exchange's parser. rtblint (cargo install rtblint, npm install rtblint-core, MCP rtblint-mcp) is the deterministic check on that object: mutations, discovery helpers, and supply-chain rules. It does not crawl adagents.json and certify agents against ads.txt; nothing in the spec requires that merge today. The package is independent of IAB Tech Lab and of AgenticAdvertising.org.
Where to go next
Start with the OpenRTB supply chain trust stack guide for how the IAB files fit together and where adagents.json sits beside them. The ads.txt vs sellers.json vs schain walkthrough is the side-by-side for the classic trio. For the agent versus schain split in agentic workflows, read adagents.json does not audit schain. If your integration speaks gRPC protobuf JSON, pair supply-chain checks with OpenRTB's two JSON dialects so a green schema pass on one transport does not mask an unparseable hop on the next.
Until your emit boundary re-applies adagents scope on the impression and your buyer policy cross-fetches both stacks, four files can all return 200 while the auction answers only the question schain was built for.
Top comments (0)