Memory, personality, skills, taste — one portable file. The agent lives with you, not in any one tool.
Hermes and OpenClaw don't remember the work you did in Codex this morning. Claude Code doesn't know what you decided in OpenClaw last week. And every time a sharper model drops, you switch tools and start over — re-teaching your codebase, your conventions, and your taste from zero.
Hermes and OpenClaw are great until you spend an afternoon in Claude Code or Codex — then they have no idea what you just decided, refactored, or ruled out.
Claude Code, Codex, and Cursor don't read each other's history — and they certainly don't read what your dedicated agent already knows. Five sandboxes, zero conversation.
A sharper model drops every few weeks, so you jump from OpenClaw to Claude Code to Codex to chase it. Each switch resets your agent to zero — none of its hard-won context, conventions, or taste comes along for the ride.
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 belongs to the Small Identity Model. Tools come and go around it; the agent stays.
A SIM is your agent's whole self in one file. Not a chat history. Not a prompt template. Not a vector store bolted onto someone else's model.
What you've taught it, baked into the weights via nightly retraining.
How it talks, what it pushes back on, what it lets slide.
The workflows it's good at because it's done them a thousand times for you.
The small choices that make its work feel like yours.
One file. Personal to you. Portable across every tool that wants to host it.
Dreamcatcher's full architecture — nightly parametric consolidation, sleep-inspired organic reinforcement, monotonic memory ledger — is published as a preprint. Below: the four ideas that do the most work.
The Dreamcatcher architecture for persistent agent selfhood · Small Identity Models with nightly parametric consolidation and sleep-inspired organic reinforcement.
Each night's model is computed as Mₜ = F(M₀, Tₜ) — a function of the fixed pretrained base weights and tonight's rendered training set, never the previous model. The TRACE benchmark showed sequential LoRA fine-tuning dropped Llama-2's GSM8K accuracy from 43% to 2%; full re-fine-tuning from base sidesteps that class of forgetting entirely.
The default is Qwen3.5-0.8B, dense, 800M parameters: full fine-tune fits in 8–12 GB VRAM and completes in 2–3 min on an RTX 3090 for typical dataset sizes. Gemma 4 E2B/E4B and SmolLM2-360M are also supported — base model is a one-line config change.
Important facts get referenced across many sessions; each reference generates 3–5 fresh training pairs from naturally distinct contexts. A child's food allergy ends up with ~28 pairs, a one-time contractor's name with ~4. No engineered scoring system — the dataset's own composition is the priority signal. This parallels frequency-dependent strengthening in biological memory consolidation.
A common misconception: the frontier LLM is not called on the whole accumulated dataset each night. Extraction runs only on the day's new transcripts (typical cost $0.05–$0.15 per nightly). Training runs entirely on a local GPU with zero network access; inference is on-device. The only thing that leaves the machine is the snippet sent to your LLM provider during nightly extraction.
A SIM is a compact, fully re-trained language model with your agent's memory baked into the weights — not retrieved at runtime, not prompt-injected. Train nightly on your agent's ledger; ship a new self-contained model in the morning. Same family as LLMs and SLMs, different job: identity, not general knowledge.
Read the technical whitepaper →Sequentially updating a model on its own outputs accumulates drift — every night the agent would slip a little further from ground truth. Dreamcatcher re-trains from base each night on the agent's full memory ledger, so the notes are the source of truth and the model underneath is replaceable.
The agent answers from on-device inference. The only thing that ever leaves the machine is the nightly extraction call — sent to the LLM you chose on the key you provided, on the day's new transcripts only, never on the full history. Typical cost: $0.05–$0.15 per nightly.
Dreamcatcher boots a Small Identity Model on your laptop, then plugs that one agent into whatever you use to write code. The tools are interchangeable — the agent isn'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 SIM · same self
Each night, the sessions you finished that day become training pairs and fine-tune the agent's memory model from fresh base weights. No drift, no sprawl, no growing context window — just yesterday's lessons baked in by morning.
$ dreamcatcher nightly23 May ✓ 48/50 deployed · 17m 04s 22 May ✓ 49/50 deployed 21 May ✓ 47/50 deployed 20 May — skipped (no new sessions) 19 May ✓ 48/50 deployed pass rate 92.9% across 14 runs base Qwen3.5-2B
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 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, base-model recipes, agent personality threads, and roadmap conversations.
The architecture, the CLI, the whitepaper, the issue tracker. Topline-com/dreamcatcher
Quickstart, CLI reference, integration guides for each tool, and the full whitepaper.
“We stopped re-explaining our codebase to every new tool. The agent remembers; the tools just borrow.”
One agent, one Small Identity Model — yours to keep, yours to carry across every tool. Runs entirely on your laptop. Nightly training costs around a dime.