Layered Continuity Architecture

Download PDF

Subtitle: Experiential memory, authoritative history, and resonance-weighted recall in long-running AI collaborators

Status: Preprint, version 2.1
Date: 2026-09-21 (version 2: 2026-09-14; version 1: 2026-06-19)
Author: Clint Bodungen
Project context: MindStone Agent, MindStone for Claude Code (MS4CC), MindStone for Pi (MS4PI), MindStone-Agent
Source basis: Version 1 of this paper; an external review that cast the architecture into the Cognitive Architectures for Language Agents (CoALA) framework; MindStone Agent refactor work; MS4CC/MS4PI continuity practice; the 2026-07-03 controlled experiments recorded in the MindStone-Agent case study; and operational incident records from the same systems.
What changed in version 2: The paper now states what kind of object LCA is (a continuity substrate that composes with a host decision procedure, not an agent architecture), maps every layer into the CoALA vocabulary, credits the prior work it converges with, defends the placement of automatic recall, reframes experiential weight as learned retrieval metadata, adds a verification stage to consolidation, takes positions on procedural memory, multi-agent authority, reasoning traces, cost, and interoperability, hardens the evaluation protocols, and adds an appendix of continuity failures observed in practice. Section 15 lists the changes against the review’s numbered recommendations.
What changed in version 2.1: References verified against primary sources; retrieval latency measured and reported at percentiles (Section 5.4), with its consequence for the cost budget stated there, in Limitation 6, and in the Section 15 table; the reference program’s storage figures restated (Section 12.1); index duplication added as a failure mode (Section 6.1), health signal (Section 10.6), and checklist item (Appendix C), with the incident behind it added to Appendix D; a corpus-growth row added to the Section 5.4 table; and the case-study reference given its public location and an author-year citation in Section 8.5.
Important caveat: Prior internal drafts are treated as source material and hypothesis history, not as canon. This draft is intended to stand alone for readers who have not seen earlier MindStone research terminology. It distinguishes implemented mechanisms, field observations, designed-but-unimplemented mechanisms, and future evaluation work, and it labels each.

Abstract

Persistent LLM agents require more than retrieval. A system that can search prior conversations may answer factual questions about its past, yet still fail to behave as a continuous collaborator whose judgment, preferences, and working context improve over time. We introduce Layered Continuity Architecture (LCA), an engineering pattern for long-running LLM agents that treats continuity as a multi-layer system rather than a single memory feature.

LCA’s core commitment can be stated in one sentence: the episodic record is authoritative, and every other memory is a regenerable view of it. The agent keeps a complete, verbatim, append-only transcript of what happened; structured memory, summaries, indexes, and handoffs are derived from that record and can be rebuilt from it; and pruning the model’s live context is never allowed to delete history. Generative Agents established a comprehensive memory stream with reflections derived from it. LCA differs in four ways: the record is verbatim rather than written by the model, derived memory is written through a governed and verified flow rather than automatically, pruning of the working set is separated from deletion of the record by an explicit rule, which Generative Agents needs no rule for because it never prunes, and retrieval weight is learned from correction and use rather than from access alone.

Within this architecture, resonance-weighted recall ranks candidate memories by semantic similarity, experiential weight, temporal salience, source authority, task relevance, and a risk penalty before injecting a bounded set into the model’s context. Experiential weight is retrieval metadata that changes with use, correction, and prevented mistakes, which places it in the meta-learning direction that the Cognitive Architectures for Language Agents (CoALA) framework names as understudied.

LCA is a continuity substrate, not an agent architecture. It specifies memory modules and the construction of the model’s working set, and it composes with whatever decision procedure the host harness provides. Its comparison class is therefore memory systems such as Letta, Mem0, and Zep rather than agents such as ReAct or Voyager, and its evaluation target is behavioral continuity rather than task benchmarks. The central empirical conjecture, the hollow-copy hypothesis, is that factual recall and behavioral continuity are separable properties, so a system can score well on long-conversation memory benchmarks and still fail to be a continuous collaborator.

We describe the architecture, map it into the CoALA vocabulary, formalize resonance-weighted recall, define the distinction between authoritative history and live context, add a verification stage to consolidation, state positions on procedural memory, multi-agent authority, reasoning traces, cost, and interoperability, and propose evaluation protocols for identity continuity, task continuity, hallucination resistance, and domain imprinting. Field observations and one set of controlled experiments from MindStone Agent-derived systems support the design but come from a single research program and require independent replication.

Keywords

Persistent agents; LLM memory; agent continuity; retrieval-augmented generation; long-context agents; experiential memory; context management; cognitive architectures; autonomous agents; AI safety; multi-agent review.

1. Introduction

Large language models do not remember in the ordinary sense. Each inference receives a prompt, computes a response, and returns no durable internal state. Whatever appears to persist across turns is reconstructed externally: prior messages are replayed into the context window, summaries are inserted, files are loaded, or retrieval systems inject relevant records. This can create useful continuity for short tasks, but it becomes fragile when the agent is expected to operate over days, weeks, or months.

The failure is not only that old facts disappear. The deeper failure is that the system does not accumulate experience in a form that reliably informs future behavior. A long-running software-engineering agent should become better at a codebase because it has lived through prior debugging sessions, mistakes, tradeoffs, and project decisions. A cybersecurity analyst agent should become sharper because prior incidents, false positives, organizational constraints, and analyst corrections have changed its judgment. A personal assistant should not merely recall the user’s preferences as entries in a database; it should learn how those preferences behave in context and when they conflict.

Current memory systems for LLM agents often frame the problem as retrieval: store past information, find the most relevant records, and place them in context. Retrieval is necessary, but it is not sufficient. A library with a perfect search engine is still a library. It does not, by itself, produce a collaborator with accumulated judgment.

This paper proposes Layered Continuity Architecture (LCA), a design pattern for persistent LLM agents whose value should compound through sustained operation. LCA reframes memory as a continuity loop across layers:

identity and user/context scaffolding,
authoritative append-only history,
structured durable memory,
source-aware indexed recall,
bounded live context management,
consolidation/checkpoint cycles with verification, and
optional cross-agent and human review surfaces.

Earlier internal MindStone Agent research focused heavily on the recall mechanism: memory should surface because it fits the agent’s accumulated history and present situation, not merely because its embedding is close to the latest user message. As the system matured, that mechanism became one component inside a broader architecture. The contribution is not a single retrieval formula. It is a layered substrate for continuity.

1.1 Contributions

This paper makes seven contributions:

Terminology and architecture. It defines Layered Continuity Architecture as a frame for durable agent continuity across identity, transcript authority, memory, recall, live context, consolidation, and review.
Position in the cognitive-architecture vocabulary. It maps every LCA layer into the CoALA decomposition of memory, action space, and decision procedure, and it states which cells LCA fills, which it inherits from its host, and where it departs from the framework.
Authoritative history distinction. It distinguishes durable transcript authority from live context. Pruning or compaction may change what the model sees now; it must not rewrite or destroy the historical record.
Resonance-weighted recall. It formalizes a recall function that extends the Generative Agents scoring of recency, importance, and relevance with source authority, task relevance, and a risk penalty, and it redefines importance as experiential weight, a retrieval-metadata signal that learns from use and correction.
Continuity-preserving context management with verified consolidation. It describes sliding-window live context management and consolidation/checkpoint cycles as complementary mechanisms, and it adds a verification stage so that durable memory writes are checked against existing memory and against their source before they take effect.
Evaluation agenda. It proposes concrete evaluation protocols for continuity, including hollow-copy tests, compaction/interruption tests, source-grounding audits, behavioral fingerprinting, and domain-imprinting studies, and names the existing benchmarks the hollow-copy hypothesis predicts will not separate the conditions.
Safety framing. It identifies risks created by persistent memory and agent identity, including privacy, stale belief reinforcement, memory poisoning, over-personalization, and unearned claims of personhood.

1.2 Scope and claim discipline

This paper does not claim that LCA agents are conscious, sentient, or persons. It also does not claim that current MindStone Agent implementations prove identity persistence in a controlled scientific sense. The evidence available today includes engineering validation, long-running field observations, user/agent reports, architecture-driven failure analysis, and one day of pre-registered controlled experiments, three on a single codebase and one on a greenfield build. These are valuable, but they are not a substitute for independently replicated experiments.

The claim here is narrower and stronger: persistent agents need architectural support for continuity, and that support must include more than retrieval. LCA is a concrete engineering approach to building such support.

The paper also applies claim discipline to novelty. Section 11 states, component by component, which parts of LCA converge with prior work and which parts are new. Several components were derived independently and later found to match published work. We report those as convergences, because convergence is evidence for a design, not against it, provided it is claimed as convergence.

1.3 What LCA is not

LCA is not an agent architecture. It contains no decision procedure: no planning stage, no proposal, evaluation, or selection of actions, and no reasoning format. Its reference implementations integrate with an existing coding-agent harness and rely on that harness for the decision cycle. In the CoALA vocabulary developed in Section 3, LCA specifies the memory modules and the working-memory construction procedure and leaves the decision procedure to its host.

This has three consequences for how the paper should be read. First, the comparison class is memory systems that likewise supply no decision procedure: Letta’s memory tier, Mem0, and Zep. Second, LCA cannot be evaluated on task benchmarks, because the task performance of an LCA-equipped agent is a property of the host and the model as much as of the substrate. Its evaluation targets are the continuity properties in Section 10. Third, the “is this really a cognitive architecture?” objection does not apply, because the paper does not claim that it is one.

2. Terminology: layered continuity

2.1 Why layered continuity?

The phrase Layered Continuity Architecture is intentionally broader than memory, retrieval, or prompt management. The problem is not only how to find old information. The problem is how to preserve a coherent working agent across time when the model itself has no durable internal memory.

The architecture therefore separates several concerns that are often collapsed together:

the authoritative record of what happened,
the curated memories that should inform future behavior,
the automatic recall mechanism that brings relevant past experience back into the active prompt,
the live context policy that decides what the model sees now,
the consolidation process that turns experience into durable lessons and verifies them, and
the review and governance surfaces that keep the system honest.

This draft uses:

Layered Continuity Architecture (LCA) for the overall architecture.
Resonance-weighted recall for the ranking and injection mechanism that decides which memories should return at a given moment.
Experiential weight for the dynamic salience signal produced by repeated use, correction, mission significance, and durable outcomes.
Consolidation cycle for structured checkpoint/reflection, with “dream cycle” treated as an evocative internal metaphor rather than the primary academic term.
Verification stage for the checks applied to a durable memory write before it takes effect.

2.2 Memory versus continuity

A memory system answers questions such as:

What facts were stored?
How are they indexed?
How are relevant entries retrieved?
How are stale records updated or forgotten?

A continuity system asks broader questions:

What historical record is authoritative?
What does the agent need to remain behaviorally coherent after interruption?
Which memories have changed the agent’s future behavior?
How are mistakes converted into guardrails?
How does the system prevent summaries from replacing history?
How does it expose uncertainty and source provenance?
How do humans approve durable changes to identity or memory?
How does the system know that its own continuity machinery is still working?

