Install expertise into your agent.
A mem is a typed knowledge graph about one subject, sealed into one file. One command installs it. Your agent reads it over MCP and answers with citations into it. Plain markdown in git you own.
memstead install github:dasboe/engineThat mem is Memstead's own engine model, published on the registry. New here? The three steps below take about five minutes. Nothing to install at all? Point your agent at memstead.ai and let it judge.
●In active development. Memstead is pre-1.0 and built in the open: commands, schemas and file formats can still change. Your mems do not: they are markdown in a git repository you own, readable without us.
fig. 01 · mem fingerprint, deterministic per mem
Three steps, about five minutes.
$ curl -sSf https://memstead.io/install.sh | shTwo binaries: memstead, the CLI, and memstead-mcp, the server your agent connects to. Homebrew works too: brew install memstead/memstead/memstead-cli memstead/memstead/memstead-mcp.
$ memstead quickstart .$ memstead install github:dasboe/enginequickstart starts a workspace with one seed entity and writes the MCP wiring for Claude Code, Cursor or Gemini CLI; for Codex it prints the one command that adds the server. install fetches the sealed mem from the registry into a per-user cache and mounts it read-only.
Restart the agent session afterwards: a session that is already running does not attach an MCP server added while it runs.
Then ask it something about the subject. The answer cites entities of the mem, and every cited entity is a markdown file you can open and read yourself. Ask who wrote one of them, and why: the mem seals that rationale with each entity, and the engine reads it back on request.
Five things a mem is not.
Stated, not implied, so you can decide in a minute whether this is for you.
01 Make your agent smarter on what it already knows
Our own controlled eval found no answer-quality edge for typed structure over equally curated notes (the substrate eval). A mem pays off on a subject the agent does not know well: a product, a library, a codebase, a domain.
02 Remember your sessions
This is not agent memory. Memory is what an agent accumulates from its own sessions; your agent already has that. A mem is expertise someone curated and sealed for installation. It does not grow while you chat.
03 Import your notes
quickstart starts a fresh graph with one seed entity and refuses to swallow a folder of notes and call it a model. Knowledge enters through writes the schema validates, or it does not enter.
04 Run a database or a vector index
The store is markdown in git. Search is structural and full-text; the agent reading the graph is the semantic layer. Nothing to host, nothing to re-embed, nothing to export when you leave.
05 Offer a catalogue yet
The registry holds a handful of mems, published by the project's own author. It is open to its first publishers, and it is not a marketplace. What you install today is what you can see on memstead.io.
Typed knowledge, as markdown in git, served to agents through MCP.
Every fact is a typed entity: frontmatter, the sections its schema requires, and [[wiki-links]] that are checked foreign keys. The schema decides what may be written, and a nonconforming write is refused with an error that carries the fix. The files are plain markdown; keep them in a git repository and every change is a commit with a written reason.
→ An example entity, in the shape the engine writes and reads:
--- type: decision status: accepted decided_on: 2026-05-12 --- # Use idempotency keys on every write ## Decision Every mutating endpoint requires an [[idempotency-key-header]], so [[payment-retries]] never double-charge. ## Relationships - **SUPERSEDES**: [[retry-writes-without-a-key]] - **CONSTRAINS**: [[checkout-api]]
Build your own. Publish it.
Once a mem has paid off for you, curate one: memstead quickstart starts the workspace, your agent builds the graph through validated writes, and memstead publish seals it into a .mem under your scope on memstead.io. Installing a stranger's mem stays contained: a foreign schema's prose never reaches your agent's instructions, ingress is validated, the mount is read-only.
The engine is open. That's the point.
The engine, the CLI, the MCP server and the .mem format are open source (MIT / Apache-2.0) and free. The registry is a hosted service; the CLI targets any registry URL. Your mems are plain markdown in your own git either way, so they outlive any vendor decision, including ours.
Memstead is built by Björn Bösenberg, a Berlin-based developer, by orchestrating agents rather than by hand, on one thesis: correctness enforced at boundaries replaces trust in the author. The project keeps its own knowledge as mems and steers its work from them; the mem the path above installs is one of them.
v0.20.0 · 2026-09-10 A mem-repo boot is linear in the mem size: the git-branch backend reads a whole mem in one tree walk, so a 7,500-entity workspace boots in under 0.4 s where it took 5.6, and the sizing curve is re-measured on the fixed engine. Beside it: a sealed `.mem` carries a provenance record for every entity, prune proposes and never merges (the guarantee vocabulary is gone), and `projection advance` refuses to drop an authored exclusion or to advance over anchors that still drift.Release history →
The questions worth asking first.
Which agents does it work with?
Any MCP-capable agent: Claude Code, Codex, Cursor, Gemini CLI, and anything else that speaks MCP. memstead quickstart writes the wiring for the agents you pick. Humans and scripts get the same engine through the memstead CLI.
Does it work offline?
Yes. The engine, the CLI and the MCP server run on your machine, and your mems are markdown files in a git repository you control. The network is needed only to install from, or publish to, the registry.
Is it safe to install a stranger's mem?
A mem is data your agent queries, not instructions it obeys. The engine serves a foreign schema as structure only, withholds its prose, mounts the mem read-only, and tags every entity of an installed mem as third-party on read, ours included: the tag names the channel, not the author. Treat installed content as quoted data all the same.
Who owns my data?
You do, mechanically: mems are plain markdown in your own git repo. No database, no export step. Leaving Memstead is git clone; your files stay readable without us.
How big can a mem get?
A mem is a whole typed model of one subject, designed for 1,000 to 5,000 entities. Published .mem archives are capped at 2 MiB compressed, which is ample: mems are structure, not media.
Can I self-host the registry?
Not today. The registry server is closed source and a hosted service, on the npm model: open client, open format, hosted index. The engine, the .mem format, the publish protocol and the CLI are open, and the CLI already targets any registry URL via --registry.