Local-first semantic code search for coding agents

Ask your codebase. Follow the evidence

Your AI coding agent must find the right code before it can change it. Satori finds it: ask in plain English, and the agent gets the function that owns the behavior, who calls it, and what to read next. Free, open source, and it runs on your machine.

Try it on a repo
npx -y @satori-code/cli@latest install
Watch it find the right code in Ollama (34 s)
Ask

Where is auth refresh handled, what owns it, and what should I read first?

  1. Search
  2. Owner
  3. Trace
  4. Source
  • src/auth/refresh.tssemantic + lexical
  • src/session/store.tssemantic
  • src/http/middleware.tslexical
  • config/security.tsconfig key
Owner, rank 1
AuthRefreshCoordinator.refresh src/auth/refresh.ts:84-146
outlinecallersexact source
Freshness: current One coherent Publication
Works with
  • Codex
  • Claude Code
  • OpenCode
  • Antigravity
  • Any MCP client
Free and open source. No account. Beta: Linux x64 and WSL2 only for now.

What Satori does, in plain words.

AI coding agents write code fast. Their weak step is finding where to make the change. In a large project they search for a word, open whole files, and often stop reading before they reach the part that matters. Satori is the search and map service that the agent calls before it edits.

Without Satori

  • The agent searches for a keyword and gets dozens of matches.
  • It opens whole files, and they fill its working memory.
  • It reads the top of a function and edits before it sees the rest.
  • It misses the other code that depends on the old behavior.

With Satori

  • The agent asks one question in plain English.
  • It gets the function that owns the behavior, ranked near the top.
  • It reads that function from start to end, with an outline of its file.
  • It sees who calls the function before it changes it.

Think of a smart new colleague on day one who does not yet know where anything is. Satori is the colleague who has read the whole project and says: “That lives here. These places use it. Read this first.”

Natural-language questions, grounded in one repository state.

Satori is not just semantic search. One Publication binds retrieval, ownership, structure, relationships, freshness, and exact source to the same repository generation, so an agent can move from a vague question to verifiable code without rebuilding context from scratch.

Search

Semantic + lexical retrieval

Behavior by meaning, BM25, exact paths, identifiers, configuration keys, and literal evidence.

find intent without losing literals
Owners

Symbols + structural spans

Parser-derived functions, methods, classes, file outlines, and bounded source ownership.

rank evidence around real owners
Trace

Supported relationships

Qualified callers, callees, imports, and exports when the language backend can prove them.

advisory, conservative, fail-closed
Truth

Freshness + Publication authority

Source checkpoints, runtime compatibility, policy, navigation readiness, and atomic replacement generations.

know which repo state answered

From a human question to source evidence.

The agent does not need a perfect identifier up front. Satori narrows the search in stages and keeps each stage tied to repository evidence.

Real run on ollama/ollama: indexed 1,138 files in 30 seconds offline. Asked in plain English where the 5-minute keep-alive default is set, Satori found envconfig.KeepAlive(), its caller, and the exact source, while a grep-driven edit landed in the wrong place. Indexing is shown sped up.
See semantic code search in an agent

Useful evidence, not more noise.

The public surface stays small. Behind it, Satori gives a generic MCP harness the code-intelligence stack it would otherwise have to rebuild.

Fast exact lookups

14-65ms p50

Exact symbol lookup measured across five pinned repositories on the offline Potion + LanceDB + LateOn runtime.

Offline after install

Potion embeddings, BM25 search, LanceDB storage, and managed local retrieval need no model API key and make no Satori runtime network requests after installation.

Reranking that finds owners

LateOn reranks a bounded candidate set locally to put the owning code first. In our 36-task test it doubled first-hit accuracy, from 0.19 to 0.39. On 46 plain-English questions, the agent’s own alt_terms lifted owners in the top 10 from 16 to 34. Switch to Voyage with one command when you want the strongest ranking. See how ranking works.

Parser-derived repository structure

Parser-backed symbols, structural evidence, exact spans, and qualified CALLS v0 navigation ship across nine production languages, plus Kotlin and PHP.

Token-efficient by design

Exact symbols and bounded reads keep broad file dumps out of the prompt, so repository discovery spends context on the code that matters.

One coherent Publication

Search, symbols, structural evidence, and qualified calls activate together. Unsupported or ambiguous relationships fail closed.

  1. search
  2. symbols
  3. structure
  4. calls

Built to put the owning code first.

When the right file comes back at rank seven, your agent reads six wrong files first. Satori ranks for the code that owns the behavior, then hands the agent the exact span to read.

  1. Retrieve three ways Potion embeddings, BM25, and exact symbol matches run together, so a paraphrase and an exact identifier both reach the candidates.
  2. Search the agent’s guesses The agent sends up to four likely identifiers as alt_terms. Satori searches each one as a separate pass, including a definition lookup, and fuses the results with the original question.
  3. Vote for definitions Definition fusion lifts the code that defines a named symbol above code that only mentions it.
  4. Rerank with context Up to 64 candidates go to the reranker with their role, callers, callees, and tests. LateOn runs on your CPU in parallel sessions sized to the machine. Voyage runs in the cloud.
  5. Return exact evidence The agent gets the owning span, a file outline, and qualified call paths to follow next, instead of whole files.

0.19 to 0.39

Owner found first, with LateOn reranking. 36 tasks on 6 repositories.

