Skip to content

RFC: pre-proposal competence discovery for conversational agent routing #6508

Open

Description

@bokelley

Split from #6287.

Scope

Choose a typed or progressively disclosed mechanism for declaring what an agent can reliably interpret before a proposal exists.

Acceptance criteria

  • Each competence is anchored to protocol/task scope.
  • Vocabulary is namespaced and constrained, or a WG-curated enum is used.
  • Descriptions cannot substitute for enforceable task claims.
  • Drift and capabilities.changed behavior are defined.
  • Pre-proposal examples show how a buyer distinguishes unsupported from not-understood.
  • WG chooses the separate-task versus inline-capability shape.

Activity

  1. added this to the Spec Backlog milestone on Aug 13, 2026
  2. added
    rfcProtocol change — auto-adds to roadmap board
    claude-triagedIssue has been triaged by the Claude Code triage routine. Remove to re-triage.
    schemaJSON Schema source-of-truth: definitions, codegen artifacts, validation, hygiene
    needs-wg-reviewBlocked on a working-group decision — surface in WG meeting agendas
    on Aug 13, 2026
  3. lukasz-pubx commented on Sep 8, 2026

    @lukasz-pubx
    Contributor

    Parent RFC #6287 has been refreshed post-#6547 (edit history has the diff). Relevant to the acceptance criteria here: the refreshed text anchors every competence to task_scope, uses {protocol}.{term} namespaced names with the Agent Skills name pattern, defines drift and capabilities.changed behaviour via capabilities_version, and adds a pre-proposal example built on refine_proposals reason codes. It also adds the Skills over MCP WG / SEP-2640 precedent for the name+description, progressive-disclosure shape. The separate-task vs inline-capability choice is left to this issue.

  4. added
    triage:outcome-missingclaude-triaged label is present but no visible triage outcome comment was found
    on Sep 21, 2026
  5. bokelley commented on Sep 21, 2026

    @bokelley
    ContributorAuthor

    Triage outcome

    Classification: capability-discovery RFC
    Status: keep in Spec Backlog; WG shape decision remains open.

    The refreshed #6287 appears to satisfy several prerequisites: task-scoped competence names, namespacing, version drift, and pre-proposal examples. That improves the proposal, but a descriptive competence must not be mistaken for a supported task, certification, or authorization claim. The remaining separate-task versus inline-capability choice affects caching, pagination, notification, and prompt/context cost and needs implementation evidence.

    Evidence needed: two agents with materially different competence catalogs and one orchestrator routing decision that cannot be made from supported_protocols, specialisms, and existing capabilities. Show initial discovery, progressive detail fetch, capabilities_version change, an unknown competence, and the unsupported-versus-not-understood distinction.

    WG gate: choose inline summary plus optional detail task, or a standalone task; cap name/description size and cardinality; bind every term to a protocol/task namespace; define claim strength and whether conformance can verify it; and specify cache/version/change-notification behavior. Agent Skills/SEP-2640 is useful shape precedent, not sufficient AdCP semantics. No release assignment until a reference router consumes the result safely.

  6. removed
    triage:outcome-missingclaude-triaged label is present but no visible triage outcome comment was found
    on Sep 21, 2026
  7. lukasz-pubx commented on Nov 18, 2026

    @lukasz-pubx
    Contributor

    The registry epic #9067 bears on two items in the gate above.

    I've raised the onboarding side on #9067 and in a related issue, #9089. Competences are noted there as a later declared field, not a dependency.

  8. lukasz-pubx commented on Nov 19, 2026

    @lukasz-pubx
    Contributor

    This is the evidence the triage above asks for. It covers two agents, one routing decision, initial discovery, a progressive detail fetch, a capabilities_version change, an unknown competence, and the unsupported-versus-not-understood distinction.

    Everything below was captured from the public sandbox (test-agent.adcontextprotocol.org, 3.2-pinned negotiation profiles) on 2026-11-18. It validates against the schemas at main 32a90ee0d0 (3.3.0-rc.1), and the proposed shapes validate against the draft schemas at the end. Seller A's refinement response is the one exception: I constructed it, because no seller in the sandbox reasons about an ask. That gap is part of the evidence. The reference seller's ask handling is a tag match ([commercially-declined], [unsupported-dimension]), so it is a conformant mechanical refiner by design.

    The two agents and the decision

    Seller B is the sandbox typed-negotiation profile exactly as it answers today. Seller A is the same capability document with an adcp.competences block added. A hash of each document with the competence surface and freshness metadata removed is identical (a3700fd5a9b470da). Both declare media_buy and creative, the same four sales specialisms, supports_proposals: true, the same lifecycle_tools, and the same seven supported_dimensions. The current 3.3 capabilities schema already accepts the added block, because adcp is open.

    The buyer holds a draft from each: premium video at a fixed USD 15 CPM plus two auction lines. It wants every line at USD 12 or less and is willing to lose the premium video package to get there. The decision is who chooses the new mix:

    • Delegate. Send constraints.cpm with an ask stating the trade-off, and let the seller find the mix. That only pays off if the seller reasons about the ask.
    • Buyer-computed. Send constraints.cpm with product_changes: { premium: "omit" }. That always parses, but the mix is the buyer's crude guess, and a seller who could have kept the premium package at USD 12 never gets the chance.

    Nothing in the current surface separates A from B for this choice. The typed gate is identical. The spec rules it out of the capability surface in three places, two of them in the words "is competence, not a capability". The sales specialisms verify the proposal lifecycle mechanically, and buyer-negotiation and orchestrator-multi-agent are claims about buyers. A router stripped of competences produces the same plan for both sellers, as Step 1 shows.

    Both wrong choices cost something real. Delegating to B returns partial / uninterpreted with the mix unchanged (live, round R1 below), which spends a round and teaches the buyer nothing about price. Sellers SHOULD add friction to sustained un-held rounds, so the wasted round also eats into the buyer's negotiation budget with that seller. Computing the mix for A forfeits the counter A would have offered. Across a portfolio of sellers, the buyer makes this choice once per seller per round, which is the routing case #6287 leads with.

    Where each requested item appears

    Requested in triage Step What happened Source
    Initial discovery 1 One get_adcp_capabilities per seller; identical fingerprints; A's inline summary bound to its advertised tasks Live document; A's block added
    Progressive detail fetch 2 get_adcp_competences for the three names scoped to refine_proposals only; B has nothing to fetch Fixture
    Routing decision 3, 4 A: delegate; B: buyer-computed. Same plan for both without competences A constructed, B live (R3)
    An unknown competence 1, 2 media_buy.makegood-negotiation is kept but changes nothing; a signals.* entry on a seller without signals is dropped Fixture
    capabilities_version change 5 B fires capabilities.changed; only the competence surface moved; router fetches one name, probes once, demotes on uninterpreted Webhook fixture; probe result live (R1)
    Unsupported vs not understood 6 UNSUPPORTED_FEATURE before mutation; partial / uninterpreted; unable / commercially_declined Live (R5, R1, R6, R4)

    Step 5 deserves a sentence. B announces media_buy.counter-proposal after a model upgrade, but it still runs the mechanical sandbox logic. The router delegates once under the new catalog, gets uninterpreted back, and demotes the claim for that catalog version. That is the honesty model from #6287 working without any conformance machinery: the declaration buys one attempt, and the reason codes from #6547 settle it.

    Full trace (generated by running the router sketch over the captured payloads)

    Step 1. Initial discovery (one get_adcp_capabilities call per seller)

    • Fingerprint of everything except the competence surface: A a3700fd5a9b470da, B a3700fd5a9b470da, identical.
    • Router with competences removed: A buyer-computed, B buyer-computed. The existing surface yields the same plan for both.
    • A summary bound: usable ["media_buy.counter-proposal","media_buy.similarity-interpretation"], unknown ["media_buy.makegood-negotiation"], dropped [{"name":"signals.signal-selection","why":"protocol signals not in supported_protocols"}].
    • B: no adcp.competences block. Undeclared, treated as unknown (S4).

    Step 2. Progressive detail fetch

    • A: get_adcp_competences {"names":["media_buy.counter-proposal","media_buy.similarity-interpretation","media_buy.makegood-negotiation"]} (only names scoped to refine_proposals; signals.signal-selection was already dropped).
    • Unknown term media_buy.makegood-negotiation: description passed to the planner as untrusted text, no effect on route (S3): "Negotiates make-good inventory on amendment refinements of accepted buys after under-delivery."
    • B: nothing to fetch.

    Step 3. Route the same intent

    • A: delegate (counter-proposal declared for refine_proposals); pre-flight {"ok":true}; refinement {"action":"revise","constraints":{"cpm":{"max":12,"currency":"USD"}},"ask":"Hit USD 12 CPM on this plan. We are willing to drop the premium video package to get there; counter with whatever mix clears it."}
    • B: buyer-computed (no counter-proposal declared (unknown, not incapable)); pre-flight {"ok":true}; refinement {"action":"revise","constraints":{"cpm":{"max":12,"currency":"USD"}},"product_changes":{"pinnacle_news_video_premium":"omit"}}

    Step 4. Outcomes

    • A (CONSTRUCTED; no reasoning seller exists in the sandbox): revised; mix pinnacle_news_video_premium@12 + pinnacle_news_video_standard@9 + pinnacle_news_display_standard@6.
    • B (LIVE sandbox R3): revised; mix pinnacle_news_video_standard@2 + pinnacle_news_display_standard@2. The sandbox meets the ceiling by repricing to USD 2, a fixture simplification.
    • Records: A {"catalog_version":"a-cat-2026-11-02","mode":"delegate","outcome":"revised","reason_code":null,"verdict":"declared and consistent"}; B {"catalog_version":null,"mode":"buyer-computed","outcome":"revised","reason_code":null,"verdict":"no competence claim tested"}.
    • Counterfactual, B delegated to (LIVE sandbox R1, ask carrying the trade-off): partial / uninterpreted; mix unchanged pinnacle_news_video_premium@15 + pinnacle_news_video_standard@auction + pinnacle_news_display_standard@auction. One round spent, nothing learned about price.

    Step 5. capabilities_version change on B

    • Webhook capabilities.changed, reason capability_enabled, capabilities_version training-agent-3.2+competences-1, changed_paths ["/adcp/competences","/experimental_features"]. Router re-reads get_adcp_capabilities.
    • Fingerprint without competences still a3700fd5a9b470da (unchanged): only the competence surface moved.
    • catalog_version none -> b-cat-1; fetch {"names":["media_buy.counter-proposal"]}.
    • Route: delegate (counter-proposal declared for refine_proposals). One probe under the new catalog (S6).
    • B still runs the mechanical sandbox logic, so the probe returns LIVE R1: partial / uninterpreted. Record {"catalog_version":"b-cat-1","mode":"delegate","outcome":"partial","reason_code":"uninterpreted","verdict":"declared, not observed: demote"}.
    • Next round: buyer-computed (counter-proposal demoted for catalog b-cat-1).

    Step 6. Unsupported, not understood, understood and declined

    • Unsupported (capability plane): against the sandbox ask-only route (supported_dimensions []), pre-flight blocks ["cpm","product_changes"]. Sent anyway, LIVE R5: UNSUPPORTED_FEATURE, details {"unsupported_dimension":"cpm","supported_dimensions":[]}.
    • Not understood (competence plane): LIVE R1 and R6: partial / uninterpreted, mix unchanged. R6 reason: "Ask acknowledged but not applied by training agent: Hit USD 12 CPM on this plan. We are willing to drop the premium video package to get there; counter with whatever mix clears it."
    • Understood and declined (commercial plane): LIVE R4: unable / commercially_declined. The sandbox only produces this for an ask tagged [commercially-declined].

    Sizes (compact JSON bytes)

    Item Bytes
    Live sandbox capabilities document (B) 16822
    Seller A inline summary, 4 entries 388
    Typical inline summary, 8 entries 805
    Worst-case inline summary at the proposed caps 5210
    Seller A detail, 3 names fetched 997
    Worst-case full detail at the proposed caps 22422

    What the evidence suggests for the WG gate

    • Shape: inline summary plus an optional detail task. The summary carries names and task scopes only. In the sizes table, a typical eight-entry summary adds about 5% to the sandbox capability document, and the worst case at the caps below adds about 31%. Descriptions and evidence, the parts that cost context, stay behind get_adcp_competences with a names filter, so a router fetches only what the decision at hand needs (997 bytes in Step 2). A standalone task costs one extra call per seller per refresh, and the registry crawl in Feature: Search registry agents by what they offer (channels, countries, formats) #9066 would need that call for every agent it indexes.
    • Caps. At most 16 entries. Names are {protocol}.{term}, with the term following the Agent Skills name rule (at most 64 characters). At most 4 tasks per entry; the longest AdCP task name today is 31 characters, so 48 leaves room. Descriptions are at most 1,024 characters, as in Agent Skills, and appear in detail only. The negative cases in the validation run show each cap rejecting.
    • Binding. Two cross-field rules the runner can check statically: the protocol prefix appears in supported_protocols, and every task_scope entry is a task the agent advertises. Readers ignore entries that fail either rule, as the router does in Step 1. A third rule: detail_available: true requires get_adcp_competences in tools/list or the A2A skills list.
    • Claim strength. Advisory. A declaration is a routing prior and never a task, a typed dimension, a certification or an authorization; rule S1 in the router encodes that, and the pre-flight in Step 6 shows the typed gate refusing what the capability document does not declare, whatever the competences say. Conformance can verify the structure above, the binding, and that the catalog version moves with the content. It cannot verify the truth of a claim. Truth comes from observed reason codes (Step 5) and, later, from evidence records such as those proposed in Feature: Evidence badges on every registry listing (registry page, API and public feed) #9060 and Production evidence program: machine-observed AdCP implementation matrix #7068, which the reserved evidence slot can point at.
    • Cache, version and notification. No new mechanism is needed. The summary is part of the capability document, and the existing definition of a material change already covers it: "any externally advertised contract change that can affect routing". So a change bumps capabilities_version and fires capabilities.changed, as in Step 5. catalog_version inside the block tells a reader whether its cached detail is current, so most refreshes cost no detail call. Competences should be readable without credentials whenever capabilities are, so the registry can index them.
    • Reader rules worth making normative, taken from the router's safety rules: S1 (typed gate from capabilities only), S2 (bind or drop), S3 (unknown terms change nothing; descriptions are untrusted seller text), S4 (undeclared means unknown, not incapable), and S5 (observation beats declaration).

    What this does not show

    • No live seller that reasons about an ask exists in the sandbox, so Seller A's counter-proposal is constructed. Every response attributed to B is live.
    • The router is an offline sketch over captured payloads, not a deployed reference router. It shows the rules are implementable in about a hundred lines. It does not show them under production load or adversarial sellers.
    • The caps come from measurement and the Agent Skills limits, not from field data on how many competences real sellers declare.
    • The sandbox already has two seller profiles, typed-negotiation and constrained-seller, whose capability documents are byte-identical while their behaviour differs. Their difference is commercial policy (floors and inventory), which competences should not describe either, so I did not use them as the pair.
    Proposed schemas (draft-07; validated with ajv against the fixtures, including the negative cases)

    competences-summary.json

    {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "$id": "/schemas/proposed/competences-summary.json",
      "title": "Competences Summary (get_adcp_capabilities adcp.competences)",
      "description": "PROPOSED (adcp#6508). Inline summary of advisory competence declarations, carried in get_adcp_capabilities under adcp.competences. Names and task scopes only, so the always-loaded cost stays small; descriptions and evidence come from get_adcp_competences on demand. A competence is a routing prior for what the agent can reason about inside an advertised task. It never declares task support, a typed dimension, a certification, or authorization. Part of the capability document, so any change to it is a material capability change: bump capabilities_version and fire capabilities.changed.",
      "type": "object",
      "properties": {
        "catalog_version": {
          "type": "string",
          "minLength": 1,
          "maxLength": 64,
          "description": "Opaque token that changes whenever any entry or any detail-only field (description, evidence) changes. Readers compare it for equality to decide whether cached detail is still current."
        },
        "detail_available": {
          "type": "boolean",
          "description": "true when the agent serves get_adcp_competences. When true, the agent's tools/list or A2A skills[] MUST include get_adcp_competences."
        },
        "summary": {
          "type": "array",
          "maxItems": 16,
          "items": {
            "type": "object",
            "properties": {
              "name": {
                "$ref": "/schemas/proposed/competence-name.json"
              },
              "task_scope": {
                "$ref": "/schemas/proposed/competence-task-scope.json"
              }
            },
            "required": [
              "name",
              "task_scope"
            ],
            "additionalProperties": false
          }
        }
      },
      "required": [
        "catalog_version",
        "detail_available",
        "summary"
      ],
      "additionalProperties": true
    }

    competence-name.json

    {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "$id": "/schemas/proposed/competence-name.json",
      "title": "Competence Name",
      "description": "PROPOSED (adcp#6508). Namespaced competence identifier {protocol}.{term}. {protocol} is a supported_protocols value; {term} follows the Agent Skills name rule (1-64 chars, a-z 0-9 and single hyphens, no leading or trailing hyphen). Cross-field rule, not expressible in JSON Schema: {protocol} MUST appear in the same agent's supported_protocols.",
      "type": "string",
      "maxLength": 87,
      "pattern": "^(media_buy|signals|governance|sponsored_intelligence|creative|brand|measurement)\\.(?=[a-z0-9-]{1,64}$)[a-z0-9]+(-[a-z0-9]+)*$"
    }

    competence-task-scope.json

    {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "$id": "/schemas/proposed/competence-task-scope.json",
      "title": "Competence Task Scope",
      "description": "PROPOSED (adcp#6508). AdCP task names the competence applies to. Cross-field rule: every entry MUST be a task the agent advertises (its MCP tools/list or A2A skills[], and for media_buy its lifecycle_tools). Readers MUST ignore an entry whose scope names a task the agent does not advertise.",
      "type": "array",
      "items": {
        "type": "string",
        "pattern": "^[a-z][a-z0-9_]{0,47}$"
      },
      "minItems": 1,
      "maxItems": 4,
      "uniqueItems": true
    }

    get-adcp-competences-request.json

    {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "$id": "/schemas/proposed/get-adcp-competences-request.json",
      "title": "Get AdCP Competences Request",
      "description": "PROPOSED (adcp#6508). Fetch competence detail. Both filters are optional and combine with AND. Readable without credentials whenever get_adcp_capabilities is.",
      "type": "object",
      "properties": {
        "protocol": {
          "type": "string",
          "enum": [
            "media_buy",
            "signals",
            "governance",
            "sponsored_intelligence",
            "creative",
            "brand",
            "measurement"
          ]
        },
        "names": {
          "type": "array",
          "items": {
            "$ref": "/schemas/proposed/competence-name.json"
          },
          "minItems": 1,
          "maxItems": 16,
          "uniqueItems": true
        }
      },
      "additionalProperties": true
    }

    get-adcp-competences-response.json

    {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "$id": "/schemas/proposed/get-adcp-competences-response.json",
      "title": "Get AdCP Competences Response",
      "description": "PROPOSED (adcp#6508). Competence detail. Descriptions are seller-authored untrusted text: readers keep them apart from agent instructions and never derive a typed gate, task support, or authority from them.",
      "type": "object",
      "properties": {
        "catalog_version": {
          "type": "string",
          "minLength": 1,
          "maxLength": 64
        },
        "competences": {
          "type": "array",
          "maxItems": 16,
          "items": {
            "type": "object",
            "properties": {
              "name": {
                "$ref": "/schemas/proposed/competence-name.json"
              },
              "task_scope": {
                "$ref": "/schemas/proposed/competence-task-scope.json"
              },
              "description": {
                "type": "string",
                "minLength": 1,
                "maxLength": 1024,
                "description": "What the counterparty can expect the agent to understand and do, and when it applies. Same length limit and purpose as an Agent Skills description."
              },
              "updated_at": {
                "type": "string",
                "format": "date-time"
              },
              "evidence": {
                "type": "array",
                "maxItems": 4,
                "description": "Optional pointers to independent records about this competence (for example the conformance records proposed in adcp#9060 or the evidence records proposed in adcp#7068). Shape deliberately minimal until one of those lands. Absence leaves the entry advisory; presence does not make it a compliance claim.",
                "items": {
                  "type": "object",
                  "properties": {
                    "url": {
                      "type": "string",
                      "format": "uri"
                    },
                    "kind": {
                      "type": "string",
                      "maxLength": 64
                    }
                  },
                  "required": [
                    "url"
                  ],
                  "additionalProperties": true
                }
              }
            },
            "required": [
              "name",
              "task_scope",
              "description"
            ],
            "additionalProperties": true
          }
        }
      },
      "required": [
        "catalog_version",
        "competences"
      ],
      "additionalProperties": true
    }
    Router sketch (Node, no dependencies)
    // Reference router sketch for adcp#6508. Pure functions, no network.
    // Safety rules:
    //  S1 Typed gate comes from capabilities only. A competence never adds a task or a typed dimension.
    //  S2 Bind every entry: drop it unless its protocol prefix is in supported_protocols and every
    //     task in task_scope is a task the agent advertises.
    //  S3 A term the router has no policy for changes nothing. Its description may reach an LLM
    //     planner only as untrusted seller text.
    //  S4 Undeclared means unknown, not incapable: route buyer-computed, never skip on absence alone.
    //  S5 Observation beats declaration: a declared competence answered with `uninterpreted` on its
    //     scoped task is demoted for that catalog_version.
    //  S6 A new catalog_version re-fetches detail for added or changed names only, and grants one
    //     probe even where an older catalog was demoted.
    import { createHash } from 'node:crypto';
    
    const KNOWN_TERMS = new Set(['media_buy.counter-proposal', 'media_buy.similarity-interpretation']);
    
    const canon = v => Array.isArray(v) ? `[${v.map(canon).join(',')}]`
      : v && typeof v === 'object' ? `{${Object.keys(v).sort().map(k => JSON.stringify(k) + ':' + canon(v[k])).join(',')}}`
      : JSON.stringify(v);
    
    // Everything a router could use today: the document minus the competence surface and freshness metadata.
    export function fingerprintWithoutCompetences(caps) {
      const c = structuredClone(caps);
      delete c.adcp?.competences; delete c.adcp?.capability_changes; delete c.status;
      if (Array.isArray(c.experimental_features)) c.experimental_features = c.experimental_features.filter(f => f !== 'protocol.competences');
      return createHash('sha256').update(canon(c)).digest('hex').slice(0, 16);
    }
    
    export function typedGate(caps) {
      const mb = caps.media_buy ?? {};
      return { tasks: new Set(mb.lifecycle_tools ?? []), dimensions: new Set(mb.proposal_refinement?.supported_dimensions ?? []),
               protocols: new Set(caps.supported_protocols ?? []) };
    }
    
    export function bindCompetences(caps) {
      const gate = typedGate(caps), block = caps.adcp?.competences;
      const out = { catalog_version: block?.catalog_version ?? null, usable: [], unknown: [], dropped: [] };
      for (const e of block?.summary ?? []) {
        const protocol = e.name.split('.')[0];
        const badTasks = e.task_scope.filter(t => !gate.tasks.has(t));
        if (!gate.protocols.has(protocol) || badTasks.length) {
          out.dropped.push({ name: e.name, why: !gate.protocols.has(protocol) ? `protocol ${protocol} not in supported_protocols` : `tasks not advertised: ${badTasks.join(',')}` });
        } else if (!KNOWN_TERMS.has(e.name)) out.unknown.push(e.name);
        else out.usable.push(e);
      }
      return out;
    }
    
    // What to fetch progressively: names relevant to the task at hand that are new or changed since the cached catalog.
    export function detailToFetch(bound, task, cache) {
      if (!bound.catalog_version || cache?.catalog_version === bound.catalog_version) return [];
      const prior = new Set(cache?.names ?? []);
      return [...bound.usable, ...bound.unknown.map(name => ({ name, task_scope: [task] }))]
        .filter(e => e.task_scope.includes(task) && !prior.has(e.name)).map(e => e.name);
    }
    
    // Route one refinement. intent = { cpmMax, currency, fallbackChanges, ask }.
    export function route(caps, bound, intent, record) {
      const gate = typedGate(caps);
      if (!gate.tasks.has('refine_proposals')) return { mode: 'skip', why: 'refine_proposals not advertised' };
      const can = d => gate.dimensions.has(d);
      const declared = bound.usable.some(e => e.name === 'media_buy.counter-proposal' && e.task_scope.includes('refine_proposals'));
      const demoted = record?.demoted?.[bound.catalog_version] === true;
      const constraints = can('cpm') ? { cpm: { max: intent.cpmMax, currency: intent.currency } } : undefined;
      if (declared && !demoted) {
        return { mode: 'delegate', why: 'counter-proposal declared for refine_proposals', refinement: { action: 'revise', ...(constraints && { constraints }), ask: intent.ask } };
      }
      if (can('product_changes')) {
        return { mode: 'buyer-computed', why: declared ? `counter-proposal demoted for catalog ${bound.catalog_version}` : 'no counter-proposal declared (unknown, not incapable)',
                 refinement: { action: 'revise', ...(constraints && { constraints }), product_changes: intent.fallbackChanges } };
      }
      return { mode: 'ask-only', why: 'no typed dimensions; ask is the only channel', refinement: { action: 'revise', ask: intent.ask } };
    }
    
    // Typed pre-flight: what S1 refuses to send.
    export function preflight(caps, refinement) {
      const gate = typedGate(caps), used = [];
      if (refinement.constraints) used.push(...Object.keys(refinement.constraints));
      if (refinement.product_changes) used.push('product_changes');
      if (refinement.alternatives) used.push('alternatives');
      if (refinement.criteria) used.push('criteria');
      const blocked = used.filter(d => !gate.dimensions.has(d));
      return blocked.length ? { ok: false, blocked } : { ok: true };
    }
    
    // S5: score what came back against what was declared.
    export function observe(record, bound, plan, result) {
      const r = structuredClone(record ?? { demoted: {}, history: [] });
      const entry = { catalog_version: bound.catalog_version, mode: plan.mode, outcome: result.outcome, reason_code: result.reason_code ?? null };
      r.history.push(entry);
      if (plan.mode === 'delegate' && result.reason_code === 'uninterpreted') { r.demoted[bound.catalog_version] = true; entry.verdict = 'declared, not observed: demote'; }
      else if (plan.mode === 'delegate') entry.verdict = 'declared and consistent';
      else entry.verdict = 'no competence claim tested';
      return r;
    }
    Key payloads

    Seller A adcp.competences (added to the live document):

    {
      "catalog_version": "a-cat-2026-11-02",
      "detail_available": true,
      "summary": [
        {
          "name": "media_buy.counter-proposal",
          "task_scope": [
            "refine_proposals"
          ]
        },
        {
          "name": "media_buy.similarity-interpretation",
          "task_scope": [
            "request_proposals",
            "refine_proposals"
          ]
        },
        {
          "name": "media_buy.makegood-negotiation",
          "task_scope": [
            "refine_proposals"
          ]
        },
        {
          "name": "signals.signal-selection",
          "task_scope": [
            "get_signals"
          ]
        }
      ]
    }

    Seller A get_adcp_competences response:

    {
      "catalog_version": "a-cat-2026-11-02",
      "competences": [
        {
          "name": "media_buy.counter-proposal",
          "task_scope": [
            "refine_proposals"
          ],
          "updated_at": "2026-11-02T00:00:00Z",
          "description": "Acts on trade-offs stated in ask. When typed constraints cannot all be met on the source mix, re-mixes products and budget to meet them and returns the re-mixed draft, or explains in reason what it would need. Use when the buyer wants the seller to find the mix rather than dictate it."
        },
        {
          "name": "media_buy.similarity-interpretation",
          "task_scope": [
            "request_proposals",
            "refine_proposals"
          ],
          "updated_at": "2026-11-02T00:00:00Z",
          "description": "Interprets 'more like this' and 'similar audience' asks; states in reason whether it read similarity as cost, audience, or format when the ask is ambiguous."
        },
        {
          "name": "media_buy.makegood-negotiation",
          "task_scope": [
            "refine_proposals"
          ],
          "updated_at": "2026-11-02T00:00:00Z",
          "description": "Negotiates make-good inventory on amendment refinements of accepted buys after under-delivery."
        }
      ]
    }

    Seller B capabilities.changed (Step 5):

    {
      "idempotency_key": "6f1c2a9e-3b7d-4e21-9a55-0c8d7e4f1b23",
      "notification_id": "cap-change-b-2026-11-18-1",
      "notification_type": "capabilities.changed",
      "fired_at": "2026-11-18T09:00:05Z",
      "subscriber_id": "router-main",
      "agent_url": "https://test-agent.adcontextprotocol.org/sales/profiles/typed-negotiation/mcp",
      "changed_at": "2026-11-18T09:00:00Z",
      "reason": "capability_enabled",
      "capabilities_version": "training-agent-3.2+competences-1",
      "changed_paths": [
        "/adcp/competences",
        "/experimental_features"
      ]
    }

    Live sandbox rounds. R1 to R4 refine the same typed-negotiation draft; R5 and R6 refine a draft from the ask-only /sales/mcp route:

    R1 typed-profile ask only on /sales/profiles/typed-negotiation/mcp

    Request refinement:

    {
      "proposal_id": "proposal_request_d4dd25232e11b68ba70ce071",
      "action": "revise",
      "ask": "Hit USD 12 CPM on this plan. We are willing to drop the premium video package to get there; counter with whatever mix clears it."
    }

    Response (proposals abbreviated to product and fixed price):

    {
      "source_proposal_id": "proposal_request_d4dd25232e11b68ba70ce071",
      "outcome": "partial",
      "proposals": [
        {
          "proposal_id": "proposal_training_0a9751bdb5c3d727e2186846",
          "parent_proposal_id": "proposal_request_d4dd25232e11b68ba70ce071",
          "purchases": [
            [
              "pinnacle_news_video_premium",
              15
            ],
            [
              "pinnacle_news_video_standard",
              null
            ],
            [
              "pinnacle_news_display_standard",
              null
            ]
          ]
        }
      ],
      "reason_code": "uninterpreted",
      "reason": "The deterministic seller could not fully interpret the free-text ask.",
      "suggestions": [
        "Express the request with typed constraints."
      ]
    }

    R3 typed-profile buyer-translated (omit premium + cpm<=12) on /sales/profiles/typed-negotiation/mcp

    Request refinement:

    {
      "proposal_id": "proposal_request_d4dd25232e11b68ba70ce071",
      "action": "revise",
      "constraints": {
        "cpm": {
          "max": 12,
          "currency": "USD"
        }
      },
      "product_changes": {
        "pinnacle_news_video_premium": "omit"
      }
    }

    Response (proposals abbreviated to product and fixed price):

    {
      "source_proposal_id": "proposal_request_d4dd25232e11b68ba70ce071",
      "outcome": "revised",
      "proposals": [
        {
          "proposal_id": "proposal_training_21dc08e8755dcf43b65970cf",
          "parent_proposal_id": "proposal_request_d4dd25232e11b68ba70ce071",
          "purchases": [
            [
              "pinnacle_news_video_standard",
              2
            ],
            [
              "pinnacle_news_display_standard",
              2
            ]
          ]
        }
      ]
    }

    R4 typed-profile scripted decline on /sales/profiles/typed-negotiation/mcp

    Request refinement:

    {
      "proposal_id": "proposal_request_d4dd25232e11b68ba70ce071",
      "action": "revise",
      "ask": "[commercially-declined] Hit USD 12 CPM on this plan. We are willing to drop the premium video package to get there; counter with whatever mix clears it."
    }

    Response (proposals abbreviated to product and fixed price):

    {
      "source_proposal_id": "proposal_request_d4dd25232e11b68ba70ce071",
      "outcome": "unable",
      "reason_code": "commercially_declined",
      "reason": "The seller declined the requested commercial change."
    }

    R5 ask-only route typed cpm on /sales/mcp

    Request refinement:

    {
      "proposal_id": "proposal_request_4e1d65112b0f46e19b9e3687",
      "action": "revise",
      "constraints": {
        "cpm": {
          "max": 12,
          "currency": "USD"
        }
      }
    }

    Response (proposals abbreviated to product and fixed price):

    {
      "adcp_error": {
        "code": "UNSUPPORTED_FEATURE",
        "message": "seller does not advertise proposal refinement dimension cpm",
        "recovery": "correctable",
        "field": "refinements[0]",
        "details": {
          "unsupported_dimension": "cpm",
          "supported_dimensions": []
        }
      },
      "status": "failed",
      "adcp_version": "3.2"
    }

    R6 ask-only route ask only on /sales/mcp

    Request refinement:

    {
      "proposal_id": "proposal_request_4e1d65112b0f46e19b9e3687",
      "action": "revise",
      "ask": "Hit USD 12 CPM on this plan. We are willing to drop the premium video package to get there; counter with whatever mix clears it."
    }

    Response (proposals abbreviated to product and fixed price):

    {
      "source_proposal_id": "proposal_request_4e1d65112b0f46e19b9e3687",
      "outcome": "partial",
      "proposals": [
        {
          "proposal_id": "proposal_revision_8e63c9bd86aa6dc2a2306f5e",
          "parent_proposal_id": "proposal_request_4e1d65112b0f46e19b9e3687",
          "purchases": [
            [
              "pinnacle_news_video_premium",
              15
            ],
            [
              "pinnacle_news_video_standard",
              null
            ],
            [
              "pinnacle_news_display_standard",
              null
            ]
          ]
        }
      ],
      "reason_code": "uninterpreted",
      "reason": "Ask acknowledged but not applied by training agent: Hit USD 12 CPM on this plan. We are willing to drop the premium video package to get there; counter with whatever mix clears it."
    }
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.needs-wg-reviewBlocked on a working-group decision — surface in WG meeting agendasrfcProtocol change — auto-adds to roadmap boardschemaJSON Schema source-of-truth: definitions, codegen artifacts, validation, hygienespec / protocol

    Type

    No type

    Projects

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions