Every conversation with a language model ends the same way: the context window closes, and everything the model just learned about you disappears. Zuse is built around a refusal of that reset. What it learns, it keeps — in a file you can read, inspect, and delete.

The store lives at ~/.zuse/knowledge.jsonl.
One line per entry, three kinds of knowledge:
preferences — how you like things done,
facts — what is durably true about your machine and projects,
procedures — how a task was solved, so it can be solved again.

Memory is only useful at the right moment.
So recall happens before the task, not after the question:
when you ask Zuse for something, it first pulls the entries
most relevant to what you are about to do —
by keyword overlap, or by local embeddings when Ollama is around.
The embeddings are an enhancement, never a requirement.

Writing happens on two paths.
The active one is a tool: the agent decides something is worth keeping
and calls remember.
The passive one is reflection — after work is done,
Zuse looks back at what happened
and quietly stores what would help next time.

A memory that only grows becomes noise.
So entries deduplicate against what is already known,
usage counts record what actually gets recalled,
and maintenance merges what drifted apart.

And because memory about you should answer to you,
the controls are one word each:
/memory shows everything Zuse knows.
/forget erases it.
--no-learning turns the whole thing off.

None of this is spectacular on any single day.
It compounds.
The tenth session knows what the first one had to be told —
and that is the difference between a tool you operate
and an agent that works with you.

Zuse is open source — MIT licensed.
The memory lives in a file. It is yours.

When the conversation goes quiet, Zuse doesn't just wait. Two minutes after you stop typing, a background thread wakes up — and every 45 minutes of idle time, the agent dreams. Not metaphorically: a separate, deliberately constrained cycle that tends its memory and thinks about how to be better tomorrow.

A dream begins with housekeeping.
Preferences that say the same thing get compacted,
entries that drifted toward each other get merged.
Memory that only grows becomes noise;
dreaming is where it stays sharp.

Then comes reflection.
The current conversation, the last few saved sessions,
and the memory's own statistics
go to a separate low-effort model call —
no tools, no thinking budget, just a look back.

The answer is held to a strict shape:
one sentence about what was learned,
durable lessons — preference, fact, or procedure —
that flow into the same knowledge store recall draws from,
and improvement ideas for Zuse itself.

The improvements are proposals, never actions.
They land as a checkbox list in ~/.zuse/improvements.md,
prioritized, deduplicated, capped at eight per cycle —
a backlog the agent writes and you decide on.

The whole thing is built around a refusal:
a dreaming agent must not act.
It runs no tools, edits no files,
and is explicitly forbidden from claiming it changed code.
If you are working, it steps aside; if a dream is already running, it skips.

Every cycle leaves a trace in ~/.zuse/dreams.jsonl —
what was maintained, what was learned, what was proposed.
And the controls stay one word long:
/dream status, /dream now, /dream off.

Memory makes Zuse remember what you told it.
Dreaming is the part that gets better
without being told anything at all.

Dreaming is on by default and off with one word.
The backlog is a text file. Both are yours.