The Continuity Layer
Practical guide

Build your own local Continuity Layer

thecontinuitylayer.com/build-your-continuity-layer

A simple local setup for carrying project state, decisions, handoffs, and progress across AI sessions. The runtime is volatile. Continuity must be durable.

Start Here routeStep 2 of 4Next: Inspect the Lab
You do not need to understand the full architecture before starting. Start with a local folder, a few durable files, and a repeatable handoff loop. The first practical step is usually a small local continuity layer or local continuity engine, not a finished runtime.
01

How to use this page with an AI assistant

This guide is meant to work whether your assistant can browse the web or only sees what you paste into the chat.

  1. 01
    If your AI can browse, paste this page link and ask it to guide you through the setup one step at a time. Do not assume every AI can browse links or write local files; ask it what it can safely do first.
  2. 02
    If your AI cannot browse, copy the starter prompt below and paste the folder structure and packet template into the same chat.
  3. 03
    Ask the AI to proceed one step at a time. A continuity layer improves through review, not by stacking a dozen unreviewed prompts in a row.
02

Copyable starter prompt

Use this when your assistant cannot browse the page, or when you want a clean setup prompt in a fresh session.

Help me set up a local Continuity Layer for my project.

Use this guide as the source of truth.

Start simple:

- local files first
- backup-first
- manual imports only
- no cloud sync
- no secrets
- no auto-import
- one step at a time

Help me create the folder structure, then help me make my first continuity packet.

Ask me only one or two questions at a time.
03

Minimal local folder structure

The folder is the starting point. Keep it local, readable, and boring enough that you can audit it later.

continuity-layer/
memory/
imports/
exports/
decisions/
handoffs/
backups/
ACTIVITY_LOG.md
CURRENT_STATE.md
SETUP_JOURNEY.md
memory/
Durable notes about the project: current facts, standing constraints, and reviewed context.
imports/
Human-approved material waiting to be folded into the continuity layer.
exports/
Packets you hand to an AI assistant at the start of a new session.
decisions/
Dated records of choices that should carry forward until superseded.
handoffs/
Planner-to-builder or session-to-session prompts, outputs, and review notes.
backups/
Copies made before deleting, reorganizing, importing, or rewriting durable files.
ACTIVITY_LOG.md
A chronological record of what happened, what changed, and what was checked.
CURRENT_STATE.md
The maintained answer to where the project stands now.
SETUP_JOURNEY.md
Notes on how the local continuity layer itself was created and improved.
04

First continuity packet

A packet is the compact handoff you give the next session so it can start from reviewed state instead of raw transcript.

Packet template
  • Project: Fill this in after review.
  • Current goal: Fill this in after review.
  • Current state: Fill this in after review.
  • Decisions made: Fill this in after review.
  • Active constraints: Fill this in after review.
  • Source material: Fill this in after review.
  • Next action: Fill this in after review.
  • Parking lot: Fill this in after review.
  • Open questions: Fill this in after review.
  • Generated at: Fill this in after review.
05

Planner / Builder handoff loop

Keep the loop small enough that the human can review it.

  1. 01
    Planner gives one prompt.
  2. 02
    Builder works locally.
  3. 03
    Builder reports output.
  4. 04
    Human reviews.
  5. 05
    Planner decides the next prompt.
  6. 06
    Do not stack prompts.
06

What makes this a continuity layer

Notes store information. Continuity governs what carries forward. A local Continuity Layer keeps the current state, decisions, provenance, supersession, handoffs, blocked actions, and next action visible enough that a new session can continue the work without pretending the whole transcript is equally current.

07

Layer, engine, runtime

The Layer
The responsibility: carrying project state, memory, provenance, decisions, identity, and progress forward.
The Engine
The implementation: files, rules, scripts, or databases that apply continuity rules and maintain the current account.
The Runtime
Where live interaction happens: the chat, editor, agent, or tool session using the continuity layer.
08

Later: turning it into an engine

Once the manual workflow is reliable, you can add machinery. None of this is required for day one.

  • SQLite or another local database
  • import/export scripts
  • validation checks
  • provenance fields
  • supersession chains
  • packet generation
09

Safety and boundaries

Make the local workflow trustworthy before you make it powerful.

  • Do not put secrets, API keys, passwords, or private credentials into memory files.
  • Keep it local first.
  • Back up before deleting, reorganizing, importing, or rewriting durable files.
  • Avoid auto-import until the manual workflow is reliable.
  • Treat AI output as draft state until reviewed.