OpenLore

AI coding agents are powerful but 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. It runs a one-time static analysis of your repo and keeps a live knowledge graph — call structure, types, tests, decisions, IaC, spec drift. Your agent queries it to start every task already oriented and to certify a change before it lands. It's deterministic and local-first — no LLM in the hot path — so the same question always returns the same grounded answer, and the agent is told when a fact goes stale instead of served a confident guess.

Install in one command

npm install -g openlore && openlore install

That one command auto-detects your agent (Claude Code, Cursor, Cline, Continue, AGENTS.md), wires it to call orient() automatically, registers the MCP server, and builds the index — no API key, no config, no questions. Then ask your agent:

orient("add a payment method")

…and it begins already knowing the relevant functions, their callers, matching specs, tests, and the risk of changing each — in a single call.

Zero config, everything discoverable. Core value needs no keys. Run openlore features to see every opt-in capability (embeddings, the commit gate, the spec store…), whether it's active, and the one command to turn it on.

What you get

Two things, both deterministic and local — OpenLore remembers your architecture so every task starts oriented, and governs what the agent changes before it lands.

🧠 Memory — start every task already oriented

• Orient in one call — orient(task) returns the relevant functions, their callers, matching specs, tests, and insertion points in a single call (~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 live on the same graph, so one query spans all three.
• Told when a fact is stale — the agent is warned when a cached fact has aged or the repo moved, instead of building on a confident guess.

🛡️ Governance — guardrails on what the agent changes

• Breaking-change verdict — certify_public_surface classifies every changed export breaking / non-breaking / potentially-breaking and names the consumers each break hits. Conservative — never silently "safe."
• Sensitive-boundary check — change_impact_certificate flags when a diff opens a new path into a boundary you declared (reachable after the change, not before).
• Grounded claims — verify_claim returns confirmed / refuted / unverifiable with a citation, before an agent asserts "X is dead" or "Y is safe to change."
• One commit gate — openlore enforce blocks only on findings you mark blocking. Advisory by default, no API key.

Full guardrail table with commands: Governance.

📊 Honest by construction — −26% agent round-trips on deep traces in large repos, with the losses published next to the wins. Every public claim traces to a command you can run.

See it in action

The same task, twice. Ask an agent to add a flag to a command it has never seen:

The measured effect on deep, multi-hop tasks: 25 → 16 round-trips on excalidraw, −26% aggregate. Not magic — the difference between rediscovering structure per task and querying it. Full numbers, including where it doesn't pay off: Does it pay for itself?

Real output — openlore orient --json "add a --since flag to the blast-radius command", run on this repo (abridged):

{
  "relevantFiles": ["src/cli/commands/blast-radius.ts", "src/core/services/mcp-handlers/blast-radius.ts"],
  "relevantFunctions": [
    { "name": "computeBlastRadius", "filePath": "src/core/services/mcp-handlers/blast-radius.ts",
      "signature": "async function computeBlastRadius(input: BlastRadiusInput): Promise<BlastRadiusBriefing>",
      "fanIn": 5, "isHub": true, "language": "TypeScript" }
  ],
  "callPaths": [
    { "function": "computeBlastRadius",
      "callers": ["handleBlastRadius", "computeImpactCertificate", "runBlastRadiusCli",
                  "composeReview", "collectGovernanceFindings"] }
  ],
  "insertionPoints": [
    { "rank": 2, "name": "computeBlastRadius", "role": "hub", "strategy": "cross_cutting_hook",
      "reason": "computeBlastRadius is called by 5 functions -- adding logic here affects the entire callsite surface." }
  ],
  "suggestedTools": ["record_decision", "analyze_impact", "get_subgraph", "check_spec_drift"]
}

The agent knows exactly where to look, what it touches, and what's risky to touch — before reading a single file. Every field is computed from the graph; nothing is inferred by a model.

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 agent benchmark (claude -p, sonnet, N=4 medians, pinned SHAs), measured 2026-06-01.

Re-confirmed live 2026-06-03 (N=2): the deep-task win reproduces (okhttp −13%). The small/familiar case is task-dependent, not a flat loss — same repo class, opposite outcomes (chalk −32% win vs. express +59% loss). Don't guess from our repos — run openlore prove on yours.

The win scales with cod