Programmatic Guaranteed vs AdCP: What Actually Differs
The most common objection to agentic media buying is that programmatic guaranteed already automates direct deals, so why build a protocol for something solved a decade ago. Fair question. PG automates one moment and leaves everything either side of it to people, which is why the same problems recur: it underdelivers, the make-good gets argued three weeks later, and there is no moving budget off a package that is not working.
I run Adgentek, which is a Founding Member of AdCP through AgenticAdvertising.org and sells products on both sides of it. Weigh this accordingly, and go read the spec yourself.
What does programmatic guaranteed actually automate?
Delivery and reconciliation, after a human negotiation has finished. A buyer and publisher settle CPM, volume, targeting, and flight dates outside the auction, the publisher mints a deal ID encoding those terms, and the ad server reserves the inventory.
So the reservation, the serving, and the billing are automated. The negotiation is not, because it happened in a meeting and an email thread before the deal ID existed. PG gave a direct insertion order the workflow properties of programmatic and did that well. Trafficking was never the expensive part.
Why do PG deals fail the same way every time?
Because a deal ID is a frozen artifact. Once terms lock there is no channel for what happens next, so every problem routes back to the people who set them.
- Underdelivery surfaces late. The remedy is a make-good negotiated after the campaign stopped needing it.
- Match rate problems look like nothing. The deal reads as live and quietly does not deliver, usually because the deal ID is not recognized in bid requests.
- The forecast is a guess. The buyer brings the targeting data, so the publisher guarantees volume without knowing the filters and caps applied against it, which pushes sellers toward overselling.
- Creative review gates the flight. Five business days before start is a normal minimum, and a policy violation and a missed deadline arrive looking identical though they belong to different people.
- No price benchmark. No competitive process ran, so nothing tells you whether the CPM was reasonable.
- Pacing belongs to the publisher. Their ad server handles budget pacing and capping, so the buyer commits at a price with little view into delivery.
Reallocation is the one with no answer. Say a campaign runs across six PG deals: two converting at target, three delivering impressions that convert at nothing, one behind pace. Renegotiation flows exist, but they run per deal and need the other side to accept, so moving budget means three proposal loops. Most teams do not bother. They let the flight run out and fix the mix next quarter, which everyone knows is the wrong answer.
How does AdCP handle negotiation and delivery instead?
Negotiation runs through repeated calls to one verb. The first round is a brief, and the products the seller returns are the proposal. Counters are scoped constraints attached to parts of that response, so each round narrows against the prior result set instead of restarting. There is no rate card, because price is expressed by which products and pricing options a seller returns.
That sequence is also the answer to the forecasting problem. The seller quotes against constraints it can read, and returns a forecast as an impression range rather than a single number it has to defend later. Commitment lands at the finalize step, which binds firm pricing, terms, and a hold. Signal targeting works the same way, with the buyer confirming eligibility before sending a targeting overlay instead of applying filters the seller finds out about in a delivery report. When a mid-flight change pushes past what was quoted, the seller requotes rather than quietly underdelivering. That narrows the asymmetry without erasing it, since no seller can forecast match rate against a buyer's own first-party audience.
Delivery reporting is where the break gets concrete. It returns impressions and spend next to outcome metrics: conversions, conversion value, ROAS, cost per acquisition, reach. Those break out per package, per creative, and by geo, device, and placement.
Pacing is a number rather than a vibe. Each package carries a pacing index where 1.0 is on track, plus a delivery status separating a package still delivering from one that is budget exhausted or flight ended. Buyer pausing stays distinct from what the system is doing, so a package that is live but not delivering is a state rather than a mystery.
Reallocation runs through the media buy update task, which changes budgets, pacing, and targeting, pauses packages, and adds new ones mid-flight, with sellers advertising which actions they accept so a buyer agent knows before asking. Updates carry a revision number, so simultaneous changes fail loudly rather than overwriting each other.
Make-goods get negotiated into the buy rather than argued afterward. A media buy carries a make-good policy listing available remedies, plus measurement terms naming who is authoritative for billing, a finalization deadline, and a maximum acceptable variance. Miss the deadline or exceed the variance and the counterparty can fall back to its own attestation, with the breach routing to those remedies rather than email.
Outcome optimization is tied to measurement rather than asserted. A goal names a measurement vendor, a metric, and a threshold, and sellers must reject it if the metric is not in the vendor's published catalog, if the product cannot steer bidding toward it, or if the package never committed to reporting it.
| Problem | Programmatic guaranteed | AdCP 3.1 |
|---|---|---|
| Brief, proposal, counter | Negotiated offline, then encoded in a deal ID | get_products brief round, then refine counters scoped to the prior result set |
| Delivery forecasting | Seller guarantees a fixed number blind to the buyer's filters and caps | Forecast returned as an impression range against a brief the seller can read |
| Pacing visibility | Publisher's ad server controls pacing and capping; buyer reads a report | pacing_index and delivery_status per package, on a 2 to 4 hour reporting delay |
| Moving budget mid-flight | Renegotiate each deal, or wait for the flight to end | update_media_buy for budget, pacing, targeting, but only where the seller declares the action |
| Make-goods | Negotiated after the shortfall | Remedies and a variance threshold agreed at buy creation; contested cases stay out of band until 3.2 |
| Reporting gaps | Chased by email | missing_metrics reconciled against what the seller committed to report |
| Outcome optimization | Outside the deal | Goals bound to a named measurement vendor, rejected without committed reporting |
| Policy approval | Trust and paperwork | Governance checks at proposal, commitment, and post-delivery, when a governance agent is configured |
| Seller commercial policy | Publisher ad server rules | Not covered by the spec; lives in the seller's own infrastructure |
What is the governance layer, and why does PG have no equivalent?
AdCP 3.1 puts policy enforcement inside the transaction rather than around it, at three points instead of one. A buyer's plans sync to the seller, a check runs against the proposed buy, the media buy gets created, and a second check runs against the committed buy. Each returns approved, denied, or escalated, and an escalated buy holds at the task layer waiting on human sign-off. The decision is a signed token a seller verifies offline, so a forged or stale one gets rejected at the transport layer.
The third check runs after delivery and tends to get skipped in summaries. Outcomes go back to the governance agent, which compares delivery against the plan to catch drift and confirms ads ran only on authorized properties. Without it, budget overruns and geo drift get reported and never caught.
PG has no equivalent and does not need one, because a human approved the deal before the deal ID existed. Take the human out of the negotiation and the approval has to live somewhere. You cannot improve PG into this: it assumes approval already happened.
Does AdCP replace real-time bidding or programmatic guaranteed?
No, and anyone claiming otherwise is selling something. RTB is still right for pricing an impression in milliseconds, and PG is still reasonable for a reserved, fixed-price commitment where none of the failure modes above are load-bearing. What shifts is the default. Plenty of media problems get routed to an auction because the auction is the only thing cheap enough to run at scale. Lower the cost of a direct relationship and more get solved directly. A change in mix, not the loss of a layer.
The market is already testing it. In January 2026 Prebid took stewardship of the AdCP sell-side agent code and released it as the Prebid Sales Agent, a neutral path in requiring no proprietary rebuild, and in June a separate publisher-side sales agent launched with theScore and RTL AdAlliance. Neither turned off anyone's exchange.
What 3.2 closes, and what stays open
Disputes are the last gap in the accountability loop, already scoped for the next minor. Remedies and variance thresholds are defined at buy time in 3.1, but the structured task for resolving a contested dispute on the wire is targeted for 3.2, so a disagreement past the agreed variance still settles out of band today. Two other 3.2 obligations are published: idempotency keys become mandatory on reads, and the vendor-metric rule tightens from a should to a must.
What matters is less the features than the fact that they carry a version number and a date, published far enough ahead to build against, under a policy of a minor release every quarter. Forward deprecations ride on the wire too, with a severity meaning required in a future version, so a conformance run tells an operator what is about to break.
That is the honest answer to why not just improve PG. Programmatic guaranteed has no version number, no cadence, and no way to tell your implementation what will be required of it next year. It is a workflow pattern each SSP implements a little differently, frozen for a decade. One of these has a roadmap, which is worth reading alongside how AdCP compares to IAB's AAMP.
Two smaller limits stay open. Mid-flight capability is declared, not guaranteed, so a seller that does not advertise support for adding packages does not support it. And reporting is never live, with broadcast unsettled until C7 closes fifteen to twenty-two days after air.
The consequential limit is not on the roadmap at all. Governance protects buyer spend and has no seller-side equivalent. A publisher facing agent demand must enforce its own commercial policy: which advertisers it transacts with, at what floors, against which content, under what exclusivity it already sold. It needs an audit trail for each accept or decline, because "the agent decided" will not survive a revenue review.
The protocol does not provide that and should not. Commercial policy is a seller's business logic, not a standard's job, and it belongs in ad serving infrastructure. That is the layer Adgentek's Agentic Ad Server is built for, with Spark as the conversational format and AdsMCP as the MCP path into the same engine. On the buy side, ORCA runs as one buyer agent for an agency, fanning out across sellers, which enables what no single bidder can do, starting with frequency management across sellers that never see the impressions they lose.
What this means for ad ops teams
Headcount compression is real and coming, and pretending otherwise is a good part of why the skepticism exists. Agentic buying does not create ad ops jobs. But mapping deal IDs, diagnosing match rates, and assembling the make-good case were never the parts that took judgment. They ate the time judgment needed. What does not automate is deciding what a campaign is for, which publishers earn a direct relationship, and when to override an agent optimizing toward the wrong objective.
What I actually think
I have watched enough standards get published to know that a spec is only as good as what gets built against it. Normative language in a document does not make a seller honor it. And AdCP's capability model cuts both ways, because sellers declare which actions they support, so being AdCP compliant can mean a seller that does discovery and nothing else. Uneven implementation is the real risk here, not the design. I would not commit a media plan on the strength of a version number.
What makes me think this one lands is the shape of the ecosystem rather than the shape of the spec. In January, Prebid took over the AdCP sell-side agent code and shipped it as the Prebid Sales Agent, a free reference implementation any publisher can pull from GitHub without a membership. Be precise about this one, because the names get muddled fast: the Sales Agent is the AdCP piece. Prebid.js is header bidding and has nothing to do with AdCP. What matters is that Prebid folded the Sales Agent into the same open-source suite it maintains Prebid.js and Prebid Server in, under the same support model, while saying plainly that it is a software organization and not a standards body, so governance stayed with AAO. The agent registry went live in March, so there is an identity and authorization layer now and not just a message format. Vendors have started selling managed seller-agent hosting, which is what happens when implementation stops being a science project. And by the middle of this year, agencies running agentic pilots were predominantly running them on AdCP.
None of that is adoption at scale. The reference implementation is still alpha and has already taken breaking changes between versions, which I would rather say out loud than have a publisher discover mid-sprint. Plenty are still sitting it out, and given how many standards have come and gone, they are not wrong to wait for proof. But the pieces that were missing a year ago showed up over the last nine months, and they showed up in roughly the order you would want: the spec, then the reference implementation, then the trust layer, then the commercial services around it. That is what a standard looks like when it is going to stick, and it is not what the last several looked like.
So my read is that this is a build year rather than a wait year, and the thing I would do first is read the delivery and governance sections of the spec instead of commentary about them, this piece included. They settle it in twenty minutes. For publishers working out what agent demand means for their commercial policy, or brands and agencies scoping an outcome-directed buy, Adgentek works both sides.
