openlore

Your coding agent forgets your codebase between tasks. OpenLore remembers it for them. Local, deterministic facts about your code, delivered to the agent at the moment it can use them. No API key. No LLM in the loop. Your code never leaves your machine.

=22.22">

Install · What the agent gets · Benchmarks · Comparison · Docs

---

The problem

Every time you start a task, your agent rediscovers your codebase. It greps, opens a dozen files, and builds a picture of how things fit together. Then the session ends and the picture is gone.

The rediscovery costs time and tokens, but that is not the expensive part. The expensive part is what happens when the agent is confident and wrong. It believes a function has no other callers. It renames an export that three services import. It weakens a test to get it green. It calls a helper that does not exist. You find out at review time, or later.

What OpenLore does

OpenLore builds a map of your repository once: every function, who calls it, which tests reach it, which specs and decisions govern it, and which infrastructure deploys it. It keeps that map current as you edit.

Then it stays out of the way. It does not ask you to learn new commands. It hands your agent short, specific facts at four points in a session:

When	What the agent sees
A session starts	A short primer on the repository. After a context compaction, a handoff of what the session already did.
You submit a prompt	The functions, callers, specs, and insertion points that matter for that prompt.
The agent edits a file or runs a command	Anything new and real: a call to a symbol that does not exist, a test that just got weaker, an edit to a generated file.
The agent is about to stop	One receipt: what changed, which tests reach it, and which specs drifted.

Every finding comes with proof: a file, a line, a call edge. If there is nothing new to say, OpenLore says nothing.

The agent can also ask questions directly, over MCP. "Who calls this?" "What breaks if I change this?" "Is this function really dead?" Each answer is computed from the map, not guessed by a model, so the same question gets the same answer every time.

Install

Claude Code (recommended). One plugin, no config:

claude plugin marketplace add clay-good/OpenLore
claude plugin install openlore@openlore

The plugin brings the hooks and the MCP server. On first use it installs its runtime in the background, and the first prompt in each repository starts the index build. The plugin README lists exactly what it runs, writes, and fetches.

Any other agent (Cursor, Cline, Continue, Codex, Pi, or anything that reads AGENTS.md):

npm install -g openlore && openlore install

openlore install detects the agents on your machine, wires each one, and builds the index. It also wires your user account, so each new repository you open indexes itself the first time you use it there.

Any MCP client. OpenLore is a standard stdio MCP server:

{
  "mcpServers": {
    "openlore": { "command": "npx", "args": ["-y", "openlore", "mcp"] }
  }
}

Pi. Pi loads extensions rather than MCP servers. Use pi install npm:openlore, or openlore install --agent pi. See the Pi guide.

Requires Node.js 22.22 or later. Run openlore doctor to check the wiring and openlore features to see what is on and how to turn on the rest.

What the agent gets

It starts every task oriented

orient(task) returns the code a task touches in one call, about 430 microseconds at the median on a 15k-node graph. The agent gets the relevant functions, their callers and callees, the tests that reach them, and the best places to add new code. It skips the exploratory file reads.

It knows when a fact has gone stale

Long sessions drift. A fact that was true an hour ago may not be true now. Each response carries a short, factual freshness note (the Epistemic Lease) once the agent's cached picture has aged or the repository has moved. The agent re-checks instead of building on a stale belief.

Its notes survive refactors

Decisions and notes are anchored to code. When a function is renamed or moved, the note follows it. When the code it describes changes, the note is marked stale instead of quietly misleading the next session.

It checks a change before claiming it is done

• blast_radius lists the callers, tests, and specs a diff affects.
• verify_claim returns confirmed, refuted, or unverifiable for a statement like "this function is unused," with the evidence.
• certify_public_surface classifies each changed export as breaking or not and names the consumers it breaks.
• change_impact_certificate flags a diff that opens a new path into a boundary you marked as sensitive.
• openlore review posts the same checks on a pull request, with no API key.

All of this is advisory by default. If you want a hard gate, mark the findings you care about as blocking and run openlore enforce before commit.

Application code, infrastructure, and contracts in one graph

Terraform resources, Kubernetes manifests, CI jobs, and Dockerfiles sit in the same graph as your functions. So do the operations declared in OpenAPI, protobuf, and GraphQL files, linked to the handlers that serve them and the code that calls them. One question, such as "what is affected if I change this IAM role?", reaches across all of it.

