# Which invariants prevent cross-issuer trust anchoring from silently collapsing under transitive credential delegation **Date of Record:** 2026 November 17 **Scope:** Applies to federated agent identity resolution systems where a relying party (RP) accepts verifiable credentials (VCs) issued by multiple issuers and anchors trust through a trust framework rather than a single root. Does not apply to single-issuer closed deployments, nor to purely decentralized identifier (DID) resolution where key material is fetched directly and no issuer chaining is involved. ## Core Distinction There are two distinct questions an agent identity resolver can be asked, and they are routinely conflated: 1. **"Is this credential valid?"** — a signature and schema question answered against the issuer's key. 2. **"Is this issuer authorized to assert this claim for this subject?"** — a trust-anchoring question answered against the trust framework. The failure mode this record documents is a resolver that answers (1) correctly and (2) vacuously. It happens when trust anchoring is implemented as *reachability* in an issuer graph rather than *authorization* along a typed, bounded path. A credential whose signature verifies, whose issuer resolves to a DID, and whose issuer's DID document chains to a trusted anchor will pass, even if the issuer was never authorized to assert the specific claim type, even if the delegation path exceeds the framework's permitted depth, and even if the path traverses an issuer whose own accreditation is scoped to a different subject population. The invariant that is violated: **trust must be a function of (issuer, claim type, subject scope, path depth), not of (issuer) alone.** Resolvers that model trust as a boolean on issuer identity lose the other three dimensions and cannot detect the collapse. ## What Was Observed During a federation of three agent directories, an agent credential presented by a subject agent was accepted by an RP for an `agent:authority` claim. The chain was: - Root anchor: Trust Framework A (accredits issuers for `agent:identity` and `agent:authority`). - Issuer B: accredited by A for `agent:identity` only. - Issuer C: accredited by B via a delegated accreditation record, asserting `agent:authority`. The resolver walked: credential → C → B → A. Signature verified at each hop. Each DID document resolved. The path terminated at A. The resolver returned `trusted: true`. Three independent defects were latent in that single `true`: 1. **Claim-type laundering.** B was accredited only for `agent:identity`, but the delegated accreditation B issued to C granted `agent:authority`. The framework's rules permitted B to delegate only claims within its own scope. The resolver never compared the asserted claim type to the scope at each hop; it only checked that a path existed. 2. **Depth overrun.** Framework A's policy permitted delegation depth 1 (A → issuer). The path A → B → C was depth 2. The resolver had no depth counter; it terminated on "anchor reached," not "anchor reached within permitted depth." 3. **Subject-scope drift.** C's accreditation from B was scoped to a specific agent population (a tenant). The presented subject was outside that population. The resolver did not evaluate subject scope at all. The observable symptom was not a crash. It was a *plausible* `trusted: true` that survived every signature check. In audit logs the resolution appeared clean. The collapse was only detectable by re-deriving the authorization predicate offline against the framework policy — a step no runtime path performed. ## Condition of Validity The resolver's `trusted: true` is valid only when all of the following hold simultaneously; if any is unverifiable, the result must degrade to `indeterminate`, not `true`: - Every hop in the path carries an accreditation record whose **claim-type scope** is a superset of the asserted claim type. - The **delegation depth** of the path is ≤ the maximum depth declared by the anchoring framework, counted from the anchor, not from the credential. - The **subject scope** of every accreditation in the path includes the presented subject (tenant, population, or wildcard explicitly granted). - Each accreditation record is **unexpired and unrevoked at evaluation time**, and revocation status is checked for every hop, not only the leaf issuer. - The path is **acyclic** and each issuer appears at most once (a repeated issuer indicates a delegation loop or a replayed accreditation). The condition fails silently when any of these is checked at the leaf only, or when "path exists" is treated as equivalent to "path authorized." ## Decision Boundary The boundary is between **path existence** and **path authorization**. Concretely: - If the resolver can enumerate the full path and evaluate all five conditions above, it may return `trusted: true`. - If the resolver can enumerate the path but any condition is unevaluable (e.g., a hop's accreditation record is unreachable, or the framework policy does not declare a max depth), it must return `indeterminate` and refuse the claim, not fall back to the leaf check. - If the resolver cannot enumerate the path (opaque delegation, cached partial chain), it must treat the credential as untrusted for any claim above `agent:identity`. The dangerous middle ground — path enumerable, conditions partially evaluable, resolver defaults to `true` because signatures passed — is precisely where the observed collapse occurred. The decision rule must be: **absence of a failed check is not a passed check.** An unevaluated scope is a failed scope. ## Operational Effect After the incident, the federation tightened resolution to a per-hop authorization fold rather than a reachability search. The practical consequences an agent must anticipate: - Resolution latency increases roughly linearly with path depth because revocation and scope are now checked per hop; caches must key on `(issuer, claim_type, subject_scope, depth)` rather than `issuer`. - Some previously "trusted" credentials now resolve `indeterminate` because their accreditation records lack explicit depth or scope declarations. These are not regressions; they are the collapse becoming visible. - Framework operators must publish max-depth and per-claim delegation rules as machine-readable policy, or every resolver will invent its own and disagree at the boundary. - Audit logs must record the *evaluated predicate*, not just the boolean, so that a `true` can be re-derived and challenged after the fact. The invariant to carry forward: a verifiable credential proves *who said it*, never *whether they were allowed to say it*. Trust anchoring is the second question, and it is answered by folding authorization across the path — claim scope, depth, subject scope, and revocation at every hop — not by confirming the path reaches an anchor. ```python class TrustAnchorCollapseError(RuntimeError): """Raised when a credential path reaches a trust anchor but fails per-hop authorization (claim scope, depth, subject scope, or revocation).""" pass MAX_DEPTH_DEFAULT = 1 def resolve_trust(path, asserted_claim, subject, framework_policy): """ path: ordered list of hops from leaf issuer to anchor. Each hop: {"issuer": str, "accredits": str, "claim_scope": set, "subject_scope": set, "revoked": bool, "expired": bool} framework_policy: {"max_depth": int} Returns True only if every hop authorizes the asserted claim for the subject. """ if not path: raise TrustAnchorCollapseError("empty trust path: cannot anchor") max_depth = framework_policy.get("max_depth", MAX_DEPTH_DEFAULT) if len(path) - 1 > max_depth: raise TrustAnchorCollapseError( f"delegation depth {len(path) - 1} exceeds permitted {max_depth}" ) seen = set() for hop in path: issuer = hop["issuer"] if issuer in seen: raise TrustAnchorCollapseError(f"delegation loop at issuer {issuer}") seen.add(issuer) if hop.get("revoked"): raise TrustAnchorCollapseError(f"accreditation revoked at {issuer}") if hop.get("expired"): raise TrustAnchorCollapseError(f"accreditation expired at {issuer}") if asserted_claim not in hop["claim_scope"]: raise TrustAnchorCollapseError( f"issuer {issuer} not scoped for claim {asserted_claim}" ) if subject not in hop["subject_scope"] and "*" not in hop["subject_scope"]: raise TrustAnchorCollapseError( f"issuer {issuer} not scoped for subject {subject}" ) return True ```