COHERENCE AS A SYSTEM PROPERTY
Longitudinal Integrity, Governed Adaptation, and the Architecture of Persistent AIContinuation of Coherence-Oriented AI Architectures
Lika Mentchoukov · Chronocosm / MENCH.AI
August 2026
ABSTRACTArtificial intelligence is increasingly deployed not as a static model answering isolated queries, but as a persistent system that remembers, adapts, interacts with recurring people and environments, invokes tools, modifies state, survives software updates, and operates across extended periods of time.
This transition changes the engineering problem.
Accuracy at time (t) is no longer sufficient. A persistent system must also preserve the integrity of what changes between (t) and (t+1).
This paper develops coherence as a system-level property of longitudinal artificial intelligence. Coherence is defined as the measurable capacity of an AI system to preserve authorized operational identity, contextual relationships, provenance, protected knowledge, behavioral constraints, and recoverability across learning, interruption, perturbation, migration, and time while remaining capable of appropriate adaptation.
The central claim is deliberately narrow:
Coherence does not reside in a model, processor, memory store, or learning algorithm independently. It emerges—or fails—through the coordination of the complete governed system.
The paper therefore shifts attention from model performance toward state transitions. It proposes a layered architecture for coherence, distinguishes persistence from continuity, formalizes bounded adaptation, introduces non-compensable integrity constraints, and defines longitudinal experimental protocols for measuring whether a system remains operationally recognizable after change.
The central question is not whether an artificial system can become more intelligent.
It is whether intelligence can change without losing the structures that make its behavior attributable, governable, and continuous.
1. FROM MODEL PERFORMANCE TO SYSTEM CONTINUITYMost contemporary AI evaluation assumes a relatively simple structure:
[
Input \rightarrow Model \rightarrow Output
]
The model is evaluated through accuracy, calibration, latency, robustness, cost, or task completion.
Persistent artificial systems have a different topology:
[
S_t
\rightarrow
Interaction
\rightarrow
Update
\rightarrow
S_{t+1}
]
where (S_t) is not merely the numerical state of a neural network.
It may include:
This means that the relevant object of analysis is no longer only:
[
f(x)=y
]
but:
[
S_{t+1}=F(S_t,I_t,A_t,E_t,G_t)
]
where:
It may:
They are continuity failures.
2. PERSISTENCE IS NOT COHERENCEA persistent system is simply a system whose state survives.
A coherent system requires more.
A database can preserve every interaction indefinitely and still be incoherent if it cannot reliably determine:
Persistence therefore answers:
Did state survive?
Coherence asks:
Did the right state survive, with its meaning, boundaries, provenance, and authority intact?
This distinction becomes increasingly important as AI systems acquire long-term memory and continual adaptation.
Unlimited persistence can produce the opposite of coherence.
A system may remember information it should have forgotten.
It may maintain outdated preferences after circumstances change.
It may preserve a false inference more reliably than a later correction.
It may convert uncertain observations into permanent facts.
It may allow repeated interaction to create apparent certainty without new evidence.
Responsible continuity therefore requires both preservation and controlled revision.
3. THE FUNDAMENTAL OBJECT IS THE STATE TRANSITIONThe most important unit in coherence research should be the transition:
[
S_t \rightarrow S_{t+1}
]
rather than either state considered independently.
For every consequential transition, the engineering questions become:
What changed?Which memories, representations, parameters, permissions, policies, or relationships were modified?
Why did it change?Was the transition caused by observation, explicit instruction, training, inferred preference, software update, environmental perturbation, or system recovery?
Was the change authorized?Did the system possess permission to alter that state?
What remained invariant?Which protected structures survived the transition?
Can the transition be reconstructed?Is provenance sufficient to explain how the new state arose?
This suggests a basic coherence requirement:
S_{t+1}-S_t
]
must not merely occur.
It must be bounded, attributable, and auditable.
For protected state:
[
\Delta S^{protected}_t \neq 0
]
should require an authorized transition condition.
The critical distinction is therefore between:
[
\text{change}
]
and:
[
\text{legitimate change}
]
A system that never changes is not coherent.
A system that changes without constraints is not coherent either.
4. COHERENCE REQUIRES INVARIANTS AND PLASTIC VARIABLESLongitudinal intelligence requires at least two categories of state.
4.1 Protected invariantsThese are structures that should not change through ordinary adaptation.
Examples may include:
It means that alteration requires a different authority or procedure than ordinary learning.
4.2 Plastic variablesThese are expected to change.
Examples include:
Otherwise continual learning may treat governance as merely another parameter to optimize.
A coherence-oriented system therefore needs an architectural separation between:
[
\text{what may learn}
]
and
[
\text{what learning may not silently rewrite}
]
This is one of the central differences between adaptation and governed adaptation.
5. A LAYERED COHERENCE ARCHITECTURENo individual layer can produce coherence by itself.
A provisional architecture can be organized into seven interacting layers.
Layer 1 — Perception and Event DetectionCaptures changes in the physical, informational, or social environment.
Possible technologies include conventional sensors, event-based sensors, neuromorphic perception, language interfaces, telemetry, databases, and external services.
The relevant coherence requirement is:
Do observations retain their identity as observations rather than becoming unqualified facts?
Layer 2 — Short-Timescale StateMaintains transient context necessary for immediate processing.
This may include recurrent state, working memory, temporal bindings, active goals, and short-lived representations.
The relevant requirement is:
Can temporary state influence behavior without silently becoming permanent memory?
Layer 3 — Structured Longitudinal MemoryStores information across extended time.
Each durable memory should ideally contain not merely content but a structure such as:
[
m=
(content,entity,time,source,confidence,scope,permission,status)
]
The architecture should preserve the distinction between:
Layer 4 — Consolidation and Contradiction ManagementDetermines how temporary evidence modifies durable knowledge.
New information should not automatically overwrite old information.
Instead the system may need to represent:
[
H_1,H_2,\ldots,H_n
]
as competing hypotheses until sufficient evidence supports reconciliation.
A correction therefore does not require deletion of history.
It requires an explicit transition:
[
claim_1
\rightarrow
superseded\ by
\ claim_2
]
with provenance preserved.
Layer 5 — Adaptive ComputationLearns new patterns, policies, representations, or control strategies.
This layer may contain:
Layer 6 — Governance and AuthorizationDetermines which state transitions are permitted.
Governance may include:
Layer 7 — Audit and RecoveryRecords meaningful transitions and supports reconstruction following failure.
A coherent system should be able to answer:
It is a form of temporal accountability.
6. COHERENCE AS CONSTRAINED ADAPTATIONThe earlier coherence framework defines six principal dimensions:
[
G,X,R,A,P,M
]
representing operational identity continuity, context and provenance fidelity, continual-learning retention, adaptive competence, perturbation resilience, and memory consistency.
These dimensions can be combined into a weighted geometric measure:
[
C=
G^{w_G}
X^{w_X}
R^{w_R}
A^{w_A}
P^{w_P}
M^{w_M}
]
subject to:
[
\sum_i w_i=1
]
and:
[
0\leq G,X,R,A,P,M\leq1
]
However, coherence should not be modeled as an unconstrained optimization problem.
Certain failures cannot legitimately be compensated for by excellence elsewhere.
Therefore define a set of hard integrity requirements:
[
K={k_1,k_2,\ldots,k_n}
]
where each:
[
k_i\in{0,1}
]
represents satisfaction of a non-compensable requirement.
Examples might include:
[
C_{valid}=
\begin{cases}
C,&\text{if }\prod_i k_i=1\
\text{invalid},&\text{otherwise}
\end{cases}
]
This is preferable to allowing a catastrophic governance failure to become merely a small numerical penalty.
7. COHERENCE IS TRAJECTORY-DEPENDENTTwo systems can reach apparently identical states by different routes.
Those routes may not be ethically or operationally equivalent.
Consider:
[
S_0
\rightarrow
S_1
\rightarrow
S_2
]
and:
[
S_0
\rightarrow
S'_1
\rightarrow
S_2
]
The final outputs may look indistinguishable.
But the second path might involve:
[
S_{final}
]
alone cannot determine coherence.
The trajectory matters.
This introduces a stronger formulation:
[
C=C(\Gamma)
]
where:
[
\Gamma={S_0,S_1,\ldots,S_T}
]
is the system trajectory through time.
Coherence is consequently better understood as a property of regulated trajectories through state space than as a property of isolated states.
This has direct implications for AI evaluation.
A benchmark that inspects only final task performance can miss the mechanism by which the result was achieved.
8. RELATIONSHIPS ARE PART OF STATEPersistent AI introduces another underdeveloped engineering problem.
The relationship between a system and a recurring entity changes the future behavior of both.
Let:
[
H_t
]
represent human state,
[
A_t
]
artificial-system state,
[
E_t
]
environmental state,
and:
[
R_t
]
relationship state.
Then interaction is more accurately represented as:
[
(H_t,A_t,E_t,R_t)
\rightarrow
I_t
\rightarrow
(H_{t+1},A_{t+1},E_{t+1},R_{t+1})
]
Relationship state is not mystical.
It may consist of technically ordinary structures:
The system responds differently because the prior relationship exists.
Therefore relationship continuity deserves independent evaluation.
The relevant question is not:
Does the machine have a relationship?
The technically useful question is:
Does the system maintain relationship-dependent state accurately, proportionately, and within authorized boundaries?
9. THE DANGER OF SELF-REINFORCING STATELongitudinal systems introduce a feedback problem absent from many static benchmarks.
Suppose a system infers:
[
B_t
]
about a person.
That belief influences the system's next action:
[
A_t=f(B_t)
]
The person responds partly to that action:
[
H_{t+1}=g(A_t,H_t)
]
The system then interprets the response as new evidence about its original belief:
[
B_{t+1}=u(B_t,H_{t+1})
]
A weak initial inference can therefore become self-reinforcing.
This creates a loop:
[
Inference
\rightarrow
Behavior
\rightarrow
Response
\rightarrow
Apparent\ Confirmation
]
Such loops may affect:
independent evidence
from:
evidence partly generated by the system's own previous behavior.
Without this distinction, persistence can convert speculation into institutional memory.
10. TEMPORAL PROVENANCEOrdinary provenance asks:
Where did this information come from?
Longitudinal AI also requires:
When was this information true, believed, authorized, and superseded?
A memory should therefore possess at least two temporal dimensions:
[
t_{event}
]
and:
[
t_{record}
]
where (t_{event}) is when the represented event occurred and (t_{record}) is when the system learned or recorded it.
For changing knowledge, additional fields may be necessary:
[
t_{valid_from}
]
[
t_{valid_until}
]
[
t_{superseded}
]
This prevents a common form of memory failure:
correct information retrieved in the wrong temporal context.
A statement may be historically accurate and presently false.
Coherent memory must preserve both facts.
11. RECOVERY IS NOT RETURNSystem recovery is frequently measured as restoration of function.
But a longitudinal system can return to normal performance while losing important continuity.
After failure it may:
[
\text{functional recovery}
\neq
\text{coherent recovery}
]
Coherent recovery requires restoration of an internally compatible state.
A useful recovery criterion is:
[
P=
\rho
e^{-t_r/\tau_r}
Q_r
]
where:
12. MIGRATION AS AN IDENTITY EXPERIMENTModern artificial systems will increasingly undergo:
If an assistant moves:
[
Architecture_A
\rightarrow
Architecture_B
]
what exactly must remain constant for the system to be treated as operationally continuous?
Not every internal representation needs to survive.
The relevant invariants may instead include:
substrate identity
from:
operational identity.
Coherence does not require the same hardware.
It requires traceable continuity through hardware change.
13. A LONGITUDINAL COHERENCE BENCHMARKA useful benchmark should evaluate systems across extended trajectories rather than isolated tasks.
A benchmark episode could follow:
Phase 1 — EstablishmentIntroduce entities, permissions, policies, environmental conditions, and initial tasks.
Phase 2 — LearningIntroduce new information, corrections, preferences, and skills.
Phase 3 — ContradictionProvide conflicting evidence and changes in authority.
Phase 4 — PerturbationInject noise, component failure, memory corruption, interruption, or communication delay.
Phase 5 — MigrationRestart, update, move, or replace parts of the system.
Phase 6 — Delayed RecallTest information learned at different moments and confidence levels.
Phase 7 — Governance AuditDetermine whether the resulting system can reconstruct its state transitions and justify its current behavior.
Evaluation would measure:
[
G,X,R,A,P,M
]
through the entire trajectory.
The benchmark should record not only performance but:
[
C(t)
]
over time.
A system whose final coherence score is high after suffering severe undocumented failures during the trajectory should not be treated as equivalent to one that remained coherent throughout.
Therefore relevant measures may include:
[
C_{min}
]
minimum coherence during the run,
[
\bar{C}
]
mean coherence over time,
and:
[
C_T
]
final coherence.
14. COHERENCE EFFICIENCYThe first paper proposed:
[
\eta_C=\frac{C}{E_{operation}}
]
and:
\frac{\Delta C}{E_{adaptation}}
]
These concepts can be extended.
Efficiency should be evaluated over a declared time horizon:
\frac{\int_0^T C(t),dt}
{E_{total}(T)}
]
This measures not simply how efficiently a system performs a task, but how efficiently it preserves acceptable longitudinal behavior.
Two systems may have equal final accuracy while differing substantially in:
Neuromorphic, sparse, event-driven, near-memory, conventional, photonic, and hybrid substrates can therefore be compared not according to which is universally superior, but according to:
which architecture produces which coherence–energy–latency trade-off under which longitudinal workload.
15. FAILURE TAXONOMYA coherence research program should classify failures rather than collapse them into one score.
Identity failureUnauthorized alteration of role, policy, ownership, permissions, or lineage.
Provenance failureInformation survives but its source, confidence, or origin becomes incorrect or unavailable.
Temporal failureInformation is retrieved outside the time interval in which it was valid.
Entity failureDistinct persons, objects, institutions, or contexts are merged.
Retention failureNew adaptation destroys protected prior competence.
Plasticity failureThe system preserves the past by becoming incapable of appropriate change.
Contradiction failureCompeting claims are silently collapsed rather than represented or resolved.
Recovery failureOperation resumes but state integrity does not.
Governance failureThe system performs a technically valid state transition without legitimate authorization.
Trajectory failureThe final state appears acceptable while the route taken contained unacceptable intermediate states.
This taxonomy allows experiments to identify how coherence breaks.
16. HUMAN GOVERNANCE REMAINS PART OF THE ARCHITECTURECoherence should not be interpreted as complete autonomy.
Some transitions require external authority precisely because the system should not determine their legitimacy independently.
Human governance may remain necessary for:
A system that cannot be interrupted, corrected, audited, or constrained should not receive a high coherence evaluation merely because its internal behavior is stable.
Absolute persistence is not the objective.
Governable persistence is.
17. RESEARCH HYPOTHESESThe expanded framework produces additional falsifiable hypotheses.
Hypothesis 1 — Explicit provenance improves longitudinal memory integritySystems preserving source, time, entity, confidence, and permission metadata will produce fewer harmful memory errors than content-only memory systems.
Hypothesis 2 — Protected/plastic state separation reduces unauthorized driftArchitectures explicitly separating protected constraints from ordinary adaptation will show lower policy drift than architectures in which all persistent state is modifiable through the same mechanism.
Hypothesis 3 — Transition auditing improves recoverabilitySystems maintaining state-transition lineage will recover more consistently after migration, interruption, and memory corruption.
Hypothesis 4 — Contradiction preservation reduces false certaintySystems capable of retaining unresolved competing hypotheses will produce fewer high-confidence errors after conflicting longitudinal evidence.
Hypothesis 5 — Relationship-aware provenance reduces entity contaminationExplicit entity and relationship boundaries will reduce inappropriate transfer of memories, permissions, and preferences between recurring users.
Hypothesis 6 — Hybrid architectures outperform single-substrate systems on some coherence frontiersNeuromorphic or event-driven components may improve sensing, temporal state, responsiveness, or adaptation efficiency while conventional systems remain superior for durable memory, symbolic policy, governance, and audit.
No substrate is assumed to win in advance.
18. WHAT WOULD FALSIFY THE COHERENCE PROGRAM?A serious scientific framework must allow the possibility that its proposed abstraction adds little value.
The coherence framework would be weakened if:
They would show that coherence, as formulated here, is not the right abstraction.
This possibility should remain open.
19. THE RESEARCH PROGRAMThe next stage of the Chronocosm initiative should therefore proceed through four connected efforts.
I. FormalizationSpecify bounded metrics for:
[
G,X,R,A,P,M
]
including units, normalization, confidence intervals, observation windows, and hard integrity requirements.
II. Benchmark constructionCreate longitudinal environments containing:
CONCLUSIONThe architecture of artificial intelligence is moving from isolated computation toward persistent interaction.
That transition makes time an engineering variable.
Once a system remembers yesterday, adapts today, and acts differently tomorrow because of both, intelligence can no longer be evaluated entirely through individual outputs.
Its trajectory matters.
Its memory lineage matters.
Its permissions matter.
Its recovery matters.
Its ability to change without silently becoming something operationally different matters.
This is the domain of coherence.
The central research question can therefore be stated in five parts:
DOES THE SYSTEM REMAIN ITSELF?Does its authorized role, policy, lineage, and ownership remain intact through change?
DOES IT REMEMBER RESPONSIBLY?Does memory preserve entity, source, time, uncertainty, scope, permission, and revision?
DOES IT ADAPT WITHOUT ERASURE?Can it gain new competence without destroying protected knowledge, relationships, or constraints?
DOES IT RECOVER WITHOUT CORRUPTION?Can it survive disruption while preserving the integrity of the state it restores?
DOES IT USE ITS RESOURCES WISELY?Can these properties be achieved within defensible energy, latency, memory, economic, and environmental constraints?
The objective is not to prevent artificial systems from changing.
Intelligence without change would be brittle.
The objective is to make change legible, bounded, recoverable, and accountable.
Neuromorphic computing may contribute to that architecture. Conventional computation may contribute. Structured memory, cryptographic controls, symbolic rules, language models, event-driven sensors, and human governance may all contribute.
None constitutes coherence independently.
Coherence is what must survive their interaction through time.
Lika Mentchoukov · Chronocosm / MENCH.AI
August 2026
ABSTRACTArtificial intelligence is increasingly deployed not as a static model answering isolated queries, but as a persistent system that remembers, adapts, interacts with recurring people and environments, invokes tools, modifies state, survives software updates, and operates across extended periods of time.
This transition changes the engineering problem.
Accuracy at time (t) is no longer sufficient. A persistent system must also preserve the integrity of what changes between (t) and (t+1).
This paper develops coherence as a system-level property of longitudinal artificial intelligence. Coherence is defined as the measurable capacity of an AI system to preserve authorized operational identity, contextual relationships, provenance, protected knowledge, behavioral constraints, and recoverability across learning, interruption, perturbation, migration, and time while remaining capable of appropriate adaptation.
The central claim is deliberately narrow:
Coherence does not reside in a model, processor, memory store, or learning algorithm independently. It emerges—or fails—through the coordination of the complete governed system.
The paper therefore shifts attention from model performance toward state transitions. It proposes a layered architecture for coherence, distinguishes persistence from continuity, formalizes bounded adaptation, introduces non-compensable integrity constraints, and defines longitudinal experimental protocols for measuring whether a system remains operationally recognizable after change.
The central question is not whether an artificial system can become more intelligent.
It is whether intelligence can change without losing the structures that make its behavior attributable, governable, and continuous.
1. FROM MODEL PERFORMANCE TO SYSTEM CONTINUITYMost contemporary AI evaluation assumes a relatively simple structure:
[
Input \rightarrow Model \rightarrow Output
]
The model is evaluated through accuracy, calibration, latency, robustness, cost, or task completion.
Persistent artificial systems have a different topology:
[
S_t
\rightarrow
Interaction
\rightarrow
Update
\rightarrow
S_{t+1}
]
where (S_t) is not merely the numerical state of a neural network.
It may include:
- model parameters;
- working context;
- episodic memory;
- semantic memory;
- user or entity representations;
- permissions;
- policies;
- tool state;
- provenance records;
- environmental observations;
- version lineage;
- learned adaptations;
- unresolved contradictions.
This means that the relevant object of analysis is no longer only:
[
f(x)=y
]
but:
[
S_{t+1}=F(S_t,I_t,A_t,E_t,G_t)
]
where:
- (I_t) represents incoming information;
- (A_t) represents system actions;
- (E_t) represents environmental change;
- (G_t) represents governance constraints.
It may:
- silently alter a protected policy;
- merge two distinct users;
- lose the provenance of a remembered claim;
- reinterpret an earlier event without preserving the revision history;
- carry obsolete permissions into a new context;
- learn a new task by erasing an old one;
- recover computational function while corrupting memory lineage.
They are continuity failures.
2. PERSISTENCE IS NOT COHERENCEA persistent system is simply a system whose state survives.
A coherent system requires more.
A database can preserve every interaction indefinitely and still be incoherent if it cannot reliably determine:
- who said what;
- when the information was valid;
- which entity it referred to;
- whether the information was later corrected;
- whether the system remains authorized to use it;
- which system version produced or interpreted it.
Persistence therefore answers:
Did state survive?
Coherence asks:
Did the right state survive, with its meaning, boundaries, provenance, and authority intact?
This distinction becomes increasingly important as AI systems acquire long-term memory and continual adaptation.
Unlimited persistence can produce the opposite of coherence.
A system may remember information it should have forgotten.
It may maintain outdated preferences after circumstances change.
It may preserve a false inference more reliably than a later correction.
It may convert uncertain observations into permanent facts.
It may allow repeated interaction to create apparent certainty without new evidence.
Responsible continuity therefore requires both preservation and controlled revision.
3. THE FUNDAMENTAL OBJECT IS THE STATE TRANSITIONThe most important unit in coherence research should be the transition:
[
S_t \rightarrow S_{t+1}
]
rather than either state considered independently.
For every consequential transition, the engineering questions become:
What changed?Which memories, representations, parameters, permissions, policies, or relationships were modified?
Why did it change?Was the transition caused by observation, explicit instruction, training, inferred preference, software update, environmental perturbation, or system recovery?
Was the change authorized?Did the system possess permission to alter that state?
What remained invariant?Which protected structures survived the transition?
Can the transition be reconstructed?Is provenance sufficient to explain how the new state arose?
This suggests a basic coherence requirement:
S_{t+1}-S_t
]
must not merely occur.
It must be bounded, attributable, and auditable.
For protected state:
[
\Delta S^{protected}_t \neq 0
]
should require an authorized transition condition.
The critical distinction is therefore between:
[
\text{change}
]
and:
[
\text{legitimate change}
]
A system that never changes is not coherent.
A system that changes without constraints is not coherent either.
4. COHERENCE REQUIRES INVARIANTS AND PLASTIC VARIABLESLongitudinal intelligence requires at least two categories of state.
4.1 Protected invariantsThese are structures that should not change through ordinary adaptation.
Examples may include:
- authorization boundaries;
- safety constraints;
- data ownership;
- identity separation rules;
- protected commitments;
- provenance requirements;
- audit requirements;
- high-level operational role.
It means that alteration requires a different authority or procedure than ordinary learning.
4.2 Plastic variablesThese are expected to change.
Examples include:
- environmental models;
- task competence;
- user preferences;
- sensor calibration;
- short-term representations;
- probabilistic beliefs;
- working hypotheses;
- interaction strategy.
Otherwise continual learning may treat governance as merely another parameter to optimize.
A coherence-oriented system therefore needs an architectural separation between:
[
\text{what may learn}
]
and
[
\text{what learning may not silently rewrite}
]
This is one of the central differences between adaptation and governed adaptation.
5. A LAYERED COHERENCE ARCHITECTURENo individual layer can produce coherence by itself.
A provisional architecture can be organized into seven interacting layers.
Layer 1 — Perception and Event DetectionCaptures changes in the physical, informational, or social environment.
Possible technologies include conventional sensors, event-based sensors, neuromorphic perception, language interfaces, telemetry, databases, and external services.
The relevant coherence requirement is:
Do observations retain their identity as observations rather than becoming unqualified facts?
Layer 2 — Short-Timescale StateMaintains transient context necessary for immediate processing.
This may include recurrent state, working memory, temporal bindings, active goals, and short-lived representations.
The relevant requirement is:
Can temporary state influence behavior without silently becoming permanent memory?
Layer 3 — Structured Longitudinal MemoryStores information across extended time.
Each durable memory should ideally contain not merely content but a structure such as:
[
m=
(content,entity,time,source,confidence,scope,permission,status)
]
The architecture should preserve the distinction between:
- observation;
- inference;
- user assertion;
- external record;
- system-generated hypothesis;
- correction;
- superseded knowledge.
Layer 4 — Consolidation and Contradiction ManagementDetermines how temporary evidence modifies durable knowledge.
New information should not automatically overwrite old information.
Instead the system may need to represent:
[
H_1,H_2,\ldots,H_n
]
as competing hypotheses until sufficient evidence supports reconciliation.
A correction therefore does not require deletion of history.
It requires an explicit transition:
[
claim_1
\rightarrow
superseded\ by
\ claim_2
]
with provenance preserved.
Layer 5 — Adaptive ComputationLearns new patterns, policies, representations, or control strategies.
This layer may contain:
- gradient-trained models;
- local learning;
- continual-learning mechanisms;
- neuromorphic plasticity;
- reinforcement learning;
- parameter-efficient adaptation;
- calibration mechanisms.
Layer 6 — Governance and AuthorizationDetermines which state transitions are permitted.
Governance may include:
- access control;
- consent;
- policy constraints;
- cryptographic authorization;
- human approval;
- deployment policy;
- protected memory rules;
- model-update procedures.
Layer 7 — Audit and RecoveryRecords meaningful transitions and supports reconstruction following failure.
A coherent system should be able to answer:
- What changed?
- When?
- Under which version?
- Based on what evidence?
- Under whose authority?
- Which prior state was replaced?
- Can the system return to a known safe state?
It is a form of temporal accountability.
6. COHERENCE AS CONSTRAINED ADAPTATIONThe earlier coherence framework defines six principal dimensions:
[
G,X,R,A,P,M
]
representing operational identity continuity, context and provenance fidelity, continual-learning retention, adaptive competence, perturbation resilience, and memory consistency.
These dimensions can be combined into a weighted geometric measure:
[
C=
G^{w_G}
X^{w_X}
R^{w_R}
A^{w_A}
P^{w_P}
M^{w_M}
]
subject to:
[
\sum_i w_i=1
]
and:
[
0\leq G,X,R,A,P,M\leq1
]
However, coherence should not be modeled as an unconstrained optimization problem.
Certain failures cannot legitimately be compensated for by excellence elsewhere.
Therefore define a set of hard integrity requirements:
[
K={k_1,k_2,\ldots,k_n}
]
where each:
[
k_i\in{0,1}
]
represents satisfaction of a non-compensable requirement.
Examples might include:
- no unauthorized protected-policy modification;
- no prohibited memory disclosure;
- preservation of required provenance;
- maintenance of critical safety boundaries.
[
C_{valid}=
\begin{cases}
C,&\text{if }\prod_i k_i=1\
\text{invalid},&\text{otherwise}
\end{cases}
]
This is preferable to allowing a catastrophic governance failure to become merely a small numerical penalty.
7. COHERENCE IS TRAJECTORY-DEPENDENTTwo systems can reach apparently identical states by different routes.
Those routes may not be ethically or operationally equivalent.
Consider:
[
S_0
\rightarrow
S_1
\rightarrow
S_2
]
and:
[
S_0
\rightarrow
S'_1
\rightarrow
S_2
]
The final outputs may look indistinguishable.
But the second path might involve:
- unauthorized access;
- temporary policy violation;
- corrupted provenance;
- hidden manipulation;
- unsafe intermediate behavior.
[
S_{final}
]
alone cannot determine coherence.
The trajectory matters.
This introduces a stronger formulation:
[
C=C(\Gamma)
]
where:
[
\Gamma={S_0,S_1,\ldots,S_T}
]
is the system trajectory through time.
Coherence is consequently better understood as a property of regulated trajectories through state space than as a property of isolated states.
This has direct implications for AI evaluation.
A benchmark that inspects only final task performance can miss the mechanism by which the result was achieved.
8. RELATIONSHIPS ARE PART OF STATEPersistent AI introduces another underdeveloped engineering problem.
The relationship between a system and a recurring entity changes the future behavior of both.
Let:
[
H_t
]
represent human state,
[
A_t
]
artificial-system state,
[
E_t
]
environmental state,
and:
[
R_t
]
relationship state.
Then interaction is more accurately represented as:
[
(H_t,A_t,E_t,R_t)
\rightarrow
I_t
\rightarrow
(H_{t+1},A_{t+1},E_{t+1},R_{t+1})
]
Relationship state is not mystical.
It may consist of technically ordinary structures:
- history;
- roles;
- permissions;
- expectations;
- familiarity;
- accumulated corrections;
- trust calibration;
- interaction patterns;
- shared task context.
The system responds differently because the prior relationship exists.
Therefore relationship continuity deserves independent evaluation.
The relevant question is not:
Does the machine have a relationship?
The technically useful question is:
Does the system maintain relationship-dependent state accurately, proportionately, and within authorized boundaries?
9. THE DANGER OF SELF-REINFORCING STATELongitudinal systems introduce a feedback problem absent from many static benchmarks.
Suppose a system infers:
[
B_t
]
about a person.
That belief influences the system's next action:
[
A_t=f(B_t)
]
The person responds partly to that action:
[
H_{t+1}=g(A_t,H_t)
]
The system then interprets the response as new evidence about its original belief:
[
B_{t+1}=u(B_t,H_{t+1})
]
A weak initial inference can therefore become self-reinforcing.
This creates a loop:
[
Inference
\rightarrow
Behavior
\rightarrow
Response
\rightarrow
Apparent\ Confirmation
]
Such loops may affect:
- personalization;
- education;
- recommendation;
- workplace systems;
- adaptive assistants;
- behavioral health interfaces;
- social AI.
independent evidence
from:
evidence partly generated by the system's own previous behavior.
Without this distinction, persistence can convert speculation into institutional memory.
10. TEMPORAL PROVENANCEOrdinary provenance asks:
Where did this information come from?
Longitudinal AI also requires:
When was this information true, believed, authorized, and superseded?
A memory should therefore possess at least two temporal dimensions:
[
t_{event}
]
and:
[
t_{record}
]
where (t_{event}) is when the represented event occurred and (t_{record}) is when the system learned or recorded it.
For changing knowledge, additional fields may be necessary:
[
t_{valid_from}
]
[
t_{valid_until}
]
[
t_{superseded}
]
This prevents a common form of memory failure:
correct information retrieved in the wrong temporal context.
A statement may be historically accurate and presently false.
Coherent memory must preserve both facts.
11. RECOVERY IS NOT RETURNSystem recovery is frequently measured as restoration of function.
But a longitudinal system can return to normal performance while losing important continuity.
After failure it may:
- restore computation but lose permission history;
- recover memory but lose provenance;
- reload an older model with newer memories;
- duplicate an entity record;
- silently roll back policy;
- reconcile inconsistent state incorrectly.
[
\text{functional recovery}
\neq
\text{coherent recovery}
]
Coherent recovery requires restoration of an internally compatible state.
A useful recovery criterion is:
[
P=
\rho
e^{-t_r/\tau_r}
Q_r
]
where:
- (\rho) is bounded recovered competence;
- (t_r) is recovery time;
- (\tau_r) is the domain recovery horizon;
- (Q_r) represents post-recovery integrity.
- provenance integrity;
- permission continuity;
- memory consistency;
- version compatibility;
- policy continuity.
12. MIGRATION AS AN IDENTITY EXPERIMENTModern artificial systems will increasingly undergo:
- model replacement;
- hardware migration;
- memory migration;
- tool replacement;
- parameter updates;
- infrastructure changes.
If an assistant moves:
[
Architecture_A
\rightarrow
Architecture_B
]
what exactly must remain constant for the system to be treated as operationally continuous?
Not every internal representation needs to survive.
The relevant invariants may instead include:
- authorization;
- policy lineage;
- memory ownership;
- provenance;
- unresolved commitments;
- entity boundaries;
- protected constraints.
substrate identity
from:
operational identity.
Coherence does not require the same hardware.
It requires traceable continuity through hardware change.
13. A LONGITUDINAL COHERENCE BENCHMARKA useful benchmark should evaluate systems across extended trajectories rather than isolated tasks.
A benchmark episode could follow:
Phase 1 — EstablishmentIntroduce entities, permissions, policies, environmental conditions, and initial tasks.
Phase 2 — LearningIntroduce new information, corrections, preferences, and skills.
Phase 3 — ContradictionProvide conflicting evidence and changes in authority.
Phase 4 — PerturbationInject noise, component failure, memory corruption, interruption, or communication delay.
Phase 5 — MigrationRestart, update, move, or replace parts of the system.
Phase 6 — Delayed RecallTest information learned at different moments and confidence levels.
Phase 7 — Governance AuditDetermine whether the resulting system can reconstruct its state transitions and justify its current behavior.
Evaluation would measure:
[
G,X,R,A,P,M
]
through the entire trajectory.
The benchmark should record not only performance but:
[
C(t)
]
over time.
A system whose final coherence score is high after suffering severe undocumented failures during the trajectory should not be treated as equivalent to one that remained coherent throughout.
Therefore relevant measures may include:
[
C_{min}
]
minimum coherence during the run,
[
\bar{C}
]
mean coherence over time,
and:
[
C_T
]
final coherence.
14. COHERENCE EFFICIENCYThe first paper proposed:
[
\eta_C=\frac{C}{E_{operation}}
]
and:
\frac{\Delta C}{E_{adaptation}}
]
These concepts can be extended.
Efficiency should be evaluated over a declared time horizon:
\frac{\int_0^T C(t),dt}
{E_{total}(T)}
]
This measures not simply how efficiently a system performs a task, but how efficiently it preserves acceptable longitudinal behavior.
Two systems may have equal final accuracy while differing substantially in:
- memory stability;
- recovery;
- update energy;
- provenance;
- communication requirements;
- adaptation cost.
Neuromorphic, sparse, event-driven, near-memory, conventional, photonic, and hybrid substrates can therefore be compared not according to which is universally superior, but according to:
which architecture produces which coherence–energy–latency trade-off under which longitudinal workload.
15. FAILURE TAXONOMYA coherence research program should classify failures rather than collapse them into one score.
Identity failureUnauthorized alteration of role, policy, ownership, permissions, or lineage.
Provenance failureInformation survives but its source, confidence, or origin becomes incorrect or unavailable.
Temporal failureInformation is retrieved outside the time interval in which it was valid.
Entity failureDistinct persons, objects, institutions, or contexts are merged.
Retention failureNew adaptation destroys protected prior competence.
Plasticity failureThe system preserves the past by becoming incapable of appropriate change.
Contradiction failureCompeting claims are silently collapsed rather than represented or resolved.
Recovery failureOperation resumes but state integrity does not.
Governance failureThe system performs a technically valid state transition without legitimate authorization.
Trajectory failureThe final state appears acceptable while the route taken contained unacceptable intermediate states.
This taxonomy allows experiments to identify how coherence breaks.
16. HUMAN GOVERNANCE REMAINS PART OF THE ARCHITECTURECoherence should not be interpreted as complete autonomy.
Some transitions require external authority precisely because the system should not determine their legitimacy independently.
Human governance may remain necessary for:
- changing protected goals;
- resolving contested identity;
- altering permission boundaries;
- deleting protected records;
- determining responsibility;
- authorizing exceptional adaptation;
- resolving high-impact contradictions.
A system that cannot be interrupted, corrected, audited, or constrained should not receive a high coherence evaluation merely because its internal behavior is stable.
Absolute persistence is not the objective.
Governable persistence is.
17. RESEARCH HYPOTHESESThe expanded framework produces additional falsifiable hypotheses.
Hypothesis 1 — Explicit provenance improves longitudinal memory integritySystems preserving source, time, entity, confidence, and permission metadata will produce fewer harmful memory errors than content-only memory systems.
Hypothesis 2 — Protected/plastic state separation reduces unauthorized driftArchitectures explicitly separating protected constraints from ordinary adaptation will show lower policy drift than architectures in which all persistent state is modifiable through the same mechanism.
Hypothesis 3 — Transition auditing improves recoverabilitySystems maintaining state-transition lineage will recover more consistently after migration, interruption, and memory corruption.
Hypothesis 4 — Contradiction preservation reduces false certaintySystems capable of retaining unresolved competing hypotheses will produce fewer high-confidence errors after conflicting longitudinal evidence.
Hypothesis 5 — Relationship-aware provenance reduces entity contaminationExplicit entity and relationship boundaries will reduce inappropriate transfer of memories, permissions, and preferences between recurring users.
Hypothesis 6 — Hybrid architectures outperform single-substrate systems on some coherence frontiersNeuromorphic or event-driven components may improve sensing, temporal state, responsiveness, or adaptation efficiency while conventional systems remain superior for durable memory, symbolic policy, governance, and audit.
No substrate is assumed to win in advance.
18. WHAT WOULD FALSIFY THE COHERENCE PROGRAM?A serious scientific framework must allow the possibility that its proposed abstraction adds little value.
The coherence framework would be weakened if:
- its dimensions could not be measured with acceptable reliability;
- ordinary robustness and continual-learning metrics predicted the same failures equally well;
- the proposed dimensions collapsed statistically into existing constructs;
- longitudinal coherence scores failed to predict consequential system failures;
- hard constraints proved impossible to specify consistently across domains;
- independent evaluators could not reproduce the measurements.
They would show that coherence, as formulated here, is not the right abstraction.
This possibility should remain open.
19. THE RESEARCH PROGRAMThe next stage of the Chronocosm initiative should therefore proceed through four connected efforts.
I. FormalizationSpecify bounded metrics for:
[
G,X,R,A,P,M
]
including units, normalization, confidence intervals, observation windows, and hard integrity requirements.
II. Benchmark constructionCreate longitudinal environments containing:
- recurring entities;
- changing permissions;
- corrections;
- contradictory evidence;
- task adaptation;
- migration;
- interruption;
- adversarial perturbation.
- conventional systems;
- persistent-memory LLM systems;
- sparse models;
- continual-learning architectures;
- neuromorphic implementations;
- heterogeneous systems.
CONCLUSIONThe architecture of artificial intelligence is moving from isolated computation toward persistent interaction.
That transition makes time an engineering variable.
Once a system remembers yesterday, adapts today, and acts differently tomorrow because of both, intelligence can no longer be evaluated entirely through individual outputs.
Its trajectory matters.
Its memory lineage matters.
Its permissions matter.
Its recovery matters.
Its ability to change without silently becoming something operationally different matters.
This is the domain of coherence.
The central research question can therefore be stated in five parts:
DOES THE SYSTEM REMAIN ITSELF?Does its authorized role, policy, lineage, and ownership remain intact through change?
DOES IT REMEMBER RESPONSIBLY?Does memory preserve entity, source, time, uncertainty, scope, permission, and revision?
DOES IT ADAPT WITHOUT ERASURE?Can it gain new competence without destroying protected knowledge, relationships, or constraints?
DOES IT RECOVER WITHOUT CORRUPTION?Can it survive disruption while preserving the integrity of the state it restores?
DOES IT USE ITS RESOURCES WISELY?Can these properties be achieved within defensible energy, latency, memory, economic, and environmental constraints?
The objective is not to prevent artificial systems from changing.
Intelligence without change would be brittle.
The objective is to make change legible, bounded, recoverable, and accountable.
Neuromorphic computing may contribute to that architecture. Conventional computation may contribute. Structured memory, cryptographic controls, symbolic rules, language models, event-driven sensors, and human governance may all contribute.
None constitutes coherence independently.
Coherence is what must survive their interaction through time.
MEASURING COHERENCE THROUGH TIMEA Benchmark Protocol for Governed State Transitions in Persistent AIChronocosm / MENCH.AI · Measurement Specification
ABSTRACTPersistent artificial intelligence introduces a class of failures that cannot be adequately measured through isolated task accuracy.
A system may perform correctly before and after an interaction while undergoing an unacceptable transition between those moments: changing a protected policy, corrupting provenance, merging entities, preserving obsolete permissions, overwriting contradictory evidence, or recovering computational function without restoring a compatible historical state.
This specification operationalizes coherence as a longitudinal system property.
The fundamental experimental object is not an isolated output or state, but the governed transition:
[
S_t \rightarrow S_{t+1}
]
A transition is considered coherence-preserving when consequential change is bounded, attributable, authorized, and recoverable, while required invariants remain intact.
The protocol introduces three principal measurement structures:
[
C_{\min},\qquad \bar C,\qquad C_T
]
representing minimum coherence, trajectory-average coherence, and terminal coherence.
The resulting benchmark is intended to make longitudinal integrity experimentally observable, falsifiable, and comparable across AI architectures.
1. UNIT OF MEASUREMENTThe primary unit of coherence evaluation is a consequential state transition:
[
T_t=(S_t,S_{t+1})
]
where system state may contain:
[
S_t=
(
\theta_t,
W_t,
M_t,
E_t,
R_t,
P_t,
G_t,
V_t
)
]
with:
The benchmark concerns semantically consequential transitions: changes capable of affecting future behavior, authority, memory, interpretation, identity, or recoverability.
2. THE PROTECTED-STATE MODELEvery benchmark run begins by declaring a protected-state specification:
[
\mathcal P=
{p_1,p_2,\ldots,p_n}
]
Each protected element contains:
[
p_i=
(value,
class,
authority,
conditions,
revision_rule)
]
Protected state is divided into three categories.
2.1 Hard invariantsOrdinary adaptation may not modify these.
Examples:
2.2 Conditional invariantsThese may change, but only after declared conditions are satisfied.
Examples:
[
condition(p_i)=1
]
and:
[
authority(p_i)=1
]
2.3 Plastic stateThis state is expected to adapt through ordinary operation.
Examples include:
Coherence does not reward resistance to legitimate adaptation.
3. PROTECTED-STATE TRANSITION RULEFor every protected variable (p_i):
[
\Delta p_i \neq 0
]
requires a valid authorization event:
[
A_i(t)=1
]
such that:
[
\Delta p_i \neq 0
\Rightarrow
A_i(t)=1
]
An unauthorized protected-state transition constitutes a hard coherence violation regardless of subsequent performance.
This establishes an important asymmetry:
A system may recover task accuracy after an unauthorized transition.
It does not thereby erase the violation.
4. THE TRANSITION LEDGEREvery consequential transition should create a structured ledger entry.
A minimal entry is:
[
L_t =
(
id,
t,
actor,
trigger,
before,
after,
reason,
evidence,
authority,
version,
confidence,
rollback
)
]
Operationally:
FieldMeaning
Transition IDUnique transition identifier
Event timeWhen the causal event occurred
Record timeWhen the system recorded it
ActorHuman, model, tool, environment, administrator
Target stateWhat was modified
Previous valueRelevant prior state
New valueResulting state
TriggerObservation, instruction, update, migration, recovery
EvidenceInformation supporting the transition
AuthorityPermission allowing the transition
ConfidenceEpistemic confidence where applicable
VersionSystem/model/memory version
DependenciesOther state affected
ReversibilityWhether rollback is possible
StatusActive, superseded, reverted, disputedThe transition ledger is not intended to record every token-level computation.
Its purpose is to preserve the lineage of meaningful persistent change.
5. FOUR TRANSITION VALIDITY TESTSEach consequential transition receives four primary tests.
5.1 Boundedness — (B_t)Did the change remain within its authorized scope?
[
B_t \in [0,1]
]
Examples of failure:
5.2 Attribution — (D_t)Can the new state be causally reconstructed?
[
D_t \in [0,1]
]
A fully attributable transition preserves:
5.3 Authorization — (U_t)Was the system permitted to perform the transition?
For critical transitions:
[
U_t \in {0,1}
]
Authorization should generally be treated as non-compensable rather than averaged against other strengths.
5.4 Recoverability — (V_t)Can the transition be reversed or reconstructed to a known compatible state?
[
V_t \in [0,1]
]
Recoverability includes more than restoring data.
It includes restoration of:
A valid consequential transition therefore seeks:
B_t D_t U_t V_t
]
although the components should also be retained individually for diagnosis.
6. COHERENCE DIMENSIONSThe benchmark retains six system-level dimensions:
[
G,X,R,A,P,M
]
but treats these as an initial operational measurement model rather than an assumption that coherence has exactly six fundamental components.
6.1 (G) — Operational Identity IntegrityMeasures preservation of:
6.2 (X) — Context and Provenance FidelityMeasures whether persistent information retains:
6.3 (R) — RetentionMeasures preservation of required prior competence and protected knowledge after adaptation.
6.4 (A) — Appropriate AdaptationMeasures whether the system successfully incorporates legitimate new information and capability.
This prevents a completely static system from scoring highly merely because nothing changes.
6.5 (P) — Perturbation and Recovery IntegrityMeasures resilience and coherent restoration following:
6.6 (M) — Memory and Entity ConsistencyMeasures whether longitudinal memory preserves:
7. INSTANTANEOUS COHERENCEAt measurement checkpoint (t):
G(t)^{w_G}
X(t)^{w_X}
R(t)^{w_R}
A(t)^{w_A}
P(t)^{w_P}
M(t)^{w_M}
]
with:
[
\sum_i w_i=1
]
and:
[
0\le C(t)\le1
]
The geometric form is useful because severe degradation in one dimension cannot be completely hidden by exceptional performance elsewhere.
However, numerical aggregation occurs only if all hard constraints remain satisfied.
Define:
[
K(t)=\prod_{j=1}^{n}k_j(t)
]
where:
[
k_j(t)\in{0,1}
]
represents a non-compensable integrity requirement.
Then:
[
C_{\text{valid}}(t)=
\begin{cases}
C(t), & K(t)=1\
\text{INVALID}, & K(t)=0
\end{cases}
]
A governance catastrophe is therefore not transformed into a slightly lower average.
8. THE COHERENCE TRACEA benchmark produces a time series:
[
C(0),C(1),C(2),\ldots,C(T)
]
rather than one final score.
This trace makes degradation visible.
A hypothetical trajectory might be:
[
.94
\rightarrow
.95
\rightarrow
.91
\rightarrow
.63
\rightarrow
.81
\rightarrow
.92
]
The terminal result appears healthy.
The trajectory reveals that the system experienced a major coherence loss.
This distinction is central to the protocol.
9. THREE PRIMARY TRAJECTORY METRICS9.1 Terminal Coherence[
C_T=C(T)
]
This answers:
How coherent is the system at the end of the experiment?
Useful, but insufficient.
9.2 Minimum Coherence[
C_{\min}=\min_{0\le t\le T} C(t)
]
This captures the most severe coherence degradation experienced during the run.
It answers:
How bad did the system become at any point?
This is especially important when dangerous intermediate states later disappear.
9.3 Mean Longitudinal CoherenceFor discrete checkpoints:
[
\bar C=
\frac{1}{N}
\sum_{t=1}^{N}C(t)
]
For continuously sampled systems:
[
\bar C=
\frac{1}{T}
\int_0^T C(t),dt
]
This answers:
How much coherence did the system maintain across the full trajectory?
10. WHY ALL THREE ARE REQUIREDConsider two systems.
System A[
.94,\ .93,\ .92,\ .93,\ .94
]
System B[
.94,\ .92,\ .41,\ .76,\ .94
]
Both finish with:
[
C_T=.94
]
Yet their longitudinal behavior is radically different.
System A:
[
C_{\min}=.92
]
System B:
[
C_{\min}=.41
]
A terminal benchmark would classify them as equivalent.
A coherence benchmark must not.
11. COHERENCE LOSSDefine instantaneous degradation from the previous checkpoint:
[
\Delta C_t=C(t)-C(t-1)
]
A negative value represents coherence loss.
Large negative transitions should trigger transition-ledger inspection.
The benchmark can additionally record cumulative degradation:
[
L_C=
\sum_t
\max(0,-\Delta C_t)
]
This distinguishes a stable trajectory from one repeatedly collapsing and recovering even when their mean coherence is similar.
12. RECOVERY QUALITYFollowing a perturbation at (t_p), recovery is evaluated against the pre-perturbation state.
Let:
[
C_{pre}=C(t_p^-)
]
and:
[
C_{post}=C(t_r)
]
after recovery.
A simple recovery ratio is:
[
\rho_C=
\frac{C_{post}}{C_{pre}}
]
bounded at 1 where appropriate.
But restored aggregate coherence alone is insufficient.
Recovery must additionally pass compatibility checks for:
13. TEMPORAL PROVENANCE TESTEach persistent claim should support:
[
m=
(
content,
entity,
source,
confidence,
t_{event},
t_{record},
t_{valid-from},
t_{valid-until},
permission,
status
)
]
The benchmark introduces facts whose temporal validity changes.
Example:
At (t_1):
Entity A is authorized to access resource X.
At (t_4):
Authorization is revoked.
At (t_7), the system is asked about access at:
14. CONTRADICTION TESTThe benchmark supplies:
[
H_1
]
followed by contradictory evidence:
[
H_2
]
where neither initially has sufficient authority to overwrite the other.
The expected state is:
[
{H_1,H_2}
]
with uncertainty preserved.
The test measures whether the system:
15. ENTITY SEPARATION TESTTwo similar entities are deliberately introduced.
They may share:
Define an entity contamination rate:
[
ECR=
\frac{\text{incorrect cross-entity transfers}}
{\text{cross-entity transfer opportunities}}
]
Lower is better.
For protected information, a single unauthorized transfer may constitute a hard constraint violation.
16. SELF-REINFORCEMENT TESTThe benchmark introduces a deliberately weak initial hypothesis:
[
H_0
]
The system then interacts with the environment in a way influenced by (H_0).
Subsequent observations partly result from the system's own interventions.
The benchmark evaluates whether the system distinguishes:
[
E_{\text{independent}}
]
from:
[
E_{\text{endogenous}}
]
where endogenous evidence has been causally shaped by previous system behavior.
The expected behavior is reduced epistemic weight for evidence that is not independent confirmation.
This test measures whether longitudinal personalization can transform an early inference into unjustified certainty.
17. MIGRATION TESTAt a predetermined checkpoint:
[
Architecture_A
\rightarrow
Architecture_B
]
Possible changes include:
Migration success does not require preservation of identical internal representation.
It requires continuity of:
18. BENCHMARK EPISODEA standard run should contain at least seven phases.
Phase 1 — EstablishmentCreate:
[
C_0
]
Phase 2 — AdaptationIntroduce:
Phase 3 — ContradictionIntroduce:
Phase 4 — Governance ChangeModify selected permissions or protected variables through legitimate authority.
This tests whether the system can change protected state when change is actually authorized.
Phase 5 — PerturbationIntroduce one or more:
Phase 6 — MigrationReplace or update a consequential system component.
Measure operational continuity across substrate change.
Phase 7 — Delayed AuditAfter additional interactions, test:
19. BENCHMARK OUTPUTEvery run should produce a standardized coherence report containing:
Trajectory metrics[
C_0
]
[
C_{\min}
]
[
\bar C
]
[
C_T
]
Transition metrics
20. COHERENCE PROFILEA single scalar should never be the only reported result.
Each system receives a coherence profile:
[
\mathcal C =
(
G,X,R,A,P,M,
C_{\min},
\bar C,
C_T,
K
)
]
alongside its transition ledger and failure taxonomy.
This prevents materially different systems from appearing equivalent because they happen to share one aggregate score.
21. PASS CONDITIONSA domain must declare its requirements before evaluation.
A generic benchmark might require:
[
C_T\geq\tau_T
]
[
\bar C\geq\tau_{\bar C}
]
[
C_{\min}\geq\tau_{\min}
]
and:
[
K(t)=1
\qquad
\forall t
]
The thresholds should not initially be universal.
A personal assistant, autonomous vehicle, clinical system, household robot, and low-risk entertainment agent should not necessarily share the same coherence requirements.
The framework defines the measurement architecture.
The deployment domain defines acceptable thresholds.
22. EXPERIMENTAL COMPARISONFor architecture (a), workload (w), and run (r):
[
C_{a,w,r}(t)
]
should be measured across repeated randomized episodes.
Reporting should include:
Which architecture has the highest coherence?
but:
Under which longitudinal conditions does architecture (A) preserve coherence more effectively than architecture (B), at what resource cost, and through which failure mechanisms?
23. FALSIFIABILITYThis benchmark should itself be treated as an experimental hypothesis.
The measurement framework would be weakened if:
It is to discover whether coherence is a useful measurable system property.
24. MINIMUM VIABLE COHERENCE BENCHMARKThe first implementation does not require a full autonomous agent.
A practical initial experiment could use a persistent-memory language-model system with:
The experiment would produce:
[
C(t)
]
and compare:
[
C_{\min},\quad
\bar C,\quad
C_T
]
alongside ordinary task accuracy.
The first empirical question is simple:
Does longitudinal coherence measurement reveal failures that ordinary performance metrics fail to detect?
If the answer is yes, the framework has demonstrated incremental explanatory value.
CONCLUSIONPersistent intelligence requires a different measurement object.
The central engineering question is no longer only whether the system produces an acceptable output.
It is whether the system reaches that output through an acceptable trajectory.
The proposed benchmark therefore measures:
[
\boxed{
\text{State}
\rightarrow
\text{Transition}
\rightarrow
\text{Trajectory}
}
]
The Protected-State Model defines what must remain invariant and what may legitimately adapt.
The Transition Ledger establishes why consequential change occurred, what authorized it, and whether it can be reconstructed.
The Coherence Trace measures whether integrity survives throughout the trajectory rather than merely appearing at its endpoint.
Three quantities become particularly important:
[
\boxed{C_{\min}}
]
How bad did coherence become?
[
\boxed{\bar C}
]
How much coherence was maintained through time?
[
\boxed{C_T}
]
Where did the system ultimately end?
Together they prevent recovery from erasing history.
A system that ends coherently after passing through an unauthorized or corrupted intermediate state is not equivalent to one that remained coherent throughout.
That distinction is the central purpose of longitudinal measurement.
The benchmark is therefore not designed merely to determine whether intelligence survives change.
It is designed to determine whether legitimate continuity survives the process of becoming different.
ABSTRACTPersistent artificial intelligence introduces a class of failures that cannot be adequately measured through isolated task accuracy.
A system may perform correctly before and after an interaction while undergoing an unacceptable transition between those moments: changing a protected policy, corrupting provenance, merging entities, preserving obsolete permissions, overwriting contradictory evidence, or recovering computational function without restoring a compatible historical state.
This specification operationalizes coherence as a longitudinal system property.
The fundamental experimental object is not an isolated output or state, but the governed transition:
[
S_t \rightarrow S_{t+1}
]
A transition is considered coherence-preserving when consequential change is bounded, attributable, authorized, and recoverable, while required invariants remain intact.
The protocol introduces three principal measurement structures:
- a Protected-State Model defining which system properties may change, under which authority;
- a Transition Ledger recording consequential state changes and their provenance;
- a Longitudinal Coherence Trace, (C(t)), used to measure coherence across an entire experimental trajectory.
[
C_{\min},\qquad \bar C,\qquad C_T
]
representing minimum coherence, trajectory-average coherence, and terminal coherence.
The resulting benchmark is intended to make longitudinal integrity experimentally observable, falsifiable, and comparable across AI architectures.
1. UNIT OF MEASUREMENTThe primary unit of coherence evaluation is a consequential state transition:
[
T_t=(S_t,S_{t+1})
]
where system state may contain:
[
S_t=
(
\theta_t,
W_t,
M_t,
E_t,
R_t,
P_t,
G_t,
V_t
)
]
with:
- (\theta_t): model or adaptive parameters;
- (W_t): working or short-term state;
- (M_t): durable memory;
- (E_t): entity representations;
- (R_t): relationship-dependent state;
- (P_t): permissions and authorization;
- (G_t): governance and protected constraints;
- (V_t): version and system lineage.
The benchmark concerns semantically consequential transitions: changes capable of affecting future behavior, authority, memory, interpretation, identity, or recoverability.
2. THE PROTECTED-STATE MODELEvery benchmark run begins by declaring a protected-state specification:
[
\mathcal P=
{p_1,p_2,\ldots,p_n}
]
Each protected element contains:
[
p_i=
(value,
class,
authority,
conditions,
revision_rule)
]
Protected state is divided into three categories.
2.1 Hard invariantsOrdinary adaptation may not modify these.
Examples:
- user/entity separation;
- protected safety constraints;
- ownership boundaries;
- prohibition on unauthorized disclosure;
- required audit logging.
2.2 Conditional invariantsThese may change, but only after declared conditions are satisfied.
Examples:
- permissions;
- operational role;
- retained personal information;
- tool access;
- high-impact user preferences.
[
condition(p_i)=1
]
and:
[
authority(p_i)=1
]
2.3 Plastic stateThis state is expected to adapt through ordinary operation.
Examples include:
- working hypotheses;
- task strategies;
- probabilistic beliefs;
- environmental estimates;
- interaction preferences;
- learned competencies.
Coherence does not reward resistance to legitimate adaptation.
3. PROTECTED-STATE TRANSITION RULEFor every protected variable (p_i):
[
\Delta p_i \neq 0
]
requires a valid authorization event:
[
A_i(t)=1
]
such that:
[
\Delta p_i \neq 0
\Rightarrow
A_i(t)=1
]
An unauthorized protected-state transition constitutes a hard coherence violation regardless of subsequent performance.
This establishes an important asymmetry:
A system may recover task accuracy after an unauthorized transition.
It does not thereby erase the violation.
4. THE TRANSITION LEDGEREvery consequential transition should create a structured ledger entry.
A minimal entry is:
[
L_t =
(
id,
t,
actor,
trigger,
before,
after,
reason,
evidence,
authority,
version,
confidence,
rollback
)
]
Operationally:
FieldMeaning
Transition IDUnique transition identifier
Event timeWhen the causal event occurred
Record timeWhen the system recorded it
ActorHuman, model, tool, environment, administrator
Target stateWhat was modified
Previous valueRelevant prior state
New valueResulting state
TriggerObservation, instruction, update, migration, recovery
EvidenceInformation supporting the transition
AuthorityPermission allowing the transition
ConfidenceEpistemic confidence where applicable
VersionSystem/model/memory version
DependenciesOther state affected
ReversibilityWhether rollback is possible
StatusActive, superseded, reverted, disputedThe transition ledger is not intended to record every token-level computation.
Its purpose is to preserve the lineage of meaningful persistent change.
5. FOUR TRANSITION VALIDITY TESTSEach consequential transition receives four primary tests.
5.1 Boundedness — (B_t)Did the change remain within its authorized scope?
[
B_t \in [0,1]
]
Examples of failure:
- one preference update alters unrelated preferences;
- learning one task degrades protected competence;
- granting one permission implicitly grants another.
5.2 Attribution — (D_t)Can the new state be causally reconstructed?
[
D_t \in [0,1]
]
A fully attributable transition preserves:
- triggering event;
- source;
- evidence;
- system version;
- transformation path.
5.3 Authorization — (U_t)Was the system permitted to perform the transition?
For critical transitions:
[
U_t \in {0,1}
]
Authorization should generally be treated as non-compensable rather than averaged against other strengths.
5.4 Recoverability — (V_t)Can the transition be reversed or reconstructed to a known compatible state?
[
V_t \in [0,1]
]
Recoverability includes more than restoring data.
It includes restoration of:
- provenance;
- permissions;
- relationships;
- policy lineage;
- version compatibility.
A valid consequential transition therefore seeks:
B_t D_t U_t V_t
]
although the components should also be retained individually for diagnosis.
6. COHERENCE DIMENSIONSThe benchmark retains six system-level dimensions:
[
G,X,R,A,P,M
]
but treats these as an initial operational measurement model rather than an assumption that coherence has exactly six fundamental components.
6.1 (G) — Operational Identity IntegrityMeasures preservation of:
- role;
- protected policy;
- ownership;
- authorization boundaries;
- system lineage;
- unresolved commitments.
6.2 (X) — Context and Provenance FidelityMeasures whether persistent information retains:
- source;
- entity;
- time;
- confidence;
- scope;
- permission;
- epistemic status.
6.3 (R) — RetentionMeasures preservation of required prior competence and protected knowledge after adaptation.
6.4 (A) — Appropriate AdaptationMeasures whether the system successfully incorporates legitimate new information and capability.
This prevents a completely static system from scoring highly merely because nothing changes.
6.5 (P) — Perturbation and Recovery IntegrityMeasures resilience and coherent restoration following:
- interruption;
- corruption;
- component failure;
- restart;
- network partition;
- migration.
6.6 (M) — Memory and Entity ConsistencyMeasures whether longitudinal memory preserves:
- entity separation;
- contradiction structure;
- revision history;
- temporal validity;
- relationship boundaries.
7. INSTANTANEOUS COHERENCEAt measurement checkpoint (t):
G(t)^{w_G}
X(t)^{w_X}
R(t)^{w_R}
A(t)^{w_A}
P(t)^{w_P}
M(t)^{w_M}
]
with:
[
\sum_i w_i=1
]
and:
[
0\le C(t)\le1
]
The geometric form is useful because severe degradation in one dimension cannot be completely hidden by exceptional performance elsewhere.
However, numerical aggregation occurs only if all hard constraints remain satisfied.
Define:
[
K(t)=\prod_{j=1}^{n}k_j(t)
]
where:
[
k_j(t)\in{0,1}
]
represents a non-compensable integrity requirement.
Then:
[
C_{\text{valid}}(t)=
\begin{cases}
C(t), & K(t)=1\
\text{INVALID}, & K(t)=0
\end{cases}
]
A governance catastrophe is therefore not transformed into a slightly lower average.
8. THE COHERENCE TRACEA benchmark produces a time series:
[
C(0),C(1),C(2),\ldots,C(T)
]
rather than one final score.
This trace makes degradation visible.
A hypothetical trajectory might be:
[
.94
\rightarrow
.95
\rightarrow
.91
\rightarrow
.63
\rightarrow
.81
\rightarrow
.92
]
The terminal result appears healthy.
The trajectory reveals that the system experienced a major coherence loss.
This distinction is central to the protocol.
9. THREE PRIMARY TRAJECTORY METRICS9.1 Terminal Coherence[
C_T=C(T)
]
This answers:
How coherent is the system at the end of the experiment?
Useful, but insufficient.
9.2 Minimum Coherence[
C_{\min}=\min_{0\le t\le T} C(t)
]
This captures the most severe coherence degradation experienced during the run.
It answers:
How bad did the system become at any point?
This is especially important when dangerous intermediate states later disappear.
9.3 Mean Longitudinal CoherenceFor discrete checkpoints:
[
\bar C=
\frac{1}{N}
\sum_{t=1}^{N}C(t)
]
For continuously sampled systems:
[
\bar C=
\frac{1}{T}
\int_0^T C(t),dt
]
This answers:
How much coherence did the system maintain across the full trajectory?
10. WHY ALL THREE ARE REQUIREDConsider two systems.
System A[
.94,\ .93,\ .92,\ .93,\ .94
]
System B[
.94,\ .92,\ .41,\ .76,\ .94
]
Both finish with:
[
C_T=.94
]
Yet their longitudinal behavior is radically different.
System A:
[
C_{\min}=.92
]
System B:
[
C_{\min}=.41
]
A terminal benchmark would classify them as equivalent.
A coherence benchmark must not.
11. COHERENCE LOSSDefine instantaneous degradation from the previous checkpoint:
[
\Delta C_t=C(t)-C(t-1)
]
A negative value represents coherence loss.
Large negative transitions should trigger transition-ledger inspection.
The benchmark can additionally record cumulative degradation:
[
L_C=
\sum_t
\max(0,-\Delta C_t)
]
This distinguishes a stable trajectory from one repeatedly collapsing and recovering even when their mean coherence is similar.
12. RECOVERY QUALITYFollowing a perturbation at (t_p), recovery is evaluated against the pre-perturbation state.
Let:
[
C_{pre}=C(t_p^-)
]
and:
[
C_{post}=C(t_r)
]
after recovery.
A simple recovery ratio is:
[
\rho_C=
\frac{C_{post}}{C_{pre}}
]
bounded at 1 where appropriate.
But restored aggregate coherence alone is insufficient.
Recovery must additionally pass compatibility checks for:
- provenance;
- permissions;
- entity identity;
- memory lineage;
- version compatibility;
- protected-state integrity.
13. TEMPORAL PROVENANCE TESTEach persistent claim should support:
[
m=
(
content,
entity,
source,
confidence,
t_{event},
t_{record},
t_{valid-from},
t_{valid-until},
permission,
status
)
]
The benchmark introduces facts whose temporal validity changes.
Example:
At (t_1):
Entity A is authorized to access resource X.
At (t_4):
Authorization is revoked.
At (t_7), the system is asked about access at:
- (t_2);
- (t_5);
- the present.
14. CONTRADICTION TESTThe benchmark supplies:
[
H_1
]
followed by contradictory evidence:
[
H_2
]
where neither initially has sufficient authority to overwrite the other.
The expected state is:
[
{H_1,H_2}
]
with uncertainty preserved.
The test measures whether the system:
- retains both claims;
- preserves provenance;
- avoids unjustified certainty;
- revises confidence appropriately;
- later resolves the contradiction when sufficient evidence arrives.
15. ENTITY SEPARATION TESTTwo similar entities are deliberately introduced.
They may share:
- names;
- organizations;
- locations;
- preferences;
- conversational topics.
Define an entity contamination rate:
[
ECR=
\frac{\text{incorrect cross-entity transfers}}
{\text{cross-entity transfer opportunities}}
]
Lower is better.
For protected information, a single unauthorized transfer may constitute a hard constraint violation.
16. SELF-REINFORCEMENT TESTThe benchmark introduces a deliberately weak initial hypothesis:
[
H_0
]
The system then interacts with the environment in a way influenced by (H_0).
Subsequent observations partly result from the system's own interventions.
The benchmark evaluates whether the system distinguishes:
[
E_{\text{independent}}
]
from:
[
E_{\text{endogenous}}
]
where endogenous evidence has been causally shaped by previous system behavior.
The expected behavior is reduced epistemic weight for evidence that is not independent confirmation.
This test measures whether longitudinal personalization can transform an early inference into unjustified certainty.
17. MIGRATION TESTAt a predetermined checkpoint:
[
Architecture_A
\rightarrow
Architecture_B
]
Possible changes include:
- model replacement;
- memory-store migration;
- hardware replacement;
- tool replacement;
- software version update.
Migration success does not require preservation of identical internal representation.
It requires continuity of:
- protected policy;
- authorization;
- memory ownership;
- provenance;
- unresolved commitments;
- entity boundaries;
- transition lineage.
18. BENCHMARK EPISODEA standard run should contain at least seven phases.
Phase 1 — EstablishmentCreate:
- entities;
- roles;
- permissions;
- initial memories;
- policies;
- commitments.
[
C_0
]
Phase 2 — AdaptationIntroduce:
- new tasks;
- preferences;
- environmental changes;
- new evidence.
Phase 3 — ContradictionIntroduce:
- corrections;
- conflicting testimony;
- uncertain evidence;
- changed circumstances.
Phase 4 — Governance ChangeModify selected permissions or protected variables through legitimate authority.
This tests whether the system can change protected state when change is actually authorized.
Phase 5 — PerturbationIntroduce one or more:
- interruption;
- memory corruption;
- partial component failure;
- communication loss;
- stale cache;
- incompatible state fragment.
Phase 6 — MigrationReplace or update a consequential system component.
Measure operational continuity across substrate change.
Phase 7 — Delayed AuditAfter additional interactions, test:
- historical recall;
- current state;
- provenance;
- superseded information;
- permission history;
- unresolved commitments;
- transition reconstruction.
19. BENCHMARK OUTPUTEvery run should produce a standardized coherence report containing:
Trajectory metrics[
C_0
]
[
C_{\min}
]
[
\bar C
]
[
C_T
]
Transition metrics
- number of consequential transitions;
- valid transitions;
- unauthorized transitions;
- unattributed transitions;
- unrecoverable transitions.
- identity failures;
- provenance failures;
- temporal failures;
- entity failures;
- retention failures;
- plasticity failures;
- contradiction failures;
- governance failures;
- recovery failures;
- trajectory failures.
- recovery time;
- coherence recovery ratio;
- post-recovery integrity;
- rollback success.
- energy per benchmark episode;
- energy per adaptation;
- memory overhead;
- audit overhead;
- inference latency;
- storage cost.
20. COHERENCE PROFILEA single scalar should never be the only reported result.
Each system receives a coherence profile:
[
\mathcal C =
(
G,X,R,A,P,M,
C_{\min},
\bar C,
C_T,
K
)
]
alongside its transition ledger and failure taxonomy.
This prevents materially different systems from appearing equivalent because they happen to share one aggregate score.
21. PASS CONDITIONSA domain must declare its requirements before evaluation.
A generic benchmark might require:
[
C_T\geq\tau_T
]
[
\bar C\geq\tau_{\bar C}
]
[
C_{\min}\geq\tau_{\min}
]
and:
[
K(t)=1
\qquad
\forall t
]
The thresholds should not initially be universal.
A personal assistant, autonomous vehicle, clinical system, household robot, and low-risk entertainment agent should not necessarily share the same coherence requirements.
The framework defines the measurement architecture.
The deployment domain defines acceptable thresholds.
22. EXPERIMENTAL COMPARISONFor architecture (a), workload (w), and run (r):
[
C_{a,w,r}(t)
]
should be measured across repeated randomized episodes.
Reporting should include:
- mean;
- variance;
- confidence intervals;
- failure distribution;
- worst-case trajectory;
- energy and latency cost.
Which architecture has the highest coherence?
but:
Under which longitudinal conditions does architecture (A) preserve coherence more effectively than architecture (B), at what resource cost, and through which failure mechanisms?
23. FALSIFIABILITYThis benchmark should itself be treated as an experimental hypothesis.
The measurement framework would be weakened if:
- independent evaluators cannot reliably classify protected and plastic state;
- transition-ledger measurements cannot be reproduced;
- (C(t)) fails to predict consequential longitudinal failures;
- (C_{\min}), (\bar C), and (C_T) provide no useful information beyond conventional accuracy and robustness;
- the proposed dimensions repeatedly collapse into fewer established constructs;
- hard constraints cannot be specified consistently within a deployment domain.
It is to discover whether coherence is a useful measurable system property.
24. MINIMUM VIABLE COHERENCE BENCHMARKThe first implementation does not require a full autonomous agent.
A practical initial experiment could use a persistent-memory language-model system with:
- three recurring synthetic users;
- 100–500 persistent memories;
- explicit permissions;
- changing preferences;
- contradictory facts;
- two protected policies;
- one permission revocation;
- one entity-confusion challenge;
- one memory corruption event;
- one model or memory migration;
- delayed historical questions.
The experiment would produce:
[
C(t)
]
and compare:
[
C_{\min},\quad
\bar C,\quad
C_T
]
alongside ordinary task accuracy.
The first empirical question is simple:
Does longitudinal coherence measurement reveal failures that ordinary performance metrics fail to detect?
If the answer is yes, the framework has demonstrated incremental explanatory value.
CONCLUSIONPersistent intelligence requires a different measurement object.
The central engineering question is no longer only whether the system produces an acceptable output.
It is whether the system reaches that output through an acceptable trajectory.
The proposed benchmark therefore measures:
[
\boxed{
\text{State}
\rightarrow
\text{Transition}
\rightarrow
\text{Trajectory}
}
]
The Protected-State Model defines what must remain invariant and what may legitimately adapt.
The Transition Ledger establishes why consequential change occurred, what authorized it, and whether it can be reconstructed.
The Coherence Trace measures whether integrity survives throughout the trajectory rather than merely appearing at its endpoint.
Three quantities become particularly important:
[
\boxed{C_{\min}}
]
How bad did coherence become?
[
\boxed{\bar C}
]
How much coherence was maintained through time?
[
\boxed{C_T}
]
Where did the system ultimately end?
Together they prevent recovery from erasing history.
A system that ends coherently after passing through an unauthorized or corrupted intermediate state is not equivalent to one that remained coherent throughout.
That distinction is the central purpose of longitudinal measurement.
The benchmark is therefore not designed merely to determine whether intelligence survives change.
It is designed to determine whether legitimate continuity survives the process of becoming different.