AdCP 3.1 Turns Creative Formats Into Declared Capabilities. The Duration Is Still a Number in a JSON File.

The format layer got a vocabulary

AdCP 3.1 is described in its own release notes as production hardening for real agent operations, which is what a specification says when the gaps were found by running buys against real publishers rather than by reading the schema. It is additive over 3.0, and the patch line has not slowed down: four releases landed between 3 and 8 August alone. The creative half of it is the part worth reading if you ship video.

The change is that a creative agent now declares what it can produce, in a machine readable way, instead of a buyer guessing from prose. Capabilities carry a supported formats array, each entry has a stable capability id that is local to the agent but durable over time, and a buyer targets that id directly when it asks for a creative to be built. Format selection stopped being string matching against a name somebody typed.

Duration got a proper model at the same time. Hosted audio and video formats can express a range with one side open, so a bound of up to sixty seconds is expressible without inventing a lower bound nobody meant, and inventory with a fixed slot uses an exact duration instead of a range collapsed to a single point. That distinction sounds pedantic until you have argued with a partner about whether a thirty second slot means exactly thirty or at most thirty.

And selectors that do not fully specify a format now fail closed rather than matching by loose overlap. Of everything in the release, that is the change most likely to save someone a campaign. A protocol that silently picks something plausible when the request was ambiguous produces a creative nobody asked for, and nobody finds out until delivery.

What that gets you, precisely

Everything above is negotiation. It fixes what the two agents believe they agreed to build, before anything is built, which is the right moment to fix it. A buyer agent that targets a capability id and receives a manifest back holds a record of the agreement that a human can audit later.

What none of it establishes is the creative itself. For video the creative is a VAST document, and AdCP carries it as an asset with a delivery type of either a URL that returns VAST XML or an inline string containing it. In the first case the bytes have not been fetched. In the second they are sitting in the manifest and still nobody has parsed them.

So the format layer and the asset layer make claims at two different altitudes, and the two can disagree without either side noticing. The capability says the agent produces spots of at most sixty seconds. The asset says the duration is a certain number of milliseconds, qualified in the schema with if known. The tag says something in an element called Duration. Three assertions, one of which is the actual instruction to the player.

Nothing in that exchange raises an error

The capability is satisfied by the asset, because thirty thousand milliseconds is under the sixty second bound. The asset validates against the JSON Schema, because thirty thousand is an integer and the field is optional anyway. The manifest is accepted, the buy is confirmed, and the tag returns a sixty five second creative into a slot that will cut it off at thirty, or reject it outright depending on the player.

Nothing has gone wrong in the protocol. AdCP exchanges creative metadata, which is what it says it does, and a metadata protocol has no business becoming a video ad parser. The gap is that the loop never closes. Something has to open the document and compare it against the claims, and until 3.1 there was no clean statement of which claims to compare it against. Now there is, which makes the absent check easier to notice.

This matters more than it did two years ago because of who is writing the document. A generative creative agent produces VAST the same way it produces text: by generating something shaped like what it has seen. Shape is not correctness. A document can carry a plausible Duration, a plausible tracking set, a MediaFile URL that resolves to nothing, and a version attribute that contradicts the elements underneath it, and a schema check on the manifest that references it sees none of that.

The mismatches a parser settles in one pass

• Declared duration against the Duration element, which is the check the format layer now makes meaningful because there is finally an authoritative bound to compare against.
• Declared VAST version against the version attribute on the root element, and against the elements actually used, since a document claiming 4.2 while using 3.0 era markup parses differently depending on who reads it.
• Declared tracking events against the TrackingEvents actually present, so a manifest promising quartile reporting cannot be fulfilled by a tag that only carries an impression.
• A VPAID claim of false against a document that still ships an application/javascript media file, which is the deprecation everyone declared complete and nobody finished.
• Whether the endpoint behind a URL delivery asset returns VAST XML at all, rather than an HTML error page with a success status.
• Whether wrapper chains terminate, and within what depth, since a manifest asset is one URL and the tag behind it can be four redirects deep before anything renders.
• Whether media file renditions exist that satisfy the placement the format kind describes, rather than a single rendition that happens to be first in the list.

The wire rules that will break an existing integration

Separately from formats, 3.1 changed how the envelope works, and two of those changes will break implementations that were written carefully.

The first is idempotency. An idempotency key is now required on every task request, reads included, with staged enforcement: sellers on 3.1 should reject reads that omit it, and 3.2 will require rejection. Reads are the requests nobody thought needed a replay guard, which is exactly why the enforcement is staged rather than immediate.

The second is envelope flattening, and it inverts an instinct. The protocol envelope no longer nests the body under a payload key. Envelope fields and body fields are siblings at the root, and servers are required to tolerate envelope fields they do not recognise. Strict validation is called out as non conformant, with the mechanisms named directly: strict MCP framework modes, strict model validation, and generated schemas that set additional properties to false. If you turned strictness on because that is what careful engineers do, you built a client that fails against a conformant server.

Version negotiation landed in the same release. Every request and response carries a version at release precision, sellers advertise the releases they support, and a buyer pinning something unsupported gets a typed error naming what would have worked. That is a mechanism the bid stream still lacks entirely, which is a separate argument we made on the OpenRTB side.

Where a validator sits in this

The vastlint MCP server answers capability discovery as an AdCP agent on the governance protocol, with a content standards specialism, idempotency support and a replay window. That is a deliberately narrow declaration. It does not plan media, it does not build creatives, and it does not negotiate. It answers one question, which is whether a document does what somebody said it does.

The reason to expose that as a protocol surface rather than a dashboard is the same reason 3.1 exists at all. In an agentic pipeline there is no human between the manifest and the delivery. A broken tag that a trafficker would have caught in an afternoon runs for a flight, and the report that eventually surfaces it describes it as underdelivery rather than as a parse failure. A check the agent can call is a check that happens. A check on a screen is a check that happens when someone remembers.

The formal verification programme AdCP has planned for 3.1, where implementations publish verifiable conformance output against a shared test corpus, is the same idea applied to the protocol itself. It is a good instinct and it stops at the protocol boundary. Conformance to AdCP proves the manifest is well formed. It proves nothing about the creative the manifest points at, and it was never meant to.