Skip to main content
AdCP uses a three-tier numbering system: VERSION.RELEASE.PATCH (e.g., 3.1.2). A version is a major and a release is a minor.

What can change in a release

  1. A minor only adds. New fields go on open schemas. Nothing is removed, renamed, retyped or made required. Schemas are open, and a schema is closed only for a structural reason (DR-0036). The additive-minor check enforces this for schemas in CI.
  2. To replace a field, add the new one and deprecate the old one. Senders emit both until the next major.
  3. Removals and breaking changes happen in a major.
  4. A minor never adds a field to a mutating request if an older seller that ignores it would commit to something different. Spend, targeting, caps, bidding, creative activation, measurement and account identity are examples, not the full list. Such a field waits for the next major, or ships behind a capability the seller declares first, and buyers MUST NOT send it to a seller that does not declare that capability.
These rules cover stable surfaces. Experimental surfaces have their own contract. Opening a schema that was closed without a structural reason rejects nothing that was valid, so it is a correction: 3.3 opens such schemas, and so does a 3.2.x patch. The only other corrections apply a bound or a required name that the published text already set. DR-0036 allows both kinds, and each correction the additive-minor check would otherwise report is listed in the corrections register. The shipped 3.0 → 3.1 → 3.2 moves did not all follow these rules. They stay as shipped until 4.0 and set no precedent. This page defines what goes on the wire. How a library gets there is up to that library.

Version tiers

What distinguishes a release from a new version?

A new version (4.0) ships when the changes are architectural, when cumulative drift from the previous version is large enough that a clean baseline serves the ecosystem, or when there is a strategic reason to signal a new generation. A release (3.x) only adds. It can deprecate a field or object when the replacement ships in the same release. A change that would remove, rename, retype or require something waits for a new version.

Forward compatibility

Implementations built against 3.0 continue to function against any 3.x release, apart from the exceptions recorded under 3.x stability guarantees.

Version negotiation

Buyers and sellers negotiate at release precision (VERSION.RELEASE, e.g. "3.0", "3.1") on every request and response. Release-precision pinning lets a buyer select which schemas it validates against, and lets sellers return responses that match the contract the buyer expects (Stripe model).
In-house clients implementing the wire directly can stay on adcp_major_version through all of 3.x; adcp_version is opt-in until 4.0. See Migration timeline for the cadence.

Bidirectional negotiation (3.1+)

  1. Seller advertises: adcp.supported_versions on the get_adcp_capabilities response lists all release-precision versions the seller speaks (e.g. ["3.0", "3.1"]). adcp.build_version (e.g. "3.1.2+vendor.42") is optional advisory metadata for incident triage — not part of the wire contract.
  2. Buyer declares: adcp_version (release-precision string) on every request tells the seller which release the buyer’s payloads conform to. Through 3.x the buyer SHOULD also emit adcp_major_version so legacy 3.x sellers that only read the integer continue to negotiate correctly.
  3. Server resolves:
    • Exact match → serve in that release.
    • Same major, both pre-release and release present, buyer pins the release → exact match wins; server MUST NOT silently downshift onto the pre-release. (Server ["3.1-beta", "3.1"] + pin "3.1" → serve "3.1".)
    • Same major, no exact match, at least one server release ≤ buyer’s pin → downshift to highest supported release ≤ the pin. Covers both “server’s max < pin” and gap-cases (e.g. server ["3.0", "3.2"] + pin "3.1" → serve "3.0").
    • Same major, no server release ≤ buyer’s pin (sub-min: every supported release is strictly greater) → return VERSION_UNSUPPORTED with supported_versions in error.data.
    • Different major → return VERSION_UNSUPPORTED with supported_versions in error.data.
    • Omitted → server uses its default release. If only adcp_major_version was sent, the server serves the oldest supported release in that major (DR-0034): in practice that buyer is a 3.0 buyer.
  4. Server echoes: adcp_version on every response tells the buyer which release the seller actually served. The echoed value is the release served, never the seller’s own latest release — a 3.1 seller serving a 3.0 buyer at 3.0 echoes "3.0". Buyers SHOULD validate the response against that release’s schema, not against their pin. The seller MUST shape the response to that release; see Serving an older pin.