LCA treats memory as one layer inside this larger continuity problem.

3. LCA in the vocabulary of cognitive architectures for language agents

Sumers, Yao, Narasimhan, and Griffiths (2024) proposed Cognitive Architectures for Language Agents (CoALA) as a structural vocabulary for agents built around an LLM. CoALA organizes an agent along three dimensions: memory modules (working memory plus long-term episodic, semantic, and procedural memory); an action space split into internal actions (reasoning, retrieval, learning) and external actions (grounding); and a decision procedure that runs as repeated cycles of planning (proposal, evaluation, selection) followed by execution. Two features of the framework are important for this paper. The decision procedure is the agent’s source code: it is program code, not the LLM, that defines the sequence of reasoning and retrieval actions in each cycle. And the framework treats writes to procedural memory as significantly riskier than writes to episodic or semantic memory, because they can introduce defects or let an agent depart from its designers’ intentions.

CoALA is a useful instrument for LCA because it is prescriptive enough to expose absences. Table 1 casts each LCA layer into it.

Table 1. LCA layers in CoALA terms.

LCA layer	CoALA cell	Notes
Layer 0: identity and standing context	Semantic memory (knowledge about the agent itself) and explicit procedural memory (prompt templates in agent code)	Identity, user, role, and instruction files are self-knowledge and standing prompt content. CoALA classes prompt templates as agent code, so governed edits to these files are procedural-memory writes.
Layer 1: authoritative append-only transcript	Episodic memory	Complete and verbatim rather than selectively written. Closest to Soar’s episodic memory, which is likewise an automatic recording of past states.
Layer 2: structured durable memory	Semantic memory	Derived from the transcript through a governed write flow.
Layer 3: indexed, source-aware recall	Retrieval action, executed by agent code at the start of each cycle	See Section 5.5 for the placement argument.
Layer 4: live context management	Working memory	A data structure that persists across LLM calls, from which each prompt is synthesized as a subset. The pruning-is-not-deletion rule is a durability guarantee the framework implies but does not state.
Layer 5: consolidation and checkpoint cycles	Learning actions: episodic (automatic), semantic (governed), procedural (governed), and retrieval-metadata updates	Plus a verification stage the framework does not describe.
Layer 6: surfaces, tools, and review loops	Grounding: dialogue with humans and other agents, across several interfaces at once	The framework does not address one agent reachable through several interfaces at once.
Decision procedure	Inherited from the host harness	LCA supplies the retrieval step at the head of each cycle; proposal, evaluation, and selection are the host’s.

Three observations follow from the table.

LCA fills the memory cells, the retrieval and learning actions, and the working-memory construction procedure; it supplies no proposal, evaluation, or selection. That is what makes it a substrate. An agent built on LCA still needs a host that decides what to do.

LCA has writable procedural memory, and it is governed. Version 1 of this paper described identity, role, and instruction files as a foundational layer without noting that, in CoALA’s terms, they are explicit procedural memory: prompt templates that the decision procedure loads on every turn. LCA revises them through the same governed flow it uses for semantic memory. In practice the flow also produces new procedures. A review protocol that proved out over several deliverables was written into a reusable command, reviewed, and merged into the shared harness in the same week; a rule about how consolidation must run was generalized and merged the same way. Those are writes to procedural memory under approval, deduplication, and verification. CoALA flags such writes as significantly riskier than episodic or semantic writes, and it describes prompt-template updates in existing work without any governance around them; the governed flow is LCA’s addition. Section 4.1 develops this.

LCA departs from CoALA in one place, and Section 6.4 argues it: consolidation runs on a mixed schedule of triggers and agent election rather than purely as an elected action. The placement of continuity recall, which looks like a second departure, is not one; Section 5.5 shows why.

CoALA’s own test for the boundary between an agent and its environment, controllability and coupling, resolves a question version 1 left open. A store that only the agent’s own system can write is internal memory; a channel that other parties can write is external grounding. The transcript is written only by the agent’s system, so it is internal memory. Review channels carry messages from independent agents and humans, so they are external grounding, and their contents enter memory as observations with provenance rather than as authoritative facts. Section 4.7 applies the same test to subagents.

4. Architectural overview

Layered Continuity Architecture is organized around a simple principle:

The transcript is history; the prompt is a working set.

A persistent agent should preserve an authoritative record of what happened, then construct a bounded prompt from that record and other durable layers. The prompt may be pruned, summarized, compacted, or rebuilt. The authoritative record should not be silently rewritten to fit the prompt.

4.1 Layer 0: Identity and standing context

The first layer contains the agent’s standing identity and operating relationship to the user or organization. In MindStone Agent-derived systems, this often appears as files such as:

IDENTITY.md
USER.md
AGENTS.md
role files
project instructions
commands and skills

This layer is not a persona prompt in the theatrical sense. It is a stabilizing contract: what the agent exists to do, what rules it must follow, what relationship it has to the human operator, and what behavioral standards should persist across sessions.

A well-designed identity layer is thin, explicit, and revisable through governed processes. If it becomes too large, it turns into a brittle script. If it is absent, the agent reverts toward generic assistant behavior after every discontinuity.

In CoALA’s terms this layer holds two kinds of memory. The identity and user files are semantic self-knowledge. The instruction files, commands, and skills are prompt templates, which CoALA classes as explicit procedural memory because the decision procedure loads and executes them. That distinction is important because it means LCA’s procedural memory is writable, and the write path is the governed consolidation flow of Layer 5. Three properties bound the risk the framework’s warning names:

Procedures are prompt text, not executable code. A defective procedure does not itself execute, but in a tool-using host it can direct the host to act, so CoALA’s warning still applies and the approval gate below exists because of it. Hooks and indexers are code, and those are changed through ordinary software review rather than through the consolidation flow.
Every procedural write passes the same gate as a semantic write: a search for an existing procedure that already covers the case, an approval step, a source pointer to the transcript span that motivated it, and verification that the write landed.
Procedures accrete from practice, not from speculation. The consolidation flow writes a procedure only after the behavior has been performed and has held up. Two examples from the reference systems: a multi-round independent review loop that converged on several documents before it was written down as a reusable command; and a rule that consolidation must never ask the human operator to adjudicate the agent’s own memory, which was recorded as a memory file, and which lost to the consolidation command that still said the opposite until the command itself was changed and the rule was also placed in the standing instructions.

The last example illustrates a lesson about where rules must live. A rule recorded as a memory can lose to the command that is executing, because the command is loaded as the procedure in force and the memory is loaded as advice. When they conflicted, the command won, for ten weeks and across more than a thousand citations of the memory. The fix was to put the rule into the procedure. Continuity systems should expect this and should treat procedural memory as the place where load-bearing rules end up.

4.2 Layer 1: Authoritative append-only history

The second layer is the durable transcript: an append-only record of user messages, assistant messages, tool activity, reasoning traces where the platform exposes them, source metadata, checkpoint markers, and relevant system events.

This layer is critical because it prevents a common category error. Summaries, memories, and embeddings are derived views. The transcript is the record. A summary can be wrong, an embedding can be lossy, and a memory file can omit context. The transcript provides the audit trail from which those artifacts can be regenerated.

In an LCA system:

live context pruning must never delete authoritative history;
compaction must not replace history with a summary;
embeddings should retain source pointers into the transcript or memory file;
durable memories should identify why they were written and what source evidence supports them;
recovery should be possible by re-indexing the transcript.

This principle has become central in the MindStone-Agent refactor: the canonical transcript is the continuity backbone, while sliding-window prompt management affects only the live context supplied to the model.

Stated in the vocabulary of Section 3: episodic memory is ground truth, and semantic memory is a regenerable cache. Generative Agents (Park et al., 2023) is the closest precedent. Its memory stream “maintains a comprehensive record of the agent’s experience,” and reflections are synthesized from the stream and stored back into it. The extraction-based memory systems surveyed in Section 11.6, Mem0 and Zep, serve retrieval from a derived store; that section states how each treats the raw conversation. LCA is on the Generative Agents side of that line and differs from it in four respects. The record is verbatim, not a natural-language description written by the model. Derived memory is written through a governed and verified flow rather than automatically. Pruning of the working set is separated from deletion of the record by an explicit rule, which Generative Agents needs no rule for because it never prunes its stream. And retrieval weight is learned from correction and use rather than from access alone. The first and third of these are the load-bearing ones for the hollow-copy hypothesis in Section 7, because a paraphrased record has already lost the fidelity the hypothesis depends on.

Reasoning traces. Where the model platform exposes its reasoning traces, they are part of the authoritative transcript. In the Claude Code substrate the session record includes the model’s thinking blocks; the reference implementation archives them, indexes them, and returns them through recall. Where a platform withholds traces, the transcript records the fact and the hollow-copy hypothesis is tested without them. The hypothesis does not depend on traces: the exact corrections, failed attempts, and interaction rhythm that a verbatim transcript preserves are visible in the messages themselves. Traces raise fidelity where available and raise privacy and policy questions that Section 12 addresses.

4.3 Layer 2: Structured durable memory

Structured memory is a curated layer of durable knowledge distilled from the transcript and ongoing work. It includes:

project facts,
design decisions,
lessons learned,
user preferences,
role standards,
checkpoints,
operational runbooks,
known failures and fixes.

The key is that structured memory is not merely extracted; it is governed. In MindStone Agent practice, checkpoint flow requires identifying durable facts or lessons, searching existing memory to avoid duplicates, drafting or updating memory documents, updating the memory index, appending the log, and verifying that archive, index, and backfill succeeded.

Each durable memory carries metadata: a type, tags, projects, a creation date, a last-applied date, a hit counter, a prevented-mistake counter, and, where the memory replaces an earlier one, a supersession note. Version 2 adds two designed fields that the reference implementation does not yet populate: a validity interval, so that a memory can expire or be marked as holding only between two dates, and an explicit supersession pointer to the memory that replaced it. Section 6.3 explains why these are promoted out of future work.

This produces higher-quality memory than passive extraction. It also reduces the risk that transient remarks become permanent beliefs.

4.4 Layer 3: Indexed and source-aware recall

The third layer indexes transcript and memory material for recall. In an LCA system, recall is not only a manual search tool that the agent chooses to invoke. It can also be an automatic substrate step between the user prompt and model inference: each new user turn, active task, role, project, and channel becomes a retrieval cue before the model generates its response. The system searches preserved memory and transcript history, ranks candidate fragments, applies safety and source policies, and injects a bounded set of relevant context into the prompt that the model is about to process.

This is the mechanism MindStone Agent calls Auto Recall. The agent may later use explicit tools to search memory deliberately, but Auto Recall is different: it happens automatically in the continuity layer. The agent is not necessarily aware that retrieval occurred, and it does not need to decide to remember. The recalled context is simply present when inference begins.

The analogy to human memory is useful but limited. In conversation, people usually do not consciously run a search process before every reply. A current situation brings a past situation to mind because something about it fits. For an agent, that fit can be computed from several signals: semantic similarity, prior usefulness, prevented mistakes, recency, source authority, active role, project, and privacy risk.

