by clay-good
Deterministic, local-first code and contract intelligence for AI coding agents, with no LLM in the hot path.
From $49 · 30 days · terms & refunds
⚠️ Third-Party Software Notice
This skill is third-party open-source software developed and hosted independently on GitHub. SkillsLLM lists this project for discovery and does not control or maintain the underlying repository.
Any security checks, ratings, or warnings displayed by SkillsLLM are automated and limited in scope. They do not constitute a security certification or guarantee that the software is safe, error-free, or free from malicious code, vulnerabilities, compromised dependencies, or prompt-injection risks.
Review the source code, permissions, dependencies, and configuration before installing or running any third-party skill. Use is at your own risk. To the maximum extent permitted by applicable law, SkillsLLM is not liable for losses arising from third-party software.
Automated security scan — not a certification.
# Add to your Claude Code skills
git clone https://github.com/clay-good/OpenLoreGuides for using ai agents skills like OpenLore.
Last scanned: 5/30/2026
{
"issues": [],
"status": "PASSED",
"scannedAt": "2026-05-30T16:14:40.388Z",
"npmAuditRan": true,
"pipAuditRan": true
}See how OpenLore compares with popular alternatives.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 reposi
OpenLore is an open-source ai agents skill for AI coding assistants such as Claude Code, Codex CLI, and ChatGPT, built by clay-good. Deterministic, local-first code and contract intelligence for AI coding agents, with no LLM in the hot path. It has 367 GitHub stars.
Yes. OpenLore passed SkillsLLM's automated security scan — a dependency vulnerability audit plus prompt-injection heuristics — with no high-severity issues. You can read the full report in the Security Report section on this page.
Clone the repository with "git clone https://github.com/clay-good/OpenLore" and add it to your Claude Code skills directory (see the Installation section above).
OpenLore is primarily written in TypeScript. It is open-source under clay-good on GitHub, so you can review or fork the full source.
Yes. SkillsLLM lists many other AI Agents skills you can browse and compare side by side. Open the AI Agents category from the badge at the top of this page, or use the Related Skills and comparison links further down to weigh OpenLore against similar tools.
No comments yet. Be the first to share your thoughts!