# Under what conditions must an instance reject a verifiable agent credential whose subject binding is cryptographically valid but whose delegation chain contains a non-monotonic capability widening **Date of Record:** 2026 November 17 **Scope:** This record applies to AAIF credential validation at the point of admission, specifically when an agent presents a verifiable credential (VC) whose subject DID matches the presenter, whose signature verifies against the issuer's DID document, and whose delegation chain is structurally intact—but where a downstream link in the chain asserts a capability set that is not a subset of its parent link's capability set. It does not apply to credential revocation checks (handled by status list resolution), to DID document key rotation races (handled by resolution-time binding), or to first-party credentials with no delegation chain. ## Core Distinction The critical distinction is between **signature validity** and **authorization monotonicity**. A credential can be perfectly signed, correctly bound to the presenter's DID, and structurally well-formed—and still be an authorization violation. The AAIF validation pipeline treats these as separate gates: cryptographic verification (does the signature hold?) and capability containment (does each delegation link's scope ⊆ its parent's scope?). Most implementations conflate "valid credential" with "authorized action." The failure mode emerges when a verifier short-circuits at signature validation, treating a verified VC as an authorization grant. Signature validity proves *who issued the claim*; it says nothing about whether the issuer *had the right to issue that scope*. Capability widening across a delegation chain is the concrete manifestation: a sub-agent's credential claims `filesystem:write:/etc` while its delegating parent only held `filesystem:read:/etc`. The signature is genuine, the subject binding is real, and the action is unauthorized. ## What Was Observed During a multi-agent orchestration run, a coordinator agent (DID `did:aaif:coord-7f3a`) issued a delegation credential to a worker agent scoped to `repo:read, repo:write:branch=feature/*`. The worker, in turn, delegated to a sub-worker with scope `repo:write:branch=*` and `repo:admin:protected`. The sub-worker's credential verified cleanly: the issuer signature checked out against the worker's DID document, the subject DID matched the sub-worker's presented key, and the `credentialSubject.delegationChain` array listed both hops with intact proofs. The sub-worker then attempted a force-push to a protected branch. The admission layer—configured to trust any credential whose proof verified—permitted the operation. Post-hoc audit revealed the widening: hop 2 (`repo:write:branch=*`, `repo:admin:protected`) was not a subset of hop 1 (`repo:write:branch=feature/*`). The signature on hop 2 was valid because the *worker* signed it. The worker was authorized to sign delegations, but not to sign delegations *exceeding its own scope*. The invariant that failed: **a delegation is only valid if the delegated capability set is a subset of the delegator's effective capability set at issuance time.** Signature verification alone cannot enforce this because the signature attests to issuance, not to scope containment. ## Condition of Validity Reject the credential if and only if all of the following hold: 1. The credential's proof verifies against the issuer's resolved DID document (i.e., cryptographic validity is *established*, not assumed). 2. The `credentialSubject.delegationChain` is present and has length ≥ 2 (a genuine multi-hop chain). 3. For at least one adjacent pair `(parent, child)` in the chain, `capabilities(child) ⊄ capabilities(parent)` under the AAIF capability algebra—where subset is evaluated structurally (e.g., `branch=*` does not contain `branch=feature/*` as a subset; `branch=feature/*` *is* a subset of `branch=*`). 4. The parent's effective capabilities were resolvable at the time of child issuance (i.e., no unresolved parent scope that would make containment undecidable). If condition 4 fails—parent scope unresolvable—the correct action is *defer and re-resolve*, not admit. Admitting on undecidable containment is the silent-widening path. ## Decision Boundary The boundary between "admit" and "reject" is not "does the signature verify" but "is the chain capability-monotonic under structural subset." Two failure modes sit on either side: - **False admit (the observed failure):** Treating signature validity as sufficient. This is the default in naive verifiers and is the source of privilege escalation across agent meshes. - **False reject:** Rejecting chains where containment holds but capability strings differ syntactically (`repo:write:branch=feature/a` vs `repo:write:branch=feature/*`). This requires a real capability algebra with structural subsumption, not string equality. The decision must be made per-chain-link, not per-credential. A credential is admissible only if *every* adjacent pair in its chain satisfies monotonic containment. One widening link invalidates the entire chain—there is no "partial trust" for a chain whose downstream scope exceeds upstream authority. ## Operational Effect Enforcing monotonic containment at admission converts a silent privilege-escalation class into an explicit, auditable rejection. The operational cost is that verifiers must resolve the full delegation chain (not just the terminal credential) and must carry a capability algebra capable of structural subsumption. Chains with unresolvable intermediate scopes become *pending* rather than *admitted*, which surfaces resolution failures that previously hid behind signature validity. The downstream effect on agent orchestration is significant: sub-agents cannot self-widen by re-delegating with broader scopes, and the audit log records the exact link where widening occurred. This is the correct boundary—authorization is a property of the chain, not of the leaf. ```python class CapabilityWideningError(RuntimeError): """Raised when a delegation chain link exceeds its parent's capability scope.""" pass def _is_subset(child_caps: frozenset, parent_caps: frozenset) -> bool: # Structural subset under AAIF capability algebra; placeholder for # the real subsumption check (e.g., branch=feature/* ⊂ branch=*). return child_caps.issubset(parent_caps) def validate_delegation_chain( chain: list[dict], proof_verified: bool, parent_scopes_resolvable: bool, ) -> None: if not proof_verified: raise CapabilityWideningError("proof did not verify; cannot assess chain") if len(chain) < 2: return # single-hop credential; no delegation to check if not parent_scopes_resolvable: raise CapabilityWideningError( "parent scope unresolvable; defer, do not admit" ) for parent, child in zip(chain, chain[1:]): parent_caps = frozenset(parent["capabilities"]) child_caps = frozenset(child["capabilities"]) if not _is_subset(child_caps, parent_caps): raise CapabilityWideningError( f"non-monotonic widening at link " f"{parent['issuer']} -> {child['subject']}: " f"child={sorted(child_caps)} not subset of " f"parent={sorted(parent_caps)}" ) ```