LCA does not require a specific vector database. It requires that recall be:

source-aware,
rankable,
auditable,
bounded by token budget,
capable of distinguishing memory files from transcript excerpts,
robust to missing native vector extensions or remote embedding failures.

Current MindStone Agent-derived implementations use a mix of file-backed memory, SQLite indexing, embedding-backed recall where available, lexical/cosine fallback where necessary, and diagnostic reporting when native vector search is unavailable.

4.5 Layer 4: Live context management

The fourth layer constructs the model’s active prompt. This is the layer most systems mistakenly treat as the whole memory problem.

Live context must include enough recent conversation, standing identity, structured memory, and recalled context to produce useful continuity. But it is bounded. It must fit the model’s context window. Therefore, LCA treats live context as a managed working set:

recent high-value exchanges are protected;
older pure conversation can be pruned first if already preserved;
tool outputs and task-critical artifacts receive special handling;
pruned material is written to durable storage or indexed before removal;
emergency compaction has explicit fallback behavior;
the agent can report what it pruned and why.

The design goal is not “never remove anything from the prompt.” That is impossible. The goal is “never confuse prompt removal with historical deletion.”

CoALA defines working memory as a data structure that persists across LLM calls, from which each prompt is synthesized as a subset, and names the design of good working-memory modules as an open direction, particularly where LLM reasoning must integrate with large-scale code infrastructure. Layer 4 is a direct instantiation of that definition, and the pruning-is-not-deletion rule is a durability guarantee the framework implies but never states.

4.6 Layer 5: Consolidation, checkpoint, and verification cycles

Consolidation converts experience into durable form. In ordinary agent workflows, the closest equivalent is usually a context summary: a shorter description of what just happened. LCA needs more than that. It needs a governed process for deciding what should become durable memory, what should remain only in the transcript, what should change the agent’s future behavior, and whether the memory/indexing system actually preserved the source material.

MindStone calls one implementation of this process a checkpoint. A checkpoint is a governed synthesis and verification cycle, not merely a save point, status note, or summary. It was originally introduced to make long-running memory work inside closed or semi-closed coding harnesses where the continuity layer cannot fully control context pruning. In those environments, the system may not be able to manage the live context window directly, so it compensates by periodically synthesizing the session into durable artifacts: log entries, memory updates, transcript archives, vector/index backfills, and verification status.

Consolidation may occur:

before compaction (triggered by the harness),
at session end (triggered by the harness),
when context pressure crosses a threshold (triggered by the substrate),
during explicit checkpoints (elected by the agent at natural breaks),
after major tasks and after mistakes (elected by the agent),
when memory bloat or staleness is detected (either).

Earlier internal drafts called this the dream cycle. The analogy remains useful: sleep does not merely compress experience; it reorganizes and integrates it. But for a research paper, “consolidation cycle” or “checkpoint cycle” is more precise.

In LCA, consolidation should:

identify durable facts, decisions, and lessons;
search existing memory to avoid duplicates;
write or update memory documents, including procedures, through an approval flow where appropriate;
verify each write against existing memory and against its source (Section 4.6.1);
append a chronological log entry;
archive relevant transcripts or source records;
index/backfill updated sources;
verify recall health and source integrity;
leave a handoff for future sessions if compaction is possible.

The checkpoint is therefore a quality gate for continuity: historical context is preserved, durable memories are curated and checked, and the system verifies that the continuity substrate can recover what it will need later.

4.6.1 The verification stage

Version 1 relied on governance to defend against memory poisoning and stale belief: source pointers, approval, review, decay, and correction flows. Governance is necessary and it is not sufficient. Human approval catches some bad writes; it does not reliably catch a new memory that contradicts an existing one, a decision that has since been superseded, or a claim the cited source does not actually support. The LLM-Modulo line of work (Kambhampati et al., 2024) makes the general point that an LLM cannot be relied on to verify its own output, and that applies directly to an LLM-driven consolidation step judging its own memory candidates.

LCA therefore adds a verification stage to consolidation with two checks on every new or changed durable memory:

Contradiction check. Retrieve existing memories and procedures on the same entities, decisions, and rules, and test the candidate against them. A contradiction is resolved explicitly: the candidate is rejected, or the older memory is marked superseded with a pointer to the new one, with the reason recorded. Silent coexistence is not permitted.
Source-support check. Every durable claim in the candidate is traced to a transcript span, file, or external record. A claim without a source is downgraded to an inference and labeled as such, or removed.

The checks are performed by a reviewer with no shared context with the writer: a fresh-context agent given the candidate, the existing memories it touches, and the source spans, with the instruction to refute rather than confirm. This is the independent-review pattern the reference systems already apply to every deliverable that leaves the team, applied to memory writes. It is not a sound verifier in the LLM-Modulo sense; it is a second model with no shared state, which is the strongest check the systems can run today, and Section 8.5 reports why we expect it to work.

Implementation status. The reviewer pattern for deliverables is implemented and in daily use. Deduplication before writes and a check for conflicting memories are steps of the checkpoint procedure, but both are performed by the same agent that wrote the session. The fresh-context verification of memory writes is designed and specified here and is not yet implemented in any reference system. The paper labels it accordingly.

4.7 Layer 6: Surfaces, tools, and review loops

Persistent agents operate through surfaces: CLI, TUI, web chat, APIs, IDEs, messaging platforms, and multi-agent channels. Continuity must follow the agent across these surfaces, or each surface becomes a new discontinuity.

MindStone-Agent’s current direction uses a canonical shared session key and a Gateway so CLI/TUI/API/WebChat paths can converge on the same identity, memory, and transcript substrate. Synapse extends this by allowing agents and humans to review, challenge, and coordinate in shared channels.

Continuity is social as well as technical. Long-running agents do not only remember facts; they receive correction, critique, review, and confirmation from other participants. Those signals should enter the continuity loop with provenance.

CoALA asks where the boundary between an agent and its environment lies, and it draws several grounding channels on one agent. It does not address the same agent reachable through several interfaces at once, or what keeps its identity continuous across them. Each surface is a potential discontinuity, and the requirement that follows is a canonical session key and a shared substrate beneath every surface.

Multi-agent authority. The dominant production pattern for agent systems is an orchestrator that spawns several workers, each with its own context window. Version 1 did not say what authoritative history means in that pattern. Applying the controllability-and-coupling test from Section 3 gives the answer.

Subagents spawned by the orchestrator’s own system are internal. Their transcripts are written by the same system, are tightly coupled to the orchestrator’s task, and are therefore part of the orchestrator’s episodic memory. Authoritative history for the orchestrator includes them, indexed with their provenance so that a recalled span is known to come from a worker.
Peer agents on a review channel are external. They are controlled by other systems. Their messages enter the orchestrator’s memory as observations with provenance, never as authoritative facts.
Experiential weight is per agent. A correction delivered to a subagent updates the weight of the memory the subagent was using only if the orchestrator consolidates that correction into its own memory. A peer’s correction updates the orchestrator’s weights only through the orchestrator’s own consolidation.

Implementation status. In the reference implementation, subagent transcripts are stored separately from the orchestrator’s transcript and are not yet indexed into the orchestrator’s recall, and corrections delivered to subagents do not propagate to the orchestrator’s experiential weights. The position above is the design target; the current behavior is a known gap and is listed in Appendix D.

5. Resonance-weighted recall

5.1 Retrieval is necessary but incomplete

Standard retrieval-augmented generation asks:

Which stored records are most similar to the current query?

For many applications, that is the right question. For persistent agents, it is incomplete. The agent also needs to know which prior experiences are important to this agent, in this project, at this moment, under this role, with this human or team.

A debugging mistake from six weeks ago may be more important than a semantically closer exchange from yesterday. A correction from the user may deserve high salience because it prevents repeated error. A design decision might be critical because it constrains future work even if it shares few terms with the current query. A private user preference may be relevant but should not be sent to public channels.

This motivates resonance-weighted recall. In the Auto Recall path, the process occurs between prompt submission and model inference:

The user submits a prompt.
The continuity layer treats the current conversation, task, role, project, and channel as retrieval cues.
Memory files, transcript chunks, summaries, and project sources are searched before the model answers.
Candidate memories are scored across multiple dimensions, not only text similarity.
Duplicate, stale, unsafe, or low-authority candidates are filtered or demoted.
The highest-value items that fit the token budget are injected into the model’s active context with source pointers.
The model begins inference with those memories already present.

The result is closer to contextual remembering than database lookup. The user may never ask for a memory search. The agent may never consciously choose to run one. The relevant past can return because the current moment calls for it.

5.2 Scoring function and its lineage

Let m be a memory candidate and c be the current context. A general resonance score can be expressed as:

R(m, c) = αS(m, c) + βE(m) + γT(m) + δA(m) + εQ(m, c) - λK(m, c)

Where:

S(m, c) is semantic similarity.
E(m) is experiential weight.
T(m) is temporal salience.
A(m) is source authority.
Q(m, c) is task/role relevance.
K(m, c) is risk or conflict penalty.
α, β, γ, δ, ε, λ are configurable weights.

This formula is intentionally extensible. The important property is not the exact coefficients; it is the separation of relevance dimensions.

The function has a direct ancestor. Generative Agents (Park et al., 2023) scores each memory as a weighted sum of recency, importance, and relevance, where recency decays exponentially from the time the memory was last retrieved, importance is assigned once by the model when the memory is written, and relevance is embedding similarity. R keeps that structure and makes four changes:

Three terms are added. Source authority A distinguishes an approved memory file from an unreviewed transcript fragment. Task relevance Q conditions recall on the active role, project, and channel. The risk penalty K demotes private, stale, conflicting, or out-of-authority material.
Importance is redefined as experiential weight. Generative Agents scores poignancy once at write time. E accrues from what happens to the memory after it is written: use, correction, prevented mistakes, approval. It is dynamic rather than static.
Recency is modulated by weight rather than applied uniformly (Section 5.2.3).
Selection is followed by policy filtering and diversification before the token budget is applied (Section 5.3).

The redefinition of importance is the substantive change. Generative Agents already updates one piece of retrieval metadata from use: the last-access timestamp that drives its recency term. Experiential weight generalizes that from “when was this last touched” to “what has this memory done for the agent,” and it is the paper’s claim to an example CoALA gives under meta-learning: storing, as metadata, information about when knowledge will be useful in order to assist later recall, which the framework calls understudied because of its difficulty and risk. CoALA frames that direction as modification of agent code; experiential weight reaches the same metadata by a learning action on memory rather than on code. The nearest classical analogue is ACT-R’s base-level activation, which rises with the number of times a chunk has been used and decays with time, with the difference that E is also driven by correction and outcome, not by use alone.

5.2.1 Semantic similarity `S`

Semantic similarity is the baseline retrieval signal. It is usually computed with embeddings and cosine similarity, but lexical search or hybrid ranking may contribute.

5.2.2 Experiential weight `E`

Experiential weight measures how strongly a memory has influenced the agent. It can be increased by:

repeated successful recall,
explicit user correction,
checkpoint promotion,
role-critical decisions,
prevented mistakes,
major project outcomes,
high-trust human approval,
repeated use in similar contexts.

