Why the OpenDirect Standard is the foundation for Agentic direct sold advertising
When a programmatic auction fires, it resolves in ~100 milliseconds. There is no negotiation, no contract, no reservation, and no long-term commitment. That said, Deal IDs provide some level of commitment and assume some commercial agreement is in place. In essence every transaction is stateless, self-contained, and completed the moment the impression is served.
Direct-sold guaranteed campaigns are the opposite of this. They are built on commitment: inventory reserved weeks in advance, budgets contractually locked, the ad creative approved before a single impression serves, and delivery is guaranteed. The commitment detail is the point — premium guaranteed inventory commands premium prices precisely because the commitment is binding.
When AI agents begin to execute these transactions, managing that commitment detail becomes the central challenge. An agent that misunderstands what was booked, misses a reservation, or submits an ad creative in the wrong format is not making a trivial error. Errors in direct-sold campaigns carry real operational and financial consequences — make-goods, missed flight windows, and strained publisher-buyer relationships — that take time and effort to resolve on both sides. This is why the standards question — what protocol do buyer agents and seller agents use to negotiate, book, and execute direct-sold campaigns — matters. It is a foundational question for whether agentic direct-sold advertising can scale reliably.
The State Problem: What Makes Direct-Sold Different for Agents
For a human media buyer, campaign state is distributed across a dozen systems and informal channels: an email confirming the hold, a signed IO in a shared drive, a Slack message about creative approval, a trafficking confirmation from an ad ops person. Humans tolerate this because they can integrate context from all of these sources and maintain a coherent picture.
An AI agent reconstructing campaign state from email threads and Slack history may infer state incorrectly — believing a campaign is booked when it is only reserved, or treating a creative as approved when it is still pending. In an autonomous workflow, those incorrect inferences can trigger downstream actions with real consequences before any human has a chance to intervene.
For agentic direct-sold advertising to work, campaign state must be machine-readable, deterministic, and canonical. Not inferred. Not reconstructed. Not summarized. Explicit, in a structured data model that both buyer and seller agents read from the same source of record.
This is the problem that OpenDirect was designed to solve — and which AgenticDirect extends for the AI-native era.
OpenDirect: The Standard That Already Exists
IAB Tech Lab’s OpenDirect specification (currently v2.1) standardizes how buyers interact with publisher inventory systems for guaranteed reserved campaigns. Its goal is to do for direct-sold what OpenRTB did for programmatic: replace bespoke buyer-publisher integrations with a single standard, creating an agreed-upon, shared language that any compliant system can speak.
The core of OpenDirect is a set of well-defined objects that encode every aspect of a direct-sold campaign.
An Account defines the relationship between a buyer (agency) and an advertiser. An Order is the campaign plan containing material instructions such as budget, currency, and flight dates. A Line is the actual booking unit, with product, pricing, quantity, targeting, and a state machine that defines exactly where in the lifecycle that commitment sits. A Product is an item in the publisher’s inventory catalog with explicit availability and pricing. A Creative carries the ad asset and its per-publisher approval status. A ChangeRequest is a formal post-booking modification proposal with an explicit approve/reject workflow.
None of this is novel to anyone who has worked in ad operations. What is relevant for agentic workflows is that all of it is expressed in a machine-readable, vendor-neutral API that buyer and seller agents can read and write against a shared data model.
Consider what this means for the state problem. OpenDirect’s Line item moves through a formal state machine:
Draft → Reserved → Booked → InFlight → Finished
State transitions are explicit calls — not inferences, not summaries, not natural language confirmations. A buyer agent that calls the reserve action knows with certainty that inventory is held. A seller agent can query that same line item and see the identical state. The reservation expiry date is a field in the object, not a phrase in an email. When the buyer agent books the campaign, both agents read ‘Booked’ from the same data source. There is no ambiguity and therefore, minimizes the likelihood of hallucination for the Agent.
This eliminates a specific and important class of errors: agents acting on conflicting or stale representations of campaign state. It does not eliminate all agent errors — an agent can still misidentify which product to book, set incorrect targeting parameters, or misinterpret an error response. But for the state of a committed campaign, the structured schema provides both parties with an unambiguous shared record.
Structured vs. Natural Language Negotiation
Imagine a buyer agent initiating a campaign negotiation in natural language:
- “I want to book a homepage takeover on your site for NewShoes Wind Rider in March, around five million impressions, targeting men 25 to 44, somewhere between twelve and fifteen dollars CPM.”
- The seller agent receiving this must resolve, through probabilistic inference, at least six questions: what product does “homepage takeover” correspond to in the actual inventory catalog? What does “around five million” mean as a contractual quantity? Which days in March? Which time zone? How exactly does the seller define “men 25-44” and does that definition match the buyer’s expectation? What price should be offered within the twelve to fifteen range? Different seller LLMs will resolve each of these differently. The same model may resolve them differently with different context windows. And the buyer agent, receiving a response, has no reliable way to detect which inferences were made incorrectly until the campaign serves — and delivers incorrectly.
- Now consider the same negotiation via OpenDirect. The buyer agent queries the product catalog, discovers that “HP-TAKEOVER-DESKTOP-001” is the correct product ID, calls the avails endpoint to confirm five million impressions are available in March at $15 CPM, and creates a Line item:
Product: HP-TAKEOVER-DESKTOP-001
Quantity: 5,000,000 (exact)
Rate: $15.00 CPM (agreed)
Start: 2025-03-01T00:00:00Z (exact, UTC)
End: 2025-03-31T23:59:59Z (exact, UTC)
Targeting: Gender=Male, Age=25-34 + 35-44
Frequency cap: 3 per user per day
Every parameter is explicit. There is no inference layer between the buyer’s intent and the seller’s execution. The seller agent either accepts the Line parameters or rejects them — it does not interpret them. This is the same advantage that IAB Tech Lab’s Taxonomies offer over natural language category descriptions: a discrete, unambiguous specification that eliminates the probabilistic interpretation step.
AgenticDirect: Extending OpenDirect for the AI-Native World
OpenDirect was designed for human-operated or human-supervised systems. It is a well-structured REST API, but it assumes an operator who can read documentation, navigate endpoints, and manage multi-step workflows manually. AI agents need more than a well-structured API. They need discoverability — the ability to find out what a system can do without reading a PDF. They need machine-interpretable tool definitions that LLMs can reason about and invoke directly. They need asynchronous communication protocols that support long-running multi-step workflows.
AgenticDirect is a proposed IAB Tech Lab extension to OpenDirect designed to address these requirements. It exposes OpenDirect operations as structured MCP (Model Context Protocol) tools with explicit JSON schemas. It implements the A2A (Agent-to-Agent) protocol, allowing buyer and seller agents to discover each other’s capabilities, delegate tasks, and communicate asynchronously via standardized JSON-RPC. It also publishes a machine-readable agent card at a well-known URI, which any buyer agent can fetch to discover what a seller agent supports, what skills it offers, and how to authenticate.
One architectural principle behind AgenticDirect is worth making explicit: natural language is the interface between humans and agents; structured schemas are the interface between agents and systems.
A human buyer tells their agent: “Book a March campaign for NewShoes Wind Rider, homepage takeover, five million impressions at fifteen CPM, targeting men 25 to 44.” The buyer agent translates that intent into a structured sequence of OpenDirect API calls. The seller agent receives structured operations, not a natural language brief. The natural language stays at the edge — it does not travel through the negotiation itself.
This is one approach to agentic system design, and it has real merit for the direct-sold use case: it keeps the contractual commitment layer deterministic and auditable. It is worth noting that other protocols in the emerging agentic advertising landscape take a hybrid approach, allowing natural language briefs to travel between agents with structured outputs on the other side. The design choice of where natural language stops and structured schema begins involves real trade-offs, and the industry is still working through them.
The Connection to Ad Servers and other systems
Every ad server has its own comprehensive API — Orders, Line Items, Ad Units, Creatives — with a data model that closely mirrors OpenDirect’s. That means the path to OpenDirect compliance is a translation layer: an OpenDirect-compliant interface that accepts standardized buyer requests and translates them to the ad server’s specific API calls on the publisher side.
This is how open standards have always coexisted with proprietary platforms. OpenRTB standardizes the programmatic bidstream without requiring DSPs and SSPs to abandon their internal systems — it standardizes the interface, but does not dictate the implementation. OpenDirect does the same for direct media buying. A buyer agent that speaks OpenDirect does not need to know what ad server the publisher uses. The standard abstracts the implementation.
It is worth being direct about what this translation layer involves. Building and maintaining an OpenDirect-compliant interface on top of an existing ad server is a meaningful engineering investment — particularly for mid-size publishers who may not have dedicated ad tech engineering teams. The value proposition is that this investment is made once and unlocks compatibility with any Agentic Direct buyer agent, rather than requiring bespoke integration with each buyer system separately. Whether that trade-off makes sense will depend on each publisher’s scale and the pace at which buyer-side agent adoption grows.
For independent publishers, getting this infrastructure right matters. Access to agentic buyer workflows through a standard interface — rather than through proprietary integrations that favor large platforms — supports a more competitive and open direct-sold market.
The Limitations: An Honest Assessment
OpenDirect is not a complete solution to agentic direct-sold campaign execution. Several gaps remain.
Synchronous polling. The specification is pull-based. In an agentic system managing many campaigns, constant polling for state changes adds latency and overhead. What is needed is an event-driven notification layer — webhooks, server-sent events, or efficient diff protocols such as JSON-Patch — so agents (and the humans overseeing them) can react to state changes as they occur, without unnecessary polling overhead.
Incomplete negotiation protocol. This is a significant gap. OpenDirect supports placing orders and requesting modifications, but price negotiation is not formalized. A counter-offer is expressed as a free-text message, not a structured object. A buyer agent requesting a rate reduction cannot receive a machine-readable counter-proposal — only approval, rejection, or unstructured text. For agent-to-agent commercial negotiation, a structured counter-offer schema is a necessary extension. This gap means the most commercially sensitive part of the direct-sold workflow — the negotiation itself — currently falls back to unstructured communication.
Creative format specifications. OpenDirect’s Product object identifies which creative formats are acceptable for a given placement, but these specifications are often expressed as human-readable text. For an agent to reliably validate creative compliance before submission, creative format requirements — dimensions, file types, duration limits, and technical constraints — need to be structured in a way that agents can parse and validate against programmatically. IAB Tech Lab’s AdCOM and the New Ad Portfolio and CTV Ad Portfolio provide the building blocks; consistent adoption in OpenDirect implementations is the remaining work.
In-flight monitoring. The stats endpoint provides impression, click, CTR, and spend totals at the line level. It does not expose hourly pacing data, projected delivery curves, or viewability signals. For agents to optimize delivery or detect under-pacing early enough to take corrective action, richer telemetry is needed.
Taxonomy integration. OpenDirect’s targeting fields accept category IDs, but there is no formally typed integration with IAB Tech Lab’s Content Taxonomy 3.1, Audience Taxonomy 1.1, or Ad Product Taxonomy 2.0. The semantic grounding layer and the transactional layer are not formally connected — an agent must bridge them independently, and implementations vary.
Terms and conditions reference. Direct-sold campaigns operate under commercial terms — viewability standards, brand safety requirements, cancellation policies — that currently live in PDF attachments or offline agreements. Making those terms machine-referenceable within an OpenDirect Order, so that seller agents can surface compliant inventory and buyer agents can confirm they are operating within agreed parameters, would meaningfully improve the reliability of autonomous execution. This does not mean exposing sensitive commercial terms; it means attaching structured references — such as a link to a standard terms document or a set of compliance flags — that agents can reason about.
The argument for OpenDirect is not that it is already the universal standard — it is that it needs to become one, and that the emergence of agentic advertising workflows may provide the forcing function that drives adoption in a way that years of advocacy alone did not.
What Needs to Be Built
Realizing the promise of agentic direct-sold campaign execution requires coordinated progress on several fronts.
Publisher-side OpenDirect interfaces. Publishers need to expose OpenDirect-compliant interfaces in front of their ad servers. The engineering investment is real but the benefit — compatibility with any compliant buyer agent without bespoke integration per buyer — compounds as buyer-side adoption grows.
Event-driven state notifications. OpenDirect needs a standard notification layer — supporting webhooks, server-sent events, or JSON-PATCH-based state diffs — so agents and their human supervisors can respond to state transitions in real time rather than through polling.
Structured negotiation schema. The ChangeRequest object needs a machine-readable counter-offer structure, enabling commercial negotiation between agents without falling back to unstructured text.
Formal taxonomy integration. IAB Tech Lab taxonomies should be formally typed in OpenDirect’s targeting schema, creating an explicit connection between the semantic grounding layer and the transactional layer.
Machine-referenceable commercial terms. Orders should be able to carry structured references to applicable terms and compliance requirements, enabling agents to surface and verify the conditions under which inventory is being transacted.
Conclusion
The question of whether AI agents can reliably execute direct-sold campaigns is ultimately a question of shared state, unambiguous communication, and enforceable commitment across system boundaries. When campaign parameters travel as natural language through multi-hop agent workflows, probabilistic inference at each step accumulates into systematic error. The structured schemas, state machines, and formal workflows in OpenDirect address that problem directly.
AgenticDirect proposes to extend OpenDirect for the requirements of AI-native systems: tool discoverability, machine-interpretable schemas, asynchronous communication, and agent identity. The gaps are real — the incomplete negotiation protocol, the missing taxonomy integration, the limited in-flight telemetry — and they represent genuine work for the industry to take on. But the direction is clear, and the foundation is already specified.
Historically, OpenDirect has been a standard in search of broad adoption since its first publication. Agentic advertising workflows may create the operational pressure that accelerates that adoption — not because the standard is new, but because the cost of agents working without it becomes visible in ways that human-managed workflows could absorb through judgment and manual correction. As that judgment is removed from the loop, the need for a shared, structured protocol becomes harder to defer.
OpenDirect is that contract. Building on it, rather than around it, is how the direct-sold market remains open in an agentic world.
Shailley Singh
COO and EVP of Product
IAB Tech Lab