SatoriIt burns tokens on broad dumps
Agents pull large files into context to “be safe,” then still lack a precise owner symbol or the right span for the edit.
Satori
Give coding agents the route from intent to evidence.
Most AI coding agents can search files. That is not enough.
Real codebases are not flat text dumps. They have symbols, ownership boundaries, wrappers, callers, callees, stale files, and logic spread across folders.
Satori is an open-source, read-only codebase map for MCP-compatible agents: less grep chaining, less context waste, fewer blind edits, and more visible evidence before the first diff.
Install supported clients
npx -y @zokizuan/satori-cli@latest install --client all
npx -y @zokizuan/satori-cli@latest doctor
AGPL-3.0-only open source
Six MCP tools
Installer-owned startup
Does not edit source code
Freshness warnings
Agents Still Build Context the Hard Way
The problem is not access to search. Without structured repo context, agents assemble evidence the expensive way — and you still cannot see a clean path from intent to the code that actually owns the behavior.
That burns budget on frontier models. It is even harder for smaller, local, or non-frontier models, where every token matters more.
It still lacks the full picture
More context is not structured context. Fragments from grep chains do not explain ownership, wrappers, or how logic is spread across folders.
It guesses who owns the behavior
Nearby text is not always the implementation. The obvious match can be a wrapper, test helper, generated clue, or stale path.
It misses callers and wrappers
A small change can touch callers, callees, and adapters. Without an investigation path, agents edit one file and leave related paths unexamined.
It trusts stale repo state
Real repos move while agents work. Without freshness signals, agents can plan against an outdated map and ship a confident wrong diff.
It gets worse on smaller models
Token-heavy exploration hurts frontier runs — and hurts even more when the model is smaller, local, or cost-constrained. Efficiency is part of quality.
One Flow: From Intent to Evidence
Satori turns codebase investigation into a fixed path MCP agents can follow before they touch code:
Less grep chaining
Less context waste
Fewer blind edits
More visible evidence
01
Search by intent
Ask what behavior or ownership area matters. Satori retrieves relevant implementation areas from plain English, not just filenames.
02
Land on owner symbols
Grouped search is symbol-owned: chunks are supporting evidence, not the final unit of navigation.
03
Outline, then exact reads
Open the function, class, or line range that matters instead of flooding the agent with broad file dumps.
04
Check related context
Inspect advisory callers and callees when supported, with recovery paths when graph confidence is low — not guessed blast radius.
Freshness-aware recovery sits under the whole path: if the index is stale, partial, or not ready, Satori returns clear next steps instead of silent confidence. Satori does not edit your source code — edits stay in your editor or agent host.
Core Capabilities
Satori is not another semantic search box. It gives coding agents structured repo context they can act on: intent retrieval, owner symbols, exact reads, advisory related paths, freshness state, and recovery steps — so investigation costs less and leaves evidence you can inspect.
Plain-English retrieval
Find behavior from intent, not only filenames or exact tokens.
Symbol-aware navigation
Open symbols and outlines for TypeScript, JavaScript, Python, C++, C#, Go, Java, Rust, and Scala from compatible navigation sidecars.
Exact reads
Open exact symbols or line ranges instead of feeding the agent a noisy file dump.
Related code paths
Check advisory callers and callees when graph support is available — useful navigation context, not sole blast-radius authority.
Freshness warnings
Detect stale context before an agent relies on old repo state.
Recovery guidance
Return clear next steps when an index is stale, partial, or not ready.
Built for Real Agent Work
Satori is for the moment when search-and-hope is not enough: real repos, real changes, and agents that need efficient context before the first diff — whether you run frontier models or tighter local budgets.
Developers using coding agents
Developers using Codex, Claude, OpenCode, or other MCP-compatible clients.
Large or unfamiliar repos
Codebases where the right file is rarely the first match and nearby text is not enough.
Bug and refactor work
Workflows where the owner, neighboring paths, and blast radius matter before edits start.
Teams that need evidence
Teams that want the agent to show its evidence, not just hand over a diff.
Try It on One Repo
Install the MCP server, check provider and vector-store setup, then give your agent context before the first edit.
Install supported clients
Provider and client-specific setup lives in the Docs.
npx -y @zokizuan/satori-cli@latest install --client all
npx -y @zokizuan/satori-cli@latest doctor
1. Build the map
Start a create or reindex operation, then poll index status until the operation is completed and the repo is searchable.
2. Ask by intent
Ask for the behavior or ownership area the agent needs to understand.
3. Open evidence
Read the returned symbol, line range, or file outline.
4. Check related paths
Follow caller/callee context when supported before proposing changes.
Open Source and Available Today
Satori is usable today: public source, published packages, supported client setup, and a small MCP surface agents can actually follow.
AGPL-3.0-only open source
Source is public and inspectable for developers evaluating the tool.
Published packages
The project ships as @zokizuan/satori-core,
@zokizuan/satori-mcp, and
@zokizuan/satori-cli.
Supported clients
The CLI installer supports Codex, Claude, and OpenCode workflows.
Vector storage
Supports Milvus-compatible vector storage today; embedded local vector storage is planned.
Embedding providers
Supports OpenAI, VoyageAI, Gemini, and Ollama embeddings through runtime configuration.
Six MCP tools
Small by design: index status, search, outlines, reads, graph context, and index management.
Toward Easier Local and Team Workflows
Satori is self-hosted today, with Ollama available for local embeddings and Milvus-compatible vector storage required for indexing. Next work focuses on making setup lighter: embedded vector storage such as Zvec, stronger retrieval quality, broader relationship-backed navigation, and shared repo context for teams.
Go Deeper
The overview stays short. The deeper pages carry setup, internals, source code, issues, and roadmap details.
Docs
Install, setup, tool reference, recovery paths, and agent workflows.
Architecture
Indexing, retrieval, freshness, sidecars, ranking, and lifecycle states.
GitHub
Source code, issues, roadmap, and package structure.
Product Hunt
Follow the launch, leave feedback, and share Satori with other agent builders.
Satori
Semantic and Symbol-aware repo context for AI coding agent
Contact
Building with coding agents, evaluating Satori, or exploring an integration? Send the repo context, goal, and setup. I'll respond with the most useful next step.