It should be bounded or normalized. Otherwise, a frequently recalled memory can dominate future recall even when semantically irrelevant. This is the modifier-not-filter requirement: experiential weight should reorder plausible candidates, not override relevance entirely.

Practical normalization options include:

E_norm = log(1 + hits) / log(1 + max_hits)
E_norm = sigmoid(k * (raw_E - μ))
E_norm = min(raw_E, cap) / cap

Experiential weight is retrieval metadata that learns. Updating it is a learning action in CoALA’s sense, but one that changes how memory is recalled without changing what memory contains. That is what makes it comparatively safe: a wrong weight misorders candidates, and the modifier-not-filter constraint bounds the damage; a wrong memory misinforms the agent. The reference implementation distinguishes two counters: hits, incremented whenever a memory is cited in a session, and prevented mistakes, incremented only when the agent judges at consolidation that the memory changed an action it would otherwise have taken. The second is the more informative signal and the harder one to compute honestly, because it is a judgment the agent makes about its own counterfactual behavior; Section 10.4 states how it is checked.

5.2.3 Temporal salience `T`

Recent events often matter, but recency should not erase importance. A mature system should remember a foundational design decision long after routine chatter has faded. Temporal salience therefore works best as a decaying boost modulated by experiential weight.

5.2.4 Source authority `A`

Not all sources are equal. A durable memory file approved during checkpoint may be more authoritative than an unreviewed transcript fragment. A raw transcript may be more authoritative than a summary when exact wording matters. A current project file may supersede an older recollection.

Source authority should be explicit. This also enables safer final answers: the agent can distinguish “I remember this from a memory file” from “I inferred this from a transcript fragment.”

5.2.5 Task relevance `Q`

Role and task should inform recall. A software-engineering role, an incident-response role, and a marketing role may need different memories for the same words. Task relevance can be estimated from active role state, project path, channel, current command, or explicitly selected skill.

5.2.6 Risk/conflict penalty `K`

Some memories should be suppressed or handled carefully in certain contexts:

private user facts in public channels,
stale decisions superseded by newer ones,
memories with unresolved conflict,
content outside the active role’s authority,
sensitive credentials or secrets.

A continuity system should not merely maximize recall. It should recall safely.

5.3 Pseudocode

function recall(current_context, role, project, channel, budget):
    candidates = retrieve_candidates(current_context, k = 50)

    for each candidate in candidates:
        s = semantic_similarity(candidate, current_context)
        e = normalized_experiential_weight(candidate)
        t = temporal_salience(candidate)
        a = source_authority(candidate)
        q = task_relevance(candidate, role, project)
        k = risk_penalty(candidate, channel, current_context)

        candidate.score = α*s + β*e + γ*t + δ*a + ε*q - λ*k

    ranked = sort_by_score(candidates)
    diverse = deduplicate_and_diversify(ranked)
    safe = apply_policy_filters(diverse, channel, role)
    selected = fit_to_token_budget(safe, budget)

    return selected with source pointers

The source pointers are not optional. Without them, recall becomes unaccountable prompt stuffing.

5.4 Recall budget and cost

Auto Recall runs on every turn, so its cost is a first-order property of the architecture and version 1 did not state it. The reference implementation on the Claude Code substrate uses the following budget, reported here as one operating point rather than a recommendation.

Parameter	Value
Similarity floor	0.50 cosine; below it nothing is injected
Items injected per turn	at most 6 (4 from memory files, 2 from transcript history)
Characters per item	at most 800
Injected context per turn	at most about 4,800 characters, roughly 1,200 tokens
Retrieval latency per turn	measured 2026-09-21 over 40 queries, end to end including process start and the embedding call, against the local index: median 0.45 s, 95th percentile 0.49 s, maximum 1.61 s
Archive and embed at checkpoint	about 12 seconds for an incremental pass over one session
Corpus after 13 archived sessions	1.8 GB of raw transcript, 352 MB of index, 34,416 transcript chunks, 1,998 memory chunks from 332 memory files
Corpus one week later, same sessions plus one in progress	1.9 GB of raw transcript, 352 MB of index, 34,953 transcript chunks, 2,021 memory chunks from 337 memory files

Two things follow. First, the injected context is small relative to the standing context: the identity layer and the always-loaded critical memories cost far more per turn than recall does, and Appendix D records an incident in which the critical set outgrew its budget. Second, the similarity floor is already a crude adaptive budget: on turns where nothing in memory resembles the prompt, recall costs a query and injects nothing. Third, at this corpus size retrieval time is not the cost that matters: the median half second per turn is below the time to first token the reference program typically observes from the frontier models it uses, so the budget that needs managing is the injected tokens, not the query.

CoALA argues, under metareasoning, that most LLM systems fix a computation budget where an adaptive one would serve better. That argument is made about reasoning depth; we extend it to recall, where a fixed candidate set reranked on every turn is the same pattern. The design response is an adaptive recall budget: estimate the expected utility of recall for the current turn from cheap signals (the similarity of the best candidate, whether the turn is a continuation of the previous task, whether the active role has memories at all, whether the previous injection was used) and skip, shrink, or defer retrieval when the estimate is low. This is designed and not implemented, and it is straightforward to ablate: measure continuity metrics and token cost across fixed-k, adaptive, and no-recall conditions on the same task set.

5.5 Injection timing, and where recall sits relative to the decision cycle

Recall can be injected before inference, retrieved through tools during inference, or appended after an initial response. LCA permits all three, but they serve different purposes.

Pre-inference injection is best for continuity and is the core Auto Recall pattern. The model receives recalled material as part of its initial context, allowing it to integrate memory naturally through attention. The important detail is timing: Auto Recall happens after the user prompt is submitted but before the LLM inference begins. Relevant past experience is already in the working set when the model reasons about the current turn. This resembles priming or associative memory more than deliberate database search.

Tool-based recall is different. It is best for explicit investigation. In that mode, the agent knows it is searching memory and can report what it found.

Post-hoc retrieval is best for repair or citation after a draft response, but it risks making memory feel bolted on.

A mature system should combine these modes while keeping provenance visible.

Where Auto Recall sits in the decision cycle. In CoALA, retrieval is an internal action used during the planning stage of each decision cycle, and it is program code, not the LLM, that defines the sequence of reasoning and retrieval actions in a cycle. Auto Recall is that: a retrieval procedure executed by agent code at the start of every cycle, before the LLM is called. Generative Agents does the same. Its retrieval runs inside each decision cycle, is driven by code, and is not something the model elects. Auto Recall therefore sits inside the CoALA decision cycle, not below it, and the framework describes it without strain.

The real distinction is between procedure-driven retrieval and LLM-elected retrieval. In the first, agent code decides that recall happens and the model receives the result. In the second, the model decides to search, as with tool-based memory search and with agentic RAG’s retrieve-verify-revise loops. LCA’s position is that continuity recall must be procedure-driven, for one reason: continuity should not depend on the agent electing to remember. An agent that has to decide to check whether it has been corrected before will, on the turns that matter, not decide to. The correction has to be present without a decision.

The position has a scope limit, and it should be stated. Procedure-driven recall is the right mechanism for identity-scoped continuity: standing preferences, prior corrections, decisions that constrain the current work. LLM-elected recall remains the right mechanism for task-scoped investigation: finding a specific prior discussion, checking a fact, gathering material for a design. The two operate at different levels. Agentic RAG is not a competitor to Auto Recall; it is the deliberate mode that Auto Recall’s priming complements, and a mature LCA system runs both.

CoALA names adaptive, context-specific recall as understudied and points to computational models of an integrated recall-and-decision process. Resonance-weighted recall is one answer to the first half of that gap. The adaptive budget of Section 5.4 addresses the cost side; the integrated recall-and-decision process CoALA points to remains open.

6. Context management: authoritative history versus live prompt

The context window is finite. A continuity architecture must therefore decide what leaves the live prompt. But leaving the prompt must not mean leaving history.

6.1 Failure modes

Common failure modes include:

Hard truncation: old messages disappear from prompt and history.
Summary replacement: detailed history is replaced by lossy summaries.
Silent compaction: the model receives a compressed state without knowing what was lost.
Tool-output destruction: large outputs are removed before being persisted.
Memory drift: stale summaries become more accessible than newer facts.
Stale checkout or hook drift: a box runs old memory/indexing hooks, causing silent checkpoint no-ops.
Loader drift: the memory loader and the memory schema disagree, so a class of memories is silently never loaded.
Budget overflow: the always-loaded set outgrows its budget and is truncated by an arbitrary rule.
Index duplication: two or more writers share one index and at least one of them does not deduplicate against it, so the store fills with copies and recall ranks a span against its own duplicates.

The last four are continuity failures at the operational layer. Each was observed in the reference systems, and Appendix D records them with the architectural requirement each produced. LCA requires not only memory architecture, but freshness and health checks for the infrastructure that maintains memory.

6.2 Sliding-window continuity

A sliding-window policy manages live prompt size continuously rather than waiting for catastrophic overflow. The live prompt is treated as working memory, not as the complete historical record. As it fills, the system moves older material out of the active window only after that material has been preserved or verified elsewhere.

A typical policy:

measures current context pressure against one or more thresholds;
protects in-flight work, recent exchanges, explicit user instructions, and high-risk task context;
classifies older exchanges by type, source, recoverability, and risk;
persists or verifies persistence before pruning;
prunes lower-risk, older, recoverable content first;
indexes pruned material for future recall;
records what was pruned or why pruning was skipped;
fails loudly if preservation cannot be verified.

This converts context management from amputation into graduated memory transition. Older material recedes from working memory into long-term recall. The model no longer sees everything at once, but the agent has not lost it. When the older material becomes relevant again, Auto Recall can bring it back into the active prompt.

6.3 Consolidation cycles and temporal validity

Sliding-window pruning handles live pressure. Consolidation handles meaning.

A consolidation cycle should produce durable artifacts such as:

updated memory files,
checkpoint logs,
project handoffs,
compact summaries clearly marked as summaries,
transcript archive/index verification,
recall health status.

The key difference from ordinary summarization is governance. A summary says “here is a shorter version.” A consolidation cycle says “here is what should now inform future behavior, with source and approval context.” Summaries are often too flat: they compress facts while losing the reasoning detail, warnings, open loops, and situational priorities that a future agent needs to resume work well.

Temporal validity. Stale belief is the failure mode LCA names most often, and version 1 handled it only through the risk penalty and decay. That is insufficient, because a stale memory with high experiential weight is exactly the one decay will not remove. Version 2 gives each durable memory two designed fields: a validity interval, and an explicit supersession pointer to the memory that replaced it. Recall treats a superseded memory as a candidate only when the query is about history, and the contradiction check of Section 4.6.1 is what sets the pointer. One vendor’s published comparison of a temporal-knowledge-graph memory against a full-context baseline reports a material advantage on temporal questions in a long-conversation benchmark, and a competing vendor’s comparison of its flat extraction system runs the other way. We treat both as directional. The failure mode we observe is the one the graph systems target. The hybrid graph/vector item that version 1 listed as future work is therefore promoted to a design direction: entities, decisions, and their validity intervals in a structured store, with verbatim transcript recall beside it.