Value Scorecard

OpenLore is only worth it if an agent with it reaches a correct answer for less than the same agent without it. We measured that and we publish the losses next to the wins. Numbers are from the Spec 14 benchmark (claude -p, sonnet, N=4 medians, pinned SHAs), measured 2026-06-01.

Scenario	Cost change	Round-trips change	Verdict
Large or unfamiliar repo, deep "how does X flow through Y"	-7% to -21%	-26%	Helps, and the win grows with repo size
Small or familiar repo, shallow "who calls X"	Task-dependent (Round 1: +43%)	+38%	Often adds overhead. Measure first.

Round-trips per task, without OpenLore and then with it:

Repo (size)	Cost change	Round-trips
excalidraw (~640 files)	-21%	25 → 16
tokio (~790 files)	-21%	17 → 13
okhttp	-13%	13 → 11
django (~3k files)	-7%	21 → 15
gin (110 files, the smallest)	+4% (about even)	10 → 9

We re-ran it live on 2026-06-03. The deep-task win held (okhttp -13%). On small repos the result depends on the task: chalk came out 32% cheaper and express 59% more expensive.

Your repo is not ours. Run openlore prove --estimate to get an estimate for your own code in a few seconds, with no API key. The method is in docs/AGENT-BENCHMARKS.md. Every number here traces to a command you can run.

Is it for you?

A strong fit if your codebase is too big to hold in your head, if it is private or niche code a model never saw in training, if your sessions run long, or if your repo mixes languages or ships its own infrastructure.

Try it and measure on mid-size repos and mixed work.

Probably not for a small repo the model already knows well, with mostly shallow questions. Your agent's built-in search is cheaper there, and the scorecard above says so.

OpenLore reads and reports. It never edits your code.

How it compares

Most tools in this space solve the first half: give the agent a way to see the codebase without reading every file. OpenLore does that too. It also covers the second half, which few tools touch: checking what the agent changes against the same map.

	Agent built-ins	LSP toolkits	Graph MCP servers	Hosted search	OpenLore
Structure instead of file reads	grep	symbols	graph	index	call graph, infrastructure, and decisions in one graph
Local, no API key, deterministic	partly	yes	yes	no	yes
Memory that survives renames	no	partly	notes	no	yes
Says when a cached fact is stale	no	no	no	no	yes
Breaking-change verdict on a diff	no	no	partly	no	yes, with consumers named
Flags a new path into a sensitive area	no	no	no	no	yes
Publishes its losses	no	no	no	no	yes

Use the other tool when it fits better. An LSP toolkit is the right choice for edits like a cross-file rename, and it works well next to OpenLore. Hosted search wins for searching hundreds of repositories at once. OpenLore also exports SCIP, so it fits next to the tools you already use.

Comparisons reflect each project's public documentation as of July 2026. Corrections are welcome.

What it costs

Measured on a fresh clone of ripgrep (232 files):

First index build	13.6 seconds, all local
Disk	27 MB in .openlore/, which you can delete and rebuild
Query time	about 430 microseconds at the median
Network	none. No account, no telemetry.
Lock-in	none. Delete .openlore/ and your repo is as it was.

Large monorepos take minutes for the first build, not seconds.

Nothing is sent anywhere. There are two diagnostics, both off by default and both stored only on your machine. OPENLORE_TELEMETRY=1 records tool calls, agent identity, latency, error messages, decision titles, and lease events to .openlore/telemetry/. OPENLORE_LLM_LOGS=1 stores the prompts and responses of the optional spec-generation commands, after secret redaction, in .openlore/logs/. Both folders are gitignored. See docs/configuration.md.

The tools

Your agent calls these on its own. You rarely type them. The default set is the substrate preset, 15 tools: the navigation core, the spec preparation tools, and three governance reads (recall, verify_claim, blast_radius). A leaner navigation preset has 10 tools, and --preset full exposes all 84 tools.

When the agent needs to	Tool
Start a task	orient
Find the code that handles something	search_code
See what a change to a function affects	analyze_impact
Trace how a request reaches a function	trace_execution_path
Check a whole diff before commit	blast_radius
Confirm a fact before stating it	verify_claim
Recall what earlier sessions learned	recall
Pick the tests a change needs (full preset)	select_tests