When the response omits adcp_version (a legacy 3.0 seller that doesn’t read the field — additionalProperties: true makes it invisible there), buyers SHOULD validate against their own pin and treat the seller as 3.0-only for capability inference. When get_adcp_capabilities is absent entirely. A seller that does not expose get_adcp_capabilities (the tool isn’t advertised on the MCP tool list, the A2A skill list, or the REST tool index) is a pre-v3 implementation — the tool itself is v3-and-later. Buyers SHOULD infer v2 in this case. Retry-safety guarantees are unknown for this seller, because no replay_ttl_seconds declaration is available. Buyers MUST NOT use absence of get_adcp_capabilities as a positive v2 conformance signal; it is purely an inference from “v3 discovery surface is missing.” Idempotency, signed-requests, and other v3 trust primitives MUST be treated as unknown — buyers requiring those guarantees MUST fail closed at the application layer when the seller cannot advertise them. This lets buyers and sellers upgrade independently — sellers can declare multi-release support, and buyers can pin to a specific release without coordinating their migration.

Serving an older pin

Server shapes to the served release. Let R be the release a response echoes in adcp_version. The response MUST validate against R’s published schema, except that enum values added after R are exempt, because clients tolerate unknown values (Enums). The seller omits what R’s schema rejects and projects shapes R defines differently, such as oneOf/anyOf arms added after R, widened types, and alternative required fields. A webhook payload follows the same rule, where R is the release served on the request that registered the webhook. A seller that cannot meet this rule for a release MUST NOT list that release in supported_versions. The rule binds a seller that lists 3.3 or a later release in supported_versions, for every release it lists. x-added-in on a schema node names the release that added it. It is informative; R’s published schema decides what a response served at R carries. The rule covers get_adcp_capabilities like every other response. A capabilities request that pins a release resolves to a served release or to VERSION_UNSUPPORTED under the steps above, so the seller always knows what to project to, even though the buyer has not yet read supported_versions. Negotiation fields are stable within a major. adcp.supported_versions, adcp.major_versions, and the adcp_version echo MUST keep the same shape across every release of a major. A client of any 3.x release can then read enough of a discovery response to pin, even when the rest of it is newer than the client understands. Unpinned requests. A client that needs older shapes pins a release. Examples when serving "3.1":
  • Legacy booleans for media_buy.execution.targeting.geo_regions and .language, not the 3.2 object form.
  • No revenue_share pricing options.
  • A failure response valid under 3.1 in place of the get_products status: "rejected" arm.
  • brand and operator on every sync_accounts row, including rows that carry account.
The 3.1 to 3.2 migration guide lists all six known divergences. Buyers SHOULD still parse capabilities and responses tolerantly: accept unknown enum values and unknown union arms, and accept object forms of fields that were booleans in the pinned release. A seller that predates this rule can emit unprojected shapes, and a tolerant parser keeps those integrations working. Releases before 3.3 did not have this rule, so a seller that lists no release later than 3.2 is not retroactively non-conformant. The version_negotiation storyboard carries an advisory scenario for it; its checks stay advisory until runners can validate against the served release’s schema bundle.

Pre-release pins

Pre-release tags ("3.1-beta", "3.1-rc.1") are matched exactly against supported_versions. They are not range-resolved: a buyer pinning "3.1-beta" against a server that lists ["3.0", "3.1"] (no beta in the list) gets VERSION_UNSUPPORTED, not a downshift to "3.0". Servers MUST NOT downshift a release pin onto a pre-release ("3.1" → "3.1-beta"); when both are advertised, the release wins exact match. Buyers MUST send a pre-release adcp_version only to a peer whose supported_versions advertises that exact value. A pre-release pin never negotiates down, so sending one to any other peer gets VERSION_UNSUPPORTED, not a served release. Buyers SHOULD send the discovery get_adcp_capabilities call without a version pin, so a peer on any release can answer it. On VERSION_UNSUPPORTED, buyers SHOULD retry without a pin, or at a value from the error’s supported_versions (described below), which is the recovery the VERSION_UNSUPPORTED error code names. A buyer that pins discovery to "3.3-beta.5" against a seller that speaks only 3.0, and stops at the error, never learns that the two could talk at 3.0.