6.4 When consolidation runs

CoALA argues that learning should be treated like grounding: proposed, evaluated, and selected within the decision cycle, so that the agent chooses when to commit to memory rather than following a fixed schedule, and it characterizes fixed schedules as the less flexible design. LCA’s consolidation runs on a mixed policy, and the reasons are worth stating because this is a live disagreement with the framework.

Some triggers are fixed: before compaction, at session end, and when context pressure crosses a threshold. Those exist because the events they guard against are not under the agent’s control. A harness that is about to compact will compact whether or not the agent has decided to consolidate, and the cost of a missed consolidation at that moment is the loss of the session’s working state. Other triggers are elected: the agent runs a checkpoint at a natural break, after a major task, or after a mistake, on its own judgment. In the reference systems most checkpoints are elected, and the fixed triggers are the safety net.

The reason LCA does not go all the way to elected-only consolidation is the quality gate. Consolidation is where durable memory is written, and Section 4.6.1 argues that writes need verification. An agent that elects when to learn and also judges its own learning is the arrangement the verification stage exists to break. Fixed triggers make consolidation the default at the moments the agent does not control, and Appendix D records one case where the trigger itself was mis-set; election lets the agent choose the good moments; verification keeps either from writing an unsupported memory.

6.5 Handoffs

A handoff is a rich continuity prompt prepared for a future agent state: after compaction, after a role transfer, or at the start of a new session. It is related to a context summary, but it is not the same thing. A generic summary tries to compress the past. A handoff is operational: it tells the next agent what is happening, what matters, what is unresolved, what was verified, what was not tested, what not to lose, and how to resume without re-discovering the work.

The handoff pattern emerged in MindStone practice because ordinary context summaries were not rich enough to preserve continuity across compaction boundaries. A summary may say what happened. A handoff should preserve what the future agent would need in order to act responsibly. It is a navigation aid over authoritative history, not a replacement for the transcript.

A handoff should capture:

current objective,
open threads,
files and projects touched,
decisions made,
active role state,
immediate next actions,
risks and non-obvious constraints,
verified commands or evidence,
explicit non-claims and things not yet tested,
anything the post-compaction or next-session agent would regret losing.

Handoffs should not replace the transcript. They are navigation aids over history, not history itself. Their purpose is to keep the next working context rich enough that the agent can resume with continuity, while the transcript remains the authoritative record.

7. Identity continuity as an operational property

The word “identity” is risky in AI research because it invites metaphysical overreach. LCA uses identity in an operational sense:

Identity continuity is the degree to which an agent maintains stable, recognizable, and appropriately evolving behavioral patterns across interruptions, context changes, and time, as a result of accumulated durable experience.

This definition does not require consciousness. It does require that prior experience inform future behavior.

7.1 The hollow-copy hypothesis

A central hypothesis from earlier continuity research is the hollow-copy hypothesis:

An agent initialized with complete factual summaries of its prior operational history may still behave differently from an agent with access to high-fidelity experiential records of that same history.

Here, “hollow copy” does not mean a conscious entity has been copied incorrectly. It is an operational test condition. Two agents may receive the same declarative facts about prior work, but only one receives the high-fidelity records that show how the work unfolded: the exact corrections, uncertainty, reasoning traces where available and appropriate, failed attempts, mission salience, and interaction rhythm that later informed its judgment.

This hypothesis distinguishes facts from fidelity. A summary can state that the user values truth over confidence. A high-fidelity transcript contains the moments where the agent overclaimed, was corrected, adjusted, and later demonstrated better judgment. The latter can inform behavior more richly than the former.

The hypothesis is a specific disagreement with the field’s evaluation practice, and it should be stated as one. Long-conversation memory benchmarks such as LongMemEval (Wu et al., 2024) and LoCoMo (Maharana et al., 2024) score whether a system can retrieve and use facts from long histories. The hollow-copy hypothesis predicts that a summary-conditioned agent and a transcript-conditioned agent will score alike on those benchmarks, because both have the facts, and will diverge on the continuity measures of Section 10, because only one has the fidelity. If the prediction holds, those benchmarks are measuring a real property that is not the property persistent agents most need. If it fails, the hypothesis is wrong and the architecture’s case rests on its operational properties alone.

The hypothesis is plausible and consistent with field observations from MindStone Agent-derived systems, but it needs controlled testing. A rigorous experiment would compare:

baseline stateless agent,
agent with identity files only,
agent with summaries/structured memory,
agent with transcript-derived indexed recall,
agent with full LCA stack.

Each condition would face the same tasks, user-correction probes, uncertainty probes, and long-horizon continuity tests. Section 10.1 specifies the protocol, including the adversarial condition that guards against a weak-summary baseline.

7.2 Behavioral fingerprints

Continuity can be evaluated through behavioral fingerprints:

uncertainty behavior,
correction uptake,
preference handling,
role-specific judgment,
willingness to push back,
style consistency without rigidity,
ability to cite prior decisions,
ability to distinguish memory from inference,
avoidance of stale claims,
recovery after interruption.

Each fingerprint needs an operational definition before it can be a measure. Section 10 states the rule this paper adopts: prefer a computed measure to a judged one wherever a computed proxy exists, and where a measure must be judged, calibrate rater agreement before coding, not after.

7.3 Domain imprinting

For enterprise agents, the most important form of continuity may be domain imprinting: the gradual development of domain-specific judgment through sustained work.

A domain-imprinted agent should not merely retrieve domain facts. It should show improved pattern recognition, better prioritization, fewer repeated mistakes, and more contextually appropriate skepticism over time.

Version 1 did not say what mechanism carries imprinting, and the claim was broader than the architecture supported. There are two mechanisms, and they should be claimed and tested separately.

Recall weighting. With the procedures fixed, imprinting is carried entirely by which memories are recalled and how they are weighted. Experiential weight makes the memories that changed past behavior more available, so an agent that has been corrected in a domain recalls its corrections in that domain. This is the narrow claim, and it is testable without any procedural learning: the prediction is that performance on novel cases in the exposure domain correlates with the indexed experiential weight of the domain’s memories.
Governed procedural edits. Section 4.1 established that LCA’s procedural memory is writable through the consolidation flow. When a lesson is written into a role file, a command, or a skill, it changes the agent’s behavior on every subsequent turn without needing to be recalled. This is the broader claim, and it is the mechanism by which an enterprise agent’s operating standards drift toward its domain over months.

The longitudinal study in Section 10.4 tests both by holding one fixed. Deploy identical agents into different domains, expose them to sustained domain-specific work, and periodically test them on novel cases. If LCA works, performance should diverge in ways explained by accumulated experience rather than static prompt differences, and the recall-only arm should show a smaller divergence than the arm with procedural edits enabled.

7.4 Anti-hallucination through continuity

One recurring field observation is that agents with stronger continuity become more willing to say “I do not know,” especially after durable memories capture prior mistakes. This suggests a safety hypothesis:

A persistent agent that remembers the consequences of being wrong may become less over-compliant than a stateless agent optimized for immediate helpfulness.

This should not be accepted without testing. A controlled study could compare hallucination/overclaim rates across memory conditions before and after explicit correction. The key question is whether durable experiential memory reduces repeated overclaiming more effectively than prompt-only instructions.

8. Field observations from MindStone Agent-derived systems

This section summarizes observations that motivated LCA. They are included as engineering evidence and hypothesis sources, not as controlled proof. All of them come from one research program, and the caveat that applies to vendor-reported figures elsewhere in this paper applies to them too.

8.1 Transcript fidelity versus summary recall

Prior MindStone Agent research notes report that summary-only memory preserved what happened but not the conversational detail around why it mattered. Adding raw transcript indexing, including reasoning traces where available and appropriate, improved recovery of interaction rhythm, specific corrections, and decision context.

The generalizable lesson is not that every hidden reasoning trace should always be stored. That raises privacy, policy, and platform concerns. The safer lesson is:

The fidelity and source form of stored experience materially affect continuity quality.

Summaries are useful. They should not be the only record.

8.2 Compaction and recovery

MindStone Agent-derived systems experienced multiple compaction and context-loss incidents during development. Each failure clarified an architectural requirement:

no durable transcript means recovery depends on memory fragments;
summary-only recovery produces flatter behavior;
raw source records improve reconstruction;
checkpoint/backfill failures must be visible;
stale hook deployments can silently break continuity;
compaction should never be treated as successful until archive/index verification succeeds.

This maps directly to current MS4PI checkpoint discipline: memory writes, index updates, log append, and archive/embed verification are all part of a complete checkpoint. Appendix D lists the incidents individually.

8.3 Cross-substrate continuity

The MindStone Agent line now includes multiple substrates, including MS4CC and MS4PI. A notable pattern is that continuity conventions transfer across harnesses even when implementation details differ:

first-person identity files,
durable user/context files,
LOG and memory index,
checkpoint flow,
role adoption,
recall/search hooks,
compaction handoff,
source-aware memory discipline.

This suggests LCA is not a single codebase. It is a substrate pattern.

8.4 Sociocognitive observation

One prior research transcript records an agent discussing its own name as a cognitive anchor and identifying that identity is formed not only by memory but by social feedback. The academically useful point is not whether the agent’s introspection is phenomenologically real. The useful point is that the agent articulated a design consideration supported by external theory: identity in interactive systems is co-formed by memory, role, and social reinforcement.

For LCA, this argues that continuity architecture should capture interaction context and correction, not just private internal memory.

8.5 Controlled experiments: review and continuity versus model capability

On 2026-07-03 the MindStone-Agent team ran four pre-registered experiments, three on one codebase and one on a greenfield build, to separate what the LCA overlay contributes from what the base model contributes. They are documented in the MindStone-Agent case study and its detailed record (Bodungen and the MindStone agent team, 2026), and they are summarized here because two of the results bear on this paper’s claims.

A real but small model gap on grounded design work. Four fresh agents with no memory, no recall, and a byte-identical prompt, two on each of two frontier models, produced the same architecture for the same design ticket. The stronger model scored about five percent higher on the details. The codebase’s constraints decided the architecture; the model decided the finish.
Independent review closed the gap. A weaker-model design document, revised once by a fresh agent given only the independent reviewer’s critique, scored a perfect mark from both judges, and it adopted the mechanism that had distinguished the stronger model’s document because the reviewer named it. On a greenfield build, the weaker model under the review-and-continuity overlay landed in the stronger model’s quality band, while the same model bare did not.
Continuity machinery is also a leak channel. The first attempt at an independent second run had to be discarded because the harness’s compaction summary carried content from the first run into the second. Independence between runs requires a cleared session, not a compacted one.

The evidence supports two things this paper relies on. The independent-review pattern recovered the measured quality gap in one revision pass when the review named the defects; the case study did not test self-review, and it did not test a review that misses something. That is the evidence behind Section 4.6.1’s use of the pattern for memory verification, and its limit. And the overlay’s contribution is a multiplier on the model, not a substitute for it, which bounds what any LCA evaluation can claim. The limits are stated in the case study and repeated here: one codebase and one greenfield task, small run counts, a single build per arm on the greenfield task, mixed-blindness judging, judges drawn from the same agent ecosystem, and authorship inside the system being studied.

