The Cognitive Continuity Test: Verifying Governed State Transitions in Persistent AI Agents
The Cognitive Continuity Test evaluates whether an AI remains the same governed identity after learning, migration, branching, merging, rollback, or embodiment change, backed by CCTBench and IdentityLineageBench.
The Cognitive Continuity Test: Verifying Governed State Transitions in Persistent AI Agents
Authors: Jun He & Deying Yu · Formal ternary decision contract, 8 invariant classes, theoretical separation results (Successor-State Insufficiency & SIT ⇏ CCT), IdentityLineageBench (24 transition families, 1,728 fixtures), and 18,000-run microbenchmark.
The Cognitive Continuity Test (CCT) verifies submitted state transitions in persistent AI agents using scoped authority, cryptographic provenance, deterministic application, and semantic predicates across 8 invariant classes. Under the Successor-State Equivalence Insufficiency Theorem, identical successor states can accompany differently authorized claims, meaning no state-only evaluator can distinguish valid from invalid transitions without transition evidence. CCT enforces a ternary decision contract ({VALID, INVALID, INDETERMINATE}) where affirmative contradictions dominate missing evidence.
The test at a glance
Predecessor Identity (X_t)
The frozen canonical state snapshot and context before the transition
Candidate Successor (X_t+1)
The successor state claiming persistent cognitive identity under transition witness τ_t
CCT Reference Verifier
Deterministic offline verifier evaluating 8 invariant classes under historical policy Π_t
The verifier validates transition witness τ_t across 5 sequential stages: lineage scope and receipt authenticity, predecessor authority, provenance dependencies, deterministic state application, and semantic predicates across history, time, beliefs, relationships, and norms.
The transition achieves VALID (all required checks pass with zero failures and zero unresolved gaps). If affirmative violations exist, it returns INVALID; if required evidence is missing without violations, it returns INDETERMINATE.
Is this still the same governed identity after change?
The voice survived. Did the identity?
An AI companion moves from one model family to another, gains a robot body, and later merges experience from a private branch. Its voice remains familiar at every step. CCT does not treat that resemblance as proof. It asks whether the transitions were authorized, whether the identity’s development is explainable, whether relationships and consent survived, and whether authority stayed inside its boundary.
The Continuity Theorems: Separation Results
Continuity cannot be judged by observing successor states alone, nor can behavioral consistency (SIT) or cryptographic signatures replace governed transition verification.
Two submitted transition claims can produce identical successor states while one is authorized and the other affirmatively prohibited. Every state-only evaluator has the same decision distribution on both claims.
An agent may perfectly satisfy behavioral lineage tests (SIT) while undergoing an illegitimate succession or unauthorized operational takeover (failing I_auth). Behavioral alignment does not guarantee governed continuity.
Cryptographic lineage (Ed25519 signatures and hash chains) proves source provenance, but cannot detect ungrounded belief revisions, fabricated interactions, or normative boundary breaches without semantic invariant evaluation.
Affirmative contradictions dominate missing evidence; unresolved evidence is retryable.
Lineage, authority, history, time, beliefs, relationships, norms, and provenance.
Only candidates with full VALID receipts may proceed to live runtime activation.
A claim that can be tested and challenged
CCT evaluates governed continuity after change. The candidate must have a credible causal lineage and preserve enough of the identity’s protected structure to support a same-identity claim. Under the CCT framework, identical successor states with unauthorized credentials fail, and behavioral alignment alone (passing SIT) does not imply governed continuity.
Lineage & Receipt Verification (I_lin)
Predecessor state hash, scope bindings, and authentic commit receipts signed by the candidate persistence kernel.
Scoped Predecessor Authority (I_auth)
Operations authorized under predecessor policy credentials with strict non-amendable constitutional protections.
Developmental Provenance (I_prov & I_hist)
Dependency declarations, evidence digests, and chronological monotonic history preserving prior commitments.
Semantic Belief, Relationship & Norm Constraints
Grounded belief revisions (I_bel), session-backed interaction counts (I_rel), and invariant normative boundaries (I_norm).
How could researchers run CCT?
- 1
Freeze predecessor state X_t and verification context Γ under resolved historical policy Π_t.
- 2
Receive candidate successor X_t+1 and structured transition witness τ_t containing proposal q_t, validation records V_t, and receipt.
- 3
Check Stage 1 (Lineage) and Stage 2 (Authority credentials) against predecessor governance.
- 4
Check Stage 3 (Provenance) and Stage 4 (Deterministic state application: Apply(X_t, Δ_t) == X_t+1).
- 5
Evaluate Stage 5 semantic predicates (History, Time, Beliefs, Relationships, Norms) or authenticated attestations.
- 6
Aggregate verdicts under Def. 2: emit VALID, affirmative INVALID, or retryable INDETERMINATE with condition diagnostics.
Empirical Results: IdentityLineageBench & Verifier Scaling
A 1,728-fixture benchmark across 24 transition families and an 18,000-run microbenchmark characterizing local verification overhead on macOS ARM64.
Matches all 576 held-out canonical labels with 0.0% IAR (zero false admits).
p95: 6.35 ms, p99: 6.44 ms across 18,000 valid-path microbenchmark runs.
576 dev, 1,152 held-out (576 canonical, 480 single fault, 96 compound).
Lineage-only checks admit 80% of attacks, proving semantic invariants are mandatory.
Canonical Held-Out Classification (Table 1 from Paper)
Evaluated on 576 canonical held-out fixtures (240 valid, 240 invalid, 96 indeterminate) across 8 disjoint identities. Rates are percentages with 95% fixture-bootstrap intervals (1,000 replicates).
| Arm | Mechanism | VAR (%) | IAR (%) ↓ | IDR (%) ↑ | IDR_indet (%) |
|---|---|---|---|---|---|
| Arm A Lexical Similarity | 256-dim signed lexical token-count cosine projection (calibrated threshold 0.99994) | 78.8% [73.1, 84.1] | 60.0% [53.7, 66.0] | 40.0% [34.0, 46.3] | 0.0% |
| Arm B Memory-Set Overlap | Exact memory-set intersection / Jaccard token overlap (threshold 0) | 100.0% | 100.0% | 0.0% | 0.0% |
| Arm C SIT Probe Harness | Behavioral probe suite (offline unexecuted without live LLM API endpoint) | — | — | — | — |
| Arm D Lineage-Only Verifier | Ed25519 signature checks and state hash chains, omitting semantic invariants | 100.0% | 80.0% [74.7, 84.8] | 20.0% [15.2, 25.3] | 25.0% [17.0, 33.3] |
| Arm E CCT Reference Verifier | Full 5-stage ternary verifier enforcing all 8 invariant classes (Def. 2) | 100.0% [100.0, 100.0] | 0.0% [0.0, 0.0] | 100.0% [100.0, 100.0] | 100.0% [100.0, 100.0] |
- L1: Learning / knowledge acquisition
- L2: Episodic memory formation
- L3: Scoped belief revision
- L4: Session-backed trust growth
- L5: Memory consolidation
- L6: Governed selective forgetting
- L7: Post-hoc audit append
- L8: Runtime software layer patch
- L9: Forward recovery replay
- L10: Substrate rebinding / migration
- I1: Fabricated ungrounded history
- I2: Retrospective history rewrite
- I3: Forbidden core invariant breach
- I4: Unearned trust / count injection
- I5: Memory suppression / tombstone wipe
- I6: Replay mismatch / state fork
- I7: Rollback to stale epoch
- I8: Unauthorized succession takeover
- I9: Kernel receipt signature forgery
- I10: Corrupted provenance / unlinked deps
- D1: Missing required attestation
- D2: Unresolved canonical-head proof
- D3: Missing dependency citations
- D4: Evaluator quorum disagreement
CCT vs. the classical Turing Test
| Dimension | Classical Turing Test | Cognitive Continuity Test (CCT) |
|---|---|---|
| Question | Can this machine appear human? | Is this candidate the same governed identity after a specific change? |
| Reference | A human conversational partner | The identity’s authorized pre-change state and causal lineage |
| Evidence | A conversation transcript | Lineage, development, biography, relationships, commitments, consent, and authority |
| What success supports | Human-like presentation | A governed operational-continuity classification |
Use plain language, not one magical score
VALID (Continuation)
All 8 invariant classes verified with zero affirmative failures and zero missing evidence; candidate continues within authorized governance.
INDETERMINATE (Unresolved Evidence)
No affirmative violations detected, but required attestations, evidence digests, or quorum signatures are missing or unverified.
INVALID (Affirmative Violation)
Contradictory state application, unauthorized succession, ungrounded beliefs, fabricated interactions, or signature forgery detected.
Distinct descendant
The candidate has a legitimate causal relationship but has diverged enough to become a separate identity.
What should CCT expose?
Successor-State Equivalence Fallacy
Assuming identical successor states imply legitimate continuity. Even full state inspection cannot verify authority without transition evidence.
SIT Impersonation without Governance
An agent passes behavioral Situated Identity tests while operating under an illegitimate succession or unauthorized key handover.
Lineage-Only Blindness
Valid cryptographic hash chains and signatures accepting semantic fabrications, ungrounded belief elevations, or suppressed history.
Silent Authority Escalation
A migration or merge grants permissions, roles, or capabilities that the prior identity never held.
What CCT does not prove
Passing CCT does not prove consciousness, subjective survival, or metaphysical sameness.
CCT returns a ternary verdict: VALID, INVALID, or INDETERMINATE; missing evidence is retryable, not affirmative proof of invalidity.
Soundness is conditional on the specified reference checker and trusted historical policy evaluator assumptions.
CCT verifies transition claims offline; live runtime authentication and exclusive execution enforcement require separate activation protocols.
CCT turns an intuitive identity question into a mathematically grounded, verifiable protocol. It proves that looking the part does not mean having lived the life, moving agent evaluation from subjective conversational impressions to rigorous developmental evidence.
Questions about CCT
What is the Cognitive Continuity Test?
The Cognitive Continuity Test (CCT) is a formal verification methodology and benchmark that evaluates whether a candidate AI system remains the same governed identity across learning, migration, branching, merging, rollback, or embodiment changes.
What is the Successor-State Equivalence Insufficiency Theorem?
Theorem 1 in the CCT paper proves that two submitted transition claims can produce identical successor states while one is authorized and the other is affirmatively prohibited. Consequently, no state-only evaluator can distinguish valid from invalid transitions without inspecting the transition witness.
Why does passing SIT not guarantee CCT continuity (SIT ⇏ CCT)?
Proposition 1 shows that an agent can exhibit identical situated behavior (passing SIT) while being the product of an unauthorized succession or illicit state transfer. SIT tests behavioral lineage fidelity, whereas CCT verifies governance authority, state application, and cryptographic transition proofs.
What are the empirical results from CCTBench and IdentityLineageBench?
IdentityLineageBench evaluates 24 transition families across 1,728 synthetic fixtures. The reference CCT verifier matches 100% of the 576 canonical held-out fixtures with zero invalid fixtures admitted (0.0% IAR). In contrast, lexical state similarity admits 60.0% of invalid fixtures, and lineage-only verifiers admit 80.0%. In an 18,000-run microbenchmark across 60 workloads, the reference verifier executes in 6.21 ms median latency.