Continuum: Verifiable State Transfer for AI Work
Built during Devpost OpenAI Build Week for a real problem — switching chats, models, or teammates loses context. How Continuum preserves an append-only event ledger and derives evidence-linked state instead of relying on summaries.
What this project is
Continuum is a local-first context continuity platform for AI-assisted work, built during Devpost's OpenAI Build Week hackathon. The problem it targets is one anyone who works across multiple AI chats, models, or tools has hit: a session ends, and the next one starts from nothing. Summaries help, but they quietly drop exact values, rejected approaches, failure history, and the evidence behind a decision.
Continuum separates preservation from compression. It keeps accessible session events in an append-only ledger, derives a working state from that ledger, and generates layered context a new session can use to continue instead of starting over.
Why summaries aren't enough
A summary is a compression of what happened, written from someone's (or something's) confident recall. It's fast to produce and easy to read, but it has no way to prove it's accurate — there's nothing to check it against once the original context is gone.
Continuum's answer is to keep the source events around in their original canonical form, and treat anything derived from them — working state, bootstrap text — as regenerable output, not the record of truth. If the derived state looks wrong, you can always go back to the ledger it came from.
The event ledger
Every session's events are normalized into a canonical schema — message, tool call/result, command/output, artifact, or system event — and appended to a per-session JSONL ledger. Each event carries a UTC timestamp, a monotonically increasing per-session sequence number, an independent schema version, and a SHA-256 hash computed over recursively key-sorted canonical JSON.
That hash, plus strict sequence and duplicate-ID checks on append, is what makes the ledger auditable rather than just a log file. A verify-ledger command walks a session's events end to end and reports invalid JSON, schema violations, broken hashes, out-of-order sequences, duplicate IDs, and cross-session ID leaks.
From events to working state
On top of the ledger sits a deterministic, signal-phrase-based extractor. It scans events for objectives, constraints, decisions, next actions, completed work, failed approaches, assumptions, and open questions, and assigns each extracted statement a confidence level.
The important detail is that every statement links back to the exact event ID it came from. That provenance link is what turns "the AI said we decided X" into "we decided X, and here's the message where that happened."
Layered bootstrap for a new session
The working state then feeds a bootstrap generator that arranges the most useful parts into three layers:
- L0 — orientation: project title, description, session/event counts, and the primary objective.
- L1 — active state: objectives, completed work, next actions, and open questions.
- L2 — governing context: constraints, decisions, failed approaches, and assumptions.
Running state bootstrap prints that as Markdown, ready to paste into a fresh AI session. It's a deliberately minimal first pass — it doesn't yet resolve contradictions, apply a token budget, or verify that the receiving session actually understood the handoff.
What's implemented vs. what's next
Continuum is an honest 0.1.0 prototype, not a finished product. Shipped: the local workspace, project/session model, JSON and Markdown transcript import, the append-only ledger, integrity verification, deterministic state extraction, and L0–L2 bootstrap generation.
Not yet built: live session capture (today, starting a session creates metadata but doesn't capture a running AI client), portable capsules, retrieval, an MCP server, automated handoff verification, encryption, and the web dashboard — all tracked openly on the project roadmap rather than implied to already work.
What this demonstrates
Continuum is a Devpost OpenAI Build Week answer to a problem that gets worse the more AI tools someone uses day to day: work that spans sessions, models, and teammates shouldn't have to start over every time. The interesting part isn't the CLI commands — it's the decision to keep the ledger as the source of truth and make every derived claim traceable back to it, instead of trusting a model's memory of its own conversation.