Continuum

Live, privacy-first context infrastructure that lets Codex continue your work without screenshots or pasted history.

Comment

Inspiration

AI agents lose crucial context whenever work is interrupted. The usual answer—more chat history, screenshots, or recordings—creates a privacy problem while still providing weak evidence of what actually changed.

Continuum takes a different approach: the developer tools already know when a workspace was focused, a safe command completed, a file was saved, a commit landed, or documentation was opened. We wanted to turn those small, meaningful signals into reliable context for Codex—without collecting screens, source-file contents, terminal output, or browsing history.

What it does

Continuum is a live, local-first context operating system for AI agents.

It observes allowlisted metadata from tools such as VS Code, zsh, Git, Chrome, macOS app activity, and approved folders. It groups related activity into evidence-backed checkpoints, a project graph, and a deterministic Context Diff.

That context is available through a native macOS app, grounded chat, an optional synchronized PWA, and read-only MCP tools for Codex:

  • current
  • timeline
  • search
  • resume
  • diff
  • graph

The core experience is simple: after an interruption, ask Codex, “Continue where I left off.” Continuum supplies a bounded context pack with cited checkpoints, files, commits, blockers, decisions, and next actions—without requiring the user to reconstruct their work in a prompt.

How we built it

Continuum uses a TypeScript/Node.js local daemon that runs only on loopback and stores state in SQLite. It combines FTS5, graph relationships, recency, and optional local vector retrieval to find useful context.

The macOS app is built with Swift, SwiftUI, and AppKit. It includes a Dock app, persistent menu-bar controls, privacy settings, timeline, graph, Context Diff, and grounded chat.

For models, users can explicitly select Apple Foundation Models, local Ollama, or OpenAI. When OpenAI is selected, Continuum sends only bounded, sanitized, policy-eligible metadata and uses structured outputs for checkpoint generation and grounded chat.

We also built an optional self-hosted companion using Fastify, PostgreSQL, Neo4j, React, Vite, Auth0, and Docker Compose. It synchronizes eligible context, powers an installable PWA, and exposes authenticated remote MCP.

Challenges we ran into

The hardest problem was defining useful context without crossing a privacy boundary. Each collector has a different raw shape: terminal commands, Git events, browser URLs, folders, and editor activity cannot share a superficial sanitizer. We built source-specific reduction gates and a shared policy gate before persistence.

Project identity was another challenge. Git clones need to resolve to the same project without storing sensitive absolute paths or remotes. Continuum uses global project IDs, device-local hashed aliases, and repository fingerprints; ambiguous matches require explicit user confirmation.

We also had to make agent actions helpful without making the agent dangerous. Continuum exposes only a small context-action vocabulary. Read actions can run immediately, while mutations—such as creating a checkpoint or acknowledging a baseline—always require explicit confirmation.

Accomplishments that we're proud of

  • Built a unified system for local capture, native UI, PWA, and local/remote MCP without making the cloud the observer.
  • Made checkpoint claims traceable to exact evidence instead of treating summaries as ungrounded memory.
  • Built Context Diff around a user-controlled baseline, so simply reading context never hides unseen changes.
  • Created a privacy architecture that excludes screenshots, source-file contents, terminal output, clipboard data, browser DOM/history, credentials, Git patches, and remotes.
  • Kept provider choice explicit: Continuum never silently falls back from OpenAI, Apple Foundation Models, or Ollama.
  • Made the graph bounded and portable across SwiftUI, the web app, SQLite/PostgreSQL, Neo4j, and MCP.

What we learned

Better agent memory is primarily a systems problem. Provenance, privacy, identity, retrieval, and lifecycle matter before model cleverness.

We learned that the strongest AI product behavior often comes from constraints: no silent provider fallback, no ambiguous clone merge, no automatic baseline movement, no Chrome project guessing without an active project lease, and no mutating agent action without confirmation.

What's next for Continuum

Next, we plan to ship signed and notarized macOS builds, package the collector installation flow, improve multi-device conflict management, and expand opt-in semantic adapters while preserving the no-content privacy boundary.

We also want to explore end-to-end encrypted synchronization for people who want cross-device context without a server-queryable companion.

Screenshots, content collection, remote shell access, and silent cloud fallback are intentionally not on the roadmap.

Built With

Share this project:

Updates

Submission history