An AI coding tool's memory lives and dies inside the context window. Fifty messages into a real project, it starts to rot. A decision you settled on Tuesday gets relitigated on Friday. The AI points you to a file that never existed. A constraint you stated three times gets broken with total confidence. And at some point you stop trusting anything the model tells you — which is worse than it knowing nothing at all.
Meanwhile the project itself drifts: two weeks after you create a file, neither you nor the AI remembers where it lives, and the root directory slowly fills with scratch.
Today we released v2 of wallaby-agent-rules, our open-source fix for both sides of that problem. The theme is the whole design in four words: AI remembers, you find.
The fix is not a bigger window
Every vendor's answer to memory rot is a larger context window. But rot is not a capacity problem — it is a trust problem. Anything that lives only in the window is unverifiable: you cannot diff it, cannot audit it, cannot correct it once and have the correction stick. Our answer is to move memory out of the window and into plain files — where a fact can carry a date and a source, a correction survives into every later session, and git diff tells you exactly what changed.
What two prompts build
There is nothing to install. You paste one prompt into the AI that already works in your project — Kimi Code, Claude Code, Cursor, Codex, or anything that can read and write files — and it builds five files:
| File | Job |
|---|---|
AGENTS.md (or CLAUDE.md / .cursorrules) |
Entry point — tells the AI to read its memory at the start of every session |
MEMORY.md |
Long-term memory: permanent facts, decisions, iron rules |
NOW.md |
Current state: work in flight, recently touched |
INDEX.md |
The project map: one line per file, built by actually scanning your project on the spot |
scripts/health_check.py |
Zero-dependency weekly check: stray root files, build artifacts, unregistered docs |
The moment the build finishes, you watch the AI scan your project and hand you the first INDEX.md — "you find," delivered on the spot. From then on, memory is a habit rather than a feature: the entry file makes the AI read MEMORY.md + NOW.md before every session, check INDEX.md before searching for anything, and register every new file the moment it is created.
Everything is plain Markdown you can read, git diff, and edit. Five files, zero dependencies, no vector store, no background service, no lock-in.
Built to stay trustworthy
Files alone do not stop rot — a file can hold a hallucination as easily as a context window can. So the system carries three habits that keep its memory worth trusting:
- Every fact carries a date and a source.
MEMORY.mdis one line per fact, each with a source — a file path, a commit, or "told by the owner." No source, no entry. - Guesses never become facts. Anything the AI is unsure of goes on a to-confirm list for you, never into the files.
- On conflict, the file wins. The standing rule is explicit: what the memory files say ranks above what the model remembers, which ranks above what it infers — and every conflict gets flagged to you instead of being silently resolved.
Three ways in
The full prompt text lives in PROMPT.md. Pick one:
- L0 — One-click install (~30 seconds). All defaults, zero questions. For "just make it work" — paste two lines and watch:
Fetch https://raw.githubusercontent.com/Dawncoral/wallaby-agent-rules/main/PROMPT.md
and follow its "L0 — One-click install" section in this project.
- L1 — 6-question interview (~2 minutes). The AI asks about your tool, project size, solo or team, chat volume, record style, and tidy-up preference — then builds the same system tuned to your answers. For when you want the memory budget and the entry file matched to how you actually work. L0 is not a separate system; it is L1 with every question answered by default. One logic, two entry points.
- L2 — Upgrade check (~2 minutes). For projects that already have memory files — from our v1 or your own conventions. The AI detects what you have and proposes an incremental upgrade list. More on this below.
Can't fetch URLs? Open PROMPT.md and paste the section directly — it is plain text.
Upgrading without losing anything
v1 shipped four days earlier as a template pack: an AGENTS.md token-budget starter and a three-tier memory convention. Those templates remain valid and unchanged — but if you adopted them, v2 has pieces you did not get (NOW.md, INDEX.md, the health check). The L2 prompt is how you catch up.
Every user-facing file in the repo now opens with a version marker — `` — so any AI can tell which generation your setup belongs to (no marker plus v1 fingerprints means v1). The upgrade itself runs on three principles, stated at the top of the L2 prompt because they override everything else:
- Add, never overwrite. New files are simply created; changes to existing files are only ever proposed as diffs.
- Your content is sacred. Every line you wrote stays untouched.
- Nothing moves without your confirmation. The AI produces a checklist; you approve item by item; it executes exactly what you approved.
Migration notes and version history live in CHANGELOG.md.
Why we open-sourced it
This is not a methodology we read about. We run this exact system, every day, on the production project behind our API service — code, deploys, monitoring, and this blog are all operated with AI agents whose instructions and memory live in these files. It is infrastructure we depend on, not advice we sell. When that is true, open source is the honest option: you get the same files we use, the repo is the diffable record of how the system evolves, and the MIT license means you can adapt it freely.
Who built this
Wallaby Token (WALLABY DATA PTY LTD, ABN 90 701 729 964) provides inference-as-a-service for open-weight large language models. We open-sourced this memory system because it runs our own project daily — and because a tool you can read, diff, and fork beats one you have to trust. More about how we run things: wallabytoken.com.