ARTF

Why Advertising Agents Need a Speed Layer

A live auction resolves in under a hundred milliseconds. A generative agent reasoning through a decision — weighing supply, checking terms, applying a strategy — takes seconds, sometimes longer. That gap is not a performance target to optimize away. It is a structural mismatch between two different kinds of computation, and no amount of faster hardware closes it on its own.

ARTF, the Agentic Real-Time Framework, exists to resolve that mismatch. It does not make agents think faster. It separates when an agent reasons from when an auction executes, and defines a standard way to carry the output of the first into the second.

What ARTF Standardizes

ARTF governs the boundary between asynchronous agent reasoning and synchronous auction execution. An agent — using AdCP, A2A, or any other protocol for its actual negotiation — does its thinking outside the auction window. Market research, strategy formulation, deal terms: all of it happens on agent time, with no latency constraint.

What ARTF standardizes is the handoff: how that reasoning gets compiled into something an exchange engine can apply inside the auction loop. The compiled output takes a small number of forms — deterministic rules, vector embeddings, or precompiled execution code — deployed as a lightweight container directly into the SSP or DSP's auction cluster. The container is what runs during the live auction. The reasoning that produced it already happened.

How ARTF Relates to AdCP and A2A

ARTF sits at a different layer than the protocols that handle agent conversation and negotiation. AdCP and A2A govern what an agent decides and how it communicates that decision to another agent. ARTF governs what happens next — how a decision, once made, becomes something an auction can actually execute against, on auction time rather than agent time.

An agent might use AdCP to negotiate terms with a seller agent, then compile the resulting strategy into an ARTF container so that strategy can apply automatically to every subsequent auction that matches, without re-running the negotiation each time. ARTF does not replace the negotiation layer. It gives the negotiation layer a way to act at auction speed once the negotiation is settled.

Where Compilation Fits

The compiled artifact ARTF carries is deliberately narrow. It is not a general-purpose agent runtime, and it does not carry open-ended reasoning into the auction loop. It carries the result of reasoning — a rule, a threshold, a vector match — small enough and deterministic enough to evaluate in microseconds.

This is a tradeoff, and ARTF is explicit about it: precision in the auction window in exchange for expressiveness. Anything that needs real-time judgment stays outside ARTF's scope, in the asynchronous layer where agents actually reason.

What ARTF Does Not Do

ARTF does not standardize agent-to-agent negotiation — that is AdCP and A2A's domain. It does not evaluate supply quality or provenance — that is the concern of supply intelligence systems operating upstream. And it is not a bidding strategy itself; it is the delivery mechanism that lets a strategy, once decided, execute inside a window no live reasoning process could otherwise meet.

Why This Matters

Every protocol built for agentic advertising eventually runs into the same physical constraint: agents reason on a timescale auctions cannot wait for. Ignoring that constraint means either slowing auctions down — breaking the systems built around them — or asking agents to reason faster than reasoning actually allows.

ARTF resolves the constraint architecturally instead of asking either side to change. It is not a competing standard to AdCP or A2A. It is the piece that makes their output usable in the one environment neither was designed to run inside directly.