Skip to content

RFC: Adjacent-code disclosure, assignment readback, and delivery-change notifications for 3.4 #6700

Open

Description

@bryanSigma

Status and scope

Proposed target: AdCP 3.4. Working Group approval is pending.

This issue now follows Brian O'Kelley's proposed split and the revised #8346. It covers the buyer-facing declaration, assignment readback, and delivery-affecting notification for seller-side code placed alongside a buyer creative.

The seller-to-vendor fragment API is tracked separately in #9109. That proposal, including any case for a separate signing profile, does not block this buyer-facing work.

This revised description supersedes the broader get_creative_addons scope in the earlier discussion. The original proposal followed #4146; neither vendor registration nor fragment assembly is part of the scope below.

Problem

Buyers need to know:

  1. Before purchase, which seller-side code is declared for the inventory.
  2. For each package–creative assignment, which code the seller reports as applied, omitted, or pending.
  3. When required code changes state in a way that affects delivery.

These needs can be addressed through existing product, creative-assignment, and notification surfaces without introducing a new buyer-facing tool.

The contract covers seller-side code broadly, including viewability, measurement, page scoring, brand safety, and runtime security. First-party seller code uses the same declaration model. Buyer-supplied assignment trackers and code already inside the creative remain on their existing surfaces and MUST NOT be included in this array.

1. Product declaration

Add optional adjacent_code[] to both canonical-product and product.

When present, the array MUST be the complete declaration for the product. Omission means undeclared, not “no code.” An empty array, [], explicitly declares none. A field excluded by product projection also remains unknown; buyers needing this information request adjacent_code in fields, only when the seller serves 3.4 or later.

Each entry has three required fields:

Field Meaning
provider A stable, opaque reference scoped to the selling agent. The reserved value seller identifies that agent's own first-party code.
purpose A buyer-readable description, such as measurement or verification. The vocabulary is open.
required An explicit boolean indicating whether the seller requires this code for delivery.

Provider references MUST remain stable across product declarations and assignment readback and MUST NOT be reassigned to another provider. They are not BrandRef values, authentication credentials, or resolvable URLs. Integration endpoints, loader URLs, credentials, and configuration remain between the parties operating the integration, including when extension properties are used.

Example declaration:

{
  "adjacent_code": [
    { "provider": "seller", "purpose": "measurement", "required": true },
    { "provider": "provider_7", "purpose": "verification", "required": false }
  ]
}

2. Assignment readback

Expose the same declaration fields, plus position and status, on:

  • list_creatives.creatives[].assignments.assigned_packages[].adjacent_code
  • get_media_buys.media_buys[].packages[].creative_approvals[].adjacent_code

A seller disclosing adjacent code for a product MUST include the complete array on returned assignments for that product, retaining pending and omitted entries. If both reads are exposed, they MUST agree for the same relationship and current state. Existing list_creatives truncation rules still apply; get_media_buys remains the complete relationship read.

Field Values and meaning
position prepend or append, relative to the unchanged creative in the seller's delivery representation. Pending or omitted entries report their intended position.
status applied: code has been applied to the current delivery representation; pending: application has not completed; omitted: code is absent from that representation.

Omission means undeclared; [] explicitly reports none for that assignment. Multiple applications of a provider's code may appear separately. Array order does not instruct the seller or guarantee browser execution order.

This is the seller's assertion about current application state. It is not independent proof of browser execution, successful measurement, or a historical per-impression record. approval_status_as_of remains a creative-review timestamp.

3. Required code and delivery holds

When any entry is required: true and its status is pending or omitted, the seller MUST hold delivery of that assignment. This applies before initial delivery and after serving has begun.

The hold MUST NOT change the library creative's status or the assignment's approval_status. Those fields retain their creative-review meanings. The per-entry application state represents the hold; this proposal introduces no general assignment-status field or new approval value.

Optional pending or omitted code does not cause this hold. When all required entries become applied, this particular hold ends, subject to the other existing approval and serving constraints. Sellers MUST NOT hide an unavailable required entry or silently downgrade its requirement to bypass a hold.

