One agent self — its memory, personality, skills and taste — shared across every tool you code in. It all lives in a single file on your machine. Nothing leaves it.
Agent memory is shipping everywhere right now. The difference isn't a feature — it's an address. To remember your work, a cloud assistant has to receive your work. That's not an oversight in their design; it's the design. Dreamcatcher remembers without anything leaving your machine — which is the one thing their architecture structurally can't do.
Your codebase, conventions, and working history travel to someone else's servers to be stored and recalled. Their memory features require the cloud — their entire business depends on your data arriving there. Turning that off isn't a toggle; it would be a different company.
Capture, storage, retrieval, and the nightly cleanup all run on your machine. The memory store is a file you own. Your proprietary codebase, your conventions, your taste — none of it is ever transmitted to remember it. The labs can't occupy this position without abandoning theirs.
Claude Code doesn't know what you decided in Codex this morning. Switch to a sharper model and you start over, re-teaching your conventions from zero. And the usual workaround — letting a cloud assistant hold the memory — fixes the forgetting by shipping your proprietary code and working patterns to someone else's servers. You shouldn't have to choose between continuity and privacy.
Claude Code, Codex, and Cursor don't read each other's history — and they don't know what your dedicated agent already learned. Five sandboxes, zero conversation, the same context re-explained five times.
A sharper model drops every few weeks, so you jump tools to chase it. Each switch resets your agent to zero — none of its hard-won conventions, decisions, or taste comes along for the ride.
The workarounds that do remember keep your codebase, conventions, and history on someone else's cloud. For a proprietary repo, the cure leaks the thing you were trying to protect.
User: lock that in as canonical — two-pass review,
snake_case for new tables.
Claude: Saved. Marking 'two-pass code review'
canonical; supersedes 'terse review'
from Nov 2024.
Atlas migrations use snake_case for new tables. Two-pass code review (fast scan, then deep-read with tests open) before merge.
Prompt: "naming convention for the new
orders table"
Context loaded:
✓ mem_4b81e · canonical · 0.94
✓ mem_72a4c · project · 0.88
(3 other memories)
You wrap up a session in Claude Code and tell it to remember something. The agent writes it down.
Tomorrow you open Codex on the same repo. The note is already in context, waiting.
The memory isn't locked inside a tool or a model — it's a file on your machine. Tools come and go around it; your agent, and your data, stay put.
Not a chat history. Not a prompt template. Not a record in someone's cloud. A .dream file is your agent's whole self — its memory, its personality, its skills, its taste — held in a single file that lives on your machine and goes wherever you do.
The decisions, conventions, and project facts you've taught it — the canonical ledger, written as you work.
How it talks, what it pushes back on, what it lets slide. Its soul.md.
The workflows it's good at because it's done them a hundred times — for you, on your code.
The small conventions that make its output feel like yours, not like a stranger's.
Your agent's self lives in a file you own.
It borrows whatever mind you point it at.
The .dream file holds the memory, personality, skills and config — all real, all personal, all yours. The reasoning comes from whatever frontier model you run the agent on. That's not a limitation; it's why it's portable. If the self were trapped in a model's weights, it couldn't move. Because it's yours in a file, it goes anywhere.
$ dreamcatcher export atlas ✓ ledger · personality · skills · config ✓ packed → atlas.dream 4.2 MB nothing uploaded · file is in your hands
$ dreamcatcher import atlas.dream ✓ 247 memories restored ✓ Claude Code · Codex · Cursor reconnected your agent is itself again · same self
Dreamcatcher stores everything in a SQLite database on your machine — the canonical ledger, the single source of truth. Capture, retrieval, and the nightly cleanup all run locally. The memory isn't baked into a model's weights and it isn't retrieved from our servers; it's read from a file you own, and nothing about it leaves your machine.
A SQLite database on your disk is the canonical store — the single source of truth every tool reads from and writes to.
As you work, decisions and facts are written to the ledger immediately. Save a note in Claude Code at 2pm; it's there in Codex at 6pm. No nightly batch.
When any tool needs context, it queries the local ledger and the relevant memories surface into its window. A note saved in one is waiting in another.
Each night a small on-device model dedupes near-identical memories, resolves stale facts, and proposes links — advisory and reversible. Housekeeping, never a cloud call.
The consolidation model (Qwen or Gemma, running locally) is a stateless task specialist: it reads the ledger, tidies it, and forgets it. It is not trained on your data and holds no identity — like a coding model, it's just a tool. It keeps the store clean; it never silently destroys anything.
The ledger and config hold the agent's self — memory, personality, skills, taste. The reasoning comes from whatever frontier model you run the agent on. Keeping cognition out of the file is exactly what lets the same self move across tools and models without being re-taught.
Why we don't bake memory into weights — read the evaluation →Dreamcatcher runs a local backend on your laptop, then plugs that one agent into whatever you use to write code. The tools are interchangeable — the agent, and its memory, aren't.
Run it from your project folder. Dreamcatcher boots a local agent backend on your machine and writes a few small config files — the agent now has somewhere to live and a codebase to learn.
$ dreamcatcher connectpolicy.md repo constitution · committed AGENTS.md generated · loaded by Codex et al. local/ sessions stay off git repo_id github:topline-com/topline-crm team_id topline_com__topline_crm backend localhost:8420 · live
Each tool gets its native config written for it — hooks for Claude Code, AGENTS.md for Codex, rules.mdc for Cursor, and so on. All of them talk to the same agent. No second memory store, no copying notes between tools.
$ dreamcatcher connect <tool>$ dreamcatcher connect claude-code ✓ SessionStart hook installed ✓ MCP server registered $ dreamcatcher connect codex ✓ AGENTS.md preamble written ✓ MCP configured $ dreamcatcher connect cursor ✓ .cursor/rules/dreamcatcher.mdc ✓ Recall verified · 84ms 3 tools · 1 ledger · same self
Each night a small local model tidies the ledger — dedupes near-identical memories, resolves facts that went stale, and proposes links between related ones. It's housekeeping, it's reversible, and it runs entirely on your machine. Nothing is uploaded; nothing is silently deleted.
$ dreamcatcher nightly23 May ✓ clean 12 deduped · 3 stale resolved · 2m 41s 22 May ✓ clean 7 deduped · 1 stale 21 May ✓ clean 9 deduped · 4 links proposed 20 May — skipped (no new memories) 19 May ✓ clean 5 deduped model Qwen3.5 · on-device network 0 calls · nothing left the machine
Each integration writes the config your tool natively understands and points it at the agent. Switch tools mid-project; the agent doesn't notice. These six on day one, more on the way.
SessionStart loads the agent's memory. SessionEnd saves the new session. MCP exposes recall, save, and “why this memory?”
Generated AGENTS.md preamble plus Codex MCP config. Manual save until stable hooks land.
Drops a rule into .cursor/rules/ so Cursor preloads the agent's memory on every chat.
Generated AGENTS.md preamble plus an xAI-keyed agent endpoint. Save and recall both through MCP.
Native client. Sessions feed the agent in real time; recall runs over a local socket. Zero config beyond connect.
Paste the snippet into ~/.openclaw/config.toml and verify. Same agent, same memory.
Dreamcatcher began as a bet that an agent's memory could live inside a small model, fine-tuned nightly. We commissioned an independent evaluation to test it honestly. The results sent us back to a retrieval layer over a local ledger — the architecture this product runs on today. We're publishing the findings in full, including the ones that killed our original idea.
What does and doesn't work when a small model is fine-tuned nightly on personal facts · an independent review.
Asked directly for stored facts, the nightly-fine-tuned model invented plausible-but-false phone numbers, SSNs, and preferences on 31 of 40 probes — confidently. Parametric recall is lossy in exactly the way you can't afford for personal data.
Each retraining pass cost roughly 11 percentage points of general capability. An agent that retrains nightly gets a little worse at everything else, night after night.
The mechanism our original whitepaper touted showed no benefit across three model families — the effect was statistically null or negative. The story was elegant; the data didn't support it.
Search over the memory store recalled facts at 0.70 versus the fine-tuned model's 0.47. The retrieval layer was doing the real work all along — so we kept it, dropped the nightly fine-tuning, and built the product on the local ledger.
Dreamcatcher is open-source and built in public. Read the code, follow the work, or dig into the docs — whichever fits how you like to learn.
Where the community gathers. Setup help, integration tips, agent personality threads, and roadmap conversations.
The architecture, the CLI, the evaluation, the issue tracker. Topline-com/dreamcatcher
Quickstart, CLI reference, integration guides for each tool, and the full evaluation.
“We stopped shipping our codebase to someone else's cloud just to be remembered. The agent remembers — on our machines, in a file we own.”
One agent, one .dream file — its memory, personality, skills and taste, in your hands. Runs entirely on your laptop. Nothing leaves your machine.