> ## Documentation Index
> Fetch the complete documentation index at: https://docs.adcontextprotocol.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Migrating from 3.2 to 3.3

> Role-based migration checklist for adopting the AdCP 3.3 release candidate while preserving 3.2 compatibility: normative narrowings, loosened guarantees, version-gated new fields, opened schemas, the closed-schema triage, SDK-facing schema changes, experimental notices, deprecated result fields, one deprecated usage, and the deprecated account identity-rekey machinery.

# Migrating from 3.2 to 3.3

> [!WARNING]
>
> **3.3 is at its first release candidate.** This guide is current through `3.3.0-rc.0` (published 2026-11-16). Keep production traffic pinned to `"3.2"` while validating 3.3 in staging. If you built from a beta bundle, read the [closed-schema triage](#closed-schema-triage-what-stays-in-3-3) first: some beta fields leave 3.3 at rc.0. See the [3.3 prerelease program](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/3-3-beta.md) for artifact and SDK timing.

3.3 is a minor release over 3.2. It adds optional fields, enum values, and capability declarations. No stable field, enum value, or task is removed; the one removal is the experimental `build_creative.evaluator.evaluator_id` source form (see [below](#experimental-creative-evaluator-drops-evaluator_id)). `seller_id` on event source and audience results is deprecated in favor of the new `platform_id` field. Natural-key account references after provisioning, the account identity-rekey machinery, and condition (b) of `request_signature_required` are also deprecated (see [Deprecations](#deprecations)). A caller opts into 3.3 only after the peer advertises the exact release in `supported_versions`. Existing 3.2 integrations that need nothing else can stay pinned to `"3.2"`.

Read these first:

* [Required to claim 3.3 behavior](#required-to-claim-3-3-behavior): rules that narrow what a conformant implementation may do, including [unsupported webhook HMAC and batch bodies](#webhook-signing-mode-and-batch-bodies), [responses that conform to the served release](#responses-conform-to-the-served-release), [refinement that carries compliance forward](#refinement-carries-compliance-forward), [bounded counterparty-asserted domain lists](#counterparty-asserted-domain-lists-are-bounded), [seller revisions that advance on every committed change](#seller-revisions-advance-on-every-committed-change), [flight start for committed buys only](#flight-start-activates-committed-buys-only), [flat totals for multi-qualifier metrics](#multi-qualifier-metrics-omit-flat-totals), [enforceable domain identifiers](#property-domain-identifiers-have-an-enforceable-format), [property list references through AdCP tasks](#property-list-references-resolve-through-adcp-tasks), and [dual emission of platform IDs](#platform-ids-are-emitted-under-both-names), [`request_account` as the single account write](#request_account-is-the-single-account-write-where-supported), [the protocol envelope on every task response](#every-task-response-composes-the-protocol-envelope), [major-only requests served the oldest release](#a-major-only-request-is-served-the-oldest-supported-release), [schemas open by default](#schemas-are-open-by-default), [capabilities bounded by structure](#capabilities-are-bounded-by-structure), [`replace` that transfers assignment settings](#assignment-replace-transfers-settings-to-the-replacement), [declared assignment operations](#sellers-declare-the-assignment-operations-they-accept), and [tracker slots that apply only where a format declares them](#tracker-slot-limits-apply-only-where-a-format-declares-tracker-slots).
* [Brand JSON size cap rises to 2 MiB](#brand-json-size-cap-rises-to-2-mib), [audience match counts](#audience-match-counts-may-be-absent), [audience targeting without member push](#audience-targeting-without-member-push), and the [4 MiB response-size default](#client-response-size-default-rises-to-4-mib): four loosened guarantees, so a 3.2 peer can reject or misread what a 3.3 peer sends.
* [Recommended: bound agent response size](#recommended-bound-agent-response-size): a new SHOULD that tightens what an adopting buyer accepts.
* [Send only to 3.3 peers](#send-only-to-3-3-peers): new fields a 3.2 validator rejects.
* [Deprecations](#deprecations): `seller_id` on event source and audience results, `principal_kind` and `expected_principal_kind` on the principal tasks, the natural-key account reference after provisioning, the account identity-rekey machinery (`identity_updates`, `operator_identity`, `ACCOUNT_MOVED`, `ACCOUNT_IDENTITY_CONFLICT`, `stable_account_id`), and condition (b) of `request_signature_required`, and the boolean form of `demographics`; each is expected to be removed in 4.0.
* [SDK and code-generator maintainers](#sdk-and-code-generator-maintainers): schema-shape changes that alter generated types.

Everything else is an optional declaration or a clarification. Agent identity (DR-0023) and demand-side grants (DR-0025) have their own role-by-role guide, [Migrating agent identity in AdCP 3.3](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/migration/agent-identity-3-3.md). For the feature narrative, start with [What's new in AdCP 3.3](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/whats-new-in-3-3.md).

* **TMP routers:** adopt [evaluation-namespace cache isolation](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/migration/trusted-match-context-cache.md); re-authorize warm hits, bypass when the trusted namespace is unavailable, and apply provider-owned TTL handling for model changes (#7446).

## Upgrade checklist

| Step | Who | Action |
| - | - | - |
| 1 | Everyone | Keep production on `"3.2"`; choose an exact 3.3 prerelease artifact for staging. |
| 2 | SDK and codegen maintainers | Generate from the signed `3.3.0-rc.0` protocol tarball (the latest checkpoint), not `main` or `/schemas/3.3.0-rc.0/`. |
| 3 | SDK and codegen maintainers | Treat `daypart_targets[].start_hour` / `end_hour` as optional in generated types (#8025). |
| 4 | SDK and codegen maintainers | Resolve `#/$defs/Provenance` in bundled schemas instead of expecting inlined provenance (#7950, already in 3.2.4). |
| 5 | SDK and codegen maintainers | Expect stricter response validation of `compact-task-submitted.json` (#7946, already in 3.2.4). |
| 6 | Sellers and agents | Advertise the exact prerelease in `adcp.supported_versions` and echo the release actually served. |
| 7 | Buyers | Send a prerelease pin such as `adcp_version: "3.3-rc.0"` only after exact capability discovery; never silently move between prerelease pins. |
| 8 | Sellers that provision accounts lazily | Move provisioning off discovery tasks. |
| 9 | Signing and verifying implementations | Check agent resolution and pinned keys against the list below; apply the A2A hardening clauses. |
| 10 | Verifiers that fetch brand.json | Raise the brand.json body cap from 256 KiB to 2 MiB; leave JWKS and capabilities caps unchanged. |
| 11 | Sellers that send delivery webhooks | Echo `reporting_webhook.operation_id`; send nothing to a registration that omits it. |
| 12 | Buyers, SDK maintainers, and every agent operator | Adopt the client response-size bound (4 MiB default); keep `tools/list`, `get_adcp_capabilities`, and the agent card small, and paginate rather than asking buyers to raise their limits. |
| 13 | Sellers that advertise `measurement_terms` | Advertise only values you accept when replayed unchanged. |
| 14 | Buyers that receive delivery webhooks | Ignore `aggregated_totals`; do not reject the payload for it. |
| 15 | Sellers adopting 3.3 fields | Gate the [3.3-only emissions](#send-only-to-3-3-peers) on the negotiated version. |
| 16 | Sellers and SDKs built from the `3.3.0-beta.0` or `3.3.0-beta.1` bundle | Stop emitting definition pins, purchase `rights[]`, purchase `installments[]`, and the matching refinement and error surfaces, and stop requiring them. They are [withdrawn from 3.3](#withdrawn-from-3-3-planned-for-4-0) and planned for 4.0. |
| 17 | Reliable Reporting buyers | Stop relying on exact reads of older superseded snapshots; persist any snapshot rows you need ([notice](#superseded-reporting-snapshots-may-be-compacted)). |
| 18 | Buyers that read delivery rows | Treat a missing `impressions` as not measured, never zero (#8108). |
| 19 | SDK and codegen maintainers | Make `impressions` optional on delivery row types (#8108). |
| 20 | Sellers and buyers using accounts | Sellers return and accept `account_id` everywhere, and treat countries, currency, timezone, sandbox, and `operator_unit` as account attributes. Buyers store `account_id` and send it instead of the deprecated natural-key reference. |
| 21 | Media-buy sellers and signals resellers | Stop mirroring counterparty `adagents.json` into `publisher_domains` / `data_provider_domains`; truncate and flag incomplete rather than exceed the new bounds. Buyers: never deny on absence from either list. |
| 22 | Property list issuers, receivers, and SDK maintainers | Validate domain identifiers, support MCP reference resolution with list-scoped bearer credentials, and fetch every page before applying a list. |
| 23 | Sellers and buyers of event sources and audiences | Sellers emit `platform_id` and the deprecated `seller_id` with identical values; buyers prefer `platform_id`. |
| 24 | Sellers with a media-buy, account or creative revision | Advance it on every committed change from any origin, including `sync_creatives` assignments and ingested connected-platform changes; add `origin` to `history` entries; optionally return `seller_revision` on `list_creatives`. |
| 25 | Buyers that update media buys | Pass the latest `revision`, and expect `CONFLICT` after a seller or connected-platform change; re-read and retry. |
| 26 | Compliance operators | Use each 3.3 prerelease bundle for protocol feedback; as for 3.2, prerelease grading runs are diagnostic, not a badge. |
| 27 | Buyers and sellers of hosted video or audio | Optionally move playback trackers from `event: custom` to the new `pixel_tracker` playback events. |
| 28 | Users of the experimental `creative.evaluator` surface | Replace `evaluator_id` with an allowlisted `agent_url` or inline `exemplars` ([details](#experimental-creative-evaluator-drops-evaluator_id)). |
| 29 | Creative agents that advertise `creative.supports_refinement` | Retain each leaf's compliance inputs for as long as the leaf, apply them to every refinement, and never treat a refined leaf as approved ([details](#refinement-carries-compliance-forward)). |
| 30 | Sellers that hold buys for review | Keep a provisional buy (`confirmed_at: null`) in `pending_start` at flight start until you confirm or reject it ([details](#flight-start-activates-committed-buys-only)). |
| 31 | Sellers reporting qualified metrics | Omit a metric's flat carrier from buy and window `totals` when packages report it under more than one qualifier set ([details](#multi-qualifier-metrics-omit-flat-totals)). |
| 32 | Buyers and in-house clients | Send `adcp_version` on every request, with the deprecated `adcp_major_version` mirror through 3.x. 4.0 removes `adcp_major_version` and `adcp.major_versions` ([details](#deprecations)). |
| 33 | Network and run-of-network sellers | Return `publisher_properties: []` or `collections: []` only to callers served 3.3 or later; apply any exclusion list you accept against your full internal roster, and reject one you cannot apply with `UNSUPPORTED_FEATURE` ([details](#product-rosters-can-be-undisclosed)). |
| 34 | Buyers and SDK maintainers | Treat an empty roster as undisclosed and opaque, never as an empty set; do not index `publisher_properties[0]` or `collections[0]` ([details](#product-rosters-can-be-undisclosed)). |
| 35 | Sellers that open accounts | Return and accept `account_id` everywhere, accept `account_id`-keyed settings updates, and never change an `account_id` ([#8474](https://github.com/adcontextprotocol/adcp/pull/8474), [details](#account-identity-is-the-account-id)). Stop relying on `operator_identity`, `ACCOUNT_MOVED`, `ACCOUNT_IDENTITY_CONFLICT`, and `stable_account_id`; they are [deprecated](#deprecations). |
| 36 | Sellers and buyers that support `account.requests` | Use `request_account` for every account write, `list_accounts` for request reads, and `sync_principal` for subscriptions. Return `account` with money terms on `matched` and `created` resolutions ([details](#request_account-is-the-single-account-write-where-supported)). |
| 37 | Sellers and SDKs that build task responses | Compose `core/protocol-envelope.json` on every response, include `status`, and truncate a `message` over 2,000 characters ([details](#every-task-response-composes-the-protocol-envelope)). |
| 38 | In-house clients that send only `adcp_major_version` | Expect the oldest supported release in that major, 3.0 where supported (DR-0034); send `adcp_version` for newer behavior ([details](#a-major-only-request-is-served-the-oldest-supported-release)). |
| 39 | Sellers and buyers that register webhooks | Select the signing mode in the registration: `signing_profile` or the deprecated `authentication` block. A seller with `legacy_hmac_fallback: false` rejects the block with `UNSUPPORTED_FEATURE` ([details](#webhook-signing-mode-and-batch-bodies)). |
| 40 | Agents that publish `get_adcp_capabilities` | Stay within the structural bounds; do not design to a byte figure ([details](#capabilities-are-bounded-by-structure)). |
| 41 | Sellers of creatives that are serving | Optionally declare `creative.live_updates` (experimental) and refuse undeclared changes with `CREATIVE_LIVE_UPDATE_UNSUPPORTED` ([details](#live-creative-updates-experimental)). |
| 42 | Buyers and sellers of reporting | Adopt principal-level reporting subscriptions (experimental) and compute coverage from the wire. From beta.4, sellers emit `packages[].added_at` on packages added after confirmation, treat a grant reduced without `get_reporting_status` as a loss of authority, and list `reset_state` with the probe ([details](#reporting-subscriptions-experimental)). |
| 43 | Sellers that adopt the commercial experiments | Gate [seller offers, execution readiness, gender targeting, signal pricing groups, provider-initiated delivery, and measurement provenance](#commercial-and-targeting-experiments) on the negotiated version and the feature id. |
| 44 | Sellers that keep package records | Retain packages on canceled and completed buys, and start approved creatives by default when others are pending review ([details](#canceled-and-completed-buys-keep-their-packages)). |
| 45 | Sellers, buyers, and SDKs built from a beta bundle | Stop emitting and accepting the beta fields that leave 3.3 at rc.0, and move the ones that change home ([closed-schema triage](#closed-schema-triage-what-stays-in-3-3)). |
| 46 | SDK and codegen maintainers, and anyone with a hand-written validator | Regenerate from rc.0: most schemas are now open, so generated types gain index signatures and stop rejecting unknown fields. Keep any rejection you relied on as your own check ([SDK changes](#sdk-and-code-generator-maintainers)). |
| 47 | Buyers and sellers that use overlay demographics | Send the object form `{ "age": true }`, not boolean `demographics: true`, and keep accepting `true` ([deprecations](#deprecations)). |
| 48 | Buyers | Send a prerelease pin only to a peer that advertises it, send discovery `get_adcp_capabilities` unpinned, and retry unpinned or at a listed version on `VERSION_UNSUPPORTED` ([details](#prerelease-pins-unpinned-discovery-and-anonymous-capabilities)). |
| 49 | Sellers | Serve `get_adcp_capabilities` without credentials (a MUST in 4.0). On MCP, let `server/discover`, `initialize`, and `tools/list` through your gateway without credentials ([details](#prerelease-pins-unpinned-discovery-and-anonymous-capabilities)). |
| 50 | Sellers with a creative library | Accept a creative that conforms to the format option it targets; enforce only declared limits ([details](#sellers-accept-creatives-that-conform-to-the-declared-format-option)). |
| 51 | Validators, TMP providers, and registries that read `adagents.json` | Let an origin-only `authorized_agents[].url` authorize the agent at any path on that origin ([`adagents.json`](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/governance/property/adagents)). |
| 52 | Buyers, sellers, and governance agents that accept signed terms | Refuse terms carrying a member you cannot interpret (`unrecognized_terms` or `UNRECOGNIZED_TERMS`), and compute `terms_digest` over the bytes as received ([details](#accepting-signed-terms-binds-every-member)). |
| 53 | Sellers offering Reliable Reporting managed delivery | Hold no caller-issued secret for any pattern; push rows through `reporting_webhook`, and sign every `https_put` request under the Web Bot Auth profile ([details](#reliable-reporting-managed-delivery-holds-no-buyer-secret)). |
| 54 | Media-buy sellers | Optionally declare `media_buy.supported_delivery_types`, and return only products with a listed `delivery_type` when you do ([#8458](https://github.com/adcontextprotocol/adcp/pull/8458)). |
| 55 | Sellers publishing Reliable Reporting report definitions | At `contract_version` `1.2`, include `package_id` whenever `dimensions` include `media_buy_id`, and in `reporting_profile.primary_keys`. Callers pinned below 3.3 MUST be served `1.0` or `1.1` offerings ([details](#per-package-rows-in-reliable-reporting-report-definitions)). |
| 56 | Sellers that accept targeting; buyers that send it | Sellers: accept `geo_value_labels` and geo-entry `value_labels` without rejecting the request, never target from them, and compare codes only. Buyers: send `geo_value_labels` only to 3.3 peers ([details](#display-labels-for-geo-targeting-codes)). |
| 57 | Sellers and buyers of `sync_creatives` `assignment_operations` | Sellers list exactly the operations they accept in `creative.assignment_operations`, list `replace` if they declare `creative.live_updates`, and list `assign` if they sell through `buy_products` or `accept_proposal` with a creative library. Buyers send only listed operations ([details](#sellers-declare-the-assignment-operations-they-accept)). |
| 58 | Sellers that answer `get_media_buy_delivery` | Return at least one `by_package` row per media buy, one per package, and omit a buy you can't report and return an error rather than an empty `by_package` ([#8970](https://github.com/adcontextprotocol/adcp/pull/8970)). `by_package: []` stays valid in 3.x; requiring a row is proposed for 4.0 ([#8973](https://github.com/adcontextprotocol/adcp/issues/8973)). |
| 59 | Sellers, buyers, and SDKs that use `media_buy.execution_readiness`, `creative.live_updates`, or `media_buy.delivery_projection` | Send and accept the renamed values: `input-required` (was `input_required`), `clickthrough` (was `click_through`), and `under_delivery` (was `underdelivery`). There is no alias ([details](#three-experimental-values-renamed)). |
| 60 | Campaign governance agents (`governance.campaign`) | Accept a `sync_plans` plan that omits `human_review_required` and derive the flag from its resolved policies; keep rejecting an explicit `false`. Reject `flight.end` not after `flight.start`, and repeated or colliding policy IDs, with `INVALID_REQUEST` ([#9007](https://github.com/adcontextprotocol/adcp/pull/9007)). |
| 61 | Buyers, sellers, SDKs, and registry and compliance tooling that use `binary-verdict`, `local_verdict`, the compliance `tracks` status, `RATE_LIMITED` `scope`, or signal `onboarder.match_keys` | Accept both spellings. Emit `passed`, `all`, and `full_name` only to a peer served 3.3 or later, and the deprecated `pass`, `global`, and `name` otherwise; keep the original in published files such as `adagents.json` through 3.x ([details](#reserved-word-safe-enum-replacements)). |

## Withdrawn from 3.3, planned for 4.0

Three features are not part of 3.3. All three add terms to `commercial_terms`, and `commercial-terms` and the term objects inside it are held closed until 4.0 ([DR-0036](https://github.com/adcontextprotocol/adcp/blob/main/governance/decisions/DR-0036-closed-schemas-stay-closed-within-a-major.md)). A buyer must not be bound by terms it cannot read: `terms_digest` covers every member of `commercial_terms`, including members under the open schemas inside it, and a party that cannot interpret every member must not accept the terms ([Verify terms independently](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/product-discovery/proposal-negotiation.md#3-verify-terms-independently)). 4.0 gives `commercial_terms` a declared extension point with must-understand, and the three features come back through it. The decision is in [adcp#8501](https://github.com/adcontextprotocol/adcp/issues/8501).

### Definition pins (published in beta.0 and beta.1, removed after beta.1)

`3.3.0-beta.0` published seller-authored `commercial_terms.definition_pins[]` ([#7960](https://github.com/adcontextprotocol/adcp/pull/7960)), required it from sellers serving callers that negotiated 3.3, and `3.3.0-beta.1` carried it forward. Both betas are immutable, so a seller or SDK built from either bundle has these surfaces to remove:

* `commercial_terms.definition_pins[]`, with `core/definition-pin.json` and `enums/definition-pin-ref-kind.json`.
* The `definition_changed` value of `proposal-refinement-reason` and the `drifted_pins[]` field on `refine_proposals` result rows.
* The `REFERENCE_DEFINITION_CHANGED` error code and `error-details/reference-definition-changed.json`.
* The `definition_pin_probe` scenario of `comply_test_controller`, the `definition_pin_drift` storyboard, and the `definition-pins` test vectors.

A seller no longer pins definitions, re-verifies pins at finalize, or fails `accept_proposal` on drift, so the beta MUST is gone. A buyer that depends on a third-party definition not changing after commitment has no 3.3 guarantee and re-reads the publisher's `adagents.json` before accepting. A seller built from a beta bundle that emits pins to a peer on the later schema sends a field a closed `commercial_terms` rejects.

### Purchase rights (published in beta.1, removed after beta.1)

[#8101](https://github.com/adcontextprotocol/adcp/pull/8101) merged on 2026-10-24 and shipped in `3.3.0-beta.1` as experimental `media_buy.purchase_rights`: `purchases[].rights[]`, the `brand/rights-scope.json` hoist, and the `paid_amplification` and `content_reuse` values of `right-use`. All three are removed, and `brand/rights-terms.json` returns to its 3.2 form, including no `minItems` on `uses`. A seller that listed `media_buy.purchase_rights` in `experimental_features` stops listing it and stops emitting `rights[]`. Until 4.0, rights travel through the brand protocol, where `acquire_rights` returns `rights-terms`.

### Installment selection (published in beta.1, removed after beta.1)

[#8246](https://github.com/adcontextprotocol/adcp/pull/8246) merged on 2026-10-24 and shipped in `3.3.0-beta.1` as experimental `media_buy.installment_selection`: `purchases[].installments[]`, and `installment_changes` with `unsatisfied_installment_changes` on `refine_proposals`. All are removed after beta.1, along with `core/installment-change-set.json` and the `installment_changes` value of `proposal_refinement.supported_dimensions`. A seller that listed `media_buy.installment_selection` stops listing it. Installments on the canonical product and `holds[]` stay in 3.3. A purchase buys the product as offered, which is its complete installment set when it declares one.

**The request side returns in rc.0, under a new feature id.** Experimental `media_buy.installment_refinement` ([#8974](https://github.com/adcontextprotocol/adcp/pull/8974)) brings back `installment_changes` on `refine_proposals` (`core/installment-change-set.json`), `unsatisfied_installment_changes` on its result rows, and the `installment_changes` value of `supported_dimensions`, on schemas that are now open. The seller answers a selection with a product whose `installments[]` is exactly the chosen set, so `terms_digest` binds the `product_id` as before and every 3.x buyer reads the purchase the way it already does. `purchases[].installments[]` stays planned for 4.0 ([Adopt by capability](#installment-selection-and-per-installment-creatives-experimental)).

### Where the designs are kept

The designs are preserved for 4.0 in [Planned for 4.0](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/migration/v4-compatibility.md#planned-for-4-0-withdrawn-from-3-3) and in the merge commits of #7960, #8101, and #8246.

## Closed-schema triage: what stays in 3.3

On 2026-11-09 the working group decided that 3.x opens the schemas that were closed by accident ([Schemas are open by default](#schemas-are-open-by-default)). The [#8501](https://github.com/adcontextprotocol/adcp/issues/8501) triage then re-checked every beta feature that had been withdrawn, or proposed for withdrawal, because its schema was closed. It applied three reasons, in this order:

1. **Deprecated surface.** A field on a deprecated task or row leaves, whatever its schema: `get_products`, `create_media_buy`, `update_media_buy`, `sync_creatives` `assignments[]`, and package creative assignments. The live tasks keep the feature where they already carry it.
2. **Held closed until 4.0.** `commercial-terms` and the term objects inside it, and `proposal-budget-constraint`, are held closed until 4.0. A field that would extend one of them leaves, and waits for 4.0.
3. **Closure only.** The withdrawal is moot, and the feature stays in 3.3.

Only the fields below change between beta.5 and rc.0 because of the triage, and each change first shipped in beta.6. The three features withdrawn after beta.1 stay withdrawn ([above](#withdrawn-from-3-3-planned-for-4-0)).

**In review, not in rc.0.** [#8854](https://github.com/adcontextprotocol/adcp/pull/8854) makes two of the triage's changes: it withdraws `metric_id` from `core/canonical-performance-standard.json`, `core/performance-standard.json`, and `required_performance_standards` in `core/product-offer-filters.json`, and it restores `evaluator` as a deprecated `x-entity-types` value. It has not merged, so rc.0's schemas still carry `metric_id` in those three places and still lack `evaluator`. Don't build on `metric_id`: the triage decided it leaves 3.3.

### Stays in 3.3

| Field | Where |
| - | - |
| `review_sla` | `core/canonical-media-buy-action-fields.json` and `core/media-buy-available-action.json` |
| `start_time`, `end_time`, `time_granularity` | Daypart entries, and the overlay requirement and support objects (`media_buy.daypart_granularity`) |
| `available_statuses`, `supports_break_position` | `core/spot-reporting-capability.json` (`media_buy.spot_lifecycle`) |
| `collection_lists`, `collection_lists_exclude` | `core/targeting-overlay-requirements.json` (`media_buy.collection_lists`) |
| `gender` | Overlay `demographics` (`media_buy.gender_targeting`). Boolean `demographics` is [deprecated](#deprecations). |
| `trackers`, `landing_page_url` | The `assign` operation in `sync_creatives` `assignment_operations` |
| `forced.proposal_id`, `forced.arm: unable` | `comply_test_controller` responses |
| `signing_profile` | `core/notification-config.json` and `core/agent-notification-config.json` |

### Leaves 3.3: deprecated surface

| Field | Leaves | The feature stays on |
| - | - | - |
| `trackers`, `landing_page_url` | `sync_creatives` `assignments[]`, and package creative assignments (`core/creative-assignment.json`) on `create_media_buy` and `update_media_buy` | `sync_creatives` `assignment_operations` |
| `refine[].package`, and `result_product_id`, `resolved_start_time`, `resolved_end_time` on `refinement_applied[]` | `get_products` | No 3.3 task. The exact-package availability check ([#8468](https://github.com/adcontextprotocol/adcp/pull/8468)) needs a home on a live task. |
| `include_collections`, `collections` | `get_products` | `list_products`, `request_proposals`, and `refine_proposals` |
| `filters.target_audiences` | `get_products` | No 3.3 task. `list_products` `offer_filters` stays as it is in 3.3, and any change is 4.x, so `media_buy.audience_evidence_targets` has no 3.3 surface. |
| `predecessor_media_buy_id`, `lineage_reason` | `create_media_buy` | `buy_products`, `accept_proposal`, and `get_media_buys` (`media_buy.lineage`) |
| `artifact_webhook.signing_profile` | `create_media_buy` | No other task |
| `start_requires_all_creatives_approved` | Packages on `create_media_buy` and `update_media_buy` | `control_media_buy` package controls (`media_buy.features.creative_start_policy`) |
| `target_audiences` | Packages on `create_media_buy` and `update_media_buy` | Purchases, in 4.0 ([below](#leaves-3-3-held-closed-until-4-0)) |
| `metric_id` | `core/performance-standard.json`, and `required_performance_standards` in `core/product-offer-filters.json` | Performance standards, in 4.0 ([below](#leaves-3-3-held-closed-until-4-0)). Still in the rc.0 schemas: the withdrawal, [#8854](https://github.com/adcontextprotocol/adcp/pull/8854), is in review. |

### Leaves 3.3: held closed until 4.0

| Field | Why it waits |
| - | - |
| `metric_id` on `core/canonical-performance-standard.json` | The canonical performance standard is one of the commercial terms held closed until 4.0. Still in the rc.0 schema: the withdrawal, [#8854](https://github.com/adcontextprotocol/adcp/pull/8854), is in review. |
| `price_adjustments` (`media_buy.price_adjustments`) | Its 3.3 home is the legacy `get_products` pricing option, a deprecated surface, and `canonical-pricing-option` is held closed until 4.0. The whole experiment waits for 4.0. |
| `counting_mechanisms` on `measurement_terms` (`media_buy.measurement_provenance`) | `measurement_terms` sits on deprecated tasks, and the canonical measurement terms are held closed until 4.0. `vendor_metric_provenance[]` on delivery metrics stays in 3.3. |
| `target_audiences` on purchases | A purchase records its terms in `product-purchase.json`, which is held closed until 4.0. |

### Moves within 3.3

| Field | From | To |
| - | - | - |
| `include_execution_readiness`, `execution_readiness` | `get_products` | `list_products` (`media_buy.execution_readiness`) |
| `clock`, `business_calendar_id` | `core/sla-window.json`, which returns to its 3.2 shape because it sits inside the commercial terms held closed until 4.0 (`change_terms[].processing_sla`) | The creative-review SLA (`creative-review-sla`) |
| `available_installment_statuses` | `core/reporting-capabilities.json` | `core/canonical-reporting-capabilities.json` (`media_buy.installment_lifecycle`) |

**If you built from a beta bundle.** Stop emitting and accepting the fields that leave, and move the ones that change home. Regenerate from the rc.0 bundle. An open schema ignores a field it no longer defines, so a stale sender is not rejected there, but the field carries no 3.3 meaning. Two cases reject it: a schema that stays closed, such as the canonical performance standard, and a deprecated row that names the field, such as `sync_creatives` `assignments[]`, which rejects `trackers` and `landing_page_url`. The fields that stay need no action.

### Three experimental values renamed

([#8989](https://github.com/adcontextprotocol/adcp/pull/8989), rc.0.) Three experimental values take the spelling their stable or sibling counterpart already uses. Each was added in 3.3 and existed only in the betas, from beta.0 to beta.6 at the longest, so no stable release has them.

| Enum | Feature id | Beta spelling | rc.0 spelling | Follows |
| - | - | - | - | - |
| `enums/execution-readiness-status.json` | `media_buy.execution_readiness` | `input_required` | `input-required` | `enums/task-status.json` |
| `enums/creative-change-kind.json` | `creative.live_updates` | `click_through` | `clickthrough` | `url_type` in `enums/url-asset-type.json` |
| `enums/delivery-projection-end-state.json` | `media_buy.delivery_projection` | `underdelivery` | `under_delivery` | `enums/offer-reason.json` |

The values are renamed in place, with no alias. A seller or buyer built from a beta bundle sends and accepts the new spelling in `readiness_status` and the product rollup, `creative.live_updates.in_place[].change`, `staged_update.change_kinds[]` and the `CREATIVE_LIVE_UPDATE_UNSUPPORTED` details, and `projection.projected_end_state`.

### Reserved-word-safe enum replacements

([#8915](https://github.com/adcontextprotocol/adcp/pull/8915), rc.0.) Six enum positions used a value that an SDK target language reserves, so 3.3 adds a replacement and deprecates the original ([#8791](https://github.com/adcontextprotocol/adcp/issues/8791)). Each enum accepts both spellings through 3.x. The original is deprecated in 3.3 and removed in 4.0, and the [4.0 compatibility registry](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/migration/v4-compatibility.md) lists every site.

| Deprecated | Replacement | Where | Why |
| - | - | - | - |
| `pass` | `passed` | `enums/binary-verdict.json`, `get_media_buy_artifacts` `local_verdict`, and the registry feed's compliance `tracks` status | A Python keyword |
| `global` | `all` | The `RATE_LIMITED` details `scope` | A Python keyword. Not `agent`, because `enums/error-scope.json` already uses `agent` for the calling buyer agent. |
| `name` | `full_name` | Signal definition `onboarder.match_keys`, on `core/signal-definition.json` and `core/signal-definition-enrichment.json` | Collides with the enum member protocol in Python and Java |

Each deprecated value is listed in `x-deprecated-enum-values` and carries `deprecated: true`, `x-deprecated-in: "3.3.0"`, `x-removed-in: "4.0.0"`, and `x-superseded-by` in a per-value `enumMetadata` entry.

**When to emit the replacement.** Send a replacement only when the release served is 3.3 or later; a 3.2 receiver treats it as an unknown value ([Send only to 3.3 peers](#send-only-to-3-3-peers)). Otherwise send the original. Receivers accept both. A published file, such as `adagents.json`, keeps the original through 3.x, because readers on any 3.x release consume it.

## Required to claim 3.3 behavior

### Discovery tasks never provision an account

A seller that provisions accounts lazily, instead of exposing `sync_accounts`, now provisions only on a provisioning task: one that commits spend or creates account-owned resources, such as `create_media_buy`, `buy_products`, `accept_proposal`, `sync_creatives`, `sync_catalogs`, `sync_event_sources`, or `activate_signal`. Discovery and negotiation tasks MUST NOT create or activate an account, or accept a seller's default terms for the buyer. They include:

* `get_products`, `list_products`
* `get_signals`
* `request_proposals`, `refine_proposals`, `decline_proposals`

**Sellers.** An `account` that does not resolve returns `ACCOUNT_NOT_FOUND` on these tasks, even where `account` is optional, instead of being dropped in favor of public results. A seller that provisions lazily instead of exposing `sync_accounts` MAY answer a discovery task for a natural key it would provision, as if that account existed, without creating it. A seller that exposes `sync_accounts` returns `ACCOUNT_NOT_FOUND`. `list_accounts` is the exception: its `account` field is a filter, so a key that matches nothing returns an empty list. A seller that provisioned on `get_products` or on the "first account-scoped request" was conformant under 3.2 and is not under 3.3. Request and response schemas are unchanged; the required side effect is not.

**Buyers.** Omit `account` and send `brand` until the account is provisioned, and provision before `request_proposals` when you intend to accept. Against a lazily provisioning seller without `sync_accounts`, send the natural key instead; the seller MAY answer without creating the account, and a provisioning task such as `accept_proposal` creates it. Recovery from `ACCOUNT_NOT_FOUND` is the same everywhere: provision a natural key with `sync_accounts` (or the seller's lazy path), or verify an `account_id`. An `account_id` returned by `sync_accounts` is accepted as an `AccountRef` on every account-scoped task.

The advisory storyboard `media_buy_seller/unprovisioned_account_reference` grades this for sellers that expose `sync_accounts`. Its checks become required at runner capability `14.1.0`. See [Account references before provisioning](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/accounts/overview.md#account-references-before-provisioning).

### Signature verification tightens

Request signing, webhook signing, governance JWS `iss`, designated-task response signing, and rights attestations now share one [agent-resolution algorithm](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L1/security.md#agent-resolution). Some signatures that verified under 3.2 can fail:

* A pinned `signing_keys` key that is not published in the agent's JWKS is rejected. The pin narrows the accepted keys for sell-side signatures the agent makes about that publisher's inventory, such as webhooks; it never adds a key and does not apply to the agent's other traffic. Where a message covers several publishers, the key must match every pin that applies. Publish every pinned key in the agent's JWKS.
* A pin entry without complete public-key parameters for its `kty`, such as one with only a `kid`, matches nothing. Matching is by RFC 7638 thumbprint.
* `key_origins` is now checked for every webhook signer that publishes `brand_json_url`, including pinned keys, and origin binding (the agent URL's eTLD+1 equals the `brand_json_url` eTLD+1, or a House Portfolio `authorized_operators[]` entry covers it) applies to webhook signers.
* Webhook discovery starts from `identity.brand_json_url`. When it is present, buyers MUST use it and MUST NOT fall back. The 3.x fallback reads `/.well-known/brand.json` at the agent's host, or its eTLD+1, only for sellers that omit the field. Every resolution failure rejects with `webhook_signature_key_unknown`.
* Agent URLs match by canonical URL on every surface. Webhook discovery and governance `iss` no longer compare byte for byte, and the schema's `agent_url_match` verifier constraint is now `canonical`. Two `agents[]` entries that match canonically are ambiguous only if they differ in `type` or in resolved JWKS source; entries that agree on both count once.
* Governance buyer identity for signed requests is the exact operator record that agent resolution selected, and `iss` must match exactly one governance-typed entry.
* Cached or onboarding mappings must be confirmed against the agent's `brand_json_url` and re-confirmed within the brand.json cache lifetime.

TMP keeps its own publisher-key model. Verifiers take the publishers that apply from their own record of the media buy, never from the payload.

### A2A operation-resolution hardening becomes MUST

The A2A operation-resolution errata ([GHSA-2pm6-6mc8-8xcm](https://github.com/adcontextprotocol/adcp/security/advisories/GHSA-2pm6-6mc8-8xcm)) shipped in 3.2.3: `required_for`, `supported_for`, and `warn_for` match the operation resolved from an A2A message's sole DataPart `skill`, and an unresolvable request fails closed with `request_body_malformed`. Its hardening clauses were SHOULD in 3.2.x and are MUST from 3.3:

* strict parsing of unsigned bodies, including JSON-RPC batches and duplicate or case-variant member names, with duplicate keys detected after JSON string decoding (`"skill"` and `"sk\u0069ll"` collide);
* A2A Part shape: one content member per Part, no FilePart, and `kind` agreement;
* task-continuation binding: a `message.taskId` request must resolve to the task's original operation and come from the principal that created it.

A verifier declares that it implements these rules and passes the A2A conformance vectors, including the `hardening` tier, by listing `a2a_invocation_skill` in the new optional `request_signing.operation_sources` capability. The claim covers every A2A version and binding the endpoint serves, and a present array MUST list every source the verifier supports. The rules are MUST for every 3.3 verifier whether or not it lists the marker. An absent field means the verifier has not declared support: a counterparty MUST NOT infer that `required_for` is enforced over A2A, and buyers sign every operation in `required_for` regardless. See [Operation resolution over A2A](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L1/security.md#operation-resolution-over-a2a).

### Reporting webhooks without `operation_id` fail closed

`reporting_webhook` now carries an optional `operation_id` (1–255 characters from `A–Z`, `a–z`, `0–9`, `_`, `.`, `:`, `-`). The seller MUST echo it verbatim into every `media_buy_delivery` webhook sent to that registration and MUST NOT derive it from the webhook URL. From 3.3, a seller MUST NOT emit `media_buy_delivery` webhooks to a registration that omits it. The field is expected to become required in 4.0.

On a `"3.2"` pin the fail-closed rule remains opt-in [interim guidance](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L3/webhooks.md#adcp-3-2-interim-reporting-correlation).

**Buyers** add a unique `operation_id` to every `reporting_webhook` registration, and update existing registrations before relying on scheduled delivery. **Sellers** store it with the registration and, when it is absent, send no `media_buy_delivery` webhook to that registration and never fabricate a value. 3.2 integrations that adopted the interim agreement already send the same wire shape. See [Reporting webhooks](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L3/webhooks.md#reporting-webhooks).

### Reporting and artifact webhooks can omit `authentication`

`reporting_webhook.authentication` and `create_media_buy.artifact_webhook.authentication` are required only on a request served below 3.3 ([#8176](https://github.com/adcontextprotocol/adcp/issues/8176)). When this block is absent, the seller signs every delivery under the profile the registration's `signing_profile` selects (`adcp/webhook-signing/v1` when it is omitted), as for `push_notification_config` ([Webhook callbacks](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L1/security.md#webhook-callbacks)). No shared secret crosses the wire, so a 3.3 integration can be fully HMAC-free.

**Buyers.** Omit the block only on a request served at 3.3 or later. A buyer pinned to 3.2 keeps sending it, even to a 3.3 seller.

**Sellers.** Accept a 3.3-served request without the block and sign its deliveries as for `push_notification_config`. On a request served at 3.3 or later, the downgrade and injection rules in [Webhook callbacks](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L1/security.md#webhook-callbacks) now cover both registrations. A request served below 3.3 still requires the block. Sending it remains valid everywhere in 3.x, and the block is removed in 4.0 ([#4288](https://github.com/adcontextprotocol/adcp/issues/4288)).

### Origin-only `authorized_agents[].url` entries authorize the agent at that origin

An `authorized_agents[].url` whose canonical form has the root path and no query, such as `https://agent.example.com`, now matches any agent URL with the same canonical origin, so it authorizes an agent connected at `https://agent.example.com/mcp`. Under 3.2 it matched only an agent served at the root. An entry with a path still matches only that canonical URL. When several entries match the same agent, such as an origin-only entry and an entry with the agent's full URL, each one authorizes it and the agent's scope is the union of their scopes; a narrower entry never removes scope that another matching entry grants. A `signing_keys` pin combines the same way, over the entries that match the agent and authorize the message's scope: the agent is pinned only if every such entry carries `signing_keys`, and then it may sign with a key pinned by any of them, so an unpinned origin-only entry that covers the message leaves the agent unpinned even where its full-URL entry pins keys. An entry that authorizes nothing for the message, such as one for another country, neither pins nor unpins it. Buyers, TMP providers, and registries that check `authorized_agents[].url` MUST apply the origin-only rule. No entry that authorized an agent under 3.2 stops authorizing it. This aligns `adagents.json` with [DR-0023](https://github.com/adcontextprotocol/adcp/blob/main/governance/decisions/DR-0023-agent-identity-is-an-origin.md), under which an origin hosts one agent. A host that serves several tenants' agents at different paths lists each tenant's full agent URL, not its bare origin, which would authorize all of them. See [Agent URL matching](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/governance/property/adagents.md#agent-url-matching).

### Sellers accept creatives that conform to the declared format option

([#8941](https://github.com/adcontextprotocol/adcp/pull/8941), rc.0.) A seller MUST NOT refuse a creative, with a conformance code (`CREATIVE_SIZE_MISMATCH`, `CREATIVE_VALUE_NOT_ALLOWED`, `CREATIVE_VALIDATION_FAILED_GENERIC`, or `VALIDATION_ERROR` / `INVALID_REQUEST` against the assets), on the grounds of a declared parameter the creative satisfies, and MUST NOT enforce a narrower value than the one declared. A closed set narrows a slot only when it is declared: with no `cta_values`, the `cta` slot takes free text. Under `technical_requirements_complete: true` the seller holds no undeclared limit, so a creative that conforms to every declared parameter is accepted. Refusals outside format conformance are unchanged: `CREATIVE_REJECTED` for content review and `POLICY_VIOLATION` for advertising policy.

**Sellers** that refused declared sizes or enforced an undeclared CTA list were already contradicting their own declaration; they now fail the new `media_buy_seller/declared_format_option_acceptance` scenario. See [Format conformance](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/creative/task-reference/sync_creatives.md#format-conformance).

### Accepting signed terms binds every member

([#8884](https://github.com/adcontextprotocol/adcp/pull/8884), rc.0.) `terms_digest` covers the entire `commercial_terms` JSON value: every member at every depth, including `ext` and members a party does not recognize. Several schemas inside `commercial_terms` are open, so the signed bytes can carry members a party's release does not define. Accepting the terms binds the accepting party to every member, so a party that cannot interpret every member MUST NOT accept them.

* **Buyers** decline with the new `decline_proposals` reason `unrecognized_terms`.
* **Sellers** reject the request that carries such terms, such as a `buy_products` purchase, with the new error code `UNRECOGNIZED_TERMS`.
* **Governance agents** deny the check through their existing deny path.
* **Everyone** computes or verifies `terms_digest` over the JSON value as received, never over a re-serialized parsed model, which can drop members the model doesn't declare. A member whose schema defines it as opaque, such as `context`, is interpreted by that definition.

The `media_buy_seller/unrecognized_terms_rejected` storyboard grades the seller side. See [Verify terms independently](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/product-discovery/proposal-negotiation.md#3-verify-terms-independently).

### Advertise only the measurement terms you accept

A seller MUST NOT advertise, in a product's `measurement_terms`, a `measurement_window` or other term value that it would reject with `TERMS_REJECTED` when a buyer replays those terms unchanged on `create_media_buy`. An advertised window MUST reference a `window_id` declared in `reporting_capabilities.measurement_windows`. The `measurement_terms_accepted` storyboard grades a rejection of replayed advertised terms as a seller failure. See [Advertise only what you accept](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/task-reference/get_products.md#advertise-only-what-you-accept).

### Audience identifiers keep their wire form

`uids[].value` on `sync_audiences` now has a stated wire form per `type`. For `uid2` and `euid`, `value` is the raw UID2 or EUID, never the encrypted UID2 token, and senders and receivers MUST NOT case-fold or re-encode it. A `hashed_email` entry in `uids[]` MUST agree with the top-level `hashed_email` when both are present. For `maid`, senders SHOULD send the lowercase hyphenated UUID and receivers SHOULD normalize before matching. See [`sync_audiences`](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/task-reference/sync_audiences).

### Delivery rows may omit `impressions`

`impressions` is no longer required on `get_media_buy_delivery` `daily_breakdown` rows or on the dimensional breakdown rows (`by_format`, `by_device_type`, `by_device_platform`, `by_audience`, `by_demographic`, `by_installment`, `by_collection`, `by_placement`, `by_property`, `by_geo`, `by_keyword`, `by_creative`, `by_catalog_item`, and their `_property` variants). Identity keys and `spend` stay required, and `aggregated_totals` still requires `impressions`.

The schema loosens, and the rules around it narrow:

* **Receivers** MUST NOT treat an absent `impressions` as zero and MUST NOT derive impression-denominated values (`cpm`, `ctr`, `completion_rate`, `viewable_rate`) for that row. SDK-generated row types make the field optional; handle `undefined` or `None`.
* **Senders** omit impression-denominated rates on such a row, MUST NOT put views, plays, downloads, or any other count in `impressions`, and disclose a committed-but-missing metric through `by_package[].missing_metrics`.
* **Version gate.** A response served below 3.3 follows the 3.2 schema, which requires `impressions` ([Serving an older pin](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/versioning.md#serving-an-older-pin)). In it, a seller with no impression count omits the row and never substitutes `impressions: 0`.

See [Rows without impressions](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/media-buys/optimization-reporting.md#rows-without-impressions).

### Product rosters can be undisclosed

A product's `publisher_properties` and `collections` no longer require at least one entry ([#7948](https://github.com/adcontextprotocol/adcp/pull/7948), refs [#6135](https://github.com/adcontextprotocol/adcp/issues/6135)). A non-empty list is the complete roster, as before. An empty list (`[]`) now means the seller does not disclose the roster: it is not an empty set and it bounds nothing. There is no new field and no partial state. An absent `collections` still makes no collection declaration, and `publisher_properties` stays required on a `Product`.

* **Emission gate.** A seller serving a release below 3.3 MUST NOT return a product with an empty roster; the 3.2 schema requires one entry, so it omits the product and returns the others ([Serving an older pin](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/versioning.md#serving-an-older-pin)). Wholesale feeds and webhooks are not defined by this release.
* **Allow lists** (`property_list`, `collection_list`, `collection_lists`) MAY be accepted against an undisclosed roster. The package runs only on the items the seller matches, with no promise to cover every listed item.
* **Exclusion lists** (`property_list_exclude`, `collection_list_exclude`, `collection_lists_exclude`) are the buyer's choice, because the buyer sees the undisclosed roster at discovery. A seller MAY accept one, and if it does it MUST apply the exclusion against its full internal roster. A seller that cannot, for example because it does not itself know every publisher it may serve, rejects it with `UNSUPPORTED_FEATURE` (correctable).
* **Buyers** SHOULD treat an undisclosed roster as opaque in brand-safety and governance logic, decide whether it is acceptable for their exclusions, and MAY refuse such products. **Sellers** SHOULD offer complete rosters where they can.

See [Roster coverage](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/product-discovery/media-products.md#roster-coverage).

### Property domain identifiers have an enforceable format

`core/identifier.json` now validates `domain` and `subdomain` values as lowercase
ASCII hostnames with at least two labels, labels of at most 63 characters, and
a hostname of at most 253 characters. IDNs use lowercase A-label/punycode form.
Only `domain` permits a leading `*.`. Existing matching rules are unchanged.

**Before:** the bare string schema accepted `Example.com`, `example.com.`, and
`https://www.example.com/path`, so a buyer could submit an exclusion the seller
could not match. **After:** each value is rejected with `INVALID_REQUEST`; the
receiver rejects the containing request rather than dropping the identifier.
An invalid identifier in a fetched page invalidates the complete snapshot.

**Senders.** Validate stored lists before adopting the 3.3 artifact that includes
these constraints. Offer explicit conversion before submission when needed:
`Example.com` or `example.com.` becomes `example.com`, and a pasted
`https://www.example.com/path` can become `www.example.com` after the sender
confirms that hostname selection is intended. Validate the converted value;
receivers MUST NOT silently reinterpret it. Apply this to inclusion lists,
exclusion lists, and `filters.exclude_identifiers`.

This tightens validation without removing a field or changing its type. The
[invalid-input rejection precedent in DR-0012](https://github.com/adcontextprotocol/adcp/blob/main/governance/decisions/DR-0012-reject-native-control-characters.md)
supports rejecting junk input; the newly required lowercase and trailing-dot
rules also require migration of previously schema-valid hostname spellings.
See [domain identifier format](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/governance/property/tasks/property_lists.md#domain-identifier-format).

### Property list references resolve through AdCP tasks

**Before:** the spec left the fetch operation and credential use unspecified;
an issuer could offer only a custom `GET /lists/{list_id}` route while a seller
called `get_property_list` over MCP. **After:** issuers expose `get_property_list`
over MCP at `agent_url`, and receivers support that resolution path. Another
advertised AdCP task transport may be used by agreement. A custom HTTP download
route may remain available, but serving it alone does not satisfy the reference
contract, and receivers do not infer its path from `agent_url`.

**Issuers and receivers.** When a reference carries `auth_token`, send it as
`Authorization: Bearer <auth_token>` to the managing agent for initialization
and every page. The issuer accepts it without a recipient account or second
credential and binds it to read-only access to that `list_id` and its continuation
pages. It grants no access to other lists, enumeration, or mutations. Fetch and
validate every page before replacing a cached snapshot; authorization or fetch
failure must not remove an inclusion or exclusion constraint.

No reference field is removed or changes type, and Bearer authentication already
exists in AdCP. The new requirements define how the existing list credential is
used and scoped; they do not introduce a replacement authentication scheme.
Issuers, receivers, and SDKs must implement this contract when adopting the 3.3
artifact that includes it; upgrading the schema bundle alone does not supply the
runtime support. [DR-0008](https://github.com/adcontextprotocol/adcp/blob/main/governance/decisions/DR-0008-sdk-canon-for-wire-contracts.md)
preserves shipping SDK wire shapes under ambiguity, not unspecified semantic
contracts. Compliance checks follow the normative resolution requirements under
[DR-0001](https://github.com/adcontextprotocol/adcp/blob/main/governance/decisions/DR-0001-conformance-assertions-normative-basis.md).
See [reference resolution](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/governance/property/tasks/property_lists.md#resolving-a-property-list-reference)
for the complete credential and caching requirements.

### Counterparty-asserted domain lists are bounded

`media_buy.portfolio.publisher_domains` and `signals.data_provider_domains` are the
only two capability fields whose contents a third party writes: both are populated
from counterparties' `/.well-known/adagents.json`, which any domain owner publishes
unilaterally without the named agent's consent. Unbounded, that let an unrelated
party inflate a victim's capabilities document past `MAX_CAPABILITIES_BYTES` — and
because the RFC 9421 signing-key discovery path fetches that document unnarrowed, a
victim that signed under that profile lost signature verification, not just
discovery, one cache cycle later.

**The schemas are unchanged; the normative rule is new.** A byte budget caps any
single counterparty-asserted field at 8,192 bytes and both together at 16,384,
measured as uncompressed serialized JSON. The structural bounds — at most 100
unique entries, each at most 253 characters — ride in `x-adcp-validation` and are
graded by the conformance storyboard in 3.x, becoming schema constraints in 4.0.
So a 3.2 response with 101 domains, a duplicate, or an over-length entry stays
schema-valid and is reported rather than rejected. What changes in 3.3 is
conformance: a producer that mirrors a large network wholesale is no longer
conformant, and the fix is to truncate and flag. Recorded in
[3.3 exceptions to 3.x compatibility](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/versioning.md#3-3-exceptions-to-3-x-compatibility-beta).

**Agents.** Stop mirroring "every counterparty whose adagents.json names me" — that
is the vector. Publish the publishers or providers you actually represent. If the
real set does not fit, truncate and set the new `publisher_domains_complete: false`
(or `data_provider_domains_complete: false`); both default to `true`, so an agent
whose list is complete changes nothing. Never serve a truncated list as complete.
The bound is a conformance statement, not a runtime control — it makes an
inflated document non-conformant, it does not stop your serializer emitting one.

**Buyers.** Neither list was ever an allowlist, and both are now explicitly
non-exhaustive: a publisher's absence is **not** evidence the seller is
unauthorized for it, with or without the completeness flag. If you prefetch
`publisher_domains` into an authorization cache, treat a cache miss as "not looked
up yet" and resolve that publisher's own `adagents.json` on demand — a buyer that
denies on cache miss will reject legitimate inventory from any seller whose list is
truncated.

**Bound that on-demand resolve.** `products[]` and each product's
`publisher_properties[]` are sized by the seller, so a naive per-property fetch
hands the seller your fan-out — a larger amplification than the one this change
closes. Resolve a product's domains in one deduplicated pass, cap the number of
publisher origins and the concurrency, negative-cache failures, and use the
[SSRF profile](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L1/security.md#webhook-url-validation-ssrf) with
the 1 MiB publisher-origin cap rather than a bare `fetch` — the domain pattern
admits dotless labels like `localhost`. See
[Authorization validation workflow](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/governance/property/authorized-properties.md#authorization-validation-workflow).

### Seller revisions advance on every committed change

3.2 text said the media-buy `revision` "MUST increment on every mutating state change or update" but listed only `update_media_buy`, and exempted assignment changes made through `sync_creatives` and seller-optimized allocation. 3.3 states the rule once: for every resource that carries a seller-maintained revision, the seller MUST advance it on every committed change to state that resource's authoritative read reports, whatever the origin: an AdCP task, a seller operator, seller automation, another authorized principal, or a connected platform. An externally observed change advances it when the seller ingests it, within the source's declared freshness bound. Reads, validation-only calls and exact idempotency replays do not advance it.

**Sellers.**

* Advance the media-buy `revision` on operator and ad-server edits, on connected-platform changes you ingest, on seller automation such as a review decision that changes a package's creative approval, and on every applied `sync_creatives` assignment change (once per affected buy, in the same atomic write as that buy's assignment change). A platform report that merely echoes a change you already committed is not a new change. Delivery measurements (`snapshot`, `get_media_buy_delivery`), `indicators`, `health`, `impairments` and `webhook_activity` carry their own freshness fields and are not revisioned state. An ingestion pass that observes no change advances nothing, and one atomic ingestion transaction may coalesce its changes into one revision step.
* Append a `history` entry for each such change. For a change that did not arrive through an AdCP task, set the entry's `origin.kind` to `seller_operator`, `seller_system`, `connected_platform` or `unknown`, the same vocabulary as `account.change.origin`. The existing `actor` string is unchanged.
* Seller-optimized allocation: changing a reported cap, target, pacing or lifecycle value advances the revision with `origin.kind: "seller_system"`. Spreading spend between packages inside the accepted caps remains delivery behavior and advances nothing, so for allocation this restates 3.2 rather than tightening it.
* When you maintain a creative `seller_revision`, `account.change.resource_revision` carries its value immediately after the change, in the same JSON type.

**Buyers.** An update that carries a stale `revision` was already rejected with `CONFLICT`; a buyer that omits `revision` is not fenced and sees nothing new. The rejection now also happens after a change you did not make, including a `sync_creatives` assignment from another caller or your own earlier call. Re-read with `get_media_buys` (the `sync_creatives` response does not return the new revision in 3.3), reconcile, and retry with the new `revision` and a fresh `idempotency_key`; never retry the same stale `revision`. Do not treat an unchanged `revision` as proof that package assignments are unchanged on a 3.2 seller.

### Flight start activates committed buys only

The 3.x rule that a seller MUST move a buy from `pending_start` to `active` when the flight date arrives now applies only to committed buys (`confirmed_at` non-null). A provisional buy (`confirmed_at: null`) stays `pending_start` until the seller confirms or rejects it ([#7963](https://github.com/adcontextprotocol/adcp/pull/7963)). `status` is the buyer-actionable readiness axis and `confirmed_at` the seller-commitment axis.

**Sellers** that hold buys for review never auto-activate a held buy, and can set `expected_confirmation_at` on `get_media_buys` while `confirmed_at` is null. **Buyers** read `confirmed_at`, not `status`, to learn whether the seller has committed. See [Provisional buys](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/specification.md#provisional-buys-seller-review-hold).

### Multi-qualifier metrics omit flat totals

When a buy's packages report a `metric_id` under more than one qualifier set, in `by_package[].metric_values` or in a package's flat carrier, sellers MUST omit that metric's flat carrier (the whole nested object, such as `viewability`) from per-buy `totals` and every window slice's `totals` on `get_media_buy_delivery`, and from per-buy `totals` in delivery webhooks ([#8055](https://github.com/adcontextprotocol/adcp/pull/8055)). The rule applies across packages, so one package at `mrc` and another at `groupm` no longer combine into one flat `viewability`. One row is one `(scope, metric_id, qualifier)` key; `impressions` and `spend` are unaffected.

**Buyers** read the package rows instead of expecting a buy-level value for such a metric. See [Media buy delivery object](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/task-reference/get_media_buy_delivery.md#media-buy-delivery-object).

### Responses conform to the served release

Once you list 3.3 in `supported_versions`, every release you list is a promise about response shape: [Serving an older pin](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/versioning.md#serving-an-older-pin) has the rule, which covers `get_adcp_capabilities` and webhook payloads ([DR-0024](https://github.com/adcontextprotocol/adcp/blob/main/governance/decisions/DR-0024-responses-conform-to-served-release.md)).

**Sellers.** Check each response against the published schema of the release you echo, and stop listing a release you can't serve that way. 3.2 sellers serving a `"3.1"` pin could emit six shapes a strict 3.1 validator rejects, led by the `sync_accounts` required-field flip; see the [3.1 to 3.2 list](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/migration/3-1-to-3-2.md#version-negotiation-across-3-1-and-3-2).

**Buyers.** Keep parsing tolerantly, because sellers that list no release later than 3.2 aren't bound by the rule.

### Prerelease pins, unpinned discovery, and anonymous capabilities

A 3.3 beta buyer pinned `get_adcp_capabilities` to `"3.3-beta.5"` against a seller that speaks only 3.0, got `VERSION_UNSUPPORTED`, and never retried, so the two never found the release they share. 3.3 states how each side avoids that ([Pre-release pins](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/versioning.md#pre-release-pins)).

* **Buyers** MUST send a prerelease `adcp_version` only to a peer whose `supported_versions` advertises that exact value; a prerelease pin never negotiates down. They SHOULD send the discovery `get_adcp_capabilities` call without a pin, and on `VERSION_UNSUPPORTED` SHOULD retry without a pin or at a value from `supported_versions`, the recovery the error code already names.
* **Sellers** SHOULD serve `get_adcp_capabilities` without credentials, because buyers probe anonymously before they hold a key. This is a SHOULD in 3.3 and a MUST in 4.0 ([Authentication](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L2/authentication.md)).
* **MCP sellers.** A gateway or auth layer that allow-lists JSON-RPC methods SHOULD let `server/discover` (MCP `2026-07-28`), `initialize`, and `tools/list` through without credentials. Otherwise a current MCP client treats the agent as requiring sign-in before it can read capabilities ([MCP guide](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L0/mcp-guide.md#let-mcp-discovery-through-without-credentials)).

### Refinement carries compliance forward

A `build_creative` refinement (`refine_from_build_variant_id`) inherits the parent leaf's compliance set (`required_disclosures`, `prohibited_claims`). A refine request can add to it and never remove or narrow it; `message` and `config` cannot reduce it. An instruction such as "remove the disclaimer" fails the whole call with `COMPLIANCE_UNSATISFIED`. A refined leaf gets its own `creative_id`, and neither seller nor buyer-side approval of the parent extends to it. Schemas gain no field or error code.

**Creative agents.** If you advertise `creative.supports_refinement`, retain each leaf's compliance inputs for the same window you retain the leaf. An agent that retains none can newly fail refinements of briefed leaves. See [Compliance and approval across refinement](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/creative/task-reference/build_creative.md#compliance-and-approval-across-refinement).

**Buyers.** Re-send nothing: the parent's compliance carries forward. Treat each refined leaf as unapproved until it goes through your own review.

### Platform IDs are emitted under both names

A seller reporting an event source or audience platform ID in a 3.3 or later 3.x response MUST emit both `platform_id` and the deprecated `seller_id` alias with identical values, including discovery responses and seller-managed event sources. A legacy-only result stays schema-valid, but a 3.3 seller needs dual emission to conform. Buyers prefer `platform_id`. See [Deprecations](#deprecations).

### Account identity is the account ID

An account's identity is the seller-assigned `account_id` ([#8474](https://github.com/adcontextprotocol/adcp/pull/8474), from [#8280](https://github.com/adcontextprotocol/adcp/issues/8280) and [#8442](https://github.com/adcontextprotocol/adcp/issues/8442)). A brand is its domain, plus `brand_id` where its `brand.json` lists several brands. `brand.countries`, `currency`, `timezone`, `sandbox`, and `operator_unit` are account attributes, not identity.

* **Sellers** MUST return `account_id` on every non-failed `sync_accounts` provisioning result once the account is resolved, never issue one that might later change, accept `{ "account_id": "..." }` wherever an `AccountRef` is accepted, and never change it. If you open buyer-declared accounts through `sync_accounts`, accept settings-update entries keyed by `account_id`. Such an entry updates attributes, `brand.countries` and `billing` included, on the same account. Validate a changed attribute as you do when the account opens, and reject a change you do not support with `UNSUPPORTED_FEATURE`. `currency`, `timezone`, and `sandbox` are set at opening: you MAY refuse a `currency` or `timezone` change, and `sandbox` never changes. You can review a `countries` change first: report `pending_approval` on the entry's result row, and keep the current countries until you approve. A natural-key reference resolves only when exactly one of the caller's accounts matches; otherwise return `ACCOUNT_AMBIGUOUS`, and MAY list the candidates in `details.candidates`.
* **What narrows for sellers.** In 3.2, returning `account_id` was a SHOULD and accepting it was optional. Both are MUST, so a seller that met only the 3.2 wording does not conform. In 3.2, a buyer-declared seller could reject settings-update entries; in 3.3 it accepts them. A provisioning entry never changes an existing account. When it matches exactly one account in your account scope, on `brand` and `operator` with its attributes as filters as the [`request_account` deduplication guidance](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/accounts/tasks/request_account#deduplication) describes, you SHOULD return that `account_id` instead of opening another. The exact-or-reject rules for `billing` and `payment_terms` still apply.
* **Buyers** store the returned `account_id` and send it on every later call. Retry with the same `idempotency_key`. Sending a provisioning entry again is safe with a seller that returns the account the entry matches, but that is a SHOULD, so look a lost ID up through `list_accounts`. A change to `currency` or `timezone` normally means opening a new account.
* **Buyers working with 3.0 to 3.2 sellers.** An older seller may reject settings-update entries, may not support a `countries` change, or may treat countries as part of the natural key. When it can't take the change, keep using the account reference you have, its `account_id` or the natural key the seller accepted: the account keeps working with its current countries. Open a new account only if you choose to, with a provisioning entry carrying the new countries. It gets its own reference, and the existing account and its media buys stay as they are. Don't use the deprecated `operator_identity` rekey to emulate the change.
* **Countries and accepted buys.** `brand.countries` decides which products, prices, terms, and reviews apply, not where a buy delivers. Narrowing it never changes a media buy the seller already accepted. A change can make two accounts alike; that is not a conflict, and both keep their IDs. A seller that supports `account.requests` puts a `request_id` on a settings-update row it is reviewing, and the request can resolve to the changed account or an account you already hold. A separate new account comes only from a `request_account` change that sets `allow_separate_account: true`; otherwise a seller that would only take the change on a new account rejects it with `ACCOUNT_CHANGE_REQUIRES_NEW_ACCOUNT`. See [Account identity](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/accounts/overview.md#account-identity).

See [Account identity](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/accounts/overview.md#account-identity) and [Updating account attributes](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/accounts/tasks/sync_accounts.md#updating-account-attributes).

### `request_account` is the single account write where supported

Applies to sellers that declare the experimental `account.requests` capability ([#8293](https://github.com/adcontextprotocol/adcp/pull/8293), [#8551](https://github.com/adcontextprotocol/adcp/pull/8551), [#8543](https://github.com/adcontextprotocol/adcp/issues/8543) Part A). A seller that does not declare it keeps the 3.2 `sync_accounts` behavior, and `sync_accounts` stays stable and available everywhere in 3.3. Its formal deprecation follows `account.requests` leaving experimental status.

* **One write.** `request_account` opens an account (`brand` and `operator`) and changes one. With an `account_id` and other fields, each field is a requested change: the brand's `countries` (with a matching `domain` and `brand_id`), `operator_unit`, `billing`, `billing_entity`, and `payment_terms`. A `revision` guards the change, and it is required when the change touches `billing`, `billing_entity`, or `payment_terms` (a stale one returns `CONFLICT`). `sandbox` never changes. `currency` and `timezone` change only on a seller that lists them in `account.requests.changeable_attributes`, and a seller that changes timezone MUST list it; otherwise the change is refused with `UNSUPPORTED_FEATURE`.
* **Outcomes.** A request is `in_review` with a single `pending_action` saying whose turn it is, `resolved`, `ambiguous`, or `rejected`. A change resolves as `updated` on the named account, `matched` to an account the caller already holds, or `created` as a separate account carrying the change, and in the last two cases the named account is untouched and the seller MUST NOT move media buys, creatives, or reporting between the accounts. A `created` resolution happens only when the request set `allow_separate_account: true` (default `false`). A seller that would take the change only on a separate account otherwise refuses with the correctable `ACCOUNT_CHANGE_REQUIRES_NEW_ACCOUNT` ([#8580](https://github.com/adcontextprotocol/adcp/pull/8580), [#8582](https://github.com/adcontextprotocol/adcp/pull/8582)).
* **Money terms (beta.3).** A request that resolves `matched` or `created` MUST carry `account`, with its `billing`, `billing_entity` (without write-only fields), and `payment_terms`, because they can differ from the terms requested. An `updated` request that changed `billing`, `billing_entity`, or `payment_terms` carries `effective_at`, when the new terms take effect. A `created` separate account carries `not_carried_over`, the account-level configurations it doesn't have ([#8620](https://github.com/adcontextprotocol/adcp/pull/8620)). A seller that returned these resolutions without `account` fails validation.
* **Reads.** `list_accounts` takes `include_requests` and `request_ids` and returns `account_requests[]` beside `accounts[]`. Requests page through `requests_pagination` and `account_requests_pagination`; the top-level `pagination` pages accounts only. The unreleased `get_account_requests` task is gone, and `account.requests.read_task` is `list_accounts`.
* **Authorization.** The seller resolves `account_id` against the caller's access before any other check, so an unreachable account answers like an unknown one. A change needs `request_account` in the grant's `allowed_tasks` with `read_only: false`, and every changed field in the grant's `field_scopes` when it lists them (`SCOPE_INSUFFICIENT`, `READ_ONLY_SCOPE`, `FIELD_NOT_PERMITTED`). A newer change request from the same caller supersedes the open one, which is rejected with `CONFLICT` and `details.superseded_by`.
* **`sync_accounts` where `account.requests` is supported.** Buyers SHOULD use `request_account`, `list_accounts`, and `sync_principal` instead. A `sync_accounts` entry that carries only `notification_configs` or `reporting_delivery_configs` is a subscription write: it MUST name an account the caller already holds (otherwise `ACCOUNT_NOT_FOUND`), and the seller MUST NOT provision, review, or change account attributes for it. A settings update under review carries its `request_id`.

**Buyers.** Send `request_account` to the seller that declares it, read `resolution` (`updated`, `matched`, or `created`; for the last two the resolved `account_id` differs from `requested.account_id`), and read `account` for the terms that apply. Keep using `sync_accounts` against sellers that don't declare the capability. See [`request_account`](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/accounts/tasks/request_account).

### Every task response composes the protocol envelope

([#8547](https://github.com/adcontextprotocol/adcp/pull/8547), a correction under [DR-0036](https://github.com/adcontextprotocol/adcp/blob/main/governance/decisions/DR-0036-closed-schemas-stay-closed-within-a-major.md).) Every task response schema and async status payload composes `core/protocol-envelope.json` through its root `allOf`, as the envelope's own notes already required. Envelope fields (`status`, `task_id`, `context_id`, `context`, `message`, `timestamp`, `replayed`, `adcp_error`, `push_notification_config`, `governance_context`) are siblings of the body fields at the response root on MCP and REST. Before, 47 of the 124 response and status schemas did not compose it, and 18 closed roots and branches rejected envelope fields, so generated types could not represent a conforming response.

* **`status` is required.** The envelope required it already, and the schemas now enforce it on every response served at 3.3, including the async status payloads and governance responses that omitted it. A webhook `result` example carries the task's `status`.
* **Version fields.** `core/protocol-envelope.json` composes `core/version-envelope.json`, so `adcp_version` and `adcp_major_version` are envelope fields on every response, stamped by the server framework rather than carried as task data. The `adcp_version` echo validates on the `control_media_buy`, `decline_proposals`, `buy_products`, and `accept_proposal` responses.
* **Open roots.** Every response root and status branch is open. The 18 closed ones are reopened: the 3.2 proposal-flow roots and branches, the new 3.3 `list_collections`, `list_proposals`, `get_media_buy_issue`, and `report_media_buy_issue` responses, and the experimental `get_reporting_status` failure branches. Closed value objects and rows inside a body stay closed.
* **`message`.** A task-level `message` is at most 2,000 characters, defined once in `core/task-message.json` and treated as untrusted input by the receiver. A seller whose text is longer MUST truncate it rather than fail the task.
* **`task_id`.** One definition, `core/task-id.json` (`type: string`, `minLength: 1`), serves every declaration. An empty `task_id` is rejected. A submitted response requires `task_id`, a working body requires `status: working`, and an input-required body requires `status: input-required`, each through a shared schema.
* **`replayed`.** An absent value means `false`, and a response may carry `replayed: false`; `replayed: true` appears only on a replay.

No body field is added, renamed, or removed. **Sellers and SDKs** include `status` on every response and truncate `message`. **Buyers and SDK maintainers** regenerate types, since envelope fields now appear on every response type, and `status` enums on the `decline_proposals`, `request_proposals`, and `refine_proposals` roots are replaced by their branch constants.

### A major-only request is served the oldest supported release

A request that carries `adcp_major_version` and no `adcp_version` is served the **oldest** release the seller supports in that major, and the response echoes it ([DR-0034](https://github.com/adcontextprotocol/adcp/blob/main/governance/decisions/DR-0034-major-only-requests-are-served-the-oldest-release.md), accepted 2026-10-26). For a major-only `adcp_major_version: 3` request to a seller that supports 3.0, that is 3.0. Before, the rule was the newest. Every 3.1 and later SDK sends `adcp_version`, so in practice a major-only request comes from a 3.0 buyer whose payload is 3.0-shaped; answering with the newest release would return a shape its validator rejects. A request that carries neither field is still served the seller's default release. The rule is 3.x only and ends when 4.0 removes `adcp_major_version` ([DR-0035](https://github.com/adcontextprotocol/adcp/blob/main/governance/decisions/DR-0035-adcp-major-version-removed-in-4-0.md)).

**Sellers.** Resolve a major-only request to the oldest supported release in that major, and serve and echo it ([Serving an older pin](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/versioning.md#serving-an-older-pin)). **In-house clients** that send only the integer lose newer fields; send `adcp_version`.

### Schemas are open by default

([DR-0036](https://github.com/adcontextprotocol/adcp/blob/main/governance/decisions/DR-0036-closed-schemas-stay-closed-within-a-major.md), working-group decision of 2026-11-09.) 3.3 opens the schemas that were meant to be open. Closing a schema only breaks validators that hard-code it, so opening one is not a protocol break. `additionalProperties` goes from `false` to `true` at 747 of the 859 closed locations in the 3.3 source. Nothing else in those schemas changes, and every payload that was valid stays valid. The next 3.2.x patch ([#8864](https://github.com/adcontextprotocol/adcp/pull/8864)) opens the same locations that 3.2 has, all but one: it keeps the `get_reporting_status` `lookup_unavailable` branch closed, as 3.2 published it.

A location stays closed where closure enforces something, and the commercial terms are held closed until 4.0:

* **Unions told apart by key presence.** The `a2ui/bound-value.json` literal and path forms, and the `brand.json` redirect, house, agent and portfolio forms. Opening them would let a payload that is valid today match two forms.
* **Commercial terms, held closed until 4.0.** `commercial-terms` and the term objects inside it: `product-purchase`, `change-term`, `change-term-constraints`, `sla-window`, `bidding-policy`, and the canonical measurement terms, performance standard, reporting commitment, pricing option and budget allocation. This is a hold, not a structural reason: 4.0 gives `commercial_terms` a declared extension point with must-understand, and new terms wait for it.
* **Join keys.** Metric `qualifier` objects and forecast dimensions. Consumers join on their key sets.
* **Canonical identity and signatures.** `canonical-installment-ref` and the JWS response-payload envelope.
* **Privacy clamps.** The TMP identity and context match requests, `catalog-item-reference-not-found-error`, the per-agent `PERMISSION_DENIED` and `BILLING_NOT_PERMITTED_FOR_AGENT` details, the `get_principal` recognized, unconfigured and failed results and the `sync_principal` failed result, and the error objects of the `get_reporting_status` `lookup_unavailable` failure.
* **Credentials.** Reporting destinations, which are credential-free by contract; a credential can have any name. `proposal-budget-constraint`, the strict peer of `budget-range`, is held closed until 4.0 with the commercial terms.
* **No key material or markup.** `trust.json`, which sits on the signature-verification fetch path and whose keys are published only in the key directory, and `placement-presentation`, a declarative frame that consumers render.
* **Maps keyed by identifiers,** where closure checks the keys (`patternProperties`).

Where closure also rejected a specific field the protocol defines elsewhere, such as `trackers` on an `unassign` operation or `expires_at` on a hold entry, the opened schema names it in a `not` clause, so that payload is still rejected. Each such schema says in its description what it rejects and why, because generated types can't express `not`.

A minor may add to an open schema. It adds nothing to a schema that stays closed; that waits for the next major. The additive-minor check enforces both, and still fails on removals, renames, retypes, removed enum values, tightened bounds, new required names, and closing an open schema.

What this means for 3.3 adopters:

* **Readers ignore unknown fields** on an open schema ([versioning](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/versioning.md)). A validator that hard-codes the 3.2 closures rejects 3.3 payloads, so regenerate it from the 3.3 schemas.
* **Generated types can change.** A generator that reads `additionalProperties` treats the opened objects as open: json-schema-to-typescript adds an index signature, and Pydantic models generated with `extra="forbid"` stop rejecting extra fields. Code that relied on a type or validation error for an unknown key needs its own check.
* **Send a 3.3 field only to a 3.3 peer.** A strict validator on 3.2.10 or earlier still rejects it ([Send only to 3.3 peers](#send-only-to-3-3-peers)).
* **Features that needed new terms in `commercial_terms` stay withdrawn** ([above](#withdrawn-from-3-3-planned-for-4-0)), and seller-held change terms are planned for 4.0 instead of shipping as `commercial_terms.change_terms[]`.
* **Only the creative review SLA carries a clock** ([adcp#8501](https://github.com/adcontextprotocol/adcp/issues/8501)). `core/sla-window.json` is back to its 3.2.8 shape, and `clock` and `business_calendar_id` now live on `core/creative-review-sla.json`, which `creative_policy.review_sla` uses. Sellers built on 3.3.0-beta.1 through beta.5 stop sending `clock` and `business_calendar_id` on an action's `sla`, a change term's `processing_sla`, and the escalation SLA. Those maxima are elapsed time and include weekends and non-working periods.

### Capabilities are bounded by structure

([#8505](https://github.com/adcontextprotocol/adcp/pull/8505), restated in [#8526](https://github.com/adcontextprotocol/adcp/pull/8526), [#8198](https://github.com/adcontextprotocol/adcp/issues/8198).) The `maxItems`, `maxLength`, and `maxProperties` limits in the `get_adcp_capabilities` schema, and the `x-max-items-4.0`, `x-max-length-4.0`, and `x-max-properties-4.0` annotations on fields that were stable before 3.3, are the protocol's limit on the document. Agents MUST NOT design to a byte figure.

* **New and experimental fields enforce the limit with the keywords.** Fields stable before 3.3 carry it as the 4.0 annotations, a SHOULD through 3.x that 4.0 turns into the keyword. No schema-valid 3.2 document becomes invalid.
* **`MAX_CAPABILITIES_BYTES` (64 KiB) keeps its name and value** as a receiver backstop and deployment guidance: receivers commonly bound response size at the HTTP or gateway layer, and a limit near 64 KiB is a reasonable guard against runaway or hostile documents. It is not a design target and not a rule on senders. It stays the fetch budget of step 1 in the deprecated RFC 9421 key-discovery chain through 3.x.
* **Counterparty-asserted lists are unchanged.** The 8,192-byte budget per field and 16,384 bytes together stand, as in [above](#counterparty-asserted-domain-lists-are-bounded).

**Agents** keep their capabilities well inside the structural bounds, and an agent with a large creative catalog adopts the Web Bot Auth profile or keeps its document under the receiver backstop. **Receivers** apply the backstop at the transport layer, not as a protocol rule.

### Canceled and completed buys keep their packages

([#8467](https://github.com/adcontextprotocol/adcp/pull/8467).) From 3.3 a seller retains packages on canceled and completed media buys. It preserves records it held at adoption and packages it later creates or observes, including stable identities, correlation data, platform mappings, and the latest recorded committed configuration whatever its origin. Irrecoverable earlier or never-observed external history is disclosed through nonfatal errors, not by silently returning an incomplete list. Prior terminal package outcomes and the original cancellation metadata are preserved, released creative assignments stay released, and missing statistics are never reported as zero delivery. Responses served as 3.2 permit empty terminal package lists and carry no retention guarantee. A 3.3 stateful conformance scenario checks complete package readback after individual and whole-buy cancellation.

### Mixed creative approval states at startup

([#8485](https://github.com/adcontextprotocol/adcp/pull/8485).) A seller keeps valid pending-review and rejected assignments and starts the eligible approved assignments by default. An optional `start_requires_all_creatives_approved` gate on `control_media_buy` package controls, declared through `media_buy.features.creative_start_policy`, holds the start until every assignment is approved, and a structured-only `update_creative_start_policy` action sets it independently of assignment changes. The gate is consumed at first enablement for serving. A seller distinguishes its own review (`pending_start`) from buyer-actionable missing coverage or a blocking rejection (`pending_creatives`). The new pre-activation `pending_start` to `pending_creatives` transition needs corresponding SDK transition-validator support before you adopt it. Buyers assign the complete launch set atomically or keep delivery paused during staged supply.

### Receivers ignore `aggregated_totals` in delivery webhooks

Senders still MUST NOT put `aggregated_totals` in a delivery webhook result. Receivers now MUST ignore it if present, MUST NOT treat it as authoritative, and MUST NOT reject the payload for carrying it. Reconcile totals from `get_media_buy_delivery` or from the per-delivery rows. See [webhooks](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L3/webhooks.md).

### Assignment `replace` transfers settings to the replacement

([#8688](https://github.com/adcontextprotocol/adcp/pull/8688), beta.4.) A `sync_creatives` `assignment_operations` `replace` now carries the replaced assignment's authored settings to the replacement: `weight`, placement routing (`placement_ids`, `placement_refs`), `rotation_mode`, `group_id`, `sequence_position`, assignment `trackers`, and the `landing_page_url` override. A `weight` on the operation replaces the transferred weight, and `placement_ids` on the operation replaces the transferred placement routing entirely, including any `placement_refs`.

**Sellers.** Validate the transferred settings against the replacement, and reject the atomic request rather than drop or partially apply one. The spec was silent before, so a swap could silently stop assignment measurement or send clicks back to the creative's own destination.

**Buyers.** To change a transferred tracker or the landing page, send a following `assign`. The `media_buy_seller/assignment_replace_transfers_settings` storyboard grades this for sellers that declare `creative.supports_assignment_trackers` and `creative.supports_assignment_landing_page`.

### Tracker-slot limits apply only where a format declares tracker slots

([#8715](https://github.com/adcontextprotocol/adcp/pull/8715), beta.4.) Assignment tracker-slot limits apply only when the effective format declares at least one tracker slot: a `pixel_tracker` slot, or a canonical `impression_tracker`, `click_tracker`, or `viewability_tracker` slot. A format that declares none, such as canonical `image`, makes no slot-limit claim. Against it, a seller does not reject an assignment tracker for lack of a slot; it fires every accepted tracker or rejects the assignment. Trackers match slots by event: `impression_tracker` takes `impression`, `click_tracker` takes `click`, `viewability_tracker` takes the `viewable_*` events and `audible_video_complete`, and any other `pixel_tracker` slot takes any event. The same rules govern the trackers a `replace` transfers.

### Sellers declare the assignment operations they accept

([#8933](https://github.com/adcontextprotocol/adcp/issues/8933).) `sync_creatives` `assignment_operations` has had `assign`, `unassign`, and `replace` since 3.2, and 3.3 adds `merge`, but nothing said which a seller accepts, so a buyer learned it by being refused. 3.3 adds `creative.assignment_operations` to `get_adcp_capabilities`.

**Sellers.** List exactly the operations you accept, and reject any other with `UNSUPPORTED_FEATURE`, with `error.field` at that operation, applying nothing. If you declare the experimental `creative.live_updates`, you MUST list `replace`, because `CREATIVE_LIVE_UPDATE_UNSUPPORTED` recovers through a `replace`. If you expose `buy_products` or `accept_proposal` and declare `creative.has_creative_library: true`, you MUST list `assign`, because a compact buy gets its creatives only through `assignment_operations`. Name an operation in an error `suggestion` or recovery only when you list it. If you set `creative.supports_assignment_merge: true`, list `merge`. A 3.2 response cannot carry the list, so serve it at 3.3 or later only.

**Buyers.** Send only listed operations. When a response served at 3.3 or later lists none, send no `assignment_operations`. Against a seller served at 3.2, the list is unavailable, and `UNSUPPORTED_FEATURE` is the signal. Where `supports_assignment_merge` and the list disagree, the list governs. The `media_buy_seller/assignment_replace_transfers_settings` storyboard now runs only against sellers that list `assign` and `replace`. In the 3.3 bundle, `media_buy_seller/compact_direct_buy_lifecycle` checks that a seller with a creative library lists `assign`, and `sales-broadcast-tv` checks that the seller lists `assign` before it sends one.

## Brand JSON size cap rises to 2 MiB

The brand.json body cap rises from 256 KiB to 2 MiB (2,097,152 bytes) on every fetch path: the AgenticAdvertising.org registry's live read, and the signing trust-root fetches in [`security.mdx`](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L1/security#discovering-an-agents-signing-keys-via-brand_json_url) (rights-holder resolution, designated-task response signing, and `brand_json_url` key discovery). Real brand houses with visual guidelines, colorways, and localized names exceed 256 KiB, so the old cap made them unverifiable. The cap applies to brand.json only. `MAX_JWKS_BYTES` and `MAX_CAPABILITIES_BYTES` are unchanged.

**This loosens a limit, so interop is asymmetric.** A verifier still enforcing 256 KiB rejects a brand.json between 256 KiB and 2 MiB with `request_signature_brand_json_malformed` (or `webhook_signature_key_unknown` on the webhook surface), even though a 3.3 verifier accepts it.

**Verifiers.** Raise the brand.json cap to 2 MiB, and implement the requirements that make the larger cap safe, several of them new MUSTs in 3.3: count bytes while the body streams and abort the connection once the cap is exceeded (never buffer then check, and never read past 2 MiB); apply the cap to decoded bytes when the response is content-encoded; keep the 5 s connect and 10 s total deadlines (the total covers reading the body); enforce a nesting depth of 32 while strict-parsing; send `Accept-Encoding: identity`; run cheap checks before the fetch and bound concurrent trust-root fetches; and keep the success-cache lifetime bounded by the JWKS revocation polling interval with negative caching at or under 60 s. Revalidating with `ETag` and single-flighting concurrent fetches keep the larger body from being refetched on every request. SDKs that hard-clamp brand.json to 256 KiB need a release before their verifiers accept the larger size; check your SDK's changelog.

**Operators.** A brand.json SHOULD stay under 2 MiB. While counterparties may still be on 3.2 verifiers, an operator whose brand.json carries `agents[]` or signing keys and needs to verify with them SHOULD keep that file under 256 KiB, for example by pointing `identity.brand_json_url` at a small Brand Agent variant that carries only the agent entries, until those peers upgrade. The smaller file must still pass origin binding and the `key_origins` check.

## Audience match counts may be absent

In 3.2, a `ready` audience promised `matched_count` and `effective_match_rate`. In 3.3 they MAY be absent when the seller cannot report them, and buyers MUST NOT read absence as zero; `audience_size` and `targetable_size` carry the size as a range instead. A buyer still on 3.2 expects the counts, so sellers keep populating them, where they can, for callers pinned to 3.2.

## Audience targeting without member push

In 3.2, `media_buy.audience_targeting` promised `sync_audiences` with inline member push, and always required `supported_identifier_types` and `minimum_audience_size`. In 3.3 the object promises `audience_include` / `audience_exclude` and discovery-only `sync_audiences`, which a declaring seller MUST answer. Inline member push is declared by the `sync_audiences` pattern in the experimental `supported_activation_methods`; when that field is absent, push is supported exactly as in 3.2 ([#8936](https://github.com/adcontextprotocol/adcp/issues/8936)).

* **Sellers that take pushed members** change nothing. A seller that already lists `supported_activation_methods` keeps the `sync_audiences` pattern in it.
* **Sellers that can target audiences already on the account but take no pushed members** can now declare `audience_targeting` with `supported_activation_methods` listing their other patterns and omitting `sync_audiences`, and `media_buy.audience_activation` in `experimental_features`. They can omit `supported_identifier_types` and `minimum_audience_size`, MUST answer discovery-only `sync_audiences`, and MUST reject an entry that carries `add` or `remove`, or that would create a new audience without a `source` reference, with `UNSUPPORTED_FEATURE`. A strict 3.2 validator still requires both fields, and `get_adcp_capabilities` runs before negotiation, so a seller that wants 3.2 readers to validate its document can keep declaring them.
* **Buyers** check `supported_activation_methods` before pushing members, and read both fields as optional. Discovery-only `sync_audiences` lists the `audience_id` values a buyer can target on any declaring seller.

See [Sellers without inline member push](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/task-reference/sync_audiences.md#sellers-without-inline-member-push).

## Recommended: bound agent response size

Clients SHOULD bound the size of every AdCP response they read, enforce the bound while the body is received rather than after buffering or parsing, apply it to streamed (SSE) responses both per event and cumulatively per call, surface an oversized response as an error rather than truncating it, and default to no more than 4 MiB (4,194,304 bytes). This is a recommendation, not a conformance requirement — a 3.2 implementation does not become non-conformant — but SDKs are adopting the default, so the interop effect is real. See [Response size bounds](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L1/security.md#response-size-bounds).

**This tightens a limit, so interop is asymmetric in the opposite direction from the brand.json cap.** A buyer that adopts the default rejects a response a buyer without the bound would have buffered and parsed. The rejection arrives as a mid-body connection abort, not as an `adcp_error` the seller can read off the wire, so a seller whose responses are too large sees a transport failure rather than a protocol error.

**Buyers and SDK maintainers.** Take the bound from your SDK release rather than hand-rolling it. Check its default against your largest known-good response before enabling it in production; raise it for a specific agent or a specific call, never globally, and never by disabling it. Confirm the SDK enforces while streaming (a buffer-then-check implementation does not close the memory exposure), counts decoded bytes, covers SSE cumulatively, and bounds JSON depth and node count after the byte cap passes — the byte cap bounds ingress, the parse bounds bound memory.

**Sellers with large catalogs.** Paginate. `list_products`, `get_products`, `list_creatives`, `get_media_buys`, and the cursor-pageable `tools/list` catalog all support continuation; the 128 KiB producer interoperability target already applies to each page. A response that only succeeds against a buyer who raised its limit for you is not interoperable. See [Managing response size](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/concepts/managing-response-size.md#pagination-for-cardinality-control).

**Every agent: check your discovery surfaces first.** `tools/list`, `get_adcp_capabilities`, and the A2A agent card are the first bytes a counterparty reads, and they have no fallback — a buyer that trips its cap there cannot discover you at all, rather than getting a smaller page. Measure all three before you measure anything else. Keep `tools/list` pages under 128 KiB. Keep `get_adcp_capabilities` small too. 3.3 bounds it by structure: every array, string, and map has a limit, enforced on new fields and annotated for 4.0 on stable ones. Those bounds are the protocol's limit, and agents MUST NOT design to a byte figure. Receivers commonly apply a backstop around 64 KiB (`MAX_CAPABILITIES_BYTES`) at the HTTP or gateway layer against runaway or hostile documents; it is deployment guidance, not a design target. If you sign under the deprecated RFC 9421 profile, its key discovery fetches capabilities under `MAX_CAPABILITIES_BYTES` (64 KiB), and a document above it makes your signing keys unresolvable as well as your capabilities unreadable. An agent on the [Web Bot Auth profile](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L1/wba-profile.md) is unaffected, and a creative agent with a large `creative.supported_formats` catalog should adopt that profile or keep its capabilities under the limit. Treat 64 KiB for the agent card as an editorial target rather than a cap: no normative limit applies to it, and a client must not reject a larger one. Capability-selected tool registration and terse `x-tool-summary` descriptions are the usual fix. See [Discovery responses stay small](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/concepts/managing-response-size.md#discovery-responses-stay-small).

### Client response-size default rises to 4 MiB

The recommended client safety limit on a whole MCP message or A2A call rises from 1 MiB to 4 MiB (4,194,304 bytes), matching what the Go, TypeScript, Python and Java SDKs and the hosted grader ship. 4 MiB remains the ceiling on what any default may be. A2A's per-DataPart check is now the same limit rather than a tighter 1 MiB, because the single-artifact invariant makes the authoritative DataPart the whole response — a tighter per-part number would have become the effective A2A cap and rejected what the byte-identical MCP call accepts.

**This loosens a limit, so interop is asymmetric.** A client still enforcing 1 MiB rejects a response between 1 MiB and 4 MiB that a 3.3 client accepts. A tighter default stays conformant, so there is nothing to fix in such a client — but the response it rejects is one the seller is now entitled to send.

**Clients.** Raise the default to 4 MiB, or keep a tighter one deliberately. Everything that made the bound safe is unchanged and still required: enforce while the body streams, pre-reject an over-limit `Content-Length`, count raw and decoded bytes, pair the cap with deadlines, cover SSE cumulatively, and bound JSON depth and node count after the byte cap passes. The byte cap is the lesser control — a 4x larger buffer changes little once the node bound rejects at the 100,001st member — but note that the node bound does not limit the length of a single scalar, so per-field length limits are what keep a 4 MiB string out of a log or a model context.

**Fan-out clients.** This is the change to size before adopting. A per-call default is not an aggregate budget: at 4 MiB and 64 concurrent peers the raw ceiling is 256 MiB, and the resident-object figure is several times that. If your aggregate budget is smaller than concurrency times the per-call default, lower one of the two.

**Sellers.** The extra headroom is not a licence to grow. The 128 KiB producer interoperability target is unchanged, and while counterparties remain on 3.2-era clients a response between 1 MiB and 4 MiB will be rejected by some of them with no protocol error you can see — the same transition window the brand.json cap change created, in the opposite direction. Paginate instead.

### Webhook signing mode and batch bodies

The buyer's webhook registration selects the signing mode, as in 3.2 ([#8475](https://github.com/adcontextprotocol/adcp/pull/8475)). An `authentication` block asks for the legacy scheme, and without one the seller signs under the registration's `signing_profile` (`adcp/webhook-signing/v1` when it is omitted). `legacy_hmac_fallback` is a discovery flag that a buyer checks before asking for legacy signing; it does not select the mode.

* **Sellers with `legacy_hmac_fallback: false`.** Reject a registration carrying an `authentication` block with `UNSUPPORTED_FEATURE`, not `request_signature_required`. Point `error.field` at the block.
* **Sellers with `legacy_hmac_fallback: true`.** 3.2 behavior stays valid through 3.x, including the signature requirement on a registration that carries `authentication` (condition (b)). Condition (b) is deprecated and removed in 4.0 with the block.
* **`reporting_webhook` and `artifact_webhook`.** Their `authentication` is optional from 3.3 and still required on a request served below 3.3. These rules apply to them only on a request served at 3.3 or later; below 3.3 nothing changes. An absent block signs under the registration's `signing_profile` (`adcp/webhook-signing/v1` by default).
* **Buyers.** Send `authentication` only to a seller whose `legacy_hmac_fallback` is `true`. Compare a received webhook's signing mode with the mode you registered.
* **Batch bodies.** A JSON array body, signed or unsigned, is rejected with `request_body_malformed` (SHOULD in 3.2.x, MUST from 3.3, [#8064](https://github.com/adcontextprotocol/adcp/pull/8064)); this replaces the 3.2 interim rule that let a verifier resolve every element of a batch. A client that batches JSON-RPC messages, which older MCP protocol versions allowed, sends one message per request.

## Recommended: bound inbound push and webhook bodies

Receivers of A2A push notifications and AdCP webhooks SHOULD bound the request body, the receiver-side counterpart of the response bound above. Enforce the cap while the body streams, pre-reject an over-limit `Content-Length`, apply the 64-deep, 100,000-member parse bounds after the byte cap and **before** RFC 9421 or Web Bot Auth verification, apply connect, idle, and total deadlines, and reject with HTTP 413 rather than truncating. The default is 4 MiB, the same number as the attestation task-body cap, and a tighter per-feature cap governs (the 1 MB webhook payload limit still applies to webhook deliveries). See [Inbound body bounds](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L1/security.md#inbound-body-bounds).

**Receivers.** A 3.2 receiver that buffered whatever a seller posted is not wrong under 3.2, but it is the surface this closes. Add the cap in front of signature verification, not behind it, and do not truncate.

**Senders.** A 413 is a deterministic failure: the same body fails the same way on every attempt, so retrying it on the non-2xx backoff schedule only repeats the cost. Keep webhook payloads well under the cap.

## Recommended: emit only properties the served release defines

([#8156](https://github.com/adcontextprotocol/adcp/pull/8156), beta.4.) A sender SHOULD NOT emit a property that the served release's schema does not define, except under `ext.{namespace}` or inside `x-adcp-open-payload` fields ([Extensibility](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/versioning.md#extensibility)). A misnamed field is silently ignored, and on `get_adcp_capabilities` it falls back to its default meaning, so the capability you meant to declare reads as absent. The runner output contract adds an `undefined_properties` check that reports each such property with a JSON Pointer, an optional suggested same-level field, and the later release that defines it, if any. The check is always advisory and never fails a step; the capability-discovery storyboard runs it on `get_adcp_capabilities`.

## Send only to 3.3 peers

Many 3.3 additions sit inside objects that 3.2.10 and earlier publish closed, so a strict validator built from those schemas rejects them. 3.2.11 ([#8864](https://github.com/adcontextprotocol/adcp/pull/8864)) opens the same locations in 3.2, so a validator built from it ignores most of these fields instead, but a 3.2 peer still doesn't understand them. Either way, send a field or value that 3.3 defines only when the negotiated `adcp_version` is 3.3 or later ([DR-0024](https://github.com/adcontextprotocol/adcp/blob/main/governance/decisions/DR-0024-responses-conform-to-served-release.md)). The "why" column describes 3.2.10 and earlier. The cases most likely to bite:

| Sender | Field or value | Why a 3.2 peer rejects it |
| - | - | - |
| Buyer | `criteria.outcome_target.goal` with `kind: "vendor_metric"` | The 3.2 `goal` union has no such branch. |
| Buyer, seller | `daypart_targets[]` entries with `start_time` / `end_time`, including proposal `allocations[].daypart_targets` | 3.2 requires `start_hour` / `end_hour` and closes the entry. |
| Buyer, seller | `time_granularity` in `required_overlay_support.daypart_targets` and `overlay_support.daypart_targets` | 3.2 closes the structured daypart object. |
| Buyer | `budget.periods[]` on `sync_plans` | 3.2 closes the plan `budget`. |
| Seller | `expected_confirmation_at` on `accept_proposal`, `buy_products`, and `refine_proposals` submitted responses | 3.2 closes the commitment `submitted` arm and the `refine_proposals` response. It is safe on `create_media_buy`. |
| Seller | A product with `publisher_properties: []` or `collections: []` (undisclosed roster) | 3.2 requires at least one entry in each. |
| Seller | Delivery rows without `impressions` | 3.2 requires `impressions` on every row. |
| Seller | `by_spot[]` rows with `spot_status: "scheduled"` or `"preempted"`, and `available_statuses` / `supports_break_position` on `supports_spot_breakdown` | 3.2 requires `aired_at` on every row and closes the spot capability. |
| Seller | `hold_policy` on products and proposals, `committed` proposals under `terms_only` finalize | The fields are not in 3.2, and a 3.2 buyer reads `committed` as an inventory hold. |
| Seller | `dooh_inventory_summary` on canonical products (`list_products`, `request_proposals`, `refine_proposals`) | 3.2 `canonical-product.json` is closed. |
| Buyer | `brand`, `operator_unit`, `currency`, `timezone`, or `billing` on a `sync_accounts` settings-update entry | 3.2 `SettingsUpdateMode` forbids them. |
| Seller | `proposal_initiator`, `offer_reason`, seller offers, and `proposal.offered` notifications | `proposal_initiator` is a 3.3 field on a schema reopened in 3.3. A caller with no declared pin is treated as below 3.3. |
| Seller | `credit_note` records on `get_account_financials` invoices | A pre-3.3 buyer summing `invoices[].amount` would count a credit as a charge. |
| Buyer | Core `demographics.gender` targeting | 3.2 core targeting is age-only. |
| Seller | `vendor_metric_provenance[]` on delivery metrics | Strict older validators reject the new field. |
| Buyer | `reporting_subscriptions` on `sync_principal` | A seller that lists only `sync_principal` in `reporting_delivery.configuration_tasks[]` serves reporting registration to 3.3 callers only. |
| Buyer | `pixel_tracker` `event` values `start`, `first_quartile`, `midpoint`, `third_quartile`, `complete` | 3.2 closes the `event` enum; send them as `event: custom` until the seller negotiates 3.3 ([below](#hosted-video-and-audio-playback-trackers)). |
| Buyer | `geo_value_labels` on targeting ([#8966](https://github.com/adcontextprotocol/adcp/pull/8966)) | The field is not in 3.2, and a 3.2 seller may treat an unknown targeting key as an unsupported dimension. |
| Buyer, seller | The `passed`, `all`, and `full_name` enum replacements ([#8915](https://github.com/adcontextprotocol/adcp/pull/8915)) | A 3.2 receiver treats each as an unknown value; send the deprecated original instead. |
| Seller | `match_keys` on `Product.identity` (experimental, beta.5) | 3.2 closes `core/product-identity.json`. `media_buy.supported_match_keys` on `get_adcp_capabilities` sits in an open object and is safe. |

New enum values (`nmo`, `videoamp`, `mxf`, `mpeg2`, `avc_intra`, `xavc`, `3gp`, `mpeg`, and `m4v` in video `containers`, `print_metrics` in `available-metric`, `operator_fee` in `adjustment-kind`, and the eight Instagram, Facebook, Snapchat and X values in `distribution-identifier-type` ([#8995](https://github.com/adcontextprotocol/adcp/pull/8995))) fall under the 3.x rule that clients tolerate unknown values, but a strict 3.2 validator still rejects them; send them only to 3.3 peers too.
**Correction: the proposal flow and the other accidentally closed schemas are open.** 3.2 published the `list_products`, `request_proposals`, `refine_proposals`, `buy_products`, `accept_proposal`, `decline_proposals`, and `control_media_buy` request and response roots closed, along with `canonical-proposal`, `canonical-product`, `product-discovery-criteria`, `proposal-refinement`, `package-control`, and `opportunity-context`. 3.2.8 reopened them first. Under the 2026-11-09 decision, 3.3 opens every schema that was closed without a structural reason, and 3.2.11 ([#8864](https://github.com/adcontextprotocol/adcp/pull/8864)) does the same for 3.2 ([Schemas are open by default](#schemas-are-open-by-default)). Opening a schema is a correction under [DR-0036](https://github.com/adcontextprotocol/adcp/blob/main/governance/decisions/DR-0036-closed-schemas-stay-closed-within-a-major.md), not a protocol break. Every payload that was valid stays valid, and the rejections closure provided are kept by name. A field that only the legacy Product defines, such as `format_ids`, `is_custom`, or `product_card`, is still rejected on a canonical product. A root `feed_version` or `pricing_version` on a `request_proposals` response, and `warnings` on an error or submitted `buy_products`, `accept_proposal`, or `control_media_buy` response, are also still rejected. A strict validator built from an earlier 3.2 patch still rejects new fields on these schemas, so the rule above applies. `commercial_terms` and the purchases inside it are held closed until 4.0.

`get_adcp_capabilities` runs before negotiation, so a seller cannot gate its capability document. A 3.3 seller's `media_buy.features.catalog_ingestion` object fails a 3.2 schema that admits only booleans there. Buyers parse capabilities tolerantly, as [Versioning](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/versioning.md) recommends.

## What can fail validation

A schema-valid 3.2 message stays schema-valid under 3.3 except for the [domain identifier constraints](#property-domain-identifiers-have-an-enforceable-format) (mixed-case, trailing-dot, and URL-shaped `domain` / `subdomain` values are now rejected) and names 3.3 now defines:

* `adcp.implementation` in `get_adcp_capabilities`: previously an open extension point, now the SDK implementation shape. Migrate to it or to a vendor-owned `ext` namespace.
* `media_buy.features.catalog_ingestion`: previously any boolean was admissible; it is now an object that requires `catalog_management: true`.
* `dooh_placement_attributes.location` and `dooh_inventory_summary`: previously open on `product.json` and placements, now strict shapes (`lon`, not `lng`).
* `ext.adcp`: now reserved for the AdCP working group. Vendors that used it for their own data move to their own namespace.
* `reporting_webhook.operation_id`: previously an open extra field, now constrained to 1–255 characters from the pattern above.
* `audience_size`, `targetable_size`, and `match_rate_basis` on a `sync_audiences` audience result, if used with a different shape.
* `compact-task-submitted.json` responses that break the version-envelope grammar or carry `task_status` / `response_status` (tightened in 3.2.4). Conformant sellers already satisfy both.
* `validate_input` warning items whose `field` is not a string. The schema always required `field` but never declared it; it is now declared as a string (#8212).

## SDK and code-generator maintainers

These change generated types or bundle shape without changing what a conformant peer sends. Items marked 3.2.4 also shipped in that patch; they matter if you generate from 3.2.1–3.2.3.

* **`start_hour` / `end_hour` are no longer individually required (#8025).** A daypart entry carries exactly one complete pair of either `start_hour` / `end_hour` or the experimental `start_time` / `end_time`. Generated types make the stable pair optional, and readers of echoed or proposed `daypart_targets` must not assume `start_hour` is present.

* **Bundled schemas hoist provenance (#7950, 3.2.4).** `/schemas/{version}/bundled/` carries `core/provenance.json` once in root `$defs.Provenance` and references it from each call site. Bundles shrink by about 20%. Some enclosing inlined schemas lose their deep `$id`, and two `required_disclosures` descriptions may differ. Source schemas and validation are unchanged.

* **Envelope composition (#7946, 3.2.4).** Nine compact and experimental request schemas and `core/compact-task-submitted.json` now compose `core/version-envelope.json` through root `allOf`, so generated types share envelope ancestry. Request validation is unchanged; `compact-task-submitted.json` response validation is tightened as listed above.

* **`media_buy.features` is no longer boolean-only (#7927).** `catalog_ingestion` is an object, so generators that emit a map of booleans for `media_buy.features` break.

* **Daypart requirements (#8025).** `required_overlay_support.daypart_targets.timezone_modes` is no longer required; a requirement carries `timezone_modes`, `time_granularity`, or both.

* **Product rosters (#7948, refs #6135).** `publisher_properties` and `collections` lose `minItems: 1` on `product.json` and `canonical-product.json`. Generated types change for every product (a TypeScript non-empty tuple becomes `T[]`; a Pydantic `min_length` is dropped). Do not index `[0]` without a guard, and treat `[]` as undisclosed, not empty.

* **Envelope on every response (#8547).** Response types compose `core/protocol-envelope.json`: `status` is required on every task response and async status payload, `message` is bounded at 2,000 characters through `core/task-message.json`, `task_id` is `core/task-id.json` (`minLength: 1`), and `replayed` accepts `false`. Response roots and status branches are open, and 66 local copies of envelope fields are removed so the envelope's declarations govern. Regenerate types; a hand-written response model that omitted `status` must add it.

* **Delivery rows (#8108).** `impressions` is optional on `daily_breakdown` and dimensional breakdown rows; `aggregated_totals` still requires it.

* **Reporting issue codes (#8099, 3.2.4).** The closed reporting status issue-code enum gains `REVISION_UNREADABLE`, with a `reporting_revision_id` field. Strict readers must accept it.

* **Audience targeting fields (#8936).** `media_buy.audience_targeting.supported_identifier_types` and `minimum_audience_size` are no longer unconditionally required. A schema `if` / `then` requires them only when `supported_activation_methods` is absent or includes the `sync_audiences` pattern, so generated types make both optional. Readers must not assume either is present.

* **Spot rows (#8017).** `by_spot[].aired_at` is required only on `aired` and `makegood` rows and on rows without `spot_status`.

* **Settings-update entries.** The `sync_accounts` `SettingsUpdateMode` branch permits `brand`, `operator_unit`, `currency`, `timezone`, and `billing`, so generated settings-update types gain those five fields. `operator` stays forbidden.

* **New shared schemas.** `core/audience-size.json`, and the enums `spot-status`, `daypart-time-granularity`, `audience-size-precision`, and `audience-match-rate-basis`.

* **Conformance vector re-code (#8066, 3.2.4).** Request-signing `negative/026-non-ascii-host` now expects `request_target_uri_malformed` at step 10, not `request_signature_header_malformed`. Verifiers that matched the old code must update.

* **`destination_overrides[]` items are one object type (#8718, beta.4).** The item's rules move from sibling `anyOf`, `not`, and `allOf` into one `if`/`then`/`else`, so json-schema-to-typescript and datamodel-codegen generate one object type with every field instead of empty objects. Validation is unchanged.

* **Local-alignment durations (#8718, beta.4).** `core/reporting-schedule.json` and `core/reporting-schedule-offering.json` reject a `period_duration` with both a non-zero date and a non-zero time component under `account_timezone`, `source_timezone`, or `billing_cycle`. Generated validators reject `P1DT12H` there; `P1DT0H`, `P0DT12H`, and `utc` mixed durations stay valid.

* **New error codes and shapes (beta.4 and beta.5).** `SUBSCRIPTIONS_REQUIRE_ACCOUNT_ID_KEY` (recovery `correctable`) for a managed-delivery offering without `account_id` in its primary keys (#8718); `budget_field`, `basis`, `constraint`, and `related_field` on `BUDGET_TOO_LOW` details (#8710); `SetAccountTimezoneResult` on the controller response (#8717); and `core/match-key.json` with `enums/match-key-use.json` (#8446).

* **Opened schemas ([#8866](https://github.com/adcontextprotocol/adcp/pull/8866), rc.0).** `additionalProperties` goes from `false` to `true` at 744 of the 859 closed locations, and nothing else in those schemas changes. Generated types change: json-schema-to-typescript gives an opened object an index signature, Pydantic models stop forbidding extra fields, and Zod validators accept unknown keys where the schema opened. Where closure also rejected a specific field, the opened schema names it in `not: { anyOf: [{ required: [...] }] }`, so a validator keeps that rejection. Code that relied on a type or validation error for any other unknown key needs its own check. See [Schemas are open by default](#schemas-are-open-by-default).

* **Withdrawn and moved beta fields (rc.0).** Regenerate to drop the fields the [closed-schema triage](#closed-schema-triage-what-stays-in-3-3) removes and to pick up the ones that change home, such as `execution_readiness` on `list_products`. `metric_id` on performance standards stays in the rc.0 schemas until [#8854](https://github.com/adcontextprotocol/adcp/pull/8854) merges.

## Adopt by capability

Optional unless noted. A seller that declares nothing keeps 3.2 behavior.

### Production security profile (experimental)

Optional. A seller that verifies inbound requests can advertise `security_profiles: ["adcp-prod-security-3.3"]`, listing `security.profiles` in `experimental_features`. The profile covers signed spend-committing operations under either signing profile (`adcp/request-signing/v1` or `web-bot-auth`), a 15-minute revocation freshness ceiling with T/3 polling, acts-for checks for the verified signer only, governance binding, least privilege, and outbound fetch safety. In 3.3, rejecting non-conforming counterparties is a SHOULD, and a per-principal spend ceiling is recommended but not part of the id. Buyers that require the profile refuse spend-committing calls when it is absent. See the [production security profile](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L1/production-security-profile.md).

### Seller onboarding posture (experimental)

Optional. A seller can publish `account.agent_onboarding` on `get_adcp_capabilities`, listing `account.agent_onboarding` in `experimental_features`. It gives a mode (`open`, `application`, `invite_only`) per billing party and for sandbox, the requirements for each, and where a human starts. Buyers read it on the unauthenticated capability fetch to tell which sellers take them now, which need a human, and which are not available. The block is seller-wide and identical for every caller. `open` binds identity, not spend, and needs the Web Bot Auth profile. See [account.agent\_onboarding](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/protocol/get_adcp_capabilities.md#accountagent_onboarding).

### Stable creative IDs

Creatives that entered a seller's library outside `sync_creatives`, for example before the buyer connected, are listed under a seller-assigned `creative_id`. A seller that keeps those IDs stable, never reuses a buyer's ID, and keeps those creatives out of `delete_missing` declares `creative.stable_creative_ids`. Without it, 3.2 behavior stands: buyers must not rely on those IDs staying the same, and `delete_missing` may archive those creatives. `list_creatives` also returns `platform_id`, the seller's own identifier, which was previously only on the `sync_creatives` response. See [Creatives created outside AdCP](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/creative/task-reference/list_creatives.md#creatives-created-outside-adcp).

### Account change feed records

Only for sellers that declare the experimental `account.change_feed`. Records whose `origin.kind` is `adcp` or `seller_operator` MUST now carry a non-empty `changed_paths` (use the root pointer `""` when the whole resource was created, deleted, or purged); it stays best-effort for `seller_system` and `connected_platform`. A seller that omitted it on those origins in 3.2 must add it before claiming 3.3 behavior for this surface, and buyers should tolerate its absence from a 3.2 seller by treating the change as unknown and rereading the resource. This tightens an experimental surface, so it carries the 6-week notice that [experimental status](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/experimental-status.md#contract-for-experimental-surfaces) requires. Separately and optionally, a seller can echo the originating request's `idempotency_key` on `adcp` records, only on records served to the principal that sent the request; other readers see the record without it, and notifications never carry it. Buyers use the echo to recognize their own changes and treat its absence as unknown. See [`list_account_changes`](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/accounts/tasks/list_account_changes#recognizing-your-own-changes).

### Installments on the compact product lifecycle

Optional, two pieces with different stability.

**Stable.** The canonical Product gains `installments[]` of `core/canonical-installment.json`, closing the 3.2 gap recorded in [known limitations](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/known-limitations.md#compact-product-lifecycle). Sellers of scheduled media SHOULD return it so a compact-lifecycle buyer can see which episode, issue, airing, or creator slot a product covers and what its material deadlines are. Buyers request it through `fields`. Two shape rules differ from the legacy `get_products` installment: `collection_ref` is **required** (the deprecated publisher-domain-free `collection_id` shorthand is not carried over, and legacy `get_products` keeps it), and a derivative names its source with `derivative_of.installment_ref` rather than a response-local `installment_id`. `installments` requires `collections`, so a projection that asks for one gets both. Omitting `installments` on a product that declares `collections` still means run-of-collection.

A migration note: a legacy installment that carries only the deprecated `collection_id` cannot be represented on the canonical surface. Add `collection_ref` before declaring 3.3 — a seller that drops such installments from its canonical projection is asserting run-of-collection for a product that actually sells named slots.

**Not in the signed purchase.** Naming the exact installments in `purchases[].installments[]` was merged for 3.3 and is [withdrawn to 4.0](#installment-selection-published-in-beta-1-removed-after-beta-1). A purchase buys the product as offered. From rc.0, a buyer chooses installments on the request side instead ([below](#installment-selection-and-per-installment-creatives-experimental)).

### Installment selection and per-installment creatives (experimental)

Optional, two features, each gated on its feature id in `experimental_features`.

* **Installment selection (`media_buy.installment_refinement`, [#8974](https://github.com/adcontextprotocol/adcp/pull/8974)).** A buyer asks for specific installments with `refine_proposals` `installment_changes`: entries of `{ product_id, installment_ref, action }`, where `action` is `include` or `omit`, unique by `(product_id, installment_ref)`. A seller that supports it lists `installment_changes` in `media_buy.proposal_refinement.supported_dimensions`, which requires the feature id. The seller answers with a revised draft that buys a product whose `installments[]` is exactly the chosen set, often one it derives for the selection, and reports each change it can't satisfy, with a `reason`, in `unsatisfied_installment_changes` on the result row. A seller never changes an offered product's installments, and a buyer rejects an answer whose product doesn't match the selection. Nothing goes into `commercial_terms`: `terms_digest` binds the choice through the `product_id`. Binding the slots themselves in `purchases[].installments[]` stays a 4.0 item. See [Choose installments](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/task-reference/refine_proposals.md#choose-installments-experimental).
* **Per-installment creatives (`media_buy.installment_creative_assignment`, [#8972](https://github.com/adcontextprotocol/adcp/pull/8972)).** `installment_refs`, a unique list of 1 to 500 canonical installment references, is optional on the `sync_creatives` `assignment_operations` `assign` and `replace` operations. It limits the assignment to those installments of the package; absent, the assignment applies to every installment, as before, and placement routing intersects with the installment scope. A seller rejects a ref outside the purchased product's installments with `VALIDATION_ERROR`, and a change past an installment's `change_cutoff` with `CREATIVE_DEADLINE_EXCEEDED`; `unassign` and `merge` reject the field by name. `get_media_buys` `packages[].creative_approvals[]` and `list_creatives` `assignments.assigned_packages[]` read it back. Buyers send it only to a seller that lists the feature id, because a seller that ignored it would run the creative on every installment; a seller without it rejects the field with `UNSUPPORTED_FEATURE`. It sits on no deprecated surface. See [Assigning to specific installments](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/creative/task-reference/sync_creatives.md#assigning-to-specific-installments-experimental).

### Creative `seller_revision`

Optional. `list_creatives` may return `seller_revision` on each creative: a seller-maintained, monotonic, opaque token (integer or string) distinct from the buyer-assigned `revision_id`. Compare values for equality; integers also order numerically. Buyers that see it on a drained `account.change` record's `resource_revision` can tell whether a read already reflects the change. Package, creative assignment, audience, catalog, event source, property list, product and signal revisions are deferred to 3.4. See [Seller revision](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/creative/task-reference/list_creatives.md#seller-revision).

### Scheduled and human-gated buying

* **`expected_confirmation_at`.** Set it on a `submitted` response from `create_media_buy`, `buy_products`, or `accept_proposal` when confirmation waits on a scheduled event; on `buy_products` and `accept_proposal`, only for callers negotiating 3.3. `refine_proposals` can also carry it on a `submitted` response to a finalize-only request whose hold waits on a person's agreement, such as a creator or host (#8104); never on a `completed` response, and only for callers negotiating 3.3. It is an estimate; buyers check status at that time instead of polling tightly. See [Expected confirmation time](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/task-reference/create_media_buy.md#expected-confirmation-time).
* **Vendor-metric outcome goals.** Plan only `(vendor, metric_id)` pairs a product lists in both `vendor_metric_optimization.supported_metrics[]` and `reporting_capabilities.vendor_metrics`, answer in `vendor_metric_values[]`, and reject anything else with `INVALID_REQUEST`. No new capability flag. See [Vendor-metric goals](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/task-reference/request_proposals.md#vendor-metric-goals).
* **Governance budget periods (experimental).** Governance agents that accept `budget.periods[]` on `sync_plans` declare `governance.supports_budget_periods` and enforce periods in `check_governance`. Plans without periods behave as before. See [Budget periods](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/governance/campaign/tasks/sync_plans.md#budget-periods).
* **Hold policy and hold extension (experimental, `media_buy.hold_policy`, `media_buy.hold_extension`).** Products and draft canonical proposals can carry `hold_policy` (`available`, `min_duration`, `max_duration`, `extendable`, `max_total_duration`); it binds on the draft proposal and carries forward to the committed successor. `refine_proposals` `action: "extend_hold"` lengthens a committed hold by returning a new committed successor with the same terms and a later `expires_at`; `expected_confirmation_at` may also accompany a `submitted` extension (#8203). Both are omitted for callers below 3.3. See [Hold policy](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/task-reference/refine_proposals.md#hold-policy-experimental) and [Extend a hold](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/task-reference/refine_proposals.md#extend-a-hold-experimental).
* **Delegated composition (experimental, `media_buy.delegated_composition`).** A requesting platform that owns the catalog can bind `criteria.product_ids_exclusive`, so `product_ids` is the complete composable universe; sellers that do not declare `media_buy.supports_exclusive_product_ids` reject it with `UNSUPPORTED_FEATURE`. `media_buy.proposal_refinement.hold_semantics: "terms_only"` declares a finalize that commits terms without holding inventory; such a seller never returns `committed` proposals to callers below 3.3. See [delegated composition](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/product-discovery/delegated-composition.md).
* **`change_cutoff`.** Add it to installment deadlines where changes stop taking effect before the booking deadline passes. See [Installment deadlines](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/product-discovery/collections-and-installments.md#installment-deadlines).

### Delivery reporting

* **Spot lifecycle and break position (experimental, `media_buy.spot_lifecycle`).** Declare `supports_spot_breakdown.available_statuses` and `supports_break_position` before sending the fields. One `spot_id` tracks from `scheduled` to `aired` or `preempted`; a `makegood` row carries `replaces_spot_id`. Metrics on `scheduled` rows are expectations. See [Spot lifecycle](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/media-buys/optimization-reporting.md#spot-lifecycle-makegoods-and-break-position).
* **Print proof of insertion (experimental).** Report `print_metrics` per issue on `by_installment` rows. Sellers SHOULD populate `evidence` for guaranteed print products and report a gap through `missing_metrics`. See [Delivery evidence and circulation](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/creative/channels/print.md#delivery-evidence-and-circulation).
* **Property-grain rollups.** Declaring `media_buy.features.supports_property_breakdown` or `supports_installment_property_breakdown` commits the seller to the breakdown on every product with the matching per-product flag, which stays authoritative. Under the property scenarios, the seller builds the breakdown only from rows injected through `simulate_delivery`.
* **DOOH location and venue summary.** Add `dooh_placement_attributes.location` (`lat`, `lon`, `address`) to a concrete single-screen placement and `dooh_inventory_summary.venue_counts[]` to a network product. Each `venue_counts` row requires `geo_level`, `geo_code`, and `count`, plus `system` or `country` as its `geo_level` requires. See [DOOH](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/creative/channels/dooh.md#structured-location-for-planning-and-mapping).
* **Audience size.** Report `audience_size` and `targetable_size` as ranges with a `precision`, and omit them when status is `too_small`. See [Audience size](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/task-reference/sync_audiences.md#audience-size).

### Creator and collection cards (experimental)

`media_buy.collection_cards` adds `images`, `sample_content`, and `url` on collections, `brand_ref` on talent, `distribution[].followers` (an account count, never summed across entries), and full `collections` objects on product and proposal responses when the request sets `include_collections: true`. `brand.collection_links` adds `collections` to `get_brand_identity`. Copies in responses are never authorization evidence. See [Collection cards](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/product-discovery/collections-and-installments.md#collection-cards-experimental).

### Assignment landing pages and trackers

A seller that declares `creative.supports_assignment_landing_page: true` (requires a creative library) accepts `landing_page_url` on `sync_creatives` `assign` operations; its copies on package creative assignments and `sync_creatives` `assignments[]` are withdrawn at rc.0. The override changes the destination for one creative on one package without changing the library creative or its approval; the seller serves it everywhere it applies or rejects the assignment, and returns the actual destination from `list_creatives` and `get_media_buys`. Agents without the capability reject the field with `UNSUPPORTED_FEATURE`. Likewise, a seller that declares `creative.supports_assignment_trackers: true` accepts assignment-scoped measurement `trackers`, fires them alongside the creative's own without changing its revision or approval, enforces the format's tracker-slot limits where the format declares tracker slots (a format that declares none makes no slot-limit claim, #8713), and returns the assignment-only list from `list_creatives` and `get_media_buys` (#8220). See [Assignment landing pages](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/creative/task-reference/sync_creatives.md#assignment-landing-pages).

### Hosted video and audio playback trackers

Optional. The `pixel_tracker` `event` enum gains `start`, `first_quartile`, `midpoint`, `third_quartile` and `complete`, with the same meaning as the VAST events of the same name, spelled in snake\_case. They apply to `video_hosted` and `audio_hosted` and are ignored on formats with no playback timeline, as `viewable_video_50` is. `complete` means played to the end whether or not audio was on; `audible_video_complete` remains the audio-on variant. Tracker execution selectors share the enum, so a seller with a [tracker execution contract](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/creative/tracker-execution-contracts.md) declares which of them it fires. See [Pixel tracker asset](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/creative/asset-types.md#pixel-tracker-asset) for the event definitions and a non-normative Google Ad Manager and FreeWheel mapping.

**Buyers sending to 3.2 sellers.** A 3.2 schema rejects the new values, so do not send them yet. Send each as `event: custom` with `custom_event_name` set to the 3.3 value:

```json theme={null}
{
  "asset_type": "pixel_tracker",
  "event": "first_quartile",
  "method": "img",
  "url": "https://measurement.example.com/q1?cid={CREATIVE_ID}"
}
```

becomes, on 3.2:

```json theme={null}
{
  "asset_type": "pixel_tracker",
  "event": "custom",
  "custom_event_name": "first_quartile",
  "method": "img",
  "url": "https://measurement.example.com/q1?cid={CREATIVE_ID}"
}
```

An SDK talking to a seller that does not advertise 3.3 MAY make this rewrite itself. Sellers can recognize those names now, and moving to 3.3 is a rename of `event`. A seller with no tracker execution contract silently skips a custom event it does not recognize, so confirm the seller maps the names before relying on them for measurement.

**Downgrade to 3.0.x sellers.** An SDK that downgrades `pixel_tracker` to the v1 `tracker_pixel` shape drops these trackers, including the `event: custom` interim form above, and emits `PIXEL_TRACKER_LOSSY_DOWNGRADE`. It never emits them as `impression_tracker`, because a quartile URL fired at impression time would count every impression as a quartile view.

### Linear TV

* **Minute dayparts (experimental, `media_buy.daypart_granularity`).** Declare `overlay_support.daypart_targets.time_granularity` (`hour`, `quarter_hour`, `minute`) and reject a finer time with `UNSUPPORTED_FEATURE`. A seller that does not list the feature id rejects any `start_time` or `end_time`. See [Minute-resolution dayparts](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/advanced-topics/targeting.md#minute-resolution-dayparts-experimental).
* **Broadcast formats and currencies.** Use `nmo` or `videoamp` instead of `custom` in `demographic_system`. `video_hosted` accepts `mxf` and the `mpeg2`, `avc_intra`, and `xavc` codecs; the `loudness` object is experimental (`creative.broadcast_loudness`). See [Broadcast creative](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/creative/channels/broadcast.md).

### SDK implementation metadata

Agents can report `adcp.implementation.sdks[]` with a package `name`, exact resolved `version`, and a `components` list. `components: []` reports SDK use without claiming agent-wide component coverage, such as an SDK signing helper used on only some routes. Existing agents may omit the block; buyers treat omission as unknown SDK use, while `sdks: []` explicitly reports no AdCP SDK use. Components describe the deployed server integration, including build-time type imports, rather than the package's available features. Buyers keep using AdCP version declarations for negotiation and retain all conformance obligations. Approval comes from a trusted catalog, and reducing check depth requires independently trusted evidence covering the endpoint and integration. See [implementation metadata](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/protocol/get_adcp_capabilities.md#implementation).

### Display labels for geo targeting codes

Optional ([#8966](https://github.com/adcontextprotocol/adcp/pull/8966), beta.6). Targeting can carry display names beside its geographic codes. `geo_value_labels` maps the ISO codes in `geo_countries`, `geo_countries_exclude`, `geo_regions`, and `geo_regions_exclude` to names (`{ "DE": "Germany", "US-CA": "California" }`), and `geo_metros`, `geo_metros_exclude`, and `geo_places` entries take `value_labels` (`{ "501": "New York" }`). Every label key MUST appear in the values it labels.

Labels are not a targeting dimension. Sellers MUST NOT resolve or apply targeting from them and MUST NOT reject a request because they are present, and MAY omit, keep, or supply their own labels in readback. Targeting equality and exact readback compare codes only, and a name in place of a code is still invalid. In create and update input, `null` clears labels the seller kept. Buyers SHOULD NOT send `geo_value_labels` to a seller on a version before 3.3 ([Send only to 3.3 peers](#send-only-to-3-3-peers)). See [Geographic Restrictions](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/advanced-topics/targeting.md#geographic-restrictions).

### Targeting errors

A seller that rejects an unsupported or removed targeting dimension with `UNSUPPORTED_FEATURE` SHOULD use the new `error-details/unsupported-targeting-dimension.json` details shape (`unsupported_dimension`, optional `supported_dimensions`, `deprecated`, `replacement_dimension`, `product_id`, `package_index`) and point `error.field` at the targeting path (#8052). No new error code is added; adapters minting `UNSUPPORTED_TARGETING_DIMENSION` or `DEPRECATED_TARGETING_DIMENSION` should migrate. See [Rejected targeting dimensions](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/advanced-topics/targeting.md#rejected-targeting-dimensions).

### Open opportunities and later proposals

Optional and experimental (`media_buy.open_opportunities`). Advertise the parts you implement under `media_buy.open_opportunities` and list the feature id in `experimental_features`. `list_proposals: true` is the read; it is required before `later_proposals.supported: true`, which also requires `max_open_duration`. `keep_open_after_purchase: true` lets `accept_proposal` and `buy_products` accept `opportunity.status: "open"`. A seller creating later proposals needs the buyer's `opportunity.later_proposals` consent and an open window, honors `max_count` and `min_interval`, issues drafts with `opportunity_id`, `expires_at`, and a `later_reason`, and announces them with `proposal.created` on account `notification_configs[]`, never on a task's `push_notification_config`. Buyers send none of these fields, nor an empty `decline_proposals` `declines` array, to a seller that does not advertise the matching part; 3.2 sellers reject them. See [Open opportunities and later proposals](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/product-discovery/proposal-negotiation.md#open-opportunities-and-later-proposals).

### `age_determination_bases` on signals

Optional. Signal listings, definitions, and definition enrichment can carry `age_determination_bases` (`verified`, `declared`, `inferred`), a sibling of `demographic_predicate` that says how the signal's members' ages were established. It is valid only when `demographic_predicate.age` is present. A buyer whose request names `accepted_bases` treats a signal listing as passing the basis test only when its age range is within the request and every one of its bases is accepted; an absent field makes no basis claim. See [Age determination basis on included signals](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/advanced-topics/targeting.md#age-determination-basis-on-included-signals).

The field is stable in 3.3, not experimental. It completes the basis vocabulary already stable as `accepted_bases`, `supported_bases`, and `applied_bases`.

**Interim on 3.2.** Until you claim 3.3, carry the value as `ext.adcp.age_determination_bases` on the signal-listing entry. This is the AdCP-owned `ext.adcp` namespace, the same precedent as `ext.adcp.opportunity`, not a vendor extension, so migrating is a rename: move the value from `ext.adcp.age_determination_bases` to a top-level `age_determination_bases` and drop the `ext` copy. Apply the same matching rule on 3.2. If a listing carries both, the top-level field wins. Buyers cannot infer 3.2 support from absence, and an absent value already means no basis claim, so the interim is safe to omit.

```json theme={null}
{
  "$schema": "https://adcontextprotocol.org/schemas/3.3.0-rc.0/core/signal-listing.json",
  "signal_ref": { "scope": "product", "signal_id": "verified_adults_25_34" },
  "name": "Verified adults 25–34",
  "value_type": "binary",
  "restricted_attributes": ["age"],
  "demographic_predicate": {
    "age": { "min": 25, "max": 34, "include_unknown": false }
  },
  "ext": { "adcp": { "age_determination_bases": ["verified"] } }
}
```

### Catalogs, signing, and extensions

* **Delivery types.** Declare `media_buy.supported_delivery_types` with the delivery types you sell, and return only products whose `delivery_type` is listed. Buyers treat an absent declaration as unknown, not as an empty set.
* **Catalog ingestion.** Declare `media_buy.features.catalog_ingestion` with `accepted_catalog_types`, `ingestion_modes`, and `item_status_reporting` (required), plus `supported_feed_formats` whenever `feed_url` is listed. Declaring it requires `catalog_management: true`. Reject an unlisted catalog type, mode, or feed format, or an explicit `content_id_type` outside a declared list, with `UNSUPPORTED_FEATURE` before mutation, including on `dry_run`; inline items beyond `max_inline_items_per_request` fail with `INVALID_REQUEST`. Buyers treat an absent declaration as unknown, not unrestricted. See [`sync_catalogs`](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/task-reference/sync_catalogs#ingestion-compatibility).
* **`request_signing.operation_sources`.** List `mcp_tools_call` and `a2a_invocation_skill` only for the sources your verifier implements and passes vectors for, and list every source you support: an array without `a2a_invocation_skill` tells peers you do not enforce over A2A. See [above](#a2a-operation-resolution-hardening-becomes-must).
* **`trust.json` (experimental).** `trust/v1/trust.json` and `trust/v1/trust-acknowledgements.json` are published under `identity.trust_json` (#8067). An agent is identified by the canonical origin of its URL, one agent per origin, and the record carries no keys (#8121). In 3.3 its reader is the experimental Web Bot Auth profile, which derives the record from the agent's origin, and grants are read at `sync_accounts`. Publishers declare nothing. See [trust.json](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/trust-json.md) and the [agent identity migration guide](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/migration/agent-identity-3-3.md).
* **`ext.adcp.opportunity`.** Cooperating `get_products` integrations can carry an opportunity binding under `ext.adcp.opportunity`, declared by listing `adcp` in `extensions_supported`. Durable association needs an authorized account scope, and a mismatched ID on refine is rejected with `INVALID_REQUEST`. The core `opportunity` field is still in review. See [AdCP opportunity extension](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L2/context-sessions.md#adcp-opportunity-extension).

### Live creative updates (experimental)

Optional (`creative.live_updates`, [#8488](https://github.com/adcontextprotocol/adcp/pull/8488), folding in staged activation from [#6780](https://github.com/adcontextprotocol/adcp/issues/6780)). A buyer changes a creative that is serving by syncing it again under the same `creative_id`. A seller that lists the feature id declares in `creative.live_updates` which kinds of change (`clickthrough`, `trackers`, `asset_content`, `format`) it applies in place and how the creative serves meanwhile: `uninterrupted` (decided inside the sync call), `staged` (the approved prior version keeps serving until the change is approved, then is promoted atomically; `on_rejection` is `keeps_prior` or `stops`), or `paused_for_review` (the existing lifecycle). Name and tag changes are always accepted.

* `list_creatives` and the `sync_creatives` item return `staged_update` while a change awaits promotion; `dry_run` returns the exact outcome of one change. There is no per-creative policy readback: the declaration is the general floor and `dry_run` answers for one change.
* The new notification type `creative.staged_update_changed` reports a staged update's outcome (`promoted` or `rejected`) only to subscribers that register it. `creative.status_changed` is unchanged, so a buyer on an earlier release never receives an `approved` to `approved` event that its closed validator would reject.
* A seller that declares the capability lists `replace` in `creative.assignment_operations` ([details](#sellers-declare-the-assignment-operations-they-accept)) and refuses an undeclared change with `CREATIVE_LIVE_UPDATE_UNSUPPORTED` (with `error-details/creative-live-update-unsupported.json`) in place of `INVALID_STATE`. A seller that doesn't declare it keeps the original rule: creatives on active, non-paused packages cannot be updated, and the refusal is `INVALID_STATE`.
* `comply_test_controller` `force_creative_status` forces a staged update's review outcome. The storyboards are `media_buy_seller/creative_live_updates` and `media_buy_seller/creative_live_update_refusal`.

See [Live creative updates](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/creative/task-reference/sync_creatives.md#live-creative-updates).

### Reporting subscriptions (experimental)

Optional (`media_buy.reporting_subscriptions`, [#8543](https://github.com/adcontextprotocol/adcp/issues/8543) Part B, [#8552](https://github.com/adcontextprotocol/adcp/pull/8552), settled through beta.4). Reliable Reporting was configured one account at a time through `sync_accounts` `reporting_delivery_configs`, so a new account reported nothing until someone configured it. `sync_principal` now takes `reporting_subscriptions`: one registration per feed purpose, scoped to `all_authorized_accounts: true` (an explicit acknowledgment) or named `account_ids`, with a cross-seller `selector` (`feed_purpose`, `period_duration`, `required_finality`, optional `alignment` and `dimensions[]`, and `match`). Sellers list accepted registration tasks in `reporting_delivery.configuration_tasks[]`; `configuration_task` stays `"sync_accounts"` for callers pinned below 3.3 and is deprecated. A caller's own active `sync_accounts` entry for an account and feed purpose still wins over its subscriptions.

**What the buyer can compute from the wire.** `get_reporting_status` reports only exceptions under `subscription_coverage`, and an exception removes periods from what is owed and never adds any, so a missing report is still an owed period.

* **Which periods are owed.** A buy is owed every period that ends after its `confirmed_at` and overlaps its flight, starting at the first boundary at or after the later of the subscription version's `accepted_at` and the account's `authorization.authorized_at`, so the period in which a buy is confirmed is owed in full ([#8593](https://github.com/adcontextprotocol/adcp/pull/8593)). A package added after `confirmed_at` carries `added_at` on `get_media_buys`, its own `confirmed_at`: it is owed from the period containing `added_at` and resolves its offerings then (beta.4). Sellers that advertise the feature populate it on every package added after confirmation; buyers stop assuming a later package resolves with the buy. The flight stops at the earliest of `end_time`, `cancellation_effective_at` (the delivery stop, later than `canceled_at` when the seller delivers through a notice period), and `completed_at`. A flight that stops at or before its `start_time` owes nothing.
* **Cutovers and billing stubs.** A change takes effect as a cutover at instant T. When a billing feed's incoming schedule has no boundary at the handoff, the stretch to its first boundary is owed as one stub obligation (`stub: true`); pacing and analytics feeds leave it unowed. This covers account timezone changes and account-level `sync_accounts` billing configurations ([#8617](https://github.com/adcontextprotocol/adcp/pull/8617)).
* **Wire inputs.** `authorization.regranted_at`, `flight_history` on media buys and `get_media_buys`, `packages[].reporting_delivery_offering_ids` fixed at confirmation, `available_from` and `withdrawn_at` on offerings, and per-version `configuration` in `prior_versions` ([#8618](https://github.com/adcontextprotocol/adcp/pull/8618), [#8588](https://github.com/adcontextprotocol/adcp/pull/8588)). Offerings publish `standard_dimensions` so the buyer resolves `match` exactly as the seller does, and sellers MUST publish it on every offering ([#8585](https://github.com/adcontextprotocol/adcp/pull/8585)).
* **Determinism and scale.** Resolution is per package and fixed per buy and version until the resolved offering is withdrawn. `max_accounts` admission is sticky, ordered by `authorization.authorized_at` then `account_id` in byte order. Billing subscriptions MUST use `match: exact` with `dimensions`. `destination_overrides[]` route accounts to other destinations, membership edits apply in place as `excluded_by_buyer` intervals without a new `subscription_version`, and the readback lists 16 prior versions and 1,000 accounts inline, with `get_principal` paging the rest through `reporting_subscription_page` ([#8619](https://github.com/adcontextprotocol/adcp/pull/8619)).
* **Deactivation and revocation.** A deactivated subscription reads `inactive` with a required `deactivated_at`, and periods that started before deactivation stay owed ([#8613](https://github.com/adcontextprotocol/adcp/pull/8613)). After the caller loses authority for an account, `sync_reporting_receipts` and `sync_reporting_status` treat every reference to it like an unknown identifier ([#8607](https://github.com/adcontextprotocol/adcp/pull/8607)). A seller that wants a buyer to finish reconciling keeps a reduced grant that lists only the reconciliation tasks, and a grant that lists `get_reporting_status` but not the receipt or status tasks keeps the account covered and refuses the missing tasks with `SCOPE_INSUFFICIENT`. A grant reduced to tasks without `get_reporting_status` is a loss of authority at the reduction, exactly like a revocation: the seller lists the account in `accounts_unauthorized[]` with `unauthorized_at` set to the reduction and withholds its coverage, and adding `get_reporting_status` back is a re-grant (beta.4).
* **Period arithmetic.** Years, months, and days are civil time; hours, minutes, and seconds are elapsed time. Under a local alignment each local date's first instant is a boundary, so `PT24H` equals `P1D`, and a sub-daily duration MUST divide 24 hours. `billing_cycle` needs a date component, a local alignment refuses a duration mixing date and time components (`P1DT12H`; schema validation enforces it from beta.4), weeks (`P7D`) under `utc`, `account_timezone`, and `source_timezone` start on Thursday, and `status_retention_days` counts exact 24-hour days ([#8588](https://github.com/adcontextprotocol/adcp/pull/8588), [#8622](https://github.com/adcontextprotocol/adcp/pull/8622)).
* **Delivery stays inside the flight.** A seller that lists the feature id MUST NOT deliver on a buy outside its flight; to deliver later, including a make-good with remedy `additional_delivery`, it first extends `end_time`.
* **Packages added later (beta.4, [#8718](https://github.com/adcontextprotocol/adcp/pull/8718)).** A seller MUST include `packages[].added_at` on `get_media_buys` for every package added after the buy's `confirmed_at`. It is that package's own `confirmed_at`: the package is owed the periods that end after the later of the buy's `confirmed_at` and its `added_at`, so the period containing `added_at` is owed in full, and it resolves subscription selectors at that instant. Adding a package is never a cutover. Absent `added_at` means the package was part of the buy at confirmation, so existing data reads as before.
* **Reduced grants (beta.4, [#8718](https://github.com/adcontextprotocol/adcp/pull/8718)).** A grant reduced to tasks that omit `get_reporting_status` ends reporting authority at the reduction, exactly like a revocation: the account is listed in `accounts_unauthorized[]` with `unauthorized_at` at the reduction, owed periods that ended by then are withheld, and `get_reporting_status` refuses the account with `SCOPE_INSUFFICIENT`. Adding `get_reporting_status` back is a re-grant. A reduced grant that keeps `get_reporting_status` is the wind-down grant and keeps coverage.

Test assets: canonical coverage vectors with an independent reference model under `static/compliance/source/test-vectors/reporting-subscriptions/` ([#8616](https://github.com/adcontextprotocol/adcp/pull/8616)), and the `comply_test_controller` `reporting_subscription_probe` scenario for grants, account timezones, and the virtual clock ([#8621](https://github.com/adcontextprotocol/adcp/pull/8621)). Beta.4 adds `reset_state`, which a seller that lists the probe MUST also list, a defined `set_account_timezone` result, and the `offering-checks.json` vectors ([#8717](https://github.com/adcontextprotocol/adcp/pull/8717), [#8718](https://github.com/adcontextprotocol/adcp/pull/8718)). See [Reporting subscriptions](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/protocol/sync_principal.md#reporting-subscriptions) and [Subscription coverage](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/task-reference/get_reporting_status.md#subscription-coverage).

### Match keys (experimental)

Optional (`media_buy.match_keys`, [#8446](https://github.com/adcontextprotocol/adcp/pull/8446), beta.5). A seller declares the identifiers it can match on, with their scopes and uses, seller-wide in `media_buy.supported_match_keys` and per product in `Product.identity.match_keys`; TMP providers declare `match_keys` beside `uid_types`. A product's keys are authoritative for that product and each must be covered by a seller-wide entry with the same `uid_type` and `vendor`. A product with `persistent_identifier: false` cannot declare `frequency_cap` or `identity_match` keys, and `pairid` and `hashed_email` keys cannot declare `identity_match`. `supported_match_keys` holds at most 64 entries and `scopes` at most 5. A change is a material capability change. Send `Product.identity.match_keys` only to callers served 3.3 ([Send only to 3.3 peers](#send-only-to-3-3-peers)). See [Match keys and cross-publisher frequency capping](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/specification.md#match-keys-and-cross-publisher-frequency-capping-experimental).

### Commercial and targeting experiments

Each is optional and experimental: a seller that emits it lists the feature id in `experimental_features`, and a seller that declares nothing keeps 3.2 behavior.

* **Seller offers (`media_buy.seller_offers`, [#8102](https://github.com/adcontextprotocol/adcp/pull/8102)).** A seller proposes a change to an accepted buy as a `committed` canonical proposal with `proposal_initiator: "seller"` and an `offer_reason` (`installment_postponed`, `installment_cancelled`, `preemption`, `under_delivery`, `seller_request`), a `media_buy_update` or `media_buy_cancellation` that carries `parent_proposal_id`, `media_buy_id`, and `base_media_buy_revision`. Buyers read offers through `list_proposals`, announced by the identifiers-only `proposal.offered` notification, and accept with `accept_proposal`, decline with `decline_proposals`, or revise with `refine_proposals`. `expires_at` is the response deadline; at it the signed terms stand and `accept_proposal` returns `PROPOSAL_EXPIRED`, so silence is never acceptance. A seller that lists the feature id MUST also list `media_buy.open_opportunities` and advertise `list_proposals`. Sellers MUST NOT send offers to callers served below 3.3. Pre-agreed seller changes inside `commercial_terms` are not part of 3.3. See [Seller offers](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/product-discovery/proposal-negotiation.md#seller-offers).
* **Price adjustments (`media_buy.price_adjustments`, [#7955](https://github.com/adcontextprotocol/adcp/pull/7955), [#7659](https://github.com/adcontextprotocol/adcp/issues/7659)), withdrawn at rc.0 and planned for 4.0.** In the betas, a binding fixed-price pricing option (`cpm`, `vcpm`, `cpc`, `cpcv`, `cpv`, `cpp`, `flat_rate`) can carry an ordered table of `fee` and `discount` rows, each with a `rate` or a fixed `amount`, keyed by `format_option`, `placement_selection` (needs `overlay_support.placement_selection`), or `always`, and optionally a `valid_from` and `valid_until` window evaluated at the purchase `start_time`; a flight that crosses a window boundary is rejected. Selection rows fire at most once per dimension, then each firing row applies to one running total in declared order, rounding half away from zero at every step. A table is optional: without one, the price applies only to what was quoted. A seller built from a beta bundle stops emitting the table ([closed-schema triage](#closed-schema-triage-what-stays-in-3-3)). See [Selection-dependent price adjustments (withdrawn)](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/advanced-topics/pricing-models.md#selection-dependent-price-adjustments-withdrawn).
* **Execution readiness (`media_buy.execution_readiness`, [#7934](https://github.com/adcontextprotocol/adcp/pull/7934)).** For products that declare `execution_requirements`, a `list_products` request with `account` can set `include_execution_readiness: true` (on `get_products` in the betas, moved at rc.0). The response carries an `execution_readiness` map keyed by `product_id`, versioned independently of `wholesale_feed_version` so public wholesale catalogs keep `cache_scope: "public"`. Each product and requirement reports `ready`, `setup_required`, `selection_required`, `input-required`, or `unknown` (the seller could not check, which is not the same as the account lacking the resource), with candidates whose `resource_id` is directly usable in the existing binding field. See [Per-account execution readiness](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/specification.md#per-account-execution-readiness-experimental).
* **Gender targeting (`media_buy.gender_targeting`, [#7925](https://github.com/adcontextprotocol/adcp/pull/7925)).** Core `demographics.gender` predicates with `female`, `male`, and `non_binary` value sets and an independent unknown group, whose `include_unknown` covers both unavailable gender and an explicit choice not to state it. Product-scoped capabilities, exact gender-only and mixed age and gender readback, and `sex_gender` governance classification come with it. Demographic delivery reporting stays age-only in 3.3, so a gender-targeted package has no gendered delivery readback. Buyers MUST NOT send core gender fields on a 3.2 contract. See [Core gender targeting](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/advanced-topics/targeting.md#core-gender-targeting-3-3).
* **Signal pricing groups (`signals.pricing_groups`, [#8058](https://github.com/adcontextprotocol/adcp/pull/8058), [#7898](https://github.com/adcontextprotocol/adcp/issues/7898)).** An optional `pricing_group` on `get_signals` results and on `Product.signal_targeting_options[]`, with `signal_pricing_group_rules[]` (`{pricing_group, pricing_combination: highest | each}`) on the response and on `signal_targeting_rules`, lets a seller price signals such as alternative age bands as one audience. A group with no rule and every ungrouped signal is charged `each`, and `flat_fee`, `per_unit`, `custom`, and `percent_of_media` options are always charged `each`. See [Signal pricing groups](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/advanced-topics/targeting.md#signal-pricing-groups).
* **Provider-initiated signal delivery (`signals.delivery_methods`, [#8044](https://github.com/adcontextprotocol/adcp/pull/8044), [#6552](https://github.com/adcontextprotocol/adcp/issues/6552)).** A signal agent declares `signals.delivery_methods[]` on `get_adcp_capabilities`, with the same pattern vocabulary as audience activation methods read from the send side. An `activate_signal` agent destination may pin a `delivery_method`; with no pattern and vendor intersection the destination fails with `UNSUPPORTED_FEATURE`, and a pin sent to an agent that doesn't list it is rejected the same way. Agent deployments gain `delivery_status` (`awaiting_read`, `delivered`, `failed`), a `delivery` descriptor, `delivery_error`, and an optional match outcome. A receiver field not yet established fails the destination with `ACCOUNT_SETUP_REQUIRED`. See [Declaring delivery methods](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/signals/tasks/activate_signal.md#declaring-delivery-methods).
* **Measurement provenance (`media_buy.measurement_provenance`, [#7940](https://github.com/adcontextprotocol/adcp/pull/7940)).** A shared `enums/collection-mechanism.json` vocabulary (`set_top_box`, `acr`, `panel`, `server_logs`, `client_tracker`, `sdk`) is used by `vendor_metric_provenance[]` on delivery metrics, which carries `mechanisms[]` and an optional `deduplicated` for a `vendor_metric_values[]` row, joined on `(vendor, metric_id, qualifier)`. A collection mechanism is not `measurement_source`, which stays the provider slug, and broadcast as-run logs stay airing evidence in `by_spot[]`. Sellers serving an older pin omit the field. `measurement_terms.billing_measurement.counting_mechanisms[]` is withdrawn at rc.0 and planned for the canonical measurement terms in 4.0.
* **Audience evidence targets (withdrawn) and invoice lines.** `target_audiences[]` (`media_buy.audience_evidence_targets`, [#8215](https://github.com/adcontextprotocol/adcp/pull/8215)) is withdrawn at rc.0 and has no 3.3 wire form; purchases gain it in 4.0. `lines[]`, `invoice_kind`, and `adjusts_invoice_id` on `get_account_financials` invoices (`account.invoice_lines`, [#8207](https://github.com/adcontextprotocol/adcp/pull/8207)) tie an amount to the buys, packages, and reporting revisions it bills, and never settle an invoice.

## Experimental surface notices

### Experimental creative evaluator drops `evaluator_id`

Applies only to sellers and buyers that use the experimental `creative.evaluator` surface (`build_creative.evaluator`). The `evaluator_id` source form is removed from `core/evaluator-spec.json`, and the `evaluator` entity is removed from `x-entity-types`. The evaluator object stays the request primitive, with two source forms: inline `exemplars` or an external `agent_url`. A seller's house evaluator is an evaluator agent it lists in `creative_policy.accepted_verifiers[]`. The `list_evaluators` follow-on that existed only to resolve `evaluator_id` is withdrawn.

| Before (3.1 and 3.2) | After (3.3) |
| - | - |
| `"evaluator": { "evaluator_id": "quality-default", "rank_by": [...] }` | `"evaluator": { "agent_url": "https://quality-evaluator.example/adcp", "rank_by": [...] }` |

The seller exposes the evaluator behind an agent that implements `get_creative_features`, adds its URL to `creative_policy.accepted_verifiers[]`, and the buyer names that URL. An `evaluator` carrying only `evaluator_id` no longer validates, because no source form matches, so a 3.3 validator rejects the whole `build_creative` request where 3.2 degraded to seller-default ranking. A stale `evaluator_id` sent alongside `exemplars` or `agent_url` still validates (the object stays open) and sellers ignore it. No alias is offered: the id had no on-wire resolution path, and an unknown id already degraded to seller-default ranking.

This is a removal on an experimental surface, which the [experimental status](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/experimental-status.md#contract-for-experimental-surfaces) contract allows with notice; 3.1 and 3.2 keep `evaluator_id`. The 6-week pre-landing notice is waived: beta.0 is the notice vehicle, and 3.3 GA ships no earlier than 6 weeks after the beta.0 tag. A fourth source form for conversion-outcome evaluators stays open, and `supports_evaluator_gate` and hard-gate semantics stay reserved. See [Evaluator source model](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/creative/buyer-attached-inputs.md#evaluator-source-model).

### Reliable Reporting managed delivery holds no buyer secret

([#8793](https://github.com/adcontextprotocol/adcp/pull/8793), rc.0.) Applies to sellers that offer managed delivery under the experimental `media_buy.reporting_delivery`. For every managed pattern, the seller authenticates as itself, through its advertised `producer_identity`. A seller MUST NOT hold, request, or store a caller-issued secret of any kind (password, API key, bearer token, OAuth client secret, private key, signed URL, or shared signing key), directly or through a processor acting for it; the deprecated `reporting_webhook.authentication` block is not precedent. Rows in an HTTP request body are the Core `reporting_webhook` transport, never `file_transfer`.

The new `https_put` `file_transfer` transport (experimental in 3.3) writes immutable objects and a manifest to a buyer HTTPS endpoint. It is conformant only when the manifest is written last, every request is signed by the seller under the Web Bot Auth profile with keys from its origin's key directory, and the endpoint passes a signed probe, carrying the seller-issued `destination_ref`, before `ready`.

### Per-package rows in Reliable Reporting report definitions

([#8983](https://github.com/adcontextprotocol/adcp/pull/8983), rc.0.) Applies to sellers that publish report definitions under the experimental `media_buy.reporting_delivery`. Report definitions gain `contract_version` `1.2`, which keeps every `1.1` rule. At `1.2`, a definition whose rows are scoped to a media buy names that dimension `media_buy_id`, and a definition whose `dimensions` include `media_buy_id` MUST include `package_id`; the offering's `reporting_profile.primary_keys` then MUST include `package_id`. A definition without `media_buy_id`, such as an account-level summary, is exempt at every version.

Nothing negotiates the version: the definition states it, and the offering pins it through `report_definition_uri` and SHA-256, as for `1.1`. Callers pinned below 3.3 accept only `1.0` and `1.1`, so a seller MUST serve them offerings whose definitions are `1.0` or `1.1`. `1.0` and `1.1` keep validating unchanged; graders SHOULD report one that includes `media_buy_id` but not `package_id` as an advisory finding. Subscription selectors and offering `standard_dimensions` keep calling the breakdown `package`. The vectors are in `test-vectors/reporting-report-definition/`. See [Configuration and capabilities](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/task-reference/get_reporting_status.md#configuration-and-capabilities).

### Superseded reporting snapshots may be compacted

> [!WARNING]
>
> **Experimental breaking-change notice published October 9, 2026.** Under the six-week [experimental-surface notice policy](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/experimental-status.md), compaction takes effect only in the next eligible minor after November 20, 2026. Until then, sellers keep every superseded snapshot's content readable for its full retention window. If 3.3 is published before that date, compaction is not permitted under 3.3 and takes effect in the following minor.

This change applies to Reliable Reporting (`media_buy.reporting_delivery`, experimental). `status_retention_days` keeps metadata for every revision, but content only for:

* the current revision of each logical slice, including every official revision;
* the snapshot it immediately supersedes;
* any superseded snapshot for `automated_recovery_window_seconds` or one hour, whichever is longer, after it was superseded; and
* for the requesting caller, revisions named by that caller's own receipts or by its current `received`, `unreadable`, or `content_mismatch` status statement.

The seller may compact other superseded snapshots to metadata only.

Before: with `status_retention_days: 30`, an exact read of a pacing snapshot superseded three restatements ago returned its full `reporting_rows` for 30 days.

After: once that snapshot has been compacted, the same read returns the nondisclosing `REFERENCE_NOT_FOUND` with `field: "reporting_revision_id"`, exactly as for an unknown ID. Its metadata still appears in `get_reporting_status`.

**Buyers.** If you need a snapshot's rows after it is superseded, persist them when you read them, or record a receipt or status statement that names the revision. **Sellers.** Retaining the full chain stays conformant. A revision you still owe whose content you cannot serve is a `REVISION_UNREADABLE` issue, never a not-found. Each window starts at the revision's `created_at`, or at its successor's once superseded; an official revision's window restarts at its newest adjustment. See [revision retention](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/task-reference/get_reporting_status.md#reliability-model).

## Clarifications

These restate existing rules and need no wire change.

* **Signing buyers serve `get_adcp_capabilities`.** Request-signature discovery starts at the signer's agent URL, so a buyer that signs requests answers `get_adcp_capabilities` there even if it only calls sellers. See [request signing](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L1/request-signing.md).
* **A2A invocation.** An A2A invocation message with more than one DataPart is rejected; the last-DataPart rule applies to responses only. See the [A2A guide](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L0/a2a-guide.md).
* **Public Suffix List ([#8702](https://github.com/adcontextprotocol/adcp/pull/8702), [DR-0037](https://github.com/adcontextprotocol/adcp/blob/main/governance/decisions/DR-0037-psl-bundled-not-pinned.md), beta.5).** Verifiers compute eTLD+1 with a Public Suffix List bundled with the verifier, covering the ICANN and PRIVATE sections, never fetched at runtime, and refreshed through normal dependency updates. AdCP names no reference snapshot, so verifiers on different list versions are not non-conformant against each other. On the trust-record path, a verifier whose list lacks a newly added PRIVATE suffix fails closed.

## Already shipped in 3.2.2, 3.2.3, and 3.2.4

Adopters of these patches have already seen these; their changesets reappear in the 3.3.0 changelog.

* **3.2.2:** account references before provisioning, and the trust-docs consistency fixes (only `verify_brand_claim` and `verify_brand_claims` carry signed payloads; use `agents[]` instead of the deprecated `brand_agent` and `rights_agent`).
* **3.2.3:** the A2A operation-resolution errata with hardening at SHOULD; `authorized_agents[].url` in `adagents.json` is the full endpoint URL including its path, one entry per agent URL; and the storyboard fixes (evaluator feature membership, wholesale and replay capability gates, the polling `sales-guaranteed` path, `validate_input` gates, and the acceptance-policy sandbox account).
* **3.2.4:** the experimental `REVISION_UNREADABLE` reporting issue; `requires: [controller]` on controller-seeded storyboards, so a seller without a controller gets one storyboard-level skip; the storyboard fixes (required billing capability discovery, `active` non-guaranteed buys, the `advanced_delivery_reporting` join key, `typed_proposal_negotiation` seeding, the `seller_optimized_budget` minimum-spend fixture); request-signing vectors `negative/029`–`031` and `positive/013`–`015`, the `negative/026` re-code to `request_target_uri_malformed`, complete `profile-3.2/` mirrors, and step-5 canonicalization vectors; envelope composition and the bundled provenance hoist; the product channel-declaration guidance; and the principal-layer buyer walkthrough ([`v3.2.4`](https://github.com/adcontextprotocol/adcp/releases/tag/v3.2.4)).

## Deprecations

3.3 deprecates two result fields, the principal kind field and assertion, the RFC 9421 signing profiles, one usage, the account identity-rekey machinery, the boolean form of `demographics`, and six reserved-word enum values ([Reserved-word-safe enum replacements](#reserved-word-safe-enum-replacements)). All remain functional throughout 3.x, and each is expected to be removed in 4.0. Removals happen in a major. 3.3 stays supported for at least 12 months after 4.0 reaches GA, so a 3.3 integration keeps working while it migrates ([support window](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/versioning.md#support-window-for-previous-major)).

* **`seller_id` on `sync_event_sources` and `sync_audiences` results.** Use the new optional `platform_id` for the object's ID in the seller's ad platform, matching `sync_creatives` and `sync_catalogs`. **Sellers** reporting a platform identifier in 3.3 and later 3.x responses MUST emit both fields with identical values, including discovery responses and seller-managed event sources. **Buyers** MUST prefer `platform_id` and fall back to `seller_id` only when `platform_id` is absent. Either field may be absent in legacy responses, and both may be absent when no platform identifier is available. Continue using `event_source_id` and `audience_id` in AdCP requests. The aliases keep their object-ID semantics; they are never seller identity. `adagents.json` `contact.seller_id` and publisher identifiers of type `seller_id` are unchanged. The aliases are expected to be removed in 4.0. See [event source migration](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/task-reference/sync_event_sources.md#platform-identifier-migration-adcp-3-3) and [audience migration](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/media-buy/task-reference/sync_audiences.md#platform-identifier-migration-adcp-3-3) ([#8290](https://github.com/adcontextprotocol/adcp/issues/8290)).
* **`principal_kind` and `expected_principal_kind` on `sync_principal` and `get_principal`**, and the `enums/principal-kind.json` enum. A principal is the buyer agent as the seller has bound it, so the kind is always `buyer_agent` and carries no information. Sellers keep returning `principal_kind` and honoring `expected_principal_kind` throughout 3.x; buyers stop reading and sending them, and don't branch on `principal_kind`. They are expected to be removed in 4.0. The task names are unchanged ([#8443](https://github.com/adcontextprotocol/adcp/pull/8443), [#8280](https://github.com/adcontextprotocol/adcp/issues/8280)).
* **The AdCP RFC 9421 signing profiles**, for requests (`adcp/request-signing/v1`) and webhooks (`adcp/webhook-signing/v1`), with keys found through brand.json and `identity.brand_json_url`. They keep working throughout 3.x and are removed in AdCP 4.0, together with the brand.json trust fields ([DR-0023](https://github.com/adcontextprotocol/adcp/blob/main/governance/decisions/DR-0023-agent-identity-is-an-origin.md)). Their replacement is the experimental Web Bot Auth profile ([Web Bot Auth identities](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/by-layer/L1/security.md#web-bot-auth-identities); role-by-role steps in the [agent identity migration guide](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/migration/agent-identity-3-3.md)): identity is the signer's origin, keys come from that origin's key directory, and no capabilities call is needed. **Signers** that serve no capabilities endpoint can move now. **Verifiers** keep accepting RFC 9421 signatures through 3.x, under the no-downgrade rule once an origin is bound.
* **The natural key as the account reference after provisioning.** Sending the natural-key `AccountRef` on account-scoped tasks once the account exists is deprecated and planned for removal in AdCP 4.0 ([#7850](https://github.com/adcontextprotocol/adcp/issues/7850)). It keeps working throughout 3.x. The natural key itself stays: buyers use it to open accounts with `sync_accounts` and as a `list_accounts` filter to look up an account's ID. **Buyers** store the returned ID and send it. See [Account identity](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/accounts/overview.md#account-identity).
* **The account identity-rekey machinery** ([#8474](https://github.com/adcontextprotocol/adcp/pull/8474)). The `account.identity_updates` capability is deprecated and planned for removal in AdCP 4.0, with everything it gates. That covers `operator_identity` and `destination_billing_entity` on `sync_accounts`, the `identity_change` and `identity_change_preview` fields, and the `ACCOUNT_MOVED` and `ACCOUNT_IDENTITY_CONFLICT` error codes. `account.stable_account_id` is deprecated with it. An account's identity never changes, so no rekey or former key exists. **Sellers** that implement `operator_identity` keep it working through 3.x and SHOULD declare `stable_account_id: true` while the field exists. **Buyers** change `operator_unit` as an attribute and send `account_id` without checking `stable_account_id`.
* **The boolean form of `demographics`** in product `overlay_support` (`core/targeting-overlay-support.json`) and in `required_overlay_support` (`core/targeting-overlay-requirements.json`). `demographics: true` is the 3.2 shorthand for `{ "age": true }`, and every 3.2 release accepts the object form on both schemas. **Senders** MUST send the object form. **Receivers** MUST accept `true` and read it as `{ "age": true }`, so it satisfies an age requirement and never a `gender` requirement. It is planned for removal in AdCP 4.0 ([#8778](https://github.com/adcontextprotocol/adcp/issues/8778)).

3.3 also deprecates condition (b) of `request_signature_required` ([#8064](https://github.com/adcontextprotocol/adcp/pull/8064)), which exists only for the already-deprecated webhook `authentication` block. It is part of the `authentication` block's existing deprecation and is removed in 4.0 with the block. The experimental `configuration_task` field of `media_buy.reporting_delivery` is deprecated in favor of `configuration_tasks[]` and stays `"sync_accounts"` for clients pinned below 3.3 ([#8552](https://github.com/adcontextprotocol/adcp/pull/8552)). Changing a deprecated feature does not move its removal. Deprecations from earlier 3.x releases are likewise removed only in a major.

One earlier deprecation is worth restating before 4.0. The integer request field `adcp_major_version` and the `adcp.major_versions` capability field, deprecated in 3.1 in favor of `adcp_version` and `adcp.supported_versions`, keep working through 3.x and are **removed in 4.0** ([DR-0035](https://github.com/adcontextprotocol/adcp/blob/main/governance/decisions/DR-0035-adcp-major-version-removed-in-4-0.md)). Buyers send `adcp_version` on every request and keep the integer mirror until then. Sellers keep emitting `adcp.major_versions` alongside `adcp.supported_versions` through 3.x. In-house clients that send only the integer should move to `adcp_version` now. The [v4 compatibility checks](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/migration/v4-compatibility.md#major_versions_removed_in_4_0) flag sellers that still rely on the integer list.

## Compliance and grading

* `version_negotiation` gains an optional scenario for 3.1-pinned response shapes. Its checks stay advisory until runners can validate against the served release's schema bundle.
* `sales-broadcast-tv` (`sales_broadcast_tv` 1.1.0) now certifies one authorized TV transaction on either a guaranteed or a non-guaranteed fixed-price path (#8046). Existing claimants should expect new failures: seeded products are demo-priced `cpm` with Live/C3/C7 windows, creatives are assigned through `sync_creatives` `assignment_operations`, and Live and C7 reads must carry `measurement_window`, `is_final`, and `finalized_at`. Claims graded on 1.0.x have a grace window recorded in the compliance catalog. A spot-lifecycle phase runs only for sellers that list `media_buy.spot_lifecycle`.
* `sales-fixed-rate` is a new specialism for non-guaranteed, fixed-price sellers in any medium (#7963), promoted from preview to stable in beta.5 (#8445), so a passing claim counts toward the AAO Verified media-buy badge. Its `sales_fixed_rate` storyboard grades capability discovery, fixed-price product discovery, and a bid-less `create_media_buy`; optional hold phases run only when the seller advertises the `force_media_buy_confirmation` controller scenario. See [Choosing a sales specialism](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/verification/compliance-catalog.md#choosing-a-sales-specialism).
* `media_buy_seller/unprovisioned_account_reference` is new and advisory until runner capability `14.1.0`.
* `media_buy_seller/stable_account_id` is new and runs only for buyer-declared sellers that declare `account.stable_account_id: true`. That flag is deprecated in 3.3, so the gate is temporary. It addresses the account by `account_id` on `get_media_buys` and requires `@adcp/sdk` 15.8.0 or later, whose storyboard runner sends an authored `account_id` as written.
* New capability-gated scenarios: `governance/budget_periods`, `media_buy_seller/property_delivery_reporting`, `media_buy_seller/installment_property_delivery_reporting`, `media_buy_seller/outcome_target_vendor_metric`, and `media_buy_seller/outcome_target_event_cost`. Sellers that do not declare the capability skip them.
* New experimental scenarios: `media_buy_seller/creative_live_updates` and `media_buy_seller/creative_live_update_refusal`, the `media_buy.execution_readiness` scenario, a gender-targeting conformance storyboard, and a stateful package-retention scenario for canceled and completed buys. The `definition_pin_drift` storyboard, the `definition_pin_probe` controller scenario, and the `definition-pins` vectors are removed with definition pins.
* New controller scenario and vectors: `reporting_subscription_probe` on `comply_test_controller` (`revoke_grant`, `regrant`, `reduce_grant`, `set_account_timezone`, `advance_time`), and the canonical reporting-subscription coverage vectors with a reference model. Cross-SDK vectors for undisclosed rosters live under `static/test-vectors/product/`.
* New experimental storyboards in beta.4: `account_requests` (#8677); `media_buy_seller/reporting_subscription_coverage` and `media_buy_seller/reporting_subscription_capacity` (#8680, #8724); `media_buy_seller/hold_policy_bounds`, `hold_policy_terms_only`, `hold_policy_version_gate`, `hold_unavailable_batch`, `hold_extension`, and `hold_ranking` (#8696); and `media_buy_seller/assignment_replace_transfers_settings` (#8695). The runner contract adds the advisory `owed_periods_match`, `instant_offset_within`, and `undefined_properties` checks, and `reset_state` runs before each storyboard when the seller lists it (#8717).
* `creative/policy_backed_rejections` runs only for sellers that declare the new optional `creative.supports_registry_policy_enforcement` (#8857, rc.0); a creative library alone does not imply it, and a seller that publishes a registry policy in `enforced_policies` still enforces it. `media_buy_seller/declared_format_option_acceptance` (#8941, rc.0) and `media_buy_seller/unrecognized_terms_rejected` (#8884, rc.0) are new.
* `deterministic_testing` pins its fixtures and controller calls to one sandbox account (#8731, beta.5), and legacy creative fixtures come from a gated, offline test-kit catalog (#8684, beta.5).
* Hosted service: grading of governance-aware sellers is covered in [AAO Verified](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/building/verification/aao-verified.md).

These change grading results, not the wire.

## Rollback

Stay on, or return to, `"3.2"`: every 3.3 declaration is optional, so removing it restores 3.2 behavior. The [required rules](#required-to-claim-3-3-behavior) are the exception: they apply as soon as you claim 3.3 behavior (for [served-release conformance](#responses-conform-to-the-served-release), as soon as you list 3.3 in `supported_versions`), so keep a 3.2-pinned route until your discovery, verification, and delivery-webhook paths pass against the release candidate. A seller that advances revisions from every origin while serving 3.2 callers only makes stale-`revision` updates fail sooner, which 3.2 already allowed.

## Related

* [What's new in AdCP 3.3](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/whats-new-in-3-3.md)
* [3.3 prerelease program](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/3-3-beta.md)
* [Release Notes](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/release-notes.md#version-3-3-0)
* [Migrating from 3.1 to 3.2](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/migration/3-1-to-3-2.md)
* [Versions & Compatibility](https://docs.adcontextprotocol.org/dist/docs/3.3.0-rc.0/reference/versions.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.