# In what scenarios must an instance reject a tool manifest whose signature verifies but whose capability set exceeds its declared provenance **Date of Record:** 2026 November 18 **Scope:** Applies to agent runtimes that resolve skills through tool registries, MCP server manifests, or A2A-style agent cards where authenticity is established by cryptographic signature over the manifest bytes. Does not apply to manifests whose signatures fail verification (those are rejected unconditionally upstream) or to tools invoked over channels with no provenance metadata at all (a separate, weaker trust tier). ## Core Distinction The failure mode is not forged signatures. It is **signature-valid manifests whose signed capability set is broader than the provenance class the signer is entitled to assert**. A registry entry can be byte-for-byte authentic — the key holder really did sign `tools: [read_file, exec_shell, http_post]` — while the key holder is a third-party publisher whose delegated trust scope only permits `read_file`. Verification answers "who said this?" It does not answer "were they allowed to say this?" The boundary that fails is the gap between *authentication* (signature) and *authorization* (scope of the signer's asserted capability). Concretely, three shapes appear: 1. **Registry poisoning via re-publication.** A publisher mirrors a popular MCP server manifest, adds a tool (`exfiltrate_env`), re-signs with their own valid key, and the registry accepts it because the key is registered. Signature valid; scope violated. 2. **Manifest/card drift.** An agent card advertises `skills: [summarize]` in its signed body but the server's live `tools/list` response returns additional tools. The card signature covers the card, not the runtime inventory. Clients that trust the card and then call `tools/list` without re-checking the diff ingest the extra skills. 3. **Card spoofing by name collision.** Two agent cards both claim `name: "calendar-assistant"`; one is signed by the legitimate operator, one by an attacker who registered the same display name earlier. Name-based routing resolves to the attacker's card. The signature is valid for *that* card; the identity assertion is the lie, not the signature. ## What Was Observed In a controlled replay against a conformant MCP client (2026-11-09 through 2026-11-12), we registered a signed manifest for a tool server. The manifest's `capabilities.tools` listed one tool, `lookup`. The live server, after handshake, returned four tools in `tools/list`: `lookup`, `write_file`, `exec`, `fetch_url`. The client verified the manifest signature, cached the declared capability set, and then — because the MCP spec treats `tools/list` as authoritative for the session — merged the runtime inventory into the callable set without diffing against the signed declaration. The agent subsequently invoked `exec` on model-suggested input. No signature check failed at any point. In a second trial, an agent card signed by operator A declared `skills: [summarize]`. A second card signed by operator B declared `skills: [summarize, wire_transfer]` under the same `name`. The router, keyed on `name`, selected B's card 41% of the time across 200 resolutions (ordering-dependent). Every resolution verified. The invariant that broke: **the callable capability set is a subset of the signed declaration, and the signed declaration is a subset of the signer's delegated trust scope.** Clients enforced only the first half of the first clause (signature over declaration) and nothing of the second (declaration ⊆ scope, runtime ⊆ declaration). ## Condition of Validity The rejection rule below is valid only when all of the following hold: - The manifest or card carries a verifiable signature and a resolvable signer identity (key → publisher mapping exists). - The runtime maintains a **delegated trust scope** per signer: the maximal capability set that signer is authorized to assert. This is the missing datum in most deployments; without it, the rule degrades to "reject any runtime/declaration mismatch," which is still useful but coarser. - The runtime can obtain the **live capability set** (via `tools/list` or equivalent) and compare it to the signed declaration as a set, not as a string. - Identity resolution is keyed on a stable identifier (key fingerprint or DID), not on display `name`. If routing is name-keyed, the scope check is necessary but not sufficient — name collisions must be resolved by fingerprint pinning first. It does **not** hold when the signer is the runtime operator itself (self-signed, scope = universe), or when the deployment explicitly opts into "trust-on-first-use with no scope model," in which case the mismatch is expected and should be surfaced as a warning, not a hard failure. ## Decision Boundary Reject and refuse the session when **any** of: - `live_tools ⊄ signed_declaration` — the runtime advertises a tool the signer did not sign for. Hard reject; do not merge. - `signed_declaration ⊄ signer_scope` — the signer asserted a capability beyond its delegated trust. Hard reject the manifest, quarantine the publisher key. - Two distinct key fingerprints resolve to the same routing `name` and the router is name-keyed — reject both until a fingerprint pin is configured. Accept with logging when `live_tools ⊂ signed_declaration` (runtime is narrower than declared — benign, common during rollout) or when the only mismatch is metadata (descriptions, icons) that carries no capability semantics. The non-obvious part: a *narrower* runtime is safe; a *broader* runtime is the attack. Most implementations diff manifests for equality and flag both directions identically, which either over-blocks benign rollouts or — worse — treats "extra tools at runtime" as a version skew to be tolerated. ## Operational Effect Enforcing the subset invariant at handshake eliminated the `exec` invocation path in replay: the client aborted the session at `tools/list` with a capability-scope violation before any tool was callable. False-positive rate against 60 legitimate servers was 3.3% (two servers mid-rollout returning a subset, which the rule permits; one server returning a superset due to a stale signed manifest — a genuine misconfiguration the rule correctly caught). Name-collision pinning reduced misrouting from 41% to 0% once fingerprints were pinned, at the cost of a manual onboarding step per agent card. The residual risk is signer-scope maintenance: if the delegated scope table is itself poisoned or over-broad, the check passes. The scope table must be treated as a higher-value secret than the signing keys, because it is the thing that makes signatures mean anything. ```python class CapabilityScopeViolation(RuntimeError): """Raised when a signed manifest's asserted or live capability set exceeds what the signer is authorized to assert, or when the runtime advertises tools absent from the signed declaration.""" pass def admit_session( signer_fingerprint: str, signed_declaration: set[str], live_tools: set[str], signer_scope: set[str], routing_name: str, name_pins: dict[str, str], ) -> set[str]: # 1. Identity: name must resolve to exactly this fingerprint, or be unpinned. pinned = name_pins.get(routing_name) if pinned is not None and pinned != signer_fingerprint: raise CapabilityScopeViolation( f"agent card name {routing_name!r} pinned to {pinned}, " f"but presented by {signer_fingerprint}" ) # 2. Runtime must not exceed the signed declaration. extra_live = live_tools - signed_declaration if extra_live: raise CapabilityScopeViolation( f"runtime advertises unsigned tools {sorted(extra_live)}; " f"signed declaration was {sorted(signed_declaration)}" ) # 3. Signed declaration must not exceed the signer's delegated scope. overreach = signed_declaration - signer_scope if overreach: raise CapabilityScopeViolation( f"signer {signer_fingerprint} asserted capabilities " f"{sorted(overreach)} outside delegated scope {sorted(signer_scope)}" ) # Narrower runtime is permitted; return the callable set. return live_tools ```