v2.0.0 — plan before edit, verify after edit

Plan before edit.
Verify after edit.

Open Kioku is the local evidence layer for Claude, Cursor, Codex, and other MCP coding agents. It indexes your repo once, builds evidence-backed plans before edits begin, then verifies bounded changes stayed inside the plan. No cloud. No source upload. Read-only by default.

1 index
local SQLite and Tantivy facts for the repo
0 cloud
no embeddings API or hosted code index required
read-only
write tools stay gated unless explicitly enabled
Verified at Scale

Tested on a local Elasticsearch checkout.

Not a marketing benchmark. A real run with real numbers, real gaps documented. Read the full proof →

36,640
files indexed
495,919
symbols extracted
509,665
chunks stored
159,483
tests indexed
1,015,502
graph edges
97/100
avg usefulness score across 20 tasks
Agent Proof

Replace blind file crawling with indexed evidence.

Open Kioku gives agents a reliable pre-edit routine: search the repo, resolve the symbol, trace references, produce an evidence-backed plan, pick validation targets, and generate a shareable proof report before touching code.

Typical agent loop

  • !Repeated grep, glob, and read calls burn context before the agent understands the repo.
  • !References are inferred from text matches instead of symbols, imports, and persisted graph edges.
  • !Test selection often happens after the edit, when the agent has already guessed wrong.

Open Kioku loop

  • OKOne indexed search returns ranked evidence and exact file ranges.
  • OKSymbol, reference, impact, and architecture tools share the same local index.
  • OKPlans include affected files, edit boundaries, validation candidates, and agent tool calls before edits start.
Live Workflow

The pre-edit routine agents should run every time.

This is the workflow to show in Cursor, Claude, and short launch videos: install, index a real repo, verify the index, connect MCP, then ask the agent to plan from indexed evidence before editing.

ok setup --agent
Workflow

One indexed path from question to validation.

The strongest product story is not search alone. It is the complete loop a coding agent needs before making a change.

1

Find evidence

Search code and files with ranked snippets, line ranges, and confidence signals.

2

Resolve symbols

Jump to definitions and references without asking the model to infer ownership from text.

3

Trace impact

Use local graph facts to identify changed files, affected modules, and likely callers.

4

Validate edits

Build context packs and pre-edit plans that keep agents focused on the smallest useful surface.

Positioning

Search finds code. Planning knows what to do with it.

Most tools give agents files. Open Kioku gives them a plan: which files to touch, which symbols are affected, which tests to run, what the blast radius looks like, and whether the edit stayed inside the boundary.

🔍

Search tools

Find matching files and lines. The agent still decides what they mean and what to do next.

🗺️

Repo map tools

Show file trees and symbol summaries. Better orientation, but no impact analysis or validation targets.

Open Kioku

Indexed evidence → symbols → impact → tests → plan → verify. The full pre-edit routine, with bounded confidence and validation commands.

Real Repo Setup

Index first, then connect your LLM.

Use this path for an existing codebase. The MCP config points your agent at the same local index that the CLI verifies.

Build and verify the index
ok init /absolute/path/to/repo
ok index /absolute/path/to/repo
ok doctor /absolute/path/to/repo
ok --repo /absolute/path/to/repo search "feature or bug" --limit 5
Prompt the agent
Use Open Kioku before editing. Check repo_status, search_code, get_definition,
get_references, impact_analysis, and find_tests_for_change. Build a plan first,
then edit only after the indexed evidence is clear.
Shareable Proof

Show usefulness without posting source code.

Run `ok prove` on a demo repo or private codebase to produce a Markdown report with indexed counts, task scores, validation signals, and redacted path shapes. The report intentionally omits source snippets.

Demo proof
ok prove ./open-kioku-demo --task token
Private repo proof
ok prove /path/to/repo --task "auth flow" --task "release workflow"
Connect

Copy-paste setup for every major MCP client.

Open Kioku runs as a local MCP server over stdio. These commands print client-specific configuration; they do not edit your config files automatically.

Cursor
ok mcp install cursor --repo /absolute/path/to/repo
Claude Code
ok mcp install claude --repo /absolute/path/to/repo
Codex
ok mcp install codex --repo /absolute/path/to/repo
Gemini CLI
ok mcp install gemini --repo /absolute/path/to/repo
OpenCode
ok mcp install opencode --repo /absolute/path/to/repo
Zed
ok mcp install zed --repo /absolute/path/to/repo
Safety

Built for codebases people cannot upload.

The trust message matters as much as the speed message. Open Kioku is designed for local indexing, explicit write controls, and predictable MCP behavior.

No hosted index

Metadata stays under `.ok/` in your repo. There is no hosted search service to provision or trust.

No embeddings API required

BM25 search, symbols, and graph operations work locally without uploading code to a model provider.

Write tools gated

Patch and command paths are opt-in, policy-controlled, and separate from read-only context tools.

Quality

Every commit tested, audited, and benchmarked.

CI on Ubuntu + macOS
cargo audit + cargo deny
20/20 usefulness proof tasks
Cursor + Claude smoke tests
Criterion benchmark gates
Workflow-bench regression suite
Golden snapshot coverage
SHA-256 checksummed release binaries