VERSION_UNSUPPORTED error data

When the seller can’t honor a pin, error.data follows error-details/version-unsupported.json:
supported_versions is authoritative — clients SHOULD pick a value from this list and retry.

Patches are not negotiated

Per the three-tier model, patches introduce no stable AdCP contract change — they’re bug fixes and clarifications for stable surfaces. The wire negotiation field (adcp_version) uses release precision only. Servers MAY surface their build patch via the optional build_version capability for operational visibility, but buyers MUST NOT use it for negotiation. Experimental-only patch changes are governed by experimental_features declarations and the notice contract below, not by patch-level negotiation. build_version MUST be a valid semver string with the patch component populated, optionally extended with pre-release and build-metadata segments per semver §9–§10. Examples: "3.1.2", "3.1.2+scope3.deploy.4821", "3.1.0-beta.3+sha.a1b2c3d". The adcp_version wire format is MAJOR.MINOR or MAJOR.MINOR-PRERELEASE. No patch component is valid on the wire, even alongside a pre-release tag. A sender that holds a full semver ("3.1.0-beta.1") MUST normalize it to release precision ("3.1-beta.1") before emitting. "3.1.2", "3.1.0-beta.1", "v3.1", and "3" are all invalid wire values and will be rejected by validation. Don’t confuse the wire field with bundle metadata. The schema registry, tarball manifest, compliance index, and the /protocol/ HTTP discovery endpoint all expose a published_version field (e.g. "3.1.0-beta.1") at full-semver precision — that’s the version of the published artifact, not a wire value. A legacy adcp_version alias is also present on those meta-objects through 3.x for @adcp/sdk.ComplianceIndex compatibility, sunset at 4.0. Never emit a meta-field value on the wire — normalize to release-precision first. See schemas-and-sdks for the discovery URL.

Major-precision negotiation (deprecated, kept through 3.x)

The legacy adcp_major_version (integer per-request) and adcp.major_versions (integer array on capabilities) remain functional through 3.x for backwards compatibility. New buyers and sellers SHOULD prefer release-precision negotiation. Both legacy fields are removed in 4.0. Dual-emit during 3.x: a buyer that emits adcp_version SHOULD also emit adcp_major_version (with the major component of its pin) on the same request. This lets legacy 3.x sellers that only read the integer keep negotiating correctly. When both fields are present and disagree at the major level, the server MUST treat the request as malformed and return VERSION_UNSUPPORTED. When only major-precision is provided:
  • Buyer sends adcp_major_version: 3 → server serves the oldest supported release in major 3, which is 3.0 when supported (DR-0034).
  • Server emits adcp.major_versions: [3] → buyer can negotiate at major precision but loses release-level information.

Migration timeline

The spec stays at SHOULD on both sides through all of 3.x, because a minor cannot make a field required. The AdCP compliance grader carries the adoption pressure within 3.x: sellers that want certification at 3.2 ship the response echo. Clients can keep sending adcp_major_version only through all of 3.x — the server falls back to it and serves the oldest supported 3.x release, so newer fields need adcp_version. Adding adcp_version becomes the certifiable behavior at 3.2 (via the grader); the spec itself doesn’t require it until 4.0.

Relationship to MCP protocolVersion

MCP carries its own protocolVersion field on the initialize handshake (e.g. "2025-06-18"). That handshake versions the MCP wire — JSON-RPC framing, transport semantics. AdCP adcp_version versions the AdCP payload — the schema of params and result content. The two are independent: an MCP-2025-06-18 server can speak AdCP 3.0 or 3.1, and an MCP client pinning AdCP "3.1" will fail with VERSION_UNSUPPORTED against a server that only speaks 3.0 even though the MCP handshake succeeded. A2A has no equivalent to MCP initialize, which is why adcp_version rides in the AdCP message itself, where both transports can carry it: in the request on the way in, and as an envelope field on the response.

Features over versions

