What is MemMini

Every AI tool you open is learning you: your voice, your judgment, your projects. Right now that version of you lives inside someone else’s product: scattered across tools, hidden from view, impossible to carry with you. MemMini moves it into plain-English files in your repo, where any AI can read it and no vendor owns it.

What you get, and how it runs

Three words make the rest make sense. MemMini is the engine: open-source, nobody’s mind, the same for everyone. Your mind is yours alone, your voice, judgment, and knowledge in a repo of your own. You get it by telling an agent install MemMini, and it builds your mind for you from what you already have. The engine rides along inside, pinned to a version and replaceable, so you can take a newer engine later without touching a line of yourself. Your mind then runs on surfaces (Claude Code, Codex, a chat app, any tool you use) and you bring it up on each by just asking. The full model: Framework, mind, surfaces.

Your mind is private by default. It lives where you put it, on your machine or in a repo only you can see, and nothing about you is published unless you say yes. The public thing is the engine, and there is nothing of you in it.

The problem it solves

AI assistants start every session from zero. They repeat mistakes, re-learn your preferences, and can’t build on prior context. So you keep re-explaining things the AI should already know. A plain context file seems like the fix, but you can’t tell if the model is even reading it, and the more you add, the less any single rule lands.

MemMini treats your context as something to engineer, not dump: written for how models actually read, checked against what the AI actually does, and split so the always-on part stays small.

Simple by default, deep when you reach for it

Two people open an AI agent. One says “just do X for me” and wants a good result, not a settings page. The other has opinions about everything (git, autonomy, what gets reviewed) and wants every dial in reach. Most tools pick one and lose the other: too simple insults the power user; too complex scares everyone else.

MemMini refuses the trade. The defaults work out of the box: say “run X for me” and a sensible version of you handles it. The depth is still there, but as a knob you reach for, never a wall you hit: every place MemMini decides something for you, you can see the decision and turn it. You start by using it; you find the knobs by reading on.

The biggest knob is how much the agent does on its own. By default it does the safe, reversible work and stops before anything it can’t take back. Turn it toward “just run it” and it acts; turn it toward “show me, ask first” and you approve each step and watch the work happen. Same system. You set the trust.

Stop reading here and you have enough to start. Everything below is a knob, not a requirement. The idea in full: Simple by default.

The two layers

MemMini separates how to think from what is true.

Layer	Directory	When it loads	Holds
Intelligence	`context/`	every turn (budget-bound)	who you are, how you work, behavioral rules
Knowledge	`wiki/`	on demand (retrieved)	facts, concepts, contracts, procedures, a linked graph

Intelligence biases the model toward your voice and judgment on every reply. Knowledge is a library it walks only when a topic comes up. So the deep material never weighs down the lean, always-on you.

The four lanes underneath

Zoom in past “loaded every turn” vs. “loaded on demand” and every piece of information in a MemMini repo sorts into one of four lanes, by how it’s used and how long it lives, not just where it loads from. You’ll meet all four directories on this page; naming the lanes together is what makes each one’s job legible on its own:

Lane	Directory	Lifecycle	Must not become
Policy	`context/`	small, changed deliberately, survives episodes	an event log, encyclopedia, or task queue
Memory	`.learnings/`	appended first; reviewed, then promoted or retired	silently-permanent policy, or unqualified truth
Knowledge	`wiki/`, `skills/`	retrieved on trigger, indexed	always-loaded instruction bulk, or live task status
Coordination	`.coord/`	active until closed, then archived	durable doctrine merely because work happened

This doesn’t replace the two layers above, it names what’s already underneath them. Policy is the Intelligence layer, same directory, same compiled artifact, named for what it owns rather than only when it loads. Knowledge stays the retrieved layer, widened to say outright what was already true: skills/ is knowledge that happens to be executable, so it’s named here too. Memory and Coordination aren’t a third and fourth thing injected into every reply; they’re the lifecycle lanes the other two pass through. Memory (.learnings/raw.md) feeds Policy and Knowledge through distill, see The loop below. Coordination (.coord/) is the shared to-do list from How work hands off, below, and never compiles into CONTEXT.md at all. Two layers get compiled and injected; four lanes are the shapes all of it moves through.

The compile step

You edit small source files; a build assembles them into the artifacts an AI consumes.

context/who.md   ┐
context/how.md   ├─►  your generated compiler     ─►  CONTEXT.md      (inject into the AI)
wiki/INDEX.md    │                                    ENFORCEMENT.md  (route in your platform)
skills/*/SKILL.md┘

CONTEXT.md is the portable “mind.” ENFORCEMENT.md carries the rules a platform should enforce deterministically rather than hope the model self-applies. You never hand-edit those two. You edit the sources and recompile. (Full source→artifact model: Repo layout.)

Nothing runnable ships to you

Worth knowing before you trust it with anything: MemMini doesn’t hand you code to run. Every guard, gate, and check that ends up watching your work is generated in your own mind, for your own tools, and has to demonstrate it can actually fail before anything relies on it. A check that can’t fail isn’t a check.

Which means auditing this is reading English. There is no binary to trust, no service holding your material, and nothing doing work you can’t open and read.

How work hands off

That builds the mind. Nothing below is setup you do now. It arrives the day your second agent does — the first time two of them are on the job, your mind offers this in plain words and you can wave it off. One agent needs none of it.

You ask; the agent runs it as a few small steps: Drafting → Up for review → Live. What changes with a second agent is where the job lives: one shared to-do list inside your repo, not in any single agent’s head. A job one agent hands to the next survives the handoff, and nothing reads as done until the agent receiving it confirms, so no work slips through the crack between two.

From there, everyone on the job has a queue, you and each agent, all shown the same way. Work nobody has picked up doesn’t vanish into a backlog; it sits in a shared pool, visibly ageing, until someone takes it. And your own queue holds only the things that need you: a decision, a yes. It never fills up with messages to pass along. That’s be the boss, not the bus, and it’s the mechanics now, not the aspiration: no server, no platform.

Walk one job end to end in How work flows here.

For the curious: that shared to-do list is the coordination bus: a plain .coord/ ledger in the same git as everything else.

The loop

MemMini gets sharper each session without you babysitting it:

Capture: after a session it records what changed to .learnings/raw.md.
Distill: between sessions it reviews captures and drafts updates to your files.
Verify: it checks the change actually moved the AI’s behavior.
You approve: by default, changes to who you are wait for your yes; routine work doesn’t. That gate is the knob from up top: tighten it to approve everything, loosen it to let more run.

See both flows up close (remember and improve) in How your mind gets smarter.

Set the pace

That loop, and the quieter checks that keep your mind fitted to your tools, run in the background on a single heartbeat: the mindbeat. One setting controls how often everything runs, and so what it costs: slow the beat and the whole mind sips less; speed it up for a fresher, busier mind. Each job rides a multiple of that beat: preset out of the box, a dial when you want it.

The full idea: The mindbeat.

That’s the whole idea: write yourself in sentences, prove the rules work, own the result.

Your first outcome: ask in plain words, get a result (no setup)
Quickstart: make it permanent
Write your first rule: change who the version of you is
How work flows here: how a job goes from ask to live, and who says yes