Retry scheduling, hold deadlines, registration, and vendor failure feedback are seller-local concerns.

4. Delivery-affecting notifications

Extend the existing creative.assignment_changed notification with:

{ "change_kind": "adjacent_code_changed" }

For sellers supporting this notification:

Change Emit the notification?
Required code enters or leaves pending Yes.
Required code becomes omitted or recovers from omitted to applied Yes.
An authorized requirement change blocks or releases assignment delivery Yes.
Ordinary configuration or purpose edits, or optional-code state changes No.
Identical state is reread No.

A required entry's pending/omitted transition still fires if another required entry also blocks delivery, so the buyer can obtain the updated reason. Assignment creation and removal continue to use assigned and unassigned; they do not need a duplicate adjacent-code event. Creative-review changes continue to use approval_changed.

Publish the updated readback before emitting the event. Existing account subscription, authentication, and deduplication rules apply. Receivers reread get_media_buys; the notification does not carry authoritative application state. Subscriptions remain prospective, and buyers can poll when notifications are unsupported.

5. Authority and changes after purchase

Disclosure does not authorize code insertion. Publisher and Sales Agent operator authorization remain prerequisites managed outside this buyer-facing contract. The fields introduce no buyer control for removing, disabling, substituting, or reordering seller code.

Readback reflects the effective policy and state of the existing assignment. Updating the current product offer does not retrospectively rewrite that assignment. An authorized change to an assignment's effective policy updates its readback and follows the delivery and notification rules above.

Existing commercial agreements govern permitted changes. This proposal adds no commercial-terms field, acceptance hash, buyer acceptance token, or new restriction on legacy purchase paths.

Out of scope

The following are excluded from this issue and #8346:

  • get_creative_addons, fragment request/response schemas, and new vendor capabilities.
  • Vendor registration APIs, credentials, fragment ordering rules, retries, hold deadlines, and vendor failure-feedback contracts.
  • addon_chain, assembly attestations, or a new signing profile/key purpose.
  • Changes to product-purchase or accepted commercial terms.
  • Independent browser-execution verification or a per-impression audit log.

Existing webhook authentication remains in place. #9109 tracks the separate vendor-integration proposal; any signing work requires its own justification and review against the applicable trust architecture.

Acceptance criteria

  • Optional product declarations exist on both product shapes, with clear omission and empty-array semantics.
  • Both assignment readbacks expose matching, complete application state with stable seller-scoped provider references.
  • Required pending/omitted code holds assignment delivery without changing creative approval.
  • Delivery-affecting transitions use the existing assignment notification, with the trigger rules above.
  • First-party seller code uses the same model; buyer-supplied trackers remain separate.
  • Schemas, documentation, and conformance checks agree; new containers remain open for additive extensions.
  • New fields are identified as 3.4 additions and are not released as part of 3.3. Working Group and human schema review remain required.
  • The vendor API and signing work remain separate and do not block this scope.

References