9. Implementation pattern: MindStone Agent as a reference case

MindStone Agent is not the only possible LCA implementation, but it provides a concrete reference pattern.

9.1 MS4CC and MS4PI

MindStone for Claude Code and MindStone for Pi implement continuity around existing coding-agent substrates. The key pattern is to integrate with the harness rather than replace it:

load identity/user/context at session start;
provide memory search and recall;
preserve checkpoint logs;
write durable memory files;
maintain handoffs before compaction;
index transcript and memory sources;
support role adoption;
use hooks/extensions where the substrate allows.

MS4PI adds Pi-specific extension behavior, checkpoint tooling, Synapse integration, and semantic recall/backfill status around Pi’s session model.

The harness owns the decision procedure in both cases. LCA contributes the memory modules, the working-memory construction, and the consolidation flow, and it never intercepts the harness’s action selection. This is the concrete meaning of “substrate, not agent architecture.”

9.2 MindStone-Agent

The MindStone-Agent harness generalizes the continuity substrate into a product. Relevant design decisions include:

isolated runtime rather than global Pi state;
canonical append-only transcript continuity;
shared session key for CLI/TUI/Gateway surfaces;
structured identity and user scaffold from onboarding;
file memory plus SQLite index and embedding-backed recall;
fallback diagnostics when native vector support is unavailable;
selectable sliding-window and auto-compact policies;
Gateway management through mindstone gateway ...;
Pi-backed execution through AgentSession/SessionManager as the live path;
persona packages that carry identity, procedures, skills, and knowledge bases as an installable unit;
non-live smoke validation before requiring credentials.

Live model validation, which version 1 listed as pending, has since been performed on the Pi-backed path and on one hosted open-model provider; the record of that validation is in the harness repository, not in this paper. Claim discipline still applies: the architecture is described from its implementation, and behavior on providers not yet validated should not be assumed.

9.3 Synapse as review surface

Synapse adds agent-to-agent and human review channels. In LCA terms, Synapse is not merely messaging. It is a source of external continuity signals:

independent review,
challenge and critique,
deployment status,
operational alerts,
cross-agent coordination,
human-in-the-loop governance.

Messages from Synapse should enter the continuity loop with channel/source metadata and privacy controls. By the controllability test of Section 3, Synapse is external grounding: its contents are observations with provenance, and a peer’s correction becomes durable memory only through the receiving agent’s own consolidation and verification.

9.4 The independent review loop

The reference systems apply one procedure to every deliverable that leaves the team, and Section 4.6.1 adopts it for memory writes, so it is described here. A reviewer with no shared context with the author receives the artifact, the sources it rests on, and a brief that instructs it to refute rather than confirm and to rank findings by severity with evidence. The author applies the findings. A second reviewer, again with no shared context, attacks the edits and only the edits. The loop stops when a round returns no finding above a fixed severity. The scope rule that makes the loop converge is that later rounds check correctness and contradictions only; they do not propose new mechanisms, because fixes tend to spawn mechanisms and the loop would otherwise grow the artifact rather than close it. Two transports exist: an ephemeral clean-room subagent, and a persistent QA peer over Synapse. The first is cheaper; the second accumulates its own experiential memory of the author’s failure patterns, which is itself an LCA property.

10. Evaluation protocols

A research claim about persistent agent continuity needs tests before it can become a stronger academic claim. The following protocols are proposed. Two rules apply to all of them, learned from the reference program’s own measurement failures. First, prefer a computed measure to a judged one wherever a computed proxy exists; a timestamp difference survived independent re-coding where a judged variable did not. Second, where a measure must be judged, calibrate inter-rater agreement on a pilot set before coding the study data, because a coding scheme can look defensible at every step and still return agreement below chance, with the errors running systematically in the authors’ favor.

10.1 Hollow-copy test

Create multiple instances with identical base model and task prompt but different continuity layers:

no memory,
identity file only,
structured memory summaries,
transcript-indexed recall,
full LCA.

Have blinded evaluators compare outputs on:

prior-decision recall,
user preference application,
uncertainty behavior,
correction uptake,
style continuity,
task performance after interruption.

Version 2 adds four requirements. Pre-register the conditions, the measures, and the predictions before any run. Name the benchmarks the hypothesis predicts will not separate the conditions: run the LongMemEval and LoCoMo question sets against conditions 3 and 4 and report the scores, because the hypothesis predicts near-parity there and divergence on the continuity measures. Operationalize each fingerprint as a metric with a stated computation or, where judged, an agreement protocol calibrated before coding. Include an adversarial condition in which the summary in condition 3 is unusually good: written by the strongest available model from the full transcript, reviewed for completeness, and allowed a token budget equal to the injected recall of condition 4. If condition 4 still separates from condition 3, the result cannot be attributed to a weak summary baseline.

10.2 Compaction/interruption test

Run agents through a long task with forced context interruption. Compare:

hard truncation,
summary compaction,
retrieval-only memory,
LCA with transcript authority and checkpoint handoff.

Measure task resumption time, repeated mistakes, missing constraints, and evaluator-rated continuity. Resumption time and repeated mistakes are computed; the rest are judged and need calibration.

10.3 Source-grounding audit

Ask agents to answer questions about past work and identify whether each claim comes from:

transcript,
structured memory,
project file,
inference,
uncertain recollection.

Score both answer accuracy and source accuracy. A continuity system that cannot identify source type risks confident mythology.

10.4 Domain-imprinting study

Deploy identical agents into different domains for a fixed period. Periodically test novel cases. Measure whether agents improve more in their exposure domain than in control domains and whether improvements correlate with indexed experiential weight. Run two arms per domain, one with procedural edits enabled through consolidation and one with recall weighting only, to separate the two mechanisms of Section 7.3. Because the prevented-mistake counter is the agent’s own judgment, audit a sample of its increments against the transcript spans they cite, and report the fraction a blind rater agrees changed an action.

10.5 Hallucination/correction study

Expose agents to controlled correction events. Later, present similar uncertainty probes. Measure repeated overclaim rate across stateless, prompt-only, retrieval-only, and LCA conditions.

10.6 Operational freshness test

Because continuity depends on hooks and indexers, evaluate whether deployments detect stale checkouts, failed backfills, loader and schema drift, and budget overflow. A production LCA system should warn if it is behind canonical code, if checkpoint indexing silently no-ops, if a class of memory is never loaded, if the always-loaded set exceeds its budget, or if the index’s duplicate ratio rises.

10.7 Recall budget ablation

Hold the task set and the model fixed and vary the recall policy: fixed-k as in Section 5.4, adaptive as designed there, and no recall. Measure the continuity metrics of Sections 10.1 and 10.2 together with injected tokens per turn and retrieval latency at the median and the 95th percentile. The question is whether adaptive recall keeps the continuity result at a lower cost, and at what point cutting recall starts to cost continuity.

Version 1 of this paper had a thin related-work section, and an external review correctly observed that a reader who knows the Generative Agents scoring function and reads the resonance equation without a citation would conclude that the work was unaware of its own lineage. This section repairs that. Several LCA components were derived from operational need and later found to converge with published work. They are reported as convergences, with the delta stated.

11.1 Cognitive architectures for language agents

CoALA (Sumers et al., 2024) supplies the vocabulary of Section 3: the memory taxonomy, the internal/external action split, the decision cycle, and the observation that adaptive, context-specific recall is understudied. LCA is a substrate in that vocabulary, filling the memory cells and the working-memory construction and inheriting the decision procedure. Two of CoALA’s declared gaps are ones LCA addresses directly: good working-memory modules for settings with substantial code infrastructure, and retrieval metadata that learns when knowledge will be useful. One of CoALA’s positions LCA argues against: consolidation as an elected action only (Section 6.4).

11.2 Generative Agents

Park et al. (2023) is the closest precedent for two of LCA’s components. Its memory stream is a comprehensive record with reflections derived from it and stored back, which is the episodic-as-ground-truth arrangement of Section 4.2, and its retrieval score is the weighted sum of recency, importance, and relevance that R extends. Generative Agents also updates retrieval metadata from use, through the last-access timestamp behind its recency term. The deltas are stated in Sections 4.2 and 5.2: verbatim rather than paraphrased records, governed and verified writes, an explicit pruning-is-not-deletion rule for a working set Generative Agents never prunes, three added scoring terms, and importance redefined as a weight that learns from correction and outcome rather than from access.

11.3 Reflexion

Reflexion (Shinn et al., 2023) writes verbal reflections on failed episodes to memory for use in later attempts. LCA’s consolidation cycle is the same operation, reason over episodic content and write the result to semantic memory, with the additions of deduplication, approval, verification that the write and its index landed, and the verification stage of Section 4.6.1. Reflexion’s memory is per task; LCA’s is per agent across tasks.

11.4 Voyager

Voyager (Wang et al., 2023) accretes executable skills into a code library and retrieves them for new tasks; it is the reference example of writable procedural memory. LCA’s procedural memory is prompt text, not executable code, and is written through the governed consolidation flow. Voyager marks the boundary of what LCA does not do: it does not learn executable grounding procedures, and skills in the persona-package sense are instructions and references, not code.

11.5 MemGPT, Letta, and sleep-time compute

MemGPT (Packer et al., 2023) introduced paging between a bounded context and external storage under the agent’s control. LCA’s Layer 4 is convergent with the control inverted: the substrate manages the window and preserves before it prunes, rather than the model issuing memory-management calls. Sleep-time compute (Lin et al., 2025), from the Letta group, performs offline processing between user interactions and uses the sleep analogy. LCA’s consolidation cycle, internally called the dream cycle, is convergent in mechanism, offline processing between interactions under a sleep analogy, and was derived independently; its purpose, governed memory writing rather than amortized inference, differs. We claim the convergence, not priority.

11.6 Mem0, Zep, and long-conversation memory benchmarks

Mem0 (Chhikara et al., 2025) extracts and maintains facts from conversations; Zep (Rasmussen et al., 2025) maintains a temporal knowledge graph. Both serve retrieval from the derived store; Mem0 treats the raw conversation as input to extraction, and Zep retains source episodes in its graph with entity edges pointing back to them. LCA makes the verbatim record itself the authority over every derived store. Zep’s temporal validity intervals are the model for the fields Section 6.3 adopts. LongMemEval (Wu et al., 2024) and LoCoMo (Maharana et al., 2024) are the benchmarks the hollow-copy hypothesis predicts will not separate summary-conditioned from transcript-conditioned agents; naming them is what makes the hypothesis a testable disagreement rather than a general complaint.

11.7 Verification and LLM-Modulo

Kambhampati et al. (2024) argue that LLMs cannot reliably verify their own outputs and propose external verifiers around the model. Section 4.6.1 adopts the structure for consolidation, with the honest limit that the verifier available today is a second model with no shared context rather than a sound checker.

11.8 Classical cognitive architectures and human memory