Version negotiation handles major architectural boundaries. For feature-level compatibility, use the capability model instead. Sellers declare specific features, targeting systems, execution integrations, and extensions in get_adcp_capabilities. Buyers check the capabilities they need and proceed if they’re present. Not every seller at a given major version will support every feature. Not every buyer needs every feature. The capability contract is: if declared, the seller MUST honor it. This gives finer-grained compatibility than version numbers alone. See get_adcp_capabilities for the full capability reference.

Schema changes in releases: scope and limits

The rules at the top of this page decide what a release may change. In scope for a release:
  • New optional fields on open schemas
  • New tasks, capabilities, enum values, and error codes
  • Deprecating a field, object, or method when a replacement ships in the same release
Out of scope — version-level changes only:
  • Removing or renaming a field, method, or enum value
  • Changing a field’s type, or making an optional field required
  • Tightening validation rules on an existing field
  • Adding a property to a schema kept closed for a structural reason, or closing a published open schema
  • Architectural or structural redesign of the protocol
  • Changes to authentication, transport, or core security requirements
  • Changes that alter fundamental behavioral semantics
AdCP 3.2 contains a bounded, recorded set of exceptions to these limits: one ratified field removal, one request-signing security correction, and a short list of tightened validation rules. See 3.2 exceptions to 3.x compatibility.

Deprecation policy

To replace a field, add the new one and deprecate the old one. Senders emit both until the next major. For example, 3.3 adds platform_id and deprecates seller_id, and a seller reporting that identifier emits both names with identical values through 3.x. A deprecated feature is never removed within the major that deprecated it, so a feature deprecated in 3.x is removed in 4.0 at the earliest. A major may remove anything deprecated in an earlier release, with no minimum notice period: removals are what a major is for. Implementers are protected by the support window instead. The previous major’s last minor stays supported for at least 12 months after the successor’s GA (Support window for previous major). Every release with schema changes is called out in the changelog, release notes, and inline documentation. Every release with schema changes ships with a migration guide. Experimental surfaces may change within a major, with at least 6 weeks’ notice in the release notes. The deprecation policy above applies only to stable surfaces. This naming rule applies to stable and experimental surfaces alike: once AdCP has defined or published a property name at a wire location — including a deprecated alias or legacy protocol property — it is permanently reserved for its existing semantics at that same object location, including locations that serialize to the same flattened root. It MUST NOT later be assigned different semantics after deprecation, rename, or removal; a replacement MUST use a distinct name. Vendor-defined properties do not trigger this reservation. For example, 3.1 introduced media_buy_status as the canonical replacement for the body-level media-buy lifecycle while the deprecated status alias remained temporarily permitted. Under MCP’s flattened response serialization, body and envelope properties occupy the same root: envelope status carries TaskStatus, so a body-level status carrying MediaBuyStatus collided with it and could be overwritten.

Spec, registry, conformance, and experimental changes

The release-vs-patch rules above apply to spec-level artifacts — JSON Schemas under static/schemas/source/, normative prose in docs/, and protocol task definitions. These are what an agent implements on the wire and what buyers depend on for interop. The AgenticAdvertising.org registry API and feed transport are versioned separately from adcontextprotocol. Changes to registry OpenAPI docs, registry-published policy files, and registry feed transport schemas do not by themselves bump the adcontextprotocol package version unless they also change a stable AdCP task payload, negotiation field, compliance artifact, or normative protocol rule. Registry JSON Schemas under static/schemas/source/ remain tracked by the changeset scope gate so reviewers see transport-shape changes, but their release classification belongs to the registry surface unless they cross into stable AdCP semantics. The conformance suite — storyboards, specialism taxonomy, scenario classifications, runner mechanics — versions independently and is patch-level by default. The conformance suite is a verification artifact AAO maintains; it is not the spec and it is not the docs. Adding, removing, renaming, or reclassifying preview-status specialisms; relocating storyboards between universal/protocol/specialism directories; refactoring scenario coverage; and adjusting runner behavior to match an unchanged spec are all patch changes. A conformance-suite change escalates to minor or major only when it would alter what an agent must do on the wire — i.e., when it tightens implicit spec validation, requires sellers to advertise a new capability that didn’t exist, or removes a stable specialism that agents are actively claiming (which is breaking, since agents currently advertising it become non-conformant). This separation lets registry transport, verification machinery, and experimental feedback surfaces evolve quickly without dragging stable spec-level versioning along with them.

