Save the thinking. Switch models. Continue like you never left.
Watch one decision leave a chat, live inside Continuum, and come back in a different AI. This is the whole product, on a loop.
Every model remembers something. None of them remember your reasoning.
Each tool ships its own kind of memory, and every one of them drops the part that actually matters the moment a chat ends or you change tools. Here is what breaks, tool by tool, and what Continuum does about it.
One decision, followed for eight weeks.
Watch a real decision travel from the chat where you made it, through a full context window, into Continuum, and back out in a different AI weeks later. It plays on its own.
It starts in a chat
An ordinary conversation, and the why exists in exactly one place.
Feel the loop in ten seconds.
A faithful simulation of the real tools. Save the reasoning in one AI, switch platforms, and resume with nothing lost.
outside every platform
The model is temporary. The reasoning is yours.
Facts are cheap to recall. Reasoning is what dies.
A fact you lose can be looked up again. The reasoning behind a decision cannot. Once it is gone, you pay for it twice: once to rebuild it, and once in the mistakes you repeat.
- The window fills, and the model silently discards the thinking that got you here.
- You switch tools, paste a wall of transcript, and spend an hour re-explaining trade offs.
- You return a month later. The decision survived. The reason for it did not.
- Every decision is saved with its why and the options you already ruled out.
- Any AI resumes the exact reasoning, in one sentence, with nothing lost.
- Any subject comes back from months of history, not just the latest save.
Capture in flight. Rebuild anywhere.
One checkpoint writes three layers at once. One resume reads them back as a compact package that fits any context window.
Six verbs you will use daily. One memory underneath.
Identical everywhere: type them in a terminal, say them in plain English over MCP, or call them from the HTTP API.
checkpoint
Freeze the working state of a chat: decisions, reasons, rejected options, open questions.
checkpoint chat.txt -p authresume
Rebuild the latest state as a compact package that pastes into any AI.
resume -p authrecallnew
Pull everything about one subject from the entire history, not just the last save.
recall -p x "dna mutation"capture
Import a session straight from Grok, Claude Code or Codex. No copy paste.
capture -p x --from grokautopilotnew
Watches the context window and hands you a ready export before anything is lost.
autopilot -p x -t chat.txtobservenew
Buffers every turn and checkpoints on its own. Saving stops being your job.
autosave --source claude_codealso ingest, export, import, improve, prune, distill, lessons, timeline, search, mode, list, status, forget
A month of work, still one continuous thread.
Continuum is not just for one chat. Across weeks, many topics, and several tools, it keeps the whole reasoning trail and hands back exactly the part you need, without ever overflowing the next context window.
The thread, not the latest
Every checkpoint on a subject, merged into one.
recall -p x "dna mutation"Always fits the window
A year of history, still one clean paste.
export -p x -f digestSaved every turn
Checkpointed after each turn, on its own.
continuum autosaveQuery, not swallow
Agents pull only what they need.
GET /decisions/authEveryone stores facts. Only Continuum stores the reasoning.
Memory systems cover a thin slice, they recall knowledge. Continuum covers the whole surface, because it saves the working state of a decision and carries it to another AI.
| Capability | Claude | Codex, Grok | mem0 | Cognee | Continuum |
|---|---|---|---|---|---|
| Remembers reasoning | internal | no | facts | entities | yes |
| Portable across AIs | locked | one way | yes | no | yes |
| Knowledge graph and vectors | no | no | partial | yes | superset |
| Recall by subject across months | no | no | no | no | yes |
| Bounded and incremental export | no | no | no | no | yes |
| Automatic per turn save | lossy | no | no | no | hook |
| Cross platform resume with reasoning | no | no | no | no | unique |
Two minutes to connect. Then you just talk.
Pick where you work. Every path ends the same way: you speak to your AI in plain English, and it remembers.
Add a custom connector
Claude web, Grok or ChatGPT, Settings, Connectors, Add custom connector.
Paste the live MCP URL
Talk to your AI
Install
Save and resume
Switch platforms
Add one Stop hook
Work normally
Every turn checkpoints itself into a project named after the folder, debounced.
Pick up any time
Start free today. Upgrade when your memory should follow you everywhere.
The local tier is free forever, no card and no keys. Pay when you want hosted memory on every device, semantic recall across months of work, and saving that happens on its own.
- Local memory, unlimited checkpoints
- Up to 3 projects
- CLI and copy paste into any AI
- Keyword search and resume
- Everything in Free
- Hosted MCP, synced on every device
- Unlimited projects
- Semantic recall across months (Cognee)
- Autopilot and automatic per turn save
- Everything in Pro
- Shared projects and roles
- Per user isolated memory
- Priority support
- Self host or private cloud
- SSO and audit trail
- SLA and dedicated support
- Volume pricing
Your reasoning is yours. Every tier exports to Markdown or JSON on demand, and the local tier keeps working even if you never pay us a cent.
Everything people ask before they connect it.
Do I need an API key or an account to try it?
What exactly does Continuum store?
How is this different from ChatGPT memory or Claude projects?
Will a long project eventually overflow the context window?
What happens to my data if I cancel?
Can my whole team share one memory?
The context window ends. Your thinking should not.
Save the why once. It will be there in any AI, on any machine, months from now, exactly as you left it.