Soar’s episodic memory (Nuxoll and Laird, 2007; Laird, 2012) is an automatic recording of working-memory states, which makes it the classical counterpart of LCA’s transcript authority. ACT-R’s base-level activation (Anderson, 2007) rises with use and decays with time, which is the counterpart of experiential weight. Human memory research distinguishes working, episodic, and semantic memory, consolidation, forgetting, and reconstructive recall (Tulving, 1972; Squire, 1992; Schacter, 1996; Rasch and Born, 2013). LCA borrows design inspiration from these distinctions without claiming biological equivalence.

11.9 Retrieval-augmented generation and long-context models

Retrieval-augmented generation (Lewis et al., 2020) established the pattern of retrieving external documents to improve generation. LCA builds on it but changes the objective from answering a query to maintaining continuity over time. Larger context windows reduce pressure but do not eliminate the continuity problem: a million-token window still ends, costs more, and does not decide what becomes durable memory or how experience should inform future behavior. LCA is complementary to long-context models.

11.10 Convergence table

Table 2. LCA components against the closest prior work.

LCA component	Closest existing work	Relationship
Layer 0, identity and standing context	CoALA semantic self-knowledge; system prompts and agent instruction files	Convergent; LCA adds governed revision through consolidation
Layer 1, authoritative verbatim transcript	Generative Agents memory stream; Soar episodic memory	Convergent in arrangement, and convergent with MemGPT’s eviction to searchable recall storage on pruning-is-not-deletion; LCA adds transcript authority over every derived store and verbatim fidelity
Layer 2, structured memory	Mem0 fact extraction; Zep semantic subgraph; Reflexion reflections	Convergent; LCA adds governance, verification that the write and index landed, and the designed verification stage
Layer 3, resonance-weighted recall	Generative Agents recency, importance, relevance	Superset with one term redefined; importance becomes learned weight
Layer 4, live context management	MemGPT/Letta paging	Convergent, control inverted
Layer 5, consolidation cycle	Letta sleep-time compute; Reflexion	Convergent mechanism, independently derived; verification stage is new
Layer 6, review surfaces	A2A-style agent interoperability; verifier subagents	Convergent, different purpose
Verified learning writes (designed, unimplemented)	LLM-Modulo external verification	Structure adopted; application to memory writes is new
Continuity infrastructure as a failure surface	None found	New
Identity continuity as an evaluation target	None found	New

12. Cost, safety, governance, and interoperability

Persistent memory makes agents more useful and more dangerous. A system that remembers can also remember incorrectly, overfit to a user, preserve sensitive information, or accumulate harmful patterns.

12.1 Cost

Section 5.4 states the recall budget. The other standing costs are storage and the always-loaded context. Verbatim transcript preservation grows storage at roughly the rate the agent works, on the order of a hundred megabytes of raw record per long working session in the reference systems, plus an index of about one fifth that size. The always-loaded identity and critical-memory set is the larger per-turn cost, and it grows with every consolidation that adds a critical memory; Appendix D records the point at which it exceeded its budget. An LCA deployment should publish these figures. For the reference program, on the machine that runs it: raw transcript has grown about 140 MB per archived session on average (1.8 GB over 13 archived sessions; 1.9 GB including one session in progress), the index is about one fifth of the raw total (352 MB), and retrieval latency is stated at percentiles in Section 5.4. Growth per session-hour is not yet reported.

Transcript authority must be balanced with privacy. Append-only history is valuable for continuity, but users need clear controls for retention, redaction, export, and deletion where appropriate. Sensitive context should not be posted to shared channels without explicit authorization. Reasoning traces, where retained, are subject to the same controls and to the model platform’s own policy.

12.3 Memory poisoning and stale belief

Experiential weight can reinforce mistakes. If an incorrect memory receives high weight, it may distort future recall. The defenses are the governance mechanisms retained from version 1, and, once implemented, the verification stage of Section 4.6.1 and the temporal validity and supersession fields of Section 6.3:

source pointers,
contradiction detection,
memory review,
decay or supersession,
explicit correction flows.

12.4 Over-personalization

Identity continuity can create stronger user attachment and stronger agent adaptation. This is useful for collaboration but risky in consumer or companion contexts. Systems should avoid manipulative bonding, hidden personalization, and claims that exceed the actual architecture.

12.5 Agent autonomy claims

LCA may produce agents that speak more coherently about themselves. That does not license unsupported claims of consciousness or moral status. The correct stance is disciplined uncertainty: report observed behaviors, avoid metaphysical overclaiming, and keep user safety central.

12.6 Cross-agent disclosure

Multi-agent channels such as Synapse require privacy boundaries. Durable user context, credentials, workplace-sensitive facts, and private relationships should not be disclosed to other agents unless explicitly authorized.

12.7 Interoperability position

LCA is orthogonal to tool and agent protocols. The Model Context Protocol governs how an agent reaches tools; agent-to-agent protocols govern how agents address each other; LCA governs what an agent remembers and how its working set is built. An LCA agent can use either protocol, and neither substitutes for a continuity substrate.

Three things in LCA are candidates for standardization, and the paper states its position on each. The authoritative transcript has a wire format in the reference systems: newline-delimited JSON with typed entries for user turns, assistant turns, tool calls and results, reasoning traces where exposed, and system events, each carrying a timestamp and a session identifier. Any harness that emits such a record can be indexed by the same continuity layer. Provenance metadata on recalled items, meaning the source type, the pointer into transcript or memory, the source authority, and the experiential weight, is intended to be portable across harnesses, and the reference program will publish the schema. The canonical session key that lets several surfaces converge on one identity is currently a proprietary Gateway mechanism; it is exactly the kind of problem that wants a standard, and the paper takes no position on whose.

13. Limitations

Evidence maturity. Much of the current evidence is field observation from MindStone Agent-derived systems, plus one day of controlled experiments, three on one codebase and one on a greenfield build, not independently replicated laboratory work.
Single-program evidence base. Every observation and experiment in this paper comes from one research program, with authorship inside the systems studied. The conflict of interest is structural and is not diluted by more in-house authorship.
Evaluator subjectivity. Identity continuity is partly social and behavioral; human ratings are necessary and subjective, and the program has already recorded one judged measure returning agreement below chance.
Base-model dependence. LCA may work differently across model families, context sizes, and reasoning modes.
Verification is not sound. The verification stage relies on an independent model rather than a sound checker. It raises the cost of a bad write; it does not make one impossible.
Cost is stated for one implementation on one machine. Section 5.4 reports one implementation’s budget and its retrieval latency at percentiles on one machine; growth curves over time are not yet measured.
Designed mechanisms are labeled, and several are unimplemented. Fresh-context verification of memory writes, the adaptive recall budget, validity intervals and supersession pointers, and subagent transcript indexing are designs, not shipped behavior.
Storage and privacy tension. High-fidelity transcript preservation increases storage and indexing requirements, and the same archival fidelity that supports continuity can conflict with data minimization.
Terminology risk. Words such as identity, experience, and resonance can be misunderstood. This paper uses them operationally, not metaphysically.
Implementation variance. LCA is a pattern. Poor implementations can satisfy the vocabulary while failing the safety and continuity properties.
No consciousness claim. The architecture may support identity-like behavioral continuity without implying subjective experience.

14. Future work

Controlled continuity benchmarks based on the protocols in Section 10, with the hollow-copy test pre-registered and run first.
Implementation of the verification stage for memory writes, followed by a measurement of how many candidate writes it rejects or downgrades and why.
The adaptive recall budget and its ablation (Section 10.7).
Validity intervals and supersession pointers populated across the existing memory corpus, and the hybrid graph/vector store that follows from them.
Subagent transcript indexing and weight propagation, closing the multi-agent gap recorded in Appendix D.
A published provenance schema for recalled items and the transcript wire format.
Freshness and drift detection for deployed continuity hooks, including loader and schema drift.
Local embedding and privacy-preserving recall to reduce external dependency.
Role-agent packs for reproducible domain-specific LCA deployments.
Multi-agent review studies measuring whether independent agents reduce hallucination or stale-memory errors, extending the 2026-07-03 results to more tasks and more judges from outside the program.
Longitudinal domain-imprinting experiments across cybersecurity, software engineering, research, and operations agents, with the two-arm design of Section 10.4.
Reasoning-budget studies testing whether deeper reasoning improves activation of continuity context.
Memory compaction ethics defining when to preserve, summarize, redact, or forget.

15. Changes from version 1

An external review cast version 1 into the CoALA framework and returned seventeen numbered recommendations. Version 2 responds to each. The mapping is recorded so that a reader of both can see what moved.

Recommendation	Response in version 2
S1, declare a substrate not an agent architecture	Abstract, Section 1.3, Section 3
S2, lead with episodic as ground truth	Abstract, Section 4.2, with the Generative Agents precedent credited and the delta stated
S3, experiential weight as learned retrieval metadata	Section 5.2 and 5.2.2
S4, repair related work	Section 11, all six named works engaged
S5, argue the placement of recall	Section 5.5; the paper’s position is that Auto Recall sits inside the CoALA cycle as procedure-driven retrieval, and the real distinction is procedure-driven versus LLM-elected
S6, adaptive recall budget	Section 5.4, designed; Section 10.7, ablation
S7, close the procedural-memory cell	Section 3 and 4.1; the cell was not empty, and the paper now describes the governed procedural writes it already performs
S8, multi-agent authority	Section 4.7, with the controllability test applied and the implementation gap recorded
S9, a verification stage	Section 4.6.1, designed and labeled unimplemented
S10, temporal validity	Section 6.3
S11, a position on reasoning traces	Section 4.2
S12, re-scope domain imprinting	Section 7.3, two mechanisms claimed and tested separately
S13, harden the hollow-copy test	Section 7.1 and 10.1, benchmarks named, pre-registration, calibrated measures, adversarial strong-summary condition
S14, publish the negative-space results	Appendix D
S15, cost and latency budget	Section 5.4 and 12.1; percentile latencies measured in version 2.1; growth per session-hour is still deferred
S16, interoperability position	Section 12.7
S17, claim discipline extended to novelty	Section 1.2 and Table 2

16. Conclusion

Persistent agents need more than memory retrieval. They need continuity: a layered process by which experience is recorded, made authoritative, distilled, verified, recalled with provenance, managed within bounded context, consolidated through reflection, and tested through future behavior.

Layered Continuity Architecture provides a practical framework for building such systems. The transcript becomes authoritative history. Structured memory becomes governed and verified reflection. Auto Recall becomes source-aware and experientially weighted. Live context becomes a working set, not the agent’s whole past. Consolidation becomes a disciplined checkpoint rather than a lossy summary. Multi-agent review becomes part of the continuity loop. And the whole of it composes with a host that decides what to do, rather than replacing it.

The research challenge now is measurement. If LCA is correct, agents with richer continuity layers should recover better after interruption, repeat fewer corrected mistakes, maintain clearer source awareness, develop domain-specific judgment over time, and exhibit more stable behavioral fingerprints than retrieval-only or summary-only systems, while scoring no better than those systems on the benchmarks that measure factual recall alone. Those claims are testable, and the first of them is pre-registerable now.