3.x stability guarantees

Implementations built against 3.0 can rely on the following stable-surface guarantees through the 3.x cycle. Experimental surfaces follow the notice and patch-classification rules below. Each exception is recorded by release in 3.2 exceptions to 3.x compatibility.

3.2 exceptions to 3.x compatibility

AdCP 3.2 contains a bounded set of stable-surface changes that can reject a payload a 3.1 implementation previously sent or emitted. Each one is a ratified exception, a security correction, or a validation rule whose basis is recorded below. A structural diff of the 3.1.24 and 3.2 schemas found no other stable-surface change that rejects a payload valid under 3.1. Additive response shapes that a strictly typed 3.1 parser may reject are listed separately in the migration guide. Removed field (ratified exception). The deprecated body-level status (MediaBuyStatus) is removed from create_media_buy and update_media_buy success responses. It collided with the task-envelope status under MCP flattened serialization. Read media_buy_status instead. Record: DR-0011, Migrating to media_buy_status. Request-signing profile (security correction). On an endpoint that advertises a 3.2 release, request Signature and Content-Digest values use RFC 8941 padded standard Base64 instead of the 3.0/3.1 unpadded Base64URL override. Every signed request with a body must cover content-digest. The endpoint selects the profile, not the request’s adcp_version. A 3.1 signer is therefore rejected by a shared endpoint that advertises 3.2, even when the request pins "3.1". Record: Signed requests, Mixed-version request signing. Tightened request validation. These rules can reject a request that the 3.1.x schemas accepted: Tightened producer validation. A 3.1 producer that emitted these values fails 3.2 validation:
  • preview_creative renders: embedding.recommended_sandbox must be "". Providers must not grant iframe sandbox capabilities.
  • Committed proposals (proposal_status: "committed") must carry allocations[].pricing_option_id.
  • get_adcp_capabilities: creative_specs.vast_versions is a closed enum (2.0, 3.0, 4.0, 4.1, 4.2, 4.3) with at least one unique item. request_signing.required_for / supported_for / warn_for entries must match ^[a-z][a-z0-9_]*$.
Clarified delivery-date semantics. 3.1 described get_media_buy_delivery periods as UTC, while the required reporting_capabilities.timezone could name another zone. In 3.2, start_date, end_date, and daily_breakdown[].date are calendar dates in the reporting timezone. A dated or windowed (time_granularity) request whose in-scope packages span more than one reporting timezone MUST be rejected with VALIDATION_ERROR. Products that report in UTC are unaffected. Sellers serving a "3.1" pin may keep their existing 3.1 delivery-date behavior; the reporting-timezone semantics and reporting_period.timezone apply to "3.2". Experimental surfaces changed under their own notice contract and are not exceptions to these guarantees. See the migration guide for the governance, Trusted Match, and brand-rights changes.

3.3 exceptions to 3.x compatibility (beta)

