Introducing Continuum: The Memory Behind the Six Weeks Is Now a Product

When I wrote about replacing HighRadius in six weeks, I said the pace wasn’t raw AI speed — it was contextual continuity. Every agent session opened already knowing the architecture, the prior decisions, the history. Nothing was re-explained. Nothing was lost.

That continuity layer now has a name and a front door. It’s called Continuum, and it’s in early access.

The Problem Is Memory, Not Intelligence

AI coding agents are remarkable inside a single session and useless at remembering across them. Close the context window and the architecture walkthrough, the decision about why the queue retries the way it does, the bug you fixed together last Tuesday — gone. The next session starts with archaeology.

Multiply that by every agent you run — I routinely work across Claude Code, Codex, and ChatGPT on the same projects — and by every repository you own, and the math gets ugly. Most of what a team learns while working with agents evaporates daily. The industry keeps treating this as a context-window problem. It isn’t. Bigger windows still empty when the session ends.

It’s a persistent memory problem, and memory is infrastructure.

From Internal System to Product

Readers of this blog have watched this system grow up. I wrote about the pgvector-backed semantic knowledge system when it was an internal tool, then about what it did in production. It went on to be the backbone of the six-week cash-application build.

Since then it’s been rebuilt from the ground up as Engram — a proprietary MCP memory server on PostgreSQL and pgvector, gated behind OAuth 2.1 with scoped tokens, with a distributable cross-platform ingest client and a six-tool read surface: semantic search, exact-text grep, file summaries, file listings, repository listings, and activity history.

Continuum is the product built on top: the engine plus the workflow that keeps memory honest, packaged and ready for early access. Engram holds the thread; Continuum is how your engineering practice writes to it and reads from it.

The Workflow Writes the Memory

Tooling alone doesn’t create institutional memory — discipline does. A Continuum session opens by reading: the agent queries memory for the decisions, conventions, and history that govern the work. It closes by writing: a session note recording what happened and why, a commit that references it, an ingest that makes both searchable.

Do that every session and something compounds. Six months later, “why is it built this way” has an answer — with the reasoning, the alternatives considered, and the file it lives in. Decision ledgers stop being aspirational documentation and become a side effect of working.

Built With Itself

The proof I’m proudest of: the Continuum website was planned, branded, and built by agents reading from — and writing to — the same memory the site describes. The homepage runs a real query against that memory, live, and gets back the reasoning behind a line in the nginx config serving the page. Every decision behind every page is recoverable from the record.

That wasn’t a demo we staged. It’s just how the loop works.

Numbers From My Own Instance

As of this writing, my production memory spans 17 repositories, roughly 7,000 documents, and about 55,000 searchable chunks — code, documentation, session notes, and git history — served to four different agents over one protocol.

And because a memory system has exactly one fatal failure mode — the silent wrong answer — the read contract is adversarially smoke-tested against production. Unknown scopes are errors, not empty lists. Empty means empty. Memory you can’t trust is worse than no memory at all.

Where It Runs

Anywhere you do. In your cloud, on your own servers, inside networks that have no path out.

Continuum is self-hosted: the database is yours, the authorization server is yours, and tenant isolation is a physically separate database per tenant — not a filter clause. For air-gapped environments, embeddings come from a local model on your hardware, over an OpenAI-compatible endpoint, with zero external network calls. Nothing leaves the enclave — and nothing reaches in, either. No phone-home, no remote switch.

That capability opens a door I know well. I spent seven years architecting DoD logistics systems and consulting with Technical Publications groups on SGML pipelines — and technical publications are the rare corpus that arrives pre-structured. S1000D data modules, IETM packages, SGML/XML sources: versioned, chunked, reuse-oriented by design. Retrieval over structured content with provenance attached is exactly what this architecture does. If that’s your world, there’s a dedicated page on Continuum for technical publications.

What Comes Next

Continuum is taking early access requests now. Bring a set of repos your agents keep forgetting — or, if you’re in the publications world, bring a build that won’t run.

The agents will keep getting smarter on their own. The memory is the part you have to choose to build. I built it because I couldn’t work without it anymore. Now it’s yours to try.

More coding articles