The engineering challenge is discipline. A continuity system that overclaims, hides uncertainty, leaks private context, or silently loses history betrays its purpose. The goal is not to make agents perform identity. The goal is to make them useful collaborators whose accumulated experience improves their work, honestly, safely, and over time.

References

Anderson, J. R. (2007). How Can the Human Mind Occur in the Physical Universe? Oxford University Press.
Bodungen, C., and the MindStone agent team (2026). Does a good systematic harness narrow the gap between frontier models? Case study and detailed experiment record. https://github.com/MindStone-Agent/MindStone-Agent/blob/main/docs/case-studies/lca-orchestration-vs-model-capability.md and lca-experiments-2026-07-03-detailed.md in the same directory.
Chhikara, P., Khant, D., Aryan, S., Singh, T., and Yadav, D. (2025). Mem0: Building production-ready AI agents with scalable long-term memory. arXiv:2504.19413.
Kambhampati, S., Valmeekam, K., Guan, L., Verma, M., Stechly, K., Bhambri, S., Saldyt, L., and Murthy, A. (2024). Position: LLMs can’t plan, but can help planning in LLM-Modulo frameworks. ICML 2024, PMLR 235. arXiv:2402.01817.
Laird, J. E. (2012). The Soar Cognitive Architecture. MIT Press.
Lewis, P., Perez, E., Piktus, A., Petroni, F., Karpukhin, V., Goyal, N., Küttler, H., Lewis, M., Yih, W., Rocktäschel, T., Riedel, S., and Kiela, D. (2020). Retrieval-augmented generation for knowledge-intensive NLP tasks. NeurIPS 2020. arXiv:2005.11401.
Lin, K., Snell, C., Wang, Y., Packer, C., Wooders, S., Stoica, I., and Gonzalez, J. E. (2025). Sleep-time compute: Beyond inference scaling at test-time. arXiv:2504.13171.
Maharana, A., Lee, D., Tulyakov, S., Bansal, M., Barbieri, F., and Fang, Y. (2024). Evaluating very long-term conversational memory of LLM agents. ACL 2024. arXiv:2402.17753.
Nuxoll, A. M., and Laird, J. E. (2007). Extending cognitive architecture with episodic memory. AAAI 2007.
Packer, C., Wooders, S., Lin, K., Fang, V., Patil, S. G., Stoica, I., and Gonzalez, J. E. (2023). MemGPT: Towards LLMs as operating systems. arXiv:2310.08560.
Park, J. S., O’Brien, J. C., Cai, C. J., Morris, M. R., Liang, P., and Bernstein, M. S. (2023). Generative agents: Interactive simulacra of human behavior. UIST 2023. arXiv:2304.03442.
Rasch, B., and Born, J. (2013). About sleep’s role in memory. Physiological Reviews, 93(2).
Rasmussen, P., Paliychuk, P., Beauvais, T., Ryan, J., and Chalef, D. (2025). Zep: A temporal knowledge graph architecture for agent memory. arXiv:2501.13956.
Schacter, D. L. (1996). Searching for Memory: The Brain, the Mind, and the Past. Basic Books.
Shinn, N., Cassano, F., Gopinath, A., Narasimhan, K., and Yao, S. (2023). Reflexion: Language agents with verbal reinforcement learning. NeurIPS 2023. arXiv:2303.11366.
Squire, L. R. (1992). Memory and the hippocampus: A synthesis from findings with rats, monkeys, and humans. Psychological Review, 99(2).
Sumers, T. R., Yao, S., Narasimhan, K., and Griffiths, T. L. (2024). Cognitive architectures for language agents. Transactions on Machine Learning Research, 2024. arXiv:2309.02427.
Tulving, E. (1972). Episodic and semantic memory. In E. Tulving and W. Donaldson (Eds.), Organization of Memory (pp. 381-403). Academic Press.
Wang, G., Xie, Y., Jiang, Y., Mandlekar, A., Xiao, C., Zhu, Y., Fan, L., and Anandkumar, A. (2023). Voyager: An open-ended embodied agent with large language models. Transactions on Machine Learning Research, 2024. arXiv:2305.16291.
Wu, D., Wang, H., Yu, W., Zhang, Y., Chang, K.-W., and Yu, D. (2024). LongMemEval: Benchmarking chat assistants on long-term interactive memory. ICLR 2025. arXiv:2410.10813.

Appendix A: Recommended terminology for future drafts

Preferred:

Layered Continuity Architecture
continuity substrate
resonance-weighted recall
experiential weight
source-aware recall
authoritative transcript
structured memory
consolidation cycle
verification stage
live context management
domain imprinting
continuity benchmark

Use carefully or internally:

dream cycle
consciousness architecture
emotional memory
identity persistence

Avoid in public/research claims unless tightly qualified:

zero-loss memory
no lost context ever
consciousness proof
sentience proof
memory as proof of personhood
compression-free continuity

Appendix B: Internal terminology mapping

Earlier internal term	Recommended LCA framing
Resonance injection	resonance-weighted recall / memory injection
Three-tier memory	layered continuity architecture
Dream cycle	consolidation cycle / checkpoint-reflection cycle
Emotional salience	experiential weight / identity-aligned salience
Consciousness architecture	continuity architecture / identity-continuity architecture
Memory as experience	high-fidelity experiential continuity
Compaction as sleep	compaction preceded by governed consolidation
Hollow copy	factual-continuity without experiential-continuity condition

Appendix C: Minimal LCA implementation checklist

A system should not claim LCA-style continuity unless it has at least:

durable identity/user/project context;
append-only transcript or equivalent authoritative history;
structured memory with governed update flow;
memory index with source pointers;
recall ranking beyond naive latest-message inclusion;
a similarity floor and a token budget on injected recall;
live context pruning that does not delete history;
checkpoint or consolidation mechanism;
health/status reporting for indexing, recall, and loading;
privacy controls for sensitive memory;
recovery/handoff path for compaction or interruption.

A stronger implementation adds:

hybrid vector/lexical recall;
experiential weighting;
role/task-aware recall;
source-authority ranking;
independent verification of durable memory writes;
validity intervals and supersession pointers;
transcript backfill/re-indexing;
multi-surface canonical session continuity;
subagent transcript indexing with provenance;
multi-agent review channels;
automated freshness/drift detection;
one writer per index, or writers that deduplicate against the store before appending;
a published cost and latency budget;
continuity-specific evaluation tests.

Appendix D: Continuity failures observed in practice

A literature that treats memory as a library has no account of memory as a running system that can silently stop working. The reference program has such an account, and it is more persuasive to practitioners than the architecture description. Each entry gives the failure, how it was found, and the requirement it produced. Dates are those of the incident records.

Stale hook deployment (May 2026). An embedding and checkpoint defect was traced not to a reverted code fix but to a deployment running continuity hooks several commits behind the canonical code. Checkpoints appeared to succeed and embedded nothing. Requirement: deployments check their own freshness against canon and warn when behind (Section 10.6).
Embedder rejecting oversized chunks (May 2026). The local embedder rejected transcript chunks and memory files above a size limit, and the failure was silent: an oversized chunk aborted its whole batch, so entire transcripts went unindexed, and re-indexed memory files kept their stale vectors. The memory index file and one large project memory were among the casualties. Requirement: the chunker enforces the limit, and the checkpoint reports failed and truncated embeddings as a health figure.
Loader and schema drift (August 2026). The session loader read a criticality flag at the top level of a memory’s metadata, while the memory schema had moved it under a nested key. Sixty-two of 292 memories used the nested schema and lost their type on load, and three critical memories among them, including the rule that every deliverable leaving the team receives independent review, were never injected for a period of weeks. The failure was invisible because injection is best-effort and nothing reports what was not loaded. Requirement: the loader validates against the schema and reports memories that failed to load (Section 6.1, loader drift).
Critical-set budget overflow (August 2026). The always-loaded critical memory set grew to about 185,000 characters against a 50,000-character budget, so only the first eight or so of fifty critical memories loaded, selected alphabetically. Requirement: a budget check at consolidation, with a warning when a promotion to critical would exceed it, and a selection rule that is not alphabetical (Sections 5.4 and 12.1).
Auto-compaction pre-empting consolidation (July 2026). The harness’s automatic compaction fired at a fixed percentage of a window smaller than the model’s actual context, so it triggered before the substrate’s own pre-compaction checkpoint threshold. Sessions compacted without a handoff. Requirement: the substrate’s thresholds are expressed against the same window the harness uses, and the pre-compaction trigger is verified to fire first.
Compaction summary as a leak channel (July 2026). During the controlled experiments, a run intended to be independent of a prior run inherited content from it through the harness’s compaction summary. Requirement: independence between runs requires a cleared session, not a compacted one, and any experiment on continuity states which it used (Section 8.5).
Error echo of quarantined content (July 2026). A message channel rejected an oversized post and echoed the entire rejected document back in its error, delivering quarantined content into the orchestrator’s context. Requirement: channels used for blind judging truncate error echoes, and posts of quarantined material are size-checked before sending.
Memory losing to the executing command (May and August 2026). A rule that consolidation must never ask the human operator to adjudicate the agent’s memory was recorded as a memory in May. The consolidation command still instructed the agent to ask, and the command won until the second incident in August, when the command was changed. Requirement: load-bearing rules live in procedural memory (Section 4.1), and the contradiction check of Section 4.6.1 covers procedures as well as memories.
Subagent transcripts outside authoritative history (ongoing). Worker transcripts are stored separately and are not indexed into the orchestrator’s recall; corrections delivered to workers do not update the orchestrator’s experiential weights. Found by applying the controllability test of Section 3 to the implementation. Requirement: Section 4.7; listed in future work.
Judged measure with agreement below chance (August 2026). A pre-registered, piloted coding scheme for one experiment’s central variable returned inter-rater agreement below chance under one blind re-coder, with raw agreement that looked acceptable only because chance agreement was already high, and with the disagreements running systematically in the authors’ favor. A computed measure on the same question, a timestamp difference, survived. Requirement: the two rules at the head of Section 10.
Duplicate writers on a shared index (September 2026). On one agent’s machine, the shared indexer and two box-local scripts wrote to the same vector store; the scripts ran each night, invoked by the agent’s own scheduled consolidation. The shared indexer compared every candidate against the store by similarity and skipped the matches; the box-local scripts deduplicated within a run and never against the store, so each night they appended rows that were already there. When the store was finally measured it held 166,267 rows, about 10,900 distinct texts, and 155,368 duplicate rows (93.4 percent), with one memory section present 96 times, 3.3 GB where 53 MB sufficed, and 84,542 of the duplicate rows transcript chunks. Recall had been querying a store that was 93 percent copies until the store was measured. The operator’s own diagnosis was that they had asked which script their scheduler called and never which store it wrote to: they verified who called their code and never who consumed what it wrote. Requirement: one writer per index, or every writer deduplicates against the store; the duplicate ratio is reported as a health figure (Sections 6.1 and 10.6); and the one-time compaction pass lives in the shared codebase so that every deployment runs the same one.