16 to 34

Owners in the top 10 when the agent adds its own alt_terms. 46 plain-English questions. Median request 2.7 s to 2.9 s.

4 to 13

Named-symbol questions answered at rank 1 with definition fusion and LateOn, against no reranker. 19 questions on 4 repositories.

1.86 s to 1.22 s

LateOn rerank of 64 candidates with the adaptive session pool on an 8-core Ryzen 7 3800X. Scores are bit-identical.

Choose a reranker

LateOn default, offline

Runs on your CPU. Code stays on the machine and needs no API key. 13 of 28 owners first, median search 2.40 s. Linux x64 and WSL2.

satori reranker use lateon

None fastest

Retrieval order only. About 200 ms per search on React, with 36,233 chunks.

satori reranker use none

Measured on 28 plain-English questions over React, Polars, and FlatBuffers with the same index for every reranker. Restart your agent after a switch. If Voyage fails during a search, Satori returns retrieval order and reports RERANKER_FAILED. Use npx -y @satori-code/cli@latest in place of satori if the CLI is not installed globally.

Use Satori when the repository is larger than the prompt.

Walk into an unfamiliar codebase with a map.

Ask where a behavior lives, identify the owning symbol, inspect the file structure, then read the implementation instead of browsing the tree at random.

“What owns billing retries?”

Turn a symptom into source.

Start from an error or behavior, then follow owner and relationship evidence toward the exact code.

Plan before the first edit.

Find the owner, nearby structure, bounded source, and supported call paths before changing a subsystem.

Give a fast model the context it would skip.

Flash and local models are cheap and quick, but they read less. A small model may edit a function after it reads only the first part, and it cannot afford to read the repository to find the right one. Satori does the discovery work: hybrid search, the model’s own alt_terms, and owner-aware reranking put the owner near the top, then the model reads one exact span and follows qualified call paths. With LateOn, the whole stack runs offline, so a fully local setup stays local.

“Where is the cleanup of useEffect?” → commitHookEffectListUnmount

Share repository intelligence, not the prompt.

Compatible local sessions attach to one managed runtime and current repository intelligence while keeping independent MCP sessions.

Free, local, read-only. No catch.

The questions worth asking before you install anything that reads your code.

Is it really free?
Yes. Satori is open source under AGPL-3.0 and costs nothing. There is no account, no sign-up, and no paid tier. The default offline runtime needs no model API key, so there is no usage bill either.
Does my code leave my machine?
Not on the default offline runtime. Embedding, storage, search, and telemetry make no network requests after installation. Optional Voyage reranking, Voyage embeddings, and Milvus/Zilliz are opt-in. Voyage AI, by MongoDB, gives each account 200 million free tokens per model.
Will it change my repository?
No. Source access is read-only. Install adds nothing to AGENTS.md or hook files and never overwrites files it did not write.
What does install download?
The runtime and about 100 MB of local models, once, into ~/.satori/. Your agent does not download anything again on startup.
Which languages?
Symbol navigation for TypeScript, JavaScript, Python, Go, Java, C#, C++, Rust, and Scala, plus Kotlin and PHP. Around 140 languages are searchable.
How do I remove it?
satori uninstall removes client config and the shared skill. Add --purge to also delete the runtime, models, and indexes.

Try it on one repo.

Two commands to install, one sentence to your agent. It is in beta and runs on Linux only for now (x64 and WSL2), fully offline after installation, with no account and no API key.

Install supported clients
npx -y @satori-code/cli@latest install
npx -y @satori-code/cli@latest doctor
Then restart your agent and tell it
Index /absolute/path/to/repo with Satori, then find where auth refresh is handled.
Optional: stronger ranking with a free Voyage API key
npx -y @satori-code/cli@latest reranker use voyage
  1. Index

    Create the repository Publication and wait until status is ready.

  2. Ask

    Ask for the behavior, owner, or source area the agent needs to understand.

  3. Follow evidence

    Open the exact symbol, bounded source, outline, or qualified call path returned by Satori.

The index is not a static cache you have to babysit.

Default offline stack

  • Potionlocal semantic embeddings
  • BM25lexical + exact evidence
  • LateOnlocal query-time reranking
  • LanceDBlocal Publication storage

No model API key is required for the qualified managed offline path after installation. Connected Voyage and Milvus/Zilliz remain optional advanced runtimes.

Freshness and repair

  1. Source changedIncremental sync prepares a replacement Publication.
  2. Sync runningA compatible proven Publication can remain readable with freshness metadata.
  3. Rebuild required, managed offlineSatori starts or joins one background reindex automatically.
  4. Remote, failed, or unsafeExplicit reindex remains the operator recovery override.
  5. ClearAlways explicit. Never automatic maintenance.
  • Read-only source. Satori does not modify repository files.
  • Conservative graph. Absent edges are not proof of no caller.
  • Open source. AGPL-3.0-only.

Build with it. Break it. Tell me.

If Satori helps, fails, or feels confusing in a real repository, I want the case. Send the language, repo size, MCP client, and what you were trying to understand.

ahmed@hamza.my.id
Repo
language and approximate size
Client
Codex, Claude, OpenCode, or another MCP host
Task
bug hunt, refactor, onboarding, or evaluation

Tried it? Tell me what happened.

Release notes, every two weeks.

What shipped, what broke, and what real users found. No spam; unsubscribe in one click.