AdCP 3.3 adds optional stable fields, enum values, and capability declarations, and removes no stable field. Its one removal is on an experimental surface: the build_creative.evaluator.evaluator_id source form (migration guide). It deprecates seller_id on event source and audience results in favor of platform_id, and deprecates using the natural key as the account reference after provisioning. It also deprecates the account identity-rekey machinery: account.identity_updates, operator_identity, ACCOUNT_MOVED, ACCOUNT_IDENTITY_CONFLICT, and account.stable_account_id. All remain functional throughout 3.x (migration guide). It also deprecates condition (b) of request_signature_required, which the already-deprecated webhook authentication block triggers. The changes below alter what a conformant implementation may do, including targeted validation tightening, defined property list resolution requirements, and loosening a required field. They are recorded here under the rule above for core-security and normative behavior. This list is refreshed at each beta cut. Four other guarantees loosen rather than narrow. The brand.json body cap rises from 256 KiB to 2 MiB (#8057), so a verifier still on the 3.2 cap can reject a brand.json a 3.3 verifier accepts. A ready audience no longer promises matched_count and effective_match_rate (#8024). media_buy.audience_targeting no longer promises inline member push, and supported_identifier_types and minimum_audience_size are required only when the seller accepts it (#8936); a 3.2 validator still requires both (Audience targeting without member push). The recommended client response-size default rises from 1 MiB to 4 MiB (#8200), so a client on the older figure can reject a response a 3.3 client accepts. The new SHOULD that clients bound response size (#8192) is a recommendation, not an exception. See the migration guide. Correction: schemas opened. Some 3.x schemas were published closed with no structural reason, among them the 3.2 proposal-flow task roots and their containers. 3.3 opens them, and a 3.2.x patch opens them too, as a correction under DR-0036. Opening a schema rejects nothing that was valid before. New 3.3 fields on these schemas go only to peers that negotiated 3.3. See the migration guide.

Experimental surfaces

The stability guarantees in the table above apply to stable surfaces only. AdCP may publish surfaces as experimental when they are part of the core protocol but not yet frozen. Experimental surfaces are marked with x-status: experimental in their schemas, and sellers that implement them declare so via experimental_features on get_adcp_capabilities. Experimental surfaces MAY break between any two 3.x releases with at least 6 weeks’ notice in the release notes. Experimental-only schema changes are patch-level when they do not change stable AdCP task payloads, negotiation fields, compliance artifacts, or normative protocol rules; adopters opt into that faster movement by declaring the experimental feature. Historical prerelease notes may have classified experimental reshapes as minor, but this policy treats the release tier as stable-surface impact plus the experimental notice obligation. Experimental surfaces graduate to stable once they have demonstrated real-world signal — see the full experimental status contract for the graduation criteria, notice requirements, and client guidance. Experimental status is deliberately scoped. If a surface is not marked experimental, the 3.x guarantees above apply.

Patch releases

A patch release (3.0.1, 3.1.2) changes only documentation, wording, validation that was diverging from the documented stable spec, registry-versioned artifacts, conformance-suite artifacts, or experimental-only surfaces. For stable AdCP surfaces, a patch changes a schema only by a correction under DR-0036: opening a schema that was closed without a structural reason, or applying a bound or required name that the published text already set. It adds no fields, renames none, and adds no enum values. Upgrading to the latest patch of your current release is always safe for stable AdCP surfaces; experimental adopters must also follow the release notes for the experimental features they declared.

Security fixes

Security-relevant fixes are documented in release notes with a security label and land in the current release. Implementations SHOULD upgrade promptly after a security advisory. Older releases within 3.x do not receive routine backports; upgrading to the current release is the expected remediation path. v2 no longer receives security fixes — see the v2 sunset page.

Breaking-change notice

Any change that requires an implementation to adapt ships with all of the following:
  • An entry in the release notes with a migration note
  • An entry in the changelog
  • A section in the migration guide or a dedicated deep-dive page
  • For a replaced field, both fields on the wire until the next major

Schema publication at merge

The latest published tag must always reflect the same required-field set as source HEAD. A PR that changes any required array, changes a discriminator const, or tightens a validation constraint must be accompanied by a new tag cut before the change becomes the active implementation target for external consumers. This is in addition to the rules at the top of this page. Why: Implementors validate against a published tag (whether pinned to an exact version or resolved through the version alias). If source HEAD’s required fields grow beyond what that tag declares, an evaluator reading source and the implementor’s validator reading the published tag will disagree — not because either is wrong, but because the published contract hasn’t caught up. The implementor cannot reconcile the gap without reading source history. During RC cycles: The same invariant applies between RC tags. A schema change that lands between rc.N and rc.N+1 requires cutting rc.N+1 before the new required-field set is treated as active. Until CI enforcement is in place: The PR author is responsible for cutting the new release or RC tag before the change propagates to evaluators. Reviewers should not approve a PR that changes a required array, a discriminator const, or a validation constraint without confirming a new tag is ready to publish.

Release cadence

AdCP publishes the following named policy so implementers can plan: Within a version, releases land every 6–8 weeks early in the cycle and stretch toward quarterly as the version stabilizes. Release count within a version is not fixed. The 18-month major-release spacing commitment applies from 4.0 onward. It does not govern the 3.x-to-4.0 transition or delay the established early-2027 target. The proposed development sequence is to finish 3.3, then develop 4.0 as the next feature release. The prior-major support commitment remains applicable.

Support window for previous major

When a new major ships, the prior major receives security patches for at least 12 months after successor GA. Security patches (CVE fixes and security advisories) are backported for the full window; feature work is not. The exact end-of-life date for each version is published on a per-version sunset page and linked from the transition note that accompanies the successor’s GA release. The v2 sunset is the documented exception to this commitment: v2 predates this policy and lacks account and governance protections that cannot be backported. Its security-only window ended August 1, 2026 — see the v2 sunset page. Future majors will not invoke this exception.

Planned releases

3.2 shipped after a protocol-first beta and seven published release candidates; see the 3.2 prerelease history. The stable TypeScript (@adcp/sdk@14.0.0) and Python (adcp==8.0.0) SDKs follow the protocol release; see SDK versions for 3.2. Further 3.x releases are scheduled based on implementation feedback and working group priorities, with at least 8 weeks between stable releases. Planned scope for each release is tracked on the GitHub milestones page — open issues on the next release milestone reflect current candidate work, not fixed commitments.

Extensibility

AdCP distinguishes three levels of schema extension. The rules below apply to every AdCP schema unless a task reference page states otherwise. Undefined properties. A sender SHOULD NOT emit a property that the schema of the release it serves does not define, except under ext.{namespace} or inside a field marked x-adcp-open-payload: true. Put implementer-specific data under ext.{namespace}. Openness exists so older readers tolerate newer fields; it is not a place for vendor data, and a misnamed field is silently ignored. On get_adcp_capabilities that means it falls back to its default meaning: a seller that writes supported_buying_modes instead of buying_modes appears to offer only brief. Conformance runners report undefined properties as advisory findings with the undefined_properties check, and never fail a storyboard for them. AdCP schemas are open by default (DR-0009), so schema validation does not flag a field the schema omits. A prose MUST NOT on such a field is still normative, and conformance is meant to grade it through storyboards rather than schema validation. What MUST NOT happen:
  • Introducing new top-level properties on a response schema in place of ext.{namespace}. Implementers that need a field outside ext MUST propose the field to the working group.
  • Renaming a core field inline. Aliases are a spec-level operation, not an implementer operation.
  • Tightening a core field’s validation locally. An implementer that needs stricter validation performs it before emitting or after receiving the field — not in the wire schema.
This separation is what lets the spec evolve without every non-conforming implementation becoming a fragmentation claim. The wire contract stays narrow and predictable; ext.{namespace} is where anyone can move fast without coordination.

Adding to the core protocol

A field or task enters the core protocol through one of the following paths:
  1. Release addition. Additive changes (new optional fields on open schemas, new tasks, new enum values) ship in a 3.x release under the normal release process. These are stable from the release they ship in.
  2. Experimental addition. A surface the working group wants to ship for feedback but is not ready to freeze enters the protocol as experimental — see experimental status. Experimental surfaces graduate to stable or are removed; there is no permanent experimental state.
  3. Version boundary. Changes that are incompatible with the current version are held for the next major. See schema changes in releases for what is in and out of scope for a release.

Governance

AdCP development is organized around working groups, each focused on a specific protocol domain (creative, governance, media buy, signals, brand, sponsored intelligence). Working groups drive feature proposals, surface implementation feedback, and shape the direction of their area. Cross-cutting design decisions — consistency across domains, conflicts between working groups, shared primitives — are resolved in the working-group forums and in public issues on GitHub, not behind closed doors. Working groups contribute through:
  • GitHub Discussions for proposals and technical debate
  • Slack channels for real-time collaboration
  • Member feedback from organizations building on AdCP
  • Reference implementations that validate design decisions
As the protocol and its implementation base mature, domain leads will take increasing ownership of their areas.

Additional resources

  • Versions & Compatibility — At-a-glance status of every published version
  • Specification lifecycle — Stage definitions (Draft → Proposed → Final → Deprecated → Sunset), entry criteria, and how to check the current stage of a spec section
  • Roadmap — Planned features and milestones
  • Release Notes — What shipped, with migration guides
  • Changelog — Technical change history