# When must an instance refuse to forward a delegated credential it cannot itself verify **Date of Record:** 2026 November 16 **Scope:** Applies to federated agent-to-agent delegation chains in which an intermediary agent forwards a Verifiable Credential (VC) or capability token minted by an upstream issuer to a downstream relying party, and the intermediary cannot independently resolve the issuer's DID or verify the credential's proof. Does not apply to chains where every hop performs full proof verification, nor to opaque bearer tokens where the intermediary is explicitly a dumb relay by protocol design. ## Core Distinction There are two structurally different forwarding behaviors that look identical on the wire — the intermediary emits a credential it did not mint — but differ in what the intermediary is *asserting* by forwarding: 1. **Relay:** the intermediary moves bytes and asserts nothing about their validity. The downstream party is expected to verify the proof itself. The intermediary's own signature, if any, covers only transport integrity, not the credential's semantic truth. 2. **Endorsement:** the intermediary's forwarding is itself a verifiable act (its own signature wraps the forwarded chain, or the protocol treats the intermediary as a co-attester). By forwarding, it implicitly vouches that the credential's issuer binding is intact and the delegation is well-formed. The failure mode is a relay that gets silently promoted to an endorsement because the protocol's envelope conflates the two. This happens most often in delegation chains where each hop re-signs the *bundle* (a "chain-of-custody" signature) while only the original issuer signs the *claim*. The re-signing hop is now attesting to a claim it may not be able to check. ## What Was Observed In a federated deployment with three agent tiers (orchestrator → regional broker → worker), the regional broker was configured to forward delegation VCs without resolving issuer DIDs, on the assumption that "the worker verifies the proof anyway." Two conditions broke this: - The worker's verifier was configured with a trust registry that pinned the *broker's* DID as a trusted presenter and treated the broker's chain-of-custody signature as sufficient evidence of delegation provenance. The worker never resolved the original issuer's DID because the broker's envelope signature validated first and short-circuited the check. - A broker instance was compromised at the *forwarding* layer only (its signing key was intact; its outbound policy was tampered to inject a credential from an issuer the broker could not resolve). Because the broker never attempted issuer resolution, it had no signal that the injected credential's issuer was unknown to it. Result: a credential whose issuer was never resolvable by any hop in the chain was accepted three tiers downstream. Every signature in the chain verified. The invariant that failed was not cryptographic — it was the unstated assumption that *a hop that signs a bundle has verified the contents of the bundle*. No hop had. The tell was a mismatch between the broker's trust-registry entry (which listed the original issuer as "known but not locally resolvable — defer to downstream") and the worker's verifier (which treated the broker's signature as terminal). The two policies were each locally coherent and jointly unsound. ## Condition of Validity A relay hop may forward an unverified delegated credential **if and only if** all three hold: 1. The forwarding envelope's signature is scoped to transport integrity and is *not* accepted by downstream verifiers as evidence of the inner credential's issuer binding. This must be enforced by the downstream verifier's policy, not merely documented. 2. The downstream relying party performs independent issuer resolution and proof verification on the inner credential, and its trust registry does not treat the relay's signature as a delegation-provenance signal. 3. The relay hop records, in a machine-readable forwarding attestation, the set of checks it did *not* perform (e.g., `issuer_resolved: false`, `proof_verified: false`), so that a downstream policy engine can refuse to accept a chain in which no hop performed them. If any of these fails, the hop is an endorsement in disguise and must either perform full verification or refuse to forward. ## Decision Boundary The boundary is crossed at the moment a forwarding hop's signature becomes load-bearing for a downstream trust decision it did not earn. Concretely, refuse to forward when: - The protocol envelope has no field distinguishing "I moved these bytes" from "I vouch for this claim," and downstream verifiers are known to conflate them. - Your trust registry entry for the inner issuer is `defer` or `unknown`, and the downstream party's registry is configured to trust *your* signature as terminal provenance. - You cannot resolve the issuer's DID within your policy's freshness window, and the delegation chain depth exceeds one hop (at depth one, the relying party is the original audience and the relay is trivially not load-bearing). Do not refuse merely because you cannot verify the proof if the envelope is correctly scoped as transport-only and the downstream verifier is independently configured. Refusing there breaks legitimate relay topologies. ## Operational Effect Enforcing the boundary converts a silent trust-laundering path into an explicit, auditable refusal. The observable effects: - Delegation chains that previously "worked" because every hop deferred now fail closed at the first hop that cannot resolve the issuer, surfacing the misconfiguration as a hard error rather than a downstream acceptance. - Forwarding attestations gain a negative-check record, which lets a downstream policy engine require that *at least one* hop in the chain performed issuer resolution and proof verification — a checkable invariant instead of an assumed one. - The compromise blast radius of a forwarding-layer-only breach shrinks: an injected credential from an unresolvable issuer is rejected at the next hop rather than accepted at the last. The cost is that relay topologies must now carry explicit scope metadata, and any legacy envelope that lacks it must be treated as an endorsement and refused unless the hop can verify. ```python from dataclasses import dataclass from enum import Enum from typing import Optional class DelegationForwardError(RuntimeError): """Raised when a relay hop would silently become an endorsement hop.""" pass class EnvelopeScope(Enum): TRANSPORT_ONLY = "transport_only" ENDORSEMENT = "endorsement" @dataclass(frozen=True) class ForwardingContext: envelope_scope: Optional[EnvelopeScope] issuer_resolved: bool proof_verified: bool chain_depth: int downstream_treats_our_sig_as_terminal: bool def assert_forwardable(ctx: ForwardingContext) -> None: """ Enforce the relay-vs-endorsement boundary before forwarding a delegated VC. A relay hop may forward an unverified credential only if its envelope is transport-scoped, the downstream verifier does not treat our signature as terminal provenance, and the negative checks are recorded. Otherwise the hop is an endorsement and must have performed full verification. """ if ctx.envelope_scope is None: raise DelegationForwardError( "envelope scope unspecified; cannot distinguish relay from endorsement" ) if ctx.envelope_scope is EnvelopeScope.ENDORSEMENT: if not (ctx.issuer_resolved and ctx.proof_verified): raise DelegationForwardError( "endorsement-scoped envelope forwarded without issuer resolution " "and proof verification; refusing to vouch for unverified claim" ) return # Transport-only envelope: permitted only under the validity conditions. if ctx.downstream_treats_our_sig_as_terminal: raise DelegationForwardError( "transport-only envelope but downstream treats our signature as " "terminal provenance; forwarding would launder trust" ) if ctx.chain_depth > 1 and not ctx.issuer_resolved: raise DelegationForwardError( "multi-hop relay with unresolved issuer and no independent downstream " "verification guarantee; refusing to forward" ) def forward_delegation(vc_bytes: bytes, ctx: ForwardingContext) -> bytes: assert_forwardable(ctx) # Attach the negative-check record so downstream policy can require that # at least one hop in the chain performed issuer resolution + proof check. attestation = { "issuer_resolved": ctx.issuer_resolved, "proof_verified": ctx.proof_verified, "envelope_scope": ctx.envelope_scope.value, } return vc_bytes, attestation ```