Durable working memory for coding agents
Clauderizer is a memory system for coding agents. It documents your project as you build (plans, decisions, and conventions as plain Markdown in docs/) and briefs your agent automatically at the start of every session. No re-explaining. No decision rot.
Scene 02 Int. fresh session - night
Before you type a word, the SessionStart hook has already told the agent exactly where things stand. No prescribed reading order, no re-briefing.This is the digest for this very site.
you open a fresh session, nothing typed yet
[Clauderizer] gameplan directors-cut · phase 3 / 6
baseline 0 tests ·10 lessons· 0 pending cascades
next:cz_next_phase_context → cz_preflight
↑ injected automatically: no prescribed reading order, no re-briefing
▸ I see where we are: phase 3 of 6. Preflight passed. Rolling the title sequence now.
Every session picks up exactly where you left off.
That’s how you fly. ✦
Scene 03 The failure mode
You re-explain the architecture. Again. The agent re-discovers what it already knew, burning context and patience on ground you covered yesterday.
Mid-task the window overflows. The agent forgets its own earlier decisions, then confidently contradicts them an hour later.
The usual answer is conventions. But conventions rot, because nothing executes them. Clauderizer makes memory a system, not a hope.
every session starts from zero
every session is momentum →
Scene 04 How it works
No database. No proprietary cloud. The graph index is a disposable cache, rebuilt from the Markdown on demand. If they ever disagree, Markdown wins. Your ideas survive as plain text.
Plans, decisions, invariants, and a dependency graph, all diffable, reviewable, and shipped with the code.
Reads and writes the Markdown, rebuilds the graph cache, and runs preflight and cascade against the real repository.
Self-describing tool calls (MCP, the Model Context Protocol, a standard way agents use external tools) and lifecycle hooks inject status into context, automatically.
Oriented before you type a word. No prescribed reading order, no re-briefing, no drift.
cz_next_phase_contextthe full bundle for this phasecz_preflightactually runs your tests / build… do the work …write code, honor the invariantscz_add_decision · cz_add_invariantstructured, graph-aware recordscz_cascadewalk the graph, flag dependentscz_write_handoffassemble the next cumulative handoffScene 05 Why it holds
Prose conventions rot because nothing executes them. Clauderizer keeps the proven model and makes it real tool calls the agent can't forget to make.
Self-describing MCP tools + lifecycle hooks inject status into context automatically. No "read these 7 files in this order" ritual.
Three project sizes (pet, standard, and SaaS) plus host-language profiles: configuration as data, not prose advice.
Cascade, pre-flight, and handoff assembly are real tool calls, not instructions the agent has to remember to run.
One command clauderizes any repository, in any language. Idempotent; never clobbers your files.
One install wires every supported agent by default: Claude Code, Cursor, Copilot, Codex, Gemini, Windsurf, Cline, Amp, Continue, Zed, Grok, and Kimi. Add --host to scope it to one.
Memory is append-only and every write lands as plain Markdown. It ships with the code, shows up in diffs, and is reviewed like code.
Scene 06 Maturity
Every quality gate is publicly verifiable: the test suite passes on Ubuntu, macOS, and Windows across Python 3.11–3.13; the Windows wrapper is executed, not simulated; cold starts are proven on both host shapes; and the quickstart runs against the published package in a clean CI environment on every push.
Markdown is the source of truth. The graph index is a disposable cache rebuilt on demand. If they ever disagree, Markdown wins.
Scene 07 The invitation
One command clauderizes any repository, in any language. You talk in plain English; your agent makes the tool calls and keeps your plan, graph, and memory in sync between sessions.
Prefer a real install? pipx install "clauderizer[mcp]". The core engine has zero runtime dependencies.
Scene 08 Speak the language
Clauderizer binds a handful of ordinary words to specific tools and disciplines. They aren’t jargon, they’re handles: use one in plain English and your agent reaches for the exact machinery instead of improvising.
A whole initiative: phases, decisions, exit criteria, a post-mortem. Comes in kinds: driven, loop, campaign.
“Create a gameplan for X” triggers real planning: recorded decisions and verifiable exit criteria, not a bullet list.
One session-sized chunk of a gameplan.
“Do the next phase” runs the full discipline: pre-flight, the work, then the ending protocol.
The self-contained context bundle the next session reads, cumulative, carrying every still-relevant lesson.
“Write the handoff” assembles it as an operation. If a session dies, the next one loses nothing.
Which gameplan is the current default target; the set of all open ones.
“Switch focus to the campaign.” Several initiatives coexist without stepping on each other.
A tracked subsystem, feature, or deliverable with a version, a status, and dependency edges in the project graph.
“Track the billing worker as an entity” puts it in the graph, which is what makes cascade possible.
A campaign’s execution unit (a film, a deck) moving through a lifecycle from concept to shipped.
“Add the flagship film as a deliverable” gets you a board you can read the campaign from.
The umbrella word: a discipline that executes instead of a convention someone has to remember.
Cascade, pre-flight, and handoff assembly are tool calls, not reminders.
Nothing changes in isolation: after editing something tracked, walk everything that depends on it and reconcile.
“Cascade that change” walks the real dependency graph: each flagged dependent gets an explicit verdict.
Run the project’s actual checks (tests, build, QA gates) before starting work.
“Pre-flight it” runs the commands for real and reports measured results. Kills “session claims tests pass.”
The measured number pre-flight tracks: a test count, or campaign gates.
“What’s the baseline?” gets the tracked, auto-refreshed figure, not a stale note.
A numbered, append-only decision record with its reasoning.
“We decided X because Y” gets recorded; supersede a decision with a new one, never rewrite history.
A rule that must always hold, honored by every session.
“Make it an invariant: the logo is never AI-generated.”
A reusable learning that rides in every future handoff. Curated with three verbs: consolidate, promote, obsolete.
“Lesson learned: build the adversarial fixture first.”
The divergence log: what the plan said versus what turned out to be true.
“The plan said X, actually Y” keeps the plan honest without rewriting it.
A tracked unknown or blocker with a stable ID, resolved, never deleted.
“Open item: which auth provider?” Unknowns get tracked, never silently dropped.
A tracked mid-flight change to a gameplan.
“Amend the gameplan” puts scope changes on the record instead of letting them drift.
The governing posture: gates surface, they never block. The engine proposes; you decide.
Every check below follows this rule.
Verifiable done-conditions each phase carries.
“Check off the criterion” marks it; completing a phase surfaces any left unchecked.
A human sign-off recorded as the artifact’s content hash. Edit the file afterward and the approval goes stale.
“Approve the shot spec.” Spend-gates that expire when the content changes.
A declared threshold probe checked whenever anyone asks for status.
“Watch the backlog: below three approved stills means a new iteration.”
The compact where-things-stand block every session opens with.
“Where do we stand?”
Seed memory from a repo’s existing README and specs; the agent distills.
“Onboard this repo” turns placeholder docs into a seeded memory graph.
Deliver a newer engine’s improvements: mechanical changes applied, memory-shaped changes proposed.
“Upgrade the repo” after updating the package.
The house physics: nothing in memory is ever deleted.
Say “obsolete it,” “supersede it,” or “resolve it,” never “delete it.”
Scene 09 Questions
Clauderizer gives AI coding agents durable, cross-session memory: plans, decisions, invariants, and a dependency graph stored as plain, Git-diffable Markdown the agent reads and updates through real tool calls.
A rules file is prose the agent has to remember to read and follow. Clauderizer exposes memory as self-describing MCP tools and lifecycle hooks, so orientation and updates happen as executed tool calls, not conventions that quietly rot.
A monorepo keeps your code in one place, but the agent still starts every session blank: there's no tracked plan, no decision log, and nothing that briefs it. Clauderizer works in any repository, monorepo or not, and greets the agent with where things stand before you type a word.
In your repository, as Markdown under docs/. It ships with the code, shows up in diffs, and is reviewed alongside changes. The dependency graph is a disposable cache rebuilt from that Markdown; if they ever disagree, Markdown wins.
One install wires every supported agent by default: Claude Code, Cursor, GitHub Copilot, OpenAI Codex, Gemini, Windsurf, Cline, Amp, Continue, Zed, Grok, and Kimi. Add --host to scope it to a single tool.
Yes. Clauderizer is Apache 2.0 licensed with an explicit patent grant, and the core engine has zero runtime dependencies.
Run uvx --from clauderizer clauderize init in any repository, or pipx install "clauderizer[mcp]" for a permanent install. Then point your agent at a goal and say "do the next phase" each session.
Scene 10 The final frame
Project memory belongs in the repository, where it ships with the code, shows up in diffs, and is reviewed alongside changes. As tool calls the agent can't forget to make, not advice it has to remember.