Activity

  1. added
    claude-triagingTriage routine is actively working on this issue (1-3 min)
    on Aug 19, 2026
  2. bokelley commented on Aug 19, 2026

    @bokelley
    Contributor

    Triage

    Classification: RFC / feature proposal
    Bucket(s): spec/protocol, creative, rfc
    Status: ready-for-human

    What the experts said:

    • ad-tech-protocol-expert: Core design is sound; three merge blockers — creative-addon capabilities block placement (must be a new top-level block, not an extension of creative-agent-capability), underspecified addon_chain signing ("SHOULD reuse JWS/RFC 8785" conflates RFC 9421 transport signatures with JOSE object signatures and isn't normative), and required failure mode needs MUST-level error-code and response-arm text.
    • adtech-product-expert: Fragment-only vendor contract is technically sound and matches how viewability/security vendors actually operate; two course corrections needed — required at operator level is too coarse for deal-level variation and needs a buyer policy-expression surface, and content-hash-only delivery reporting leaves enterprise buyers without an audit path.

    My take: Both experts accept the core design as the right direction compared to the governance-layer approach in #4146, but flag concrete specification gaps that would yield incompatible implementations or block enterprise adoption. Flagging for Creative WG review with decision memo below; the revision gates are author-addressable, not fundamental redesigns.


    Decision memo — pending WG ratification

    id: DR-PENDING (#6700)
    title: Accept get_creative_addons mechanism in principle; three revision gates required before WG vote
    class: normative
    status: recorded
    date: 2026-08-19
    refs: ["#6700", "#4146"]
    dissent: none at this stage
    

    Decision: Accept get_creative_addons and the Sales Agent-centric fragment contract in principle. Three gates must close before WG vote:


    Gate 1 — Capabilities block placement

    creative-addon must be a new top-level block on get_adcp_capabilities response (parallel to creative, governance, measurement), not an extension of creative-agent-capability.json:

    + "creative_addon": {
    +   "addons": {
    +     "supported_format_kinds": ["image", "html5", "display_tag"]
    +   }
    + }

    Gate 2 — Addon chain signing (choose one)

    "SHOULD reuse AdCP's existing JWS/RFC 8785 profile" is not normative — RFC 9421 transport signatures and JOSE object signatures are different artifact formats. The revision must pick one:

    Option A — reuse existing attestation-reference conventions (lower-friction):

    {
      "addon_chain_attestation": {
        "type": "adcp-attestation/v1",
        "signed_by": "https://sales.streamhaus.com",
        "algorithm": "ed25519",
        "chain_hash": "sha256:7e30..."
      }
    }

    Reuses core/attestation-reference.json and existing key infrastructure; no new profile document required.

    Option B — new named signing profile:

    {
      "signed_attestation": {
        "profile": "adcp/addon-chain/v1",
        "protected": "…",
        "payload": { "creative_id": "html456", "chain_hash": "sha256:7e30…", "iat": 1787175120 },
        "signature": "…"
      }
    }

    Requires a complete adcp/addon-chain/v1 profile specifying algorithm subset, covered claims, and key-reference mechanism — cannot remain as "SHOULD reuse" reference text.


    Gate 3 — required vendor failure semantics

    "Delivery held on failure" is underspecified. Revision must add MUST-level text covering: which error code the Sales Agent surfaces on the delivery-request response path when a required vendor fails, whether the hold is indefinite or operator-configured, and the buyer retry-logic contract. Without this, required-mode behavior will diverge across implementations.


    Advisory (not blocking for WG vote):

    • Enterprise buyers need a credentialed fragment-retrieval path for audit (parallel to detail_url in get_creative_features). Scope into v1 or explicitly defer with a documented boundary.
    • required at operator registration is too coarse for deal-level variation; the WG should decide whether a buyer policy expression (vendor allowlist/denylist by identity or type) is in scope for v1.
    • Experts recommend attestation signing be MUST, not optional; the current draft implies SHOULD or optional during adoption.
    • Static reference mode needs at minimum a batch attestation delivery summary for buyers above the long tail.

    Rationale: Fragment-only contract correctly separates seller-adjacent execution from buyer creative ownership. Sales Agent assignment is coherent with AdCP's agent-responsibility principle. The three gates are interop-critical specification gaps addressable by the author without a fundamental redesign.

    Implications: Resolves the role-separation question from #4146 — adjacent execution belongs to the Sales Agent, not governance agents. Video explicitly deferred. Prior art for the revision: core/attestation-reference.json, core/attestation-capabilities.json, and the webhook_signing profile naming pattern in protocol/get-adcp-capabilities-response.json.


    Triaged by Claude Code. Session: https://claude.ai/code/cse_01BQmFTSkFDhL1WYj8hQFD6n


    Generated by Claude Code

  3. added
    rfcProtocol change — auto-adds to roadmap board
    claude-triagedIssue has been triaged by the Claude Code triage routine. Remove to re-triage.
    needs-wg-reviewBlocked on a working-group decision — surface in WG meeting agendas
    and removed
    claude-triagingTriage routine is actively working on this issue (1-3 min)
    on Aug 19, 2026
  4. bryanSigma commented on Aug 24, 2026

    @bryanSigma
    Author

    @bokelley I’ve updated the RFC to address the triage feedback and the three revision gates. Would appreciate a re-review / next-step toward Creative WG discussion.

    Changes made:

    • Gate 1: moved creative_addon to a new top-level get_adcp_capabilities block, separate from creative.supported_formats.
    • Gate 2: chose a dedicated adcp/addon-chain/v1 JWS profile, made signing MUST, and defined Ed25519/EdDSA, RFC 8785/JCS canonicalization, covered claims, key purpose/resolution, and delivery-context binding.
    • Gate 3: made required explicitly seller-required, added finite max_hold_seconds, terminal ADDON_REQUIRED_UNAVAILABLE, async hold behavior, and buyer retry semantics.
    • Added an optional credentialed detail_url audit path without requiring disclosure of proprietary fragment/source code.
    • Static-reference executions now receive the same mandatory signed addon-chain reporting.

    One clarification on the buyer-policy advisory: the revision does not give buyers authority to approve, veto, remove, reorder, or otherwise dictate publisher-controlled code. Publishers already control what runs on their page/CMS/ad server. Buyer compatibility is evaluated before the media buy is committed: the buyer can choose whether to transact based on the seller’s disclosed addon configuration, but cannot change that configuration through this protocol.

    Video remains explicitly out of scope.

  5. lukasz-pubx commented on Sep 15, 2026

    @lukasz-pubx
    Contributor

    Cross-link: seller first-party measurement trackers — does the addon contract intend to cover them?

    This RFC intersects with a thread we've been working from the measurement side, and the two should find each other before either reaches the WG:

    This RFC looks like it could be that disclosure surface for display, and do it better than a capability flag: a Sales Agent that fires its own first-party measurement pixel could register itself as a static reference (§6), getting deployment, per-delivery disclosure, and signed attestation through the same addon_chain as third-party vendors. Three questions to make that intentional rather than accidental:

    1. Is seller-first-party in scope? The RFC's framing, registration model, and failure machinery are built for third-party vendors under a fragment-only contract. A seller registering its own loader satisfies the letter of §6 — is that an intended adoption tier, or should the RFC say so explicitly either way? (If in scope, mode: required + the hold machinery is odd for code the seller itself operates; a first-party entry arguably wants a lighter registration row.)
    2. Chain entries as measurement disclosure. If a seller's counting pixel rides the chain, the buyer learns that seller measurement executed (applied/omitted, position, hash) — which composes cleanly with Measurement: declare seller-initiated trackers and impression-ID joinability #6878's what the numbers mean plane (counting source, joinability). Worth one sentence in the Disclosure section positioning the chain as execution attestation, explicitly not measurement/count semantics, so implementers don't read counting authority into it.
    3. The video/audio boundary. The dominant seller-measurement path outside display is VAST/DAAST <Impression> insertion at assembly time, which this RFC's container model deliberately excludes. Fine to stay excluded — but if seller first-party measurement is in scope for display via addons, the severed disclosure issue will need to cover the VAST path by other means, and it would help if this RFC stated that boundary explicitly rather than leaving format coverage to imply it.

    None of this blocks the RFC — the fragment-only contract, ordering rules, and signed chain stand on their own. We'll cite this issue as a neighbour (and possible mechanism) when filing the severed disclosure issue, and would rather converge on one surface than file a competing one.

  6. added this to the Spec Backlog milestone on Sep 21, 2026
  7. modified the milestones: Spec Backlog, 3.3.0 on Oct 6, 2026
  8. bokelley commented on Oct 6, 2026

    @bokelley
    Contributor

    Updated 2026-10-06: decision-record number is assigned at merge; several briefs had claimed DR-0023, so it is now shown as DR-XXXX.

    WG decision brief (3.3)

    Problem. Publishers already run third-party code (runtime security, viewability, compliance) next to ads, each via bespoke engineering, and buyers can't see what executed. The RFC (author @bryanSigma) proposes a Sales-Agent-owned, fragment-only get_creative_addons contract with a signed attestation chain. The revision of 2026-08-24 closes all three triage gates: top-level creative_addon capabilities block, adcp/addon-chain/v1 JWS profile (Ed25519, JCS, MUST-sign), and terminal ADDON_REQUIRED_UNAVAILABLE with finite max_hold_seconds. Pull: @lukasz-pubx (a measurement-side seller) asked the three scope questions below; no draft PR exists — the spec lives only in the issue body. (The DR-PENDING memo on this issue is not a recorded decision; next free number is DR-XXXX.)

    Proposed shape. Display only (image, html5, display_tag). New task, capability block, signing profile, error code, and delivery-reporting chain — size L.

    Open questions for the WG

    1. Are seller first-party measurement trackers in scope? Rec: yes, as ordinary registration (a seller may register itself as a static-reference addon; no lighter first-party row in v1). The chain then becomes the display disclosure surface, and Measurement: declare seller-initiated trackers and impression-ID joinability #6878 field 3 only needs the VAST/DAAST path.
    2. Is the chain explicitly execution attestation only, with no counting-authority semantics? Rec: yes — add one normative sentence; counting authority stays with billing_measurement.
    3. Is video/audio (VAST <Impression> insertion) explicitly out of scope, with disclosure handled elsewhere? Rec: yes — state the boundary in the RFC; route to Measurement: declare seller-initiated trackers and impression-ID joinability #6878 field 3 / spec(creative): implement preview event and macro observation sessions #6782.
    4. Author's blocking question: which existing pre-commit surface returns account-specific resolved addon config? Rec: product discovery when product-scoped, otherwise the account-sync response — no new task; this carries the RFC's "disclose before spend" claim.
    5. Commit to 3.3 beta, or ratify in principle and implement in 3.4? Rec: ratify in principle; implement in 3.4 unless the author lands a complete spec PR before the beta cut.

    Out of scope / deferred. Video/audio, buyer veto of publisher code, vendor-signed content_hash, addon-count/size caps and max_latency_ms (author's remaining open questions, none blocking).

    Prepared by Claude Code for WG agenda; verified against origin/main 870115e (2026-10-06).

  9. modified the milestones: 3.3.0, 3.4.0 on Oct 6, 2026
  10. bokelley commented on Oct 6, 2026

    @bokelley
    Contributor

    Deferred to 3.4 in the 3.3 scope review: L-size with no PR this close to beta, and the brief itself says to implement in 3.4. The WG decision brief above stays as the starting point for 3.4.

  11. numarasSigmaSoftware commented on Oct 14, 2026

    @numarasSigmaSoftware

    @bokelley — could the WG reconsider the full feature for 3.3, and what approval and release-readiness gates would apply? Please also advise on routing the proposed signing profile for the required human review.

    @lukasz-pubx — do the proposed first-party registration and execution-attestation rules resolve your measurement and reporting-boundary concerns, including the boundary with #6878?


    Proposed decision addendum — reconsider full get_creative_addons support for AdCP 3.3

    Status: Proposed for Working Group review
    Class: Normative, with explicit human approval required for the signing profile
    Target: AdCP 3.3, conditional on scope approval and implementation readiness

    Request reconsideration of the decision to defer #6700 to 3.4.

    The October 6 WG brief states that the revised RFC addressed the original triage gates. The subsequent deferral cited the feature’s size and the absence of a PR near beta. This addendum proposes a bounded path to deliver the full feature during the remaining 3.3 cycle, including mandatory signed addon chains.

    This is a request to reopen the release-scope decision. It records no approval and makes no claim that the specification or implementation evidence is already complete.

    1. Retain the full feature and its existing boundaries

    Recommend retaining get_creative_addons for image, html5, and display_tag, including live vendor calls and static references.

    The Sales Agent owns assembly in a seller-controlled delivery container. The buyer’s creative remains unchanged, and addon vendors receive context without receiving the creative payload.

    Keep the top-level creative_addon capability block, deterministic placement rules, and the existing required/best-effort failure model. Every resulting addon chain remains signed, including static-reference chains and chains containing omissions.

    Publishers retain control of seller-side execution. Buyers can evaluate compatibility before committing spend; this feature gives them no instruction to disable, reorder, or replace seller-required addons.

    Seller first-party measurement loaders are in scope through ordinary registration. Their chain entries describe the Sales Agent’s execution claims. Counting authority remains governed by billing_measurement.

    Video/audio assembly, including VAST/DAAST tracker insertion, remains outside this RFC. Coordinate the disclosure boundary with #6878.

    2. Approve a bounded 3.3 signing profile using supported key infrastructure

    Recommend shipping adcp/addon-chain/v1 using the existing, supported 3.x brand.json/JWKS discovery infrastructure.

    DR-0023, ratified October 12, keeps that infrastructure functional through 3.x while scheduling JWS document-signing work for 3.4. The WG and trust maintainers must explicitly approve the proposed 3.3 use and record its relationship to that sequencing decision. Legacy compatibility alone does not authorize the new addon profile.

    The proposed profile is:

    • Signature format: Standard flattened JWS, with base64url-encoded protected, payload, and signature fields. The payload bytes are the UTF-8 encoding of its RFC 8785/JCS canonical form. Detached and unencoded payload variants are outside v1.
    • Algorithm and type: Ed25519 with alg: EdDSA. The protected header requires kid and the exact type adcp-addon-chain+jws. Verifiers reject unsupported algorithms or profile identifiers.
    • Key purpose: Require a dedicated key with use: sig, verification permitted by key_ops, and the proposed purpose adcp_use: addon-chain-signing. Approval of this new purpose is part of the signing decision. The key must remain separate from transport-signing material.
    • Key discovery: Resolve the expected Sales Agent through the existing supported agent-resolution rules, including identity.brand_json_url and the selected agent’s JWKS. A presented attestation cannot introduce an arbitrary key URL or replace the expected seller identity. Preserve the existing safe-fetch and key-refresh controls.
    • Publisher authorization: Preserve applicable publisher key pins. Determine the relevant publisher from trusted transaction context, and require matching key material wherever the existing pin rules apply. A matching kid alone is insufficient.
    • Covered claims: Bind the signer identity, creative identity and hash, ordered chain hash, and issuance time. Include the delivery-scoping identifiers needed to distinguish the reported execution, including revision and variant identifiers where applicable.

    The specification PR must define the exact hash inputs for each supported format and provide deterministic signing vectors. Fragment hashes cover the exact fragment bytes; a loader hash does not establish the contents of code subsequently fetched from a mutable URL.

    Verification must fail when the signature or key authority is invalid, or when covered identifiers disagree with the reporting context. Missing or unverifiable signing evidence cannot be reported as a verified addon chain.

    The PR must also specify rotation and revocation behavior, including how retained historical chains are verified. It should reuse applicable existing mechanisms and identify any additional requirements for human review.

    This proposal changes no Web Bot Auth transport behavior and adds no alternate trust-discovery system. Any later migration to the 3.4 document-signing framework must use explicit version or profile negotiation and preserve the interpretation of previously issued chains.

    3. Resolve disclosure through existing surfaces

    Recommend product-scoped disclosure through get_products, with account-scoped resolved configuration on the relevant sync_accounts response row. Introduce no standalone discovery task.

    Disclosure must identify its scope and whether it is complete for the intended transaction. Absence means undeclared and must not be interpreted as an empty addon set.

    Before committing spend, the seller must establish that the complete configuration disclosed to the buyer still applies. Prefer binding that configuration through the existing transaction or proposal mechanism.

    This addendum does not assume a new buyer-echoed configuration field. The specification PR must demonstrate a reliable binding for every supported purchase path. If the existing mechanism cannot provide one, the required minimal schema addition must receive review before that path is advertised as supported.

    After commitment, configuration changes remain seller-controlled. Reporting must retain the configuration actually applied to each execution so later changes cannot overwrite the historical record. This creates no runtime buyer veto.

    4. Close required-mode and ordering ambiguities

    For an affected creative with a seller-required addon, success requires the valid fragment or fragments required by seller policy.

    A required vendor returning no fragment follows the existing finite hold and terminal ADDON_REQUIRED_UNAVAILABLE behavior. An empty addons array cannot silently satisfy the requirement. The buyer creative’s lifecycle status remains unchanged, and retries follow the invoking task’s existing contract.

    Best-effort omission may proceed, but the chain must distinguish a deliberate vendor omission from a connection or validation failure. The specification PR must define that vocabulary.

    Keep vendor failure feedback within the RFC’s existing mechanisms. Add no vendor-controlled “not applicable” exemption to required mode in v1.

    Define prepend and append as deterministic placement within the seller-controlled container, preserving registration order within each position. The specification must distinguish placement from asynchronous execution timing. A seller must support any execution prerequisite on which a required addon depends before advertising that route as compatible. A general dependency scheduler remains outside scope.

    5. Keep the remaining open questions bounded

    Question Recommended 3.3 decision
    Protocol-wide vendor-count or fragment-size caps Defer universal values pending implementation evidence. Operators enforce local limits through the existing failure modes; silent truncation is prohibited.
    creative_addon.max_latency_ms Defer. Operators enforce call timeouts and the finite hold period. A future declaration needs a precise meaning.
    Dedicated audit-evidence schema Reuse the RFC’s optional, access-controlled detail_url convention. Add no separate retrieval task or evidence-document schema.
    Vendor signatures over content_hash Defer. Mandatory Sales Agent signing attributes the final assembly claim; independent vendor authorship can follow separately.

    6. Make 3.3 inclusion conditional on concrete evidence

    Reconsidering the milestone should authorize review of the complete feature. Inclusion in a 3.3 release remains conditional on:

    • Human approval of the protocol decisions and the bounded signing profile, with their relationship to DR-0023 recorded.
    • A focused specification PR containing the schemas and matching normative documentation, with an appropriate changeset.
    • Reproducible signature tests covering altered chains, incorrect key purpose, and mismatched delivery context.
    • Behavioral coverage for live and static addons, including required-vendor omission and best-effort failure.
    • A documented integration demonstrating seller-side assembly and buyer verification, using named implementation partners and exact protocol versions.
    • Compatibility rules that scope new obligations to negotiated addon support.

    The next deliverable after WG agreement is the focused specification PR linked to #6700. Its review should establish whether the full feature is ready for a specific 3.3 release checkpoint.

  12. modified the milestones: 3.4.0, Spec Backlog on Nov 8, 2026
  13. KonstantinMirin commented on Nov 9, 2026

    @KonstantinMirin
    Collaborator

    Thanks for writing this up so carefully, and for the addendum.

    I think the core problem is real. A buyer should be able to see, before buying, which third-party code the seller runs next to its ad. Today product.delivery_measurement.vendors covers measurement vendors on the legacy product only, and there's nothing on canonical-product or for security and compliance vendors.

    I'm less sure the rest belongs in the protocol, and I'd like to understand it better:

    • Vendor registration, ordering, hold policy and vendor failure feedback all seem to happen inside the seller's stack. Is there a case where a buyer would observe them, or where the spec could test them? The registration schema describes itself as operator-local configuration, which makes me wonder whether it's application config rather than the wire.
    • What does the signed addon_chain let a buyer verify? As far as I can tell, the buyer never receives the fragments, so it can't check content_hash, and the signature attests to the seller's own statement. Our measurement taxonomy says verification matters because it isn't the seller's word. Am I missing a way the buyer uses it?

    I'm also not sure how #8346 fits with what's already lined up for 3.3:

    Would a smaller first step work? For example, one optional declaration at product level on canonical-product and product, listing each vendor as a BrandRef with a purpose, where absence means undeclared. That would be an additive minor on open schemas. Binding it into accepted commercial terms could wait for the 4.0 extension point on commercial-terms. If sellers and vendors want a shared integration API, I wonder whether it would be better as its own spec with named adopters, separate from the buyer–seller protocol.

  14. bryanSigma commented on Nov 16, 2026

    @bryanSigma
    Author

    Thanks, @KonstantinMirin. I agree that a buyer should be able to see before spending whether seller-side addons may run alongside its ad. I’d put a small, optional declaration on canonical-product. The buyer can use it to decide whether to buy the inventory. Enabling an addon is a separate decision that requires both the publisher and the Sales Agent operator to opt in.

    I’d keep BrandRef out of this. A brand domain identifies a company. What the operator is enabling is a specific integration for specific publisher inventory, and that belongs in the operator’s configuration. The buyer-facing declaration can describe the offer without publishing a vendor directory or requiring a purpose for each vendor. Endpoint and loader URLs, configuration, and implementation details stay between the parties operating the integration.

    The contract is deliberately broad. A publisher might use it for a viewability pixel, page scoring, brand safety, or runtime security. The publisher or the Sales Agent operator can supply its own addon through the same path. For a live integration, the Sales Agent sends placement and format context and gets a fragment back. The creative payload stays out of that request. I’d also make runtime isolation explicit: the seller can place a fragment alongside the creative only where the delivery environment prevents the fragment from reading or modifying it.

    I agree registration itself is local config. The shared fragment API is useful because the same integration can work across Sales Agents. The buyer-facing attestation serves a different purpose. It lets the buyer verify who signed the delivery record and which delivery it belongs to. The record reflects what the seller says it applied or omitted. Independent verification of what ran in the browser requires separate evidence. The operator can retain the detailed record for audit, while the signed buyer record can use opaque addon references.

    For 3.3, I’d put the optional declaration on the product offer and keep the fragment API and delivery reporting in scope for review. I’d revise #8346 so the buyer-facing attestation signs only the information intended for disclosure, with any new signing profile reviewed against the 3.3 Web Bot Auth rules.

  15. bokelley commented on Nov 16, 2026

    @bokelley
    Contributor

    Thanks @bryanSigma and @KonstantinMirin. Bryan, I think your latest comment gets most of the way there. I'd like to go one step further and ask whether we need a new tool at all.

    What the buyer needs comes down to three things: (1) before buying, does seller-side code run next to my ad; (2) what actually ran on my creative; (3) tell me when that changes or blocks delivery. We already have places for each:

    1. Declaration: an optional adjacent_code[] on canonical-product / product: {provider, purpose, required}, where absence means undeclared. A seller's own first-party trackers (Measurement: declare seller-initiated trackers and impression-ID joinability #6878) are just entries where the seller is the provider, so there's one concept, not two.
    2. Readback: the same adjacent_code[] on each list_creatives assigned_packages[] row (mirrored in get_media_buys), with position and status: applied | omitted | pending. It sits next to the trackers and approval_status already there.
    3. Lifecycle: a seller-required add-on that isn't ready holds the assignment in pending, so the creative's status doesn't change. creative.assignment_changed gets a new change_kind: adjacent_code_changed, fired only when delivery is affected: a required add-on entering or leaving pending, or being omitted. It doesn't fire on every configuration change. approval_status stays about creative review.

    Registration, ordering, holds, vendor failure feedback and the fragment API all happen between the seller and its vendors. The buyer can't observe them and we can't test them, so I'd keep them out of the buyer–seller protocol. I'd also drop the signed chain: it signs the seller's own statement, which the buyer can't check independently, and it would add a new key purpose to the chain DR-0023/DR-0026 are retiring.

    I'd suggest splitting #8346: one small PR with the product declaration, the list_creatives readback and the adjacent_code_changed assignment webhook. The fragment API and signing profile would become a separate proposal the WG can take on its own merits. That gets the buyer-facing piece moving for 3.4 as an additive minor on open schemas, without settling the vendor-integration question first. Happy to help on the small PR if that's useful.

  16. changed the title [-]RFC: get_creative_addons: Operator-Registered Creative-Adjacent Addons with a Fragment-Only Vendor Contract[/-] [+]RFC: Adjacent-code disclosure, assignment readback, and delivery-change notifications for 3.4[/+] on Nov 19, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    claude-triagedIssue has been triaged by the Claude Code triage routine. Remove to re-triage.creativeneeds-wg-reviewBlocked on a working-group decision — surface in WG meeting agendasrfcProtocol change — auto-adds to roadmap board

    Type

    No type

    Projects

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions