Basic Memory
Validated on demand.
Ships real schema tooling — validate, infer, drift-diff — but writes stay ungated: structure is checked when you ask, not when the write lands. Drift enters first, gets flagged later.
For developers building with AI agents
Project knowledge your AI agent can trust.
Memstead keeps a typed knowledge graph of your project — markdown in git you own, validated on every write, so a nonconforming entry is refused at the boundary rather than rotting silently into the record, and drift becomes visible. Not notes. Not a database you have to run.
●In active development. Memstead is pre-1.0 and built in the open — APIs, schemas, and file formats can still change. Use it, kick the tyres, and expect a work in progress rather than a finished product.
One measured self-proof: Memstead catches its own drift — 79% of 153 findings closed at a ~12-minute median — method & source.
fig. 01 · mem fingerprint — deterministic per mem
The 30-second answer
Why isn't MEMORY.md enough?
Your agent's native memory is a flat file it appends to — untyped, tool-bound, and never validated, so nothing stops it drifting or contradicting itself. That's fine for session notes. A project is not session notes: it needs typed entities with checked relationships, enforcement that refuses a bad write instead of absorbing it, and portability that outlives any one agent. Memstead is the graduation path from a notes file to a model your agent can trust.
Start fresh — it takes one command:
$
memstead quickstart ./my-project It starts a new typed graph — it won't silently swallow an existing MEMORY.md or a folder of notes and pretend they're a model. Nothing enters the graph without passing the schema; that refusal at the doorway is the same guarantee that keeps the graph honest ever after.
The problem
Knowledge rots, because nothing ever refuses the rot.
Specs drift from the code. Docs go stale. The person who knew why walks out the door. And every layer that could have caught it — a style guide, a review checklist, a note in the README — is advice, not a gate. Nothing says no at the moment the wrong thing gets written down.
01 It drifts
Documentation describes a system that no longer exists. Nobody can tell the record from the reality.
02 It walks out
Institutional knowledge lives in heads and chat logs. When people leave, it leaves with them.
03 Nothing says no
A folder of notes accepts every write. Contradictions, half-facts, and off-vocabulary entries land unchallenged and stay — there is no boundary that could have refused them.
What it is
Typed knowledge, as markdown in git, served to agents through MCP.
Every fact is a typed entity with frontmatter, a ## Relationships block, and [[wiki-links]] that are real foreign keys — not prose mentions. The graph is diffable, human-readable, and has no vendor lock-in.
→ This is exactly what your agent reads:
--- type: Decision id: D-014
status: accepted
title: Use idempotency keys on all writes
---
We require an [[Idempotency-Key]] header on every
mutating endpoint so [[Payment-Retries]] never
double-charge. Supersedes [[D-006]].
## Relationships - supersedes → [[D-006]] - constrains → [[Checkout-API]] - referenced-by → [[Payment-Retries]]
How it works
Three steps from knowledge to a queryable .mem.
01 · AUTHOR
$ memstead quickstart ./specs One command starts a workspace: pinned schema, agent wiring, first entity. Then your agent builds the typed graph through validated writes — entities, relationships, checked links.
02 · PUBLISH
$ memstead publish my.mem Package the graph as a .mem and push it to the registry under your scope and authority.
03 · INSTALL
$ memstead install acme/payments Any agent pulls it and queries through MCP — validated on ingress, mounted read-only, with each entity's authoring rationale sealed inside the package.
The command shapes are real; acme/… and my.mem are placeholder names — your scope and mem take their place.
And between those steps there is nothing to memorize: everyday graph work has no command — just talk to your agent. The engine's tools are always live, and the agent reaches for them on its own whenever you describe what you want.
The trust story
Three guarantees the engine holds — so you don't have to.
Trust here is a mechanism, not a promise. Three things hold at the engine boundary — so a malformed write never lands, many agents and a human can work one graph without quietly overwriting each other, and every claim in the record can be traced to who put it there and why.
Enforced
One validator guards every ingress — each write, package install, and git pull. A nonconforming write is refused, never coerced or flagged later, and the typed error carries the fix: the declared fields, the allowed values, a nearest-match. The agent corrects from the error and retries.
Governed
Many agents, one graph. Every write carries a hash lock and out-of-band sibling commits are caught, so a stale write fails loudly and nothing is silently lost — MCP, CLI, and a human on one branch. Agent autonomy is default-deny: schema-scoped zones you carve and can edit at runtime.
Accountable
Every mutation is a git commit with actor and tool trailers and a one-sentence rationale — readable with git log alone: no running engine, no PII. That rationale travels per-entity inside the sealed .mem, so an installer can ask "why should I believe this entity?" offline.
The mechanism
How drift becomes visible.
"Visible" is a mechanism here, not a metaphor — three layers, each one you can check yourself.
01 In the graph, automatically
The engine flags what's structurally rotting on every health check — stale entities, dangling links, missing required fields — and can diff any two states of a mem, entity by entity. No setup.
02 To you, as plain git
Every change to the graph is a git commit with a written why. Drift in your knowledge reads like drift in your code: as a diff you can review, blame, and revert.
03 Against your source, as a loop
A verify run measures how faithfully the mem still matches the source it describes — read-only, leading with a verdict — and files what diverged. sync is the single maintenance writer that acts on those findings: changes flow source → mem, never the reverse. One measured run on our own project: 79% of 153 findings closed at a ~12-minute median — method & source.
Layer 03 is a closed loop you can run today, five commands end to end: /ingest builds the mem from your source, memstead status shows what has gone stale, /sync catches the mem up, /verify measures and reports, /commit lands anything still pending. Measuring and writing never share a hand.
Don't take the layers on faith either — point your own agent at memstead.ai and let it check.
How it compares
Two things you can check, not take on faith.
We analysed fourteen agent-memory tools. Most axes are contested — good tools exist. Two are not. Here they are, stated honestly.
Validation
Memstead
Enforced on every write.
Each write is validated at the engine boundary against a closed, typed vocabulary — entity types, relationship types, cardinality. A nonconforming write is refused, with a machine-readable hint the agent uses to recover.
Packaging
Memstead
Knowledge as a versioned, installable package.
A mem seals into a schema-validated .mem archive with a semver version — published to a registry, installed by anyone with one command.
Anthropic Memory Server
A whole file into context.
The reference MCP memory server keeps its graph in one JSONL file the agent loads wholesale. No versions, no packaging — sharing knowledge means copying the file.
That's the whole comparison — no benchmark theater. Even our own drift numbers are bound by a written contract: coverage, accuracy, and freshness reported as three separate axes, never blended into one score — the fidelity contract. The rest you can judge yourself: point your own agent at memstead.ai and let it evaluate Memstead live.
Open core
The engine is open source. That's the point.
Memory infrastructure you can't inspect is just another place your knowledge gets locked away. The engine, schema format, and MCP surface are open — so the mems you author outlive any single vendor, including us.
What it costs: nothing. Memstead is open source (MIT/Apache-2.0) and free — the engine, the CLI, the MCP server, and the registry. A commercial offering for teams and companies may come later. Your mems are yours either way: plain markdown in your own git.
A native Mac app is in the works — a human cockpit over the same open engine, for reviewing and undoing what agents change. Early, in private preview; the engine never depends on it.
MIT / Apache-2.0
ENGINE LICENSE
.mem
OPEN FORMAT
MCP
AGENT INTERFACE
Built in the open, on itself
We run Memstead on Memstead — gaps and all.
Memstead is built by one person — Björn Bösenberg, a Berlin-based full-stack developer of ~25 years, building Memstead in the open — on a single thesis: correctness enforced at boundaries replaces trust in the author. That is why the engine is Rust (the compiler stands in for the code review a solo builder gives up), and why every write to a mem is validated at the boundary rather than trusted after the fact. The same thesis, applied to knowledge instead of code, is the product: roughly 138K lines of Rust, none written by hand, about 3,100 agent commits against 4 human ones, across ~4.5 calendar months of part-time work.
What works today. The project models itself as 9 live mems — 621 typed entities across the engine, macOS app, plugin, registry and strategy, plus a 14-assertion claims register. Drift detection runs against that knowledge and surfaces where the docs and the code have diverged: in one measured run it closed 79% of 153 drift findings at a ~12-minute median (method & source) — Memstead catching its own rot. And 97.2% of mutating commits carry a written rationale, so the why lives in git, not in someone's memory.
What doesn't yet. No single mechanism closes rot alone: automated detection finds the drift, but repairing the source side still takes a human pass, and the freshness mechanisms bind rot only where they run — a minority of the project's own surfaces so far. The self-proof is in progress, not achieved; we'd rather show the gap than claim it closed. These numbers are one measured run over the project's own graph, not a benchmark.
On the "13× smaller" number. A fresh agent rebuilt a domain's full working picture by reading a finished, curated mem at about ~1/13 of the tokens the conversations that authored it had consumed (method & rerun kit). We read that as what curation buys — not the typed graph specifically: a controlled follow-up (the substrate eval) found typed structure adds no answer-time edge over equally-curated flat notes. So the number lives here on the proof page, not in the headline.
FAQ
The questions worth asking first.
Does it work offline?
Yes. The engine, the CLI, and the MCP server all run on your machine, and your mems are markdown files in a git repository you control. The network is only needed to publish to — or install from — the registry.
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.
How big can a mem get?
A mem is a whole typed model of one subject — designed for 1,000–5,000 entities. Published .mem archives are capped at 2 MB, which is ample: mems are structure, not media.
Can I self-host the registry?
The engine, the .mem format, the publish protocol, and the CLI are open. The registry server itself is not open source — the npm model: open client and format, hosted service. A private or enterprise registry is a later option, and the CLI already targets any registry URL via --registry.
Who owns my data?
You do — mechanically, not contractually. Mems are plain markdown in your own git repo: no database, no export step, no lock-in. Leaving Memstead is git clone; your files stay readable without us.
Is this an Obsidian replacement?
No. Obsidian is a notes app for humans; Memstead is typed, schema-enforced knowledge for AI agents. Keep your Obsidian vault — a mem is a different artifact: a validated graph your agent queries through MCP, where every link is a checked foreign key.
Where's the semantic search?
There isn't one — by design. The store is the exact layer: typed entities, checked links, structural and full-text search. The LLM reading it is the semantic layer, and it interprets better than an embedding index. No vector DB means nothing to re-embed, drift, or silently decay — agents navigate relationships, not similarity scores.
How do I get my existing notes in?
Deliberately — never silently. memstead quickstart starts a fresh graph and refuses to swallow a folder of notes wholesale; you (or your agent) bring knowledge in through validated writes, so nothing enters without passing the schema. An import that pretends notes are already a model would break the one guarantee that makes the graph trustworthy.