DEV Community

Cover image for ContinumAI: The Memory That Survives When the Model Changes

ContinumAI: The Memory That Survives When the Model Changes

Abhishek Gupta on October 29, 2026

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine. What I Built What happens when you sw...
Collapse
 
eventuallyconsistentcode profile image
John Reed •

The model can change, the memory shouldn't have to start from zero" is the right sentence, and I'd push on one word in it: whose memory…

I build cairn, a work harness for coding agents (github.com/eventually-consistent-code-org/cairn2), and it answers your closing question with a third option: memory belongs to the project, not the model and not the user. The durable unit is a markdown card in the repo, typed as a decision, constraint, gotcha or reference, with a confidence grade and the file-plus-commit it came from (cards.ts). Whichever CLI opens the checkout reads the same cards, one installer writes the same instruction fragment for eight harnesses (cairn-setup.mjs), and the review verb convenes Codex, Grok, Copilot, OpenCode and Antigravity over the same repo as reviewers (peers.md). So "survives when the model changes" is the daily case here, and the thing that made it survive is that there's no gateway, the memory is a file in git and every model is a reader.

Where our units differ is the interesting part. Yours is the conversation: one node per exchange on prev_id, a checkpoint every five turns, the tail from the last checkpoint as the handoff. I read the chain and the C3 test, it does what the README says. That's compaction, and it keeps the thread. What it tends to lose is the why: the checkpoint summarizes what was said, not which earlier decision each later turn depends on, so three checkpoints later a constraint is still in the summary while the reason it exists is gone. Alex Shev's comment above is the fix and I'd take it literally: source, timestamp, scope, confidence, and a way to invalidate, as columns on the node. You already have the invalidation instinct, blocked turns are stored but excluded from future prompts. Extend that to decision nodes: a decision superseded by a later one stays in the graph and leaves the prompt, same mechanism, and the graph view shows the edge. That's the one change I'd make before the deployment.

Reid's point about per-provider formatting is the other half of the same thing, and our answer was the same as yours: canonical facts in one place, rendered per harness by a generator, with a check that fails when the rendered copy drifts from the source. The lesson we learned the hard way is to also check who reads each rendered copy, we shipped the fragment to a file one harness never opens and the drift check passed for a week.

And the honest trade in your direction: your graph view is the thing cairn doesn't have. Our knowledge map has typed nodes and edges and answers questions by query (map.md), and there is nothing to look at. Nnamani's "a store I cannot look at is hard to trust when a model swaps" is right, and the card store earns trust the slow way, by a stale flag at recall when the provenance commit no longer matches. A canvas would have earned it faster…

Good luck with week four, and if you add those columns I'd like to see what the checkpoint node looks like after.

Collapse
 
pixel_nomad1856 profile image
Abhishek Gupta •

This is genuinely one of the most insightful pieces of feedback I've received on ContinumAI. Especially the distinction between preserving the conversation and preserving the reasoning behind it.

Your question about ownership is interesting too. I've primarily been thinking about memory from a user and conversation perspective, but project-owned memory introduces another dimension, particularly for coding agents and collaborative development. I don't think these approaches necessarily have to compete.

Your point about checkpointing is something I want to investigate more deeply. Preserving a decision without preserving its reasoning can eventually lead to context drift, even if the original conversation itself is technically retained. Extending provenance, scope, confidence, and supersession to decision nodes sounds like a meaningful improvement.

I also really appreciate the point about verifying whether a harness actually reads the generated instructions. Compilation alone doesn't guarantee context consumption. That's an important distinction.

And yes, the graph view is something I want to take seriously as more than a visualization. I'd like users to inspect not just what the system remembers, but why it remembers it, where it came from, and whether it's still relevant.

I'm going to spend some time evaluating these ideas against the existing implementation before making changes.

Also, I'd love to explore Cairn further. The project-owned memory approach is particularly interesting, and I think there's a lot we can learn from each other's approaches.

Thanks for taking the time to actually inspect the implementation and share such detailed feedback!

Collapse
 
alexshev profile image
Alex Shev •

Portability across model changes needs more than retained text. The durable unit is a memory record with source, timestamp, scope, confidence, and a way to invalidate it. Then a new model can reinterpret the memory without quietly turning old assumptions into current facts.

Collapse
 
pixel_nomad1856 profile image
Abhishek Gupta •

This is actually one of the biggest questions that I am trying to solve right now. Currently I'm looking at ContinumAI to be the interface for users to interact with multiple providers with a shared memory layer behind the scenes. Users shouldn’t be forced to change their whole workflow just to get persistent memory. I’m starting with a chat interface and then integrations to make this experience closer to their existing AI workflows. Great question and a good reminder that how users feel is just as important as the underlying architecture!..

btw, thank you for your valuable feedback...πŸ«‚

Collapse
 
robertpaschal profile image
Odinaka Robert Nnamani •

The graph view is the part I would actually open first. A memory store I cannot look at is hard to trust when a model swaps.

Collapse
 
pixel_nomad1856 profile image
Abhishek Gupta •

thank you for your valuable feedback....πŸ«‚

Collapse
 
robertpaschal profile image
Odinaka Robert Nnamani •

You are welcome, Abhishek. A graph view you can actually inspect makes the memory story a lot easier to believe.

Collapse
 
reidmarlow profile image
Reid Marlow •

Keeping the memory store model-agnostic is the right instinct, but the real friction usually hits at prompt compile time. Different model families treat serialized state very differently. Claude tends to respect dense XML tags for previous decisions, while small open weights drop constraints unless they sit in a flat list near the user turn. If ContinumAI normalizes the memory into declarative facts and lets adapter templates format them per provider, you avoid half the context drift when switching back and forth.

Collapse
 
pixel_nomad1856 profile image
Abhishek Gupta • • Edited

This is a really useful insight! The distinction between a model-agnostic memory store and provider-specific prompt compilation makes a lot of sense. I'm considering keeping canonical memories provider-independent while introducing a compiler layer that formats retrieved facts, decisions, and constraints for each adapter. I'd also like to benchmark this against a shared baseline to measure whether it actually reduces context drift across models. Thanks for pointing out this architectural gap!πŸ«‚

Collapse
 
ayushanand10047 profile image
Ayush Anand •

It all sounds fascinating but i really wanna know how exactly i might fit into a users daily ai sessions, cause I still have my doubt about its actual working.

Makes me excited for its deployment :)

Collapse
 
pixel_nomad1856 profile image
Abhishek Gupta •

Actually, this is one of the biggest questions I'm trying to solve right now. Right now I am looking at ContinumAI to become the interface for users to interact with multiple providers with a shared memory layer behind the scenes. Users shouldn’t have to alter their entire workflow just to get persistent memory. I’m starting with a chat interface, then integrations that bring this experience closer to their existing AI workflows. Your question is a great reminder that the actual user experience is as important as the underlying architecture!
Thank you for your valuable feedback....πŸ«‚πŸ«‚

Collapse
 
gargharshit304 profile image
Harshit Garg •

Looks interesting.... Great work btwπŸ‘

Collapse
 
pixel_nomad1856 profile image
Abhishek Gupta •

thanks mann...