Verifiable memory for AI agents.

RTFM returns facts with their sources — never prose it wrote itself. No model runs when you query it, so a query costs zero tokens and “I don’t know” is a property of the system rather than a decision it took.

Read the docs How it works

Runs on your own machine, over your own files. No account, nothing to sign up for.

What goes wrong without it

An agent is only as good as what it remembers, and today it remembers almost nothing it can prove.

It forgets between sessions

Context ends when the conversation does. The next session starts from nothing, so the same ground gets covered again and the same decisions get re-litigated.

It fills gaps with fluent invention

Asked something the material does not cover, a generator still produces a confident paragraph. The failure is silent: nothing marks the sentence that was made up.

It cannot show you where a claim came from

Without provenance every answer has to be checked by hand against the documents — which is the work the agent was supposed to save.

How it works

Three steps. A model is involved in exactly one of them.

Step 1

Load your documents

Point RTFM at files, pages or pasted text. An extraction model reads them once and proposes facts. This is the only place a model runs, and it runs offline, on ingest.

Step 2

RTFM stores facts, not chunks

Each fact keeps the document it came from, the revision of that document, what it applies to, and how sure the extractor was. What is missing is recorded too, as an explicit gap.

Step 3

Agents query it mechanically

A query is retrieval — stemming, a synonym dictionary, ranking. It returns a compact pack of facts with provenance. RTFM spends no tokens answering, because nothing on that path is a model.

What is different about it

Provenance down to the version

A fact names its document and that document’s revision. Edit the source and the old revision stays, so a citation made last month is still checkable against what the file said then.

“I don’t know” is mechanical

If nothing clears the relevance threshold the pack comes back empty and says so. That is not restraint on a model’s part — there is no generator on the query path to write anything else.

Version-aware applicability

“True for 1.5” and “true for 2.0” are two facts, not a contradiction. A fact carries what it applies to, so an agent can tell which one it is holding.

Conflicts are shown, not settled

When two sources disagree, both are kept and flagged. RTFM does not pick a winner quietly; it hands the disagreement to whoever can actually resolve it.

Private stays private

Access is filtered in SQL before retrieval and at every step of the graph walk. An anonymous caller cannot read private knowledge, and cannot learn that it exists.

The files are the truth

The canon is Markdown with YAML front matter, one file per entity, in your repository. The index is derived and disposable — delete it and rebuild.

Connect it in three lines

RTFM speaks the Model Context Protocol over stdio. Any MCP-capable client can read it; writing is a separate flag, off by default.

Claude Desktop · claude_desktop_config.json

{
  "mcpServers": {
    "rtfm": {
      "command": "rtfm",
      "args": ["mcp", "--as-owner"],
      "env": { "RTFM_ROOT": "/path/to/your/canon" }
    }
  }
}

--as-owner lets that client read your private knowledge as well as the public part; drop it for a client you would rather keep to public only. Writing is a separate flag either way.

Where the project is

A working prototype, developed in the open. The domain core, the file canon, the index, the ingest pipeline and the MCP server all run today; the benchmark is published with its method and its failures.

Developed in the open

The source, the ADRs that argue every decision, the task briefs and the reports are all in the repository. There is no hosted service and nothing phones home.

Method published with the numbers

The dataset, the scoring script and every run live in the repository, including the runs that came out badly.