AI coding agents are amnesiac and ungoverned. Every task restarts by re-reading the same files, long sessions drift onto stale assumptions, and nothing warns the agent when a change is about to break a contract or cross a boundary.
OpenLore fixes both halves, and then gets out of your way. A one-time static analysis builds a live knowledge graph of your repo — call structure, types, tests, decisions, IaC. From then on your agent is already oriented at the start of every task and its changes are certified before they land — automatically, deterministically, with no LLM in the hot path, so the same question returns the same grounded answer and the agent is told when a fact goes stale instead of served a confident guess.
Install once, then forget it
npm install -g openlore && openlore install
That is the only command most people ever run. It auto-detects your agent (Claude Code, Cursor, Cline, Continue, Pi, AGENTS.md), wires it, registers the MCP server, and builds the index — no API key, no config, no prompts. After that, it's on in the background and you don't think about it:
- 🔄 Every task starts oriented, automatically — a compact architecture digest is injected into your agent's context at the start of each session, and your agent calls
orient()and the other tools itself over MCP. You don't type anything. - 🌱 Every repo, not just this one —
installwires your user account too, so each new git repo you open indexes itself in the background on first touch. "Install once" is literal. - 🩹 Always fresh — a file watcher re-indexes as you edit and converges to a full analysis; anything it can't recompute in time is marked explicitly stale, never silently wrong.
- 🛡️ Changes get checked before they land — the governance tools (and
openlore reviewon a PR) run deterministically with no API key.
The CLI below exists for humans and CI — prove, review, doctor, features. The everyday path is: install, then let your agent use it.
Zero config. Run
openlore featuresto see every opt-in capability (embeddings, the commit gate, the spec store…), whether it's on, and the one command to enable it.openlore doctorverifies the wiring.
What you get
Two things, both deterministic and local:
🧠 Memory — your agent starts every task already oriented
- Orient in one call —
orient(task)returns the relevant functions, callers, specs, tests, and insertion points (~430µs p50 on a 15k-node graph) instead of a dozen exploratory file reads. - Survives refactors — anchored notes and decisions carry forward when a symbol is renamed or moved, instead of orphaning.
- One graph for everything — application code, Infrastructure-as-Code, and architectural decisions share one graph, so a single query spans all three.
- Told when a fact is stale — every response carries a brief, factual freshness note (the Epistemic Lease) once a cached fact has aged or the repo moved, so a long session can't drift onto a confident guess.
🛡️ Governance — guardrails on what the agent changes
- Breaking-change verdict —
certify_public_surfaceclassifies every changed exportbreaking / non-breaking / potentially-breakingand names the consumers each break hits. Never silently "safe." - Sensitive-boundary check —
change_impact_certificateflags when a diff opens a new path into a boundary you declared (reachable after the change, not before). - Grounded claims —
verify_claimreturnsconfirmed / refuted / unverifiablewith a citation, before an agent asserts "X is dead" or "Y is safe to change." - One commit gate —
openlore enforceblocks on findings you markblocking. Advisory by default, no API key.
The one line to remember: an agent's expensive failure mode isn't ignorance — it's confidence. A model that doesn't know a function exists will go look. A model that "knows" a stale fact builds on it, and you pay at review time. OpenLore is built so the agent can be told "that fact is stale" and "this change opens a path you said was sensitive" — deterministically, with no second model guessing about the first.
Value Scorecard — does it pay for itself?
OpenLore only earns its place if an agent with it reaches a correct answer for less total cost than the same agent without it. We measure that and publish it — wins and losses. Numbers from the Spec 14 benchmark (claude -p, sonnet, N=4 medians, pinned SHAs), measured 2026-06-01.
The win scales with codebase size (round-trips without → with):
Re-confirmed live 2026-06-03: the deep-task win reproduces (okhttp −13%); the small/familiar case is task-dependent, not a flat loss (chalk −32% win vs. express +59% loss). Don't guess from our repos — run
openlore prove --estimateon yours (seconds, no API key).
Honesty contract. We never publish a savings number the benchmark didn't produce, we always show the losses next to the wins, and every claim traces to a command you can run. Methodology: docs/AGENT-BENCHMARKS.md.
Is OpenLore for you?
What your agent reaches for (you rarely type these)
Once wired, your agent calls these over MCP on its own. The default surface is the substrate preset — 15 tools: the navigation core, the highest-value governance reads (recall, verify_claim, blast_radius), and the spec composites. The lean navigation preset (10 tools) and the full 80 tools (--preset full) are one flag away.
Full reference — all 80 tools: docs/mcp-tools.md. Ships as a Claude Code Skill at skills/openlore-orient/.
OpenLore vs. alternatives
Everyone in this category answers the same first question: how does the agent see the codebase without reading it file by file? LSP toolkits answer with symbols, graph MCP servers with a parsed graph, search platforms with an index. OpenLore answers it too — then keeps going into the second question almost nobody answers: what happens when the agent starts writing? A retrieval layer makes an agent informed; it doesn't make it safe. That second half — governance on the same graph, no LLM in the loop — is what OpenLore is for.
Use the other tool when it's the right one: symbol-level edits (rename across files) are an LSP toolkit's home turf — OpenLore is deliberately read-only, and the two compose. Org-wide search across hundreds of repos is a search platform. Just-fast-graph-retrieval is a smaller graph MCP server. And a small, familiar repo with shallow questions is cheaper with your agent's built-in search. OpenLore also exports SCIP, so it sits alongside these tools, not against them.
Comparisons reflect each project's publicly documented capabilities as of July 2026; a correction PR is always welcome.
What it costs
Measured on a fresh clone of ripgrep with published [email protected]:
Large monorepos take minutes rather than seconds, stated plainly in Known limitations. Platform: Linux and Windows are exercised in CI; macOS is supported.
Fully local — nothing phones home. No account, no network call; your source, the index, and every query stay on your machine. The only diagnostics that exist are opt-in and local-only, off by default and never transmitted:
OPENLORE_TELEMETRY=1records tool calls, agent identity, latency, error messages, decision titles, and lease events to the gitignored.openlore/telemetry/directory, andOPENLORE_LLM_LOGS=1stores prompts and responses (after secret redaction) in the gitignored.openlore/logs/directory. → docs/configuration.md
Languages & Infrastructure-as-Code
Languages: TypeScript · JavaScript · Python · Go · Rust · Ruby · Java · C++ · Swift · C# · Kotlin · PHP · C · Scala · Dart · Lua · Elixir · Bash — call graphs ride the same primitives for every language. → docs/language-support.md
Infrastructure-as-Code: Terraform/HCL · Kubernetes · Helm · CloudFormation · Ansible · Pulumi · AWS CDK · CDKTF · Dockerfile · Docker Compose · GitHub Actions · Azure Bicep — IaC resources project onto the same graph as application code, so orient, search_code, and analyze_impact answer "what's the blast radius of changing this security group / IAM role / base image / CI job?" with zero new tooling. → docs/iac.md
Known limitations
We'd rather you know these up front.
- Static analysis only. Polymorphic dispatch, event channels, and route→handler bindings are recovered (provenance-labeled
synthesized). What isn't: reflective invocation with a non-literal target (getattr(o, name)()),eval, and DI/plugin registries with no visible binding — silently absent from the graph. - LLM spec quality varies. Generated spec prose reflects the model's understanding — review complex business logic. Structure, format, coverage, and drift are checked deterministically.
- Keyword (BM25) search is the default; semantic is an opt-in upgrade.
orient/search_codework immediately with no key. Add hybrid dense+BM25 withopenlore embed --local(bundled, CPU-only, ~23 MB). - Large monorepos analyze one package at a time after the first full build (
openlore analyze --shard <name>); the initial index is still a full analysis. - Incremental updates converge or flag, never silently diverge. When a change exceeds the per-save budget, the rest is marked explicitly stale and self-heals on later edits or a background re-analyze.
Documentation
Start here: the documentation index maps every task to the one canonical page that answers it. The essentials:
Development
npm install
npm run build
npm run test:run # 5500+ unit tests, one-shot (npm test is watch mode)
npm run typecheck
New contributor? See CONTRIBUTING.md for setup, MCP wiring, and the commit gate. Please also read our Code of Conduct; to report a vulnerability, see SECURITY.md.
Community
If OpenLore saves your agents from re-reading the same files — or catches one risky change before it lands — star the repo. It's the signal that tells us to keep building, and it helps other engineers find it.
- ⭐ Star to follow along: github.com/clay-good/OpenLore
- 🐛 Bug or idea? Open an issue.
- 🤝 Contribute? Start with CONTRIBUTING.md.