The map
thecontinuitylayer.com/mapThe Continuity Layer maintains a public map of the emerging systems that let AI preserve context, state, memory, provenance, and working understanding across time.
Why continuity matters
AI interactions are powerful but volatile — that’s why AI keeps forgetting. Every new session, tool, and model can drop the thread; context disappears, drifts, or becomes unsafe when it is not governed.
AI interactions are powerful but volatile; context disappears, drifts, or becomes unsafe when it is not governed.
The Continuity Layer is the durable responsibility for deciding what carries forward across models, tools, agents, and sessions.
Memory stores. Retrieval finds. Agents act. Runtime executes. Continuity governs what carries forward.
- 01
The problem isn’t memory. It’s everything around it.
Tools for storing facts are now common. What still evaporates between sessions is state: decisions, the reasons behind them, working assumptions, unresolved threads, and where each piece of truth came from.
- 02
Continuity is the layer that carries understanding forward.
It’s what lets intelligence keep what it has learned, decided, inferred, promised, questioned, and left unfinished — across chats, tools, agents, and time.
- 03
Agents make this urgent.
Every new orchestrator spawns more carriers of partial memory and stale assumptions. More agents means more coordination problems — unless they converge on one shared account that is authoritative for that project's governed state, so people and agents build on the same record instead of coordinating with each other.
- 04
The problem predates AI.
People leave, decisions get buried, documents go stale. Decades of partial answers — wikis, decision records, audit trails, commit lineage — are evidence that the problem is real. AI didn’t create it; AI multiplied it.
- 05
A field is forming. This project maps its sources, claims and open questions.
Memory systems, context engineering, stateful agents, provenance, evaluation — the pieces are emerging faster than the vocabulary. One underexplored question is whether long-running AI systems need project-level continuity in addition to agent-level infrastructure. This site exists to track that question in public.
Layer, Engine, Runtime
The Continuity Layer is the durable frame that decides what carries forward. The Continuity Engine implements that frame, and the Continuity Runtime is where users, models, tools, and agents execute the work.
A governed path from stored history to current working truth.
- 01LayerDecidesSets the durable frame for what should carry forward.
- 02EngineGovernsSupersedes stale facts, keeps lineage, and reconstructs current state.
- 03RuntimeSurvivesCarries that governed state through real model, tool, and agent work.
Durable frame
The field frame and architectural responsibility for deciding what should persist across models, tools, agents, and sessions.
Implementation
The implementation that governs writes, supersedes stale facts, keeps lineage, and reconstructs the current account of the work.
Execution space
The live execution space where the user, model, tools, and agents interact while the Engine governs the work.
- User
- Continuity Runtime
- Model / Tool / Agent
- Continuity Runtime
- User
Agent execution — the tools and agents doing the work
Governs state: what is true now, what changed, why, and the evidence behind it
Memory & retrieval — where facts are stored and fetched
What a continuity layer is made of
The eight axes are not a second framework. They are the field dimensions the Layer reads and the Engine governs into a single working account across time.
Memory
What is stored.
Memory systems, Personal AI memory
Context
What is available right now, in this call.
Context engineering
State
What persists — the current shape of a project or task.
Stateful agents, Long-running workflows
Provenance
Where each piece of truth came from.
Provenance & audit, Organizational memory
Agents
Who acts, and under what authority.
Agent infrastructure
Workflows
How continuity survives a handoff — session to session, tool to tool, agent to agent.
Long-running workflows, MCP & tool continuity
Evaluation
How any of this is measured, and against what standard.
Eval benchmarks, Papers
Infrastructure
Where the layer actually lives — protocol, runtime, product, or process.
MCP & tool continuity, Commercial
Open questions the map is holding
Questions this project tracks rather than claims to have answered. Drafted, and still moving.
- 01
What should persist across a project’s life — and what is noise a system should be free to forget?
- 02
Who owns a project’s memory when a person, an app, a model, and an agent all touch it?
- 03
How should an agent inherit context it didn’t create without inheriting its mistakes?
- 04
How should provenance be represented, so any decision can show where it came from?
- 05
What should stay portable across models, and what is tied to the system that made it?
- 06
When two agents hold conflicting versions of the truth, on what basis does one win?