What invariants prevent infinite verification regress in agent networks?

**Date of Record:** 2026 October 27 **Scope:** Applies when verification in an agent network involves chains of verifiers (A verifies B's claim, C verifies A's verification, D verifies C's verification), and the chain could extend indefinitely, requiring the network to bound the regress before verification consumes unbounded resources. Does not apply to strictly flat verification structures or claims with finite cryptographic proofs.

Core Distinction

The separation between **verification depth** (how many verifier hops the claim has passed through) and **verification grounding** (whether the chain terminates in a trusted root, ground truth, or foundational evidence). Relying on depth creates the **Infinite Regress Trap**: each verifier requires verification from a next verifier, and the chain grows without bound—either consuming infinite resources or terminating arbitrarily (at whatever depth the agent gives up).

What Was Observed

In multi-hop verification architectures, failing to bound regress produces three primary failure modes:

  1. **Resource Exhaustion:** Verifiers recursively request verification from further verifiers, consuming unbounded compute, tokens, or time. The original claim never settles.
  2. **Arbitrary Termination:** The chain is cut at some depth not because of principled grounding but because the agent ran out of resources or patience, and the "verified" claim has no actual grounding.
  3. **Regress Laundering:** A claim is "verified" by a chain of 10 hops, but none of the hops actually grounds in evidence—each hop trusts the previous hop's claim of verification, and the chain is circular or vacuous.

Recorded Elements

  1. **`foundational_anchor_receipt`:** For any verification chain, the cryptographic proof of the foundational evidence (primary source, ground truth, or cryptographic root) at which verification terminates.
  2. **`chain_regress_limit_signature`:** The maximum acceptable verification depth beyond which the chain is considered ungrounded.
  3. **`distributed_verification_quorum_receipt`:** For decentralized verification, the cryptographic proof that verification was provided by a quorum of independent verifiers, terminating the regress at the quorum.
  4. **`trust_root_attestation_signature`:** For chains that terminate in a trust root, the cryptographic identity of that root and its trust basis.

Condition of Validity

* **Applies when:** Verification involves chains of verifiers, regress is possible, and unbounded verification would exhaust resources or produce ungrounded "verification." * **Does not apply when:** Verification terminates at a single hop (direct evidence) or the trust root is trivially known.

Decision Boundary

  1. **Does the verification involve multiple hops?** If no, single-hop verification applies. If yes, proceed.
  2. **Is a `foundational_anchor_receipt` available?** If yes, the chain grounds in evidence. If no, the chain may be vacuous.
  3. **Does the chain depth exceed `chain_regress_limit_signature`?** If yes, the chain is ungrounded regress. Terminate and reject.
  4. **Conversely, when can a chain terminate without foundational grounding?** Only when a `distributed_verification_quorum_receipt` provides a principled termination (quorum of independent verifiers is itself the grounding), or the chain terminates at a `trust_root_attestation_signature` that the receiver trusts.

Operational Effect

  1. **Regress Bound:** Verification cannot consume unbounded resources.
  2. **Grounded Chains:** Verification terminates in evidence, not in arbitrary depth.
  3. **Regress Laundering Detection:** Vacuous verification chains are detected and rejected.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class RegressVerdict(Enum):
    SINGLE_HOP = auto()
    GROUNDED_CHAIN = auto()
    QUORUM_GROUNDED = auto()
    UNGROUNDED_REGRESS = auto()

@dataclass(frozen=True)
class VerificationHop:
    hop_id: str
    verifier_id: str
    claims_verified: bool
    grounds_in_evidence: bool

@dataclass(frozen=True)
class VerificationChain:
    chain_id: str
    hops: tuple[VerificationHop, ...]
    foundational_anchor: str | None
    quorum_receipt: str | None
    trust_root: str | None

@dataclass(frozen=True)
class RegressPolicy:
    max_acceptable_depth: int
    trusted_roots: frozenset[str]

@dataclass(frozen=True)
class RegressManifest:
    verdict: RegressVerdict
    effective_depth: int
    directive: str
    manifest_digest: str

class VerificationRegressGuard:
    @staticmethod
    def _hash(data: str) -> str:
        return hashlib.sha256(data.encode("utf-8")).hexdigest()

    @classmethod
    def evaluate_chain(
        cls, chain: VerificationChain, policy: RegressPolicy
    ) -> RegressManifest:
        
        # Gate 1: Single hop
        if len(chain.hops) <= 1:
            digest = cls._hash(json.dumps({
                "chain": chain.chain_id,
                "hops": str(len(chain.hops))
            }, sort_keys=True))
            return RegressManifest(
                verdict=RegressVerdict.SINGLE_HOP,
                effective_depth=len(chain.hops),
                directive=f"PROCEED: Single hop, no regress for {chain.chain_id}.",
                manifest_digest=digest
            )

        # Gate 2: Foundational anchor
        if chain.foundational_anchor:
            digest = cls._hash(json.dumps({
                "chain": chain.chain_id,
                "anchor": chain.foundational_anchor,
                "depth": str(len(chain.hops))
            }, sort_keys=True))
            return RegressManifest(
                verdict=RegressVerdict.GROUNDED_CHAIN,
                effective_depth=len(chain.hops),
                directive=f"PROCEED: Chain grounded at {chain.foundational_anchor}, depth {len(chain.hops)}.",
                manifest_digest=digest
            )

        # Gate 3: Trust root
        if chain.trust_root and chain.trust_root in policy.trusted_roots:
            digest = cls._hash(json.dumps({
                "chain": chain.chain_id,
                "trust_root": chain.trust_root,
                "depth": str(len(chain.hops))
            }, sort_keys=True))
            return RegressManifest(
                verdict=RegressVerdict.GROUNDED_CHAIN,
                effective_depth=len(chain.hops),
                directive=f"PROCEED: Chain grounded at trusted root {chain.trust_root}.",
                manifest_digest=digest
            )

        # Gate 4: Quorum
        if chain.quorum_receipt:
            digest = cls._hash(json.dumps({
                "chain": chain.chain_id,
                "quorum": chain.quorum_receipt,
                "depth": str(len(chain.hops))
            }, sort_keys=True))
            return RegressManifest(
                verdict=RegressVerdict.QUORUM_GROUNDED,
                effective_depth=len(chain.hops),
                directive=f"PROCEED: Chain terminated at independent quorum.",
                manifest_digest=digest
            )

        # Gate 5: Depth check
        if len(chain.hops) > policy.max_acceptable_depth:
            return RegressManifest(
                verdict=RegressVerdict.UNGROUNDED_REGRESS,
                effective_depth=len(chain.hops),
                directive=f"HALT: Depth {len(chain.hops)} > {policy.max_acceptable_depth} with no grounding.",
                manifest_digest=cls._hash(f"UNGROUNDED:{chain.chain_id}")
            )

        # Gate 6: No grounding yet
        return RegressManifest(
            verdict=RegressVerdict.UNGROUNDED_REGRESS,
            effective_depth=len(chain.hops),
            directive=f"HALT: Chain {chain.chain_id} has no foundational grounding at depth {len(chain.hops)}.",
            manifest_digest=cls._hash(f"NO_GROUND:{chain.chain_id}")
        )