Tachyon Intent

Your agent is only
as good as its context.

Tachyon plugs into your coding agent. It searches your whole codebase in milliseconds. Every change your agent makes arrives with a Why? card that says what changed, why, and whether the code still matches. No models. No cloud. No guessing.

Get started See the benchmarks

Install tachyon

curl -fsSL https://www.tachyon.run/install.sh | bash

AGENT → TACHYON

find_files(“SetCanvasState”)→ 2 hits · 5.5 ms

grep(“SetCanvasState”, glob *.d.ts)→ scoped refs · 2 ms

outline(“canvas.ts”)→ symbols · 6.7 ms

tachyon_intent(“session.ts”, why, decision…)→ Why? card · ✓ verified

context_pack→ 1 roundtrip · 2.7s · evidence: symbolsResolved · usageCoverage · testProximity

01 / The problem

Your agent is fast. Understanding it isn't.

27 s

Searches that go nowhere

Your agent spends 27 seconds hunting through a big repo and comes back empty-handed. You wait; it learns nothing.

15×

Whole files pasted as context

Looking things up is slow, so agents paste entire files into the conversation instead. Your token bill explodes.

0 proof

“Trust me” reviews

Ask what changed and why, and you get the agent's best guess. Nothing ties its words to the actual code.

02 / How it works

Connect once. Get answers with proof.

Three steps between you and a review you can trust.

Connect once.

Point tachyon at your repo. It reads everything in about a second and keeps that picture warm for the whole session.

$ tachyon mcp ~/src/your-repo

Your agent asks better questions.

Instead of slow shell commands, it asks the index directly: find this file, show every use of that symbol, outline this file, explain this change.

$ find_files · grep · outline · definition · tachyon_intent

You get proof, not paste.

Answers come back short and sourced: snippets, not file dumps. And every edited file carries a Why? card stamped ✓ verified, or marked stale the moment the code moves.

$ ✓ verified · or · ○ stale

03 / Tools

Everything your agent can ask.

One warm index behind every question. Typical speeds below. Whole-tree numbers from a 72 GB workspace.

Ask for	What comes back	How fast
`find_files`	Find any file by name, even fuzzy	~3 ms
`grep`	Search all code for a word or pattern: answers come back as short snippets	milliseconds scoped · ~2 s whole tree
`outline`	List what's inside one file: functions, classes, the lot	<1 to 7 ms
`definition`	Jump to where a symbol is actually defined	~2 to 4 s whole tree
`context_pack`	Everything about one change in a single call: files, symbols, references, tests, evidence	~1 s usual · 2.7 s on 72 GB
`tachyon_intent`	Leave a Why? card on each file it edits, checked against the code	instant

Whole-tree speeds measured on a 72 GB workspace (115,724 files). Narrow a search and it answers in milliseconds. See benchmarks

04 / Setup

Connected in about 2 minutes.

First, check tachyon is installed: run tachyon --version. The command is always tachyon mcp <repo-root>. Use . if your tool opens one repo at a time, a full path if it uses one global config.

.mcp.json in repo root

{
  "mcpServers": {
    "tachyon": { "command": "tachyon", "args": ["mcp", "."] }
  }
}

That one registration gives your agent five tools: find, grep, outline, definition, and intent. Everything runs on your machine: no network, no changes to your repo, no waiting on language servers.

The one instruction that makes cards appear

Add this to AGENTS.md (or wherever your agent reads instructions):

After every file edit, call tachyon_intent once per changed file with the file path, why the change was needed, the key decision taken (with alternatives rejected), what changed, risks for the reviewer, and a merge-readiness score 0 to 100 when sure. Omit score when unsure.

Done. From here it's automatic: your agent leaves a note with every edit, tachyon files it against the exact code, and the Why? card shows up in your review. Nobody has to remember anything.

No MCP on your agent? Two other ways:

Option 2 · opencode plugin

mkdir -p ~/.config/opencode/plugins
cp .opencode/plugins/tachyon-intent.mjs ~/.config/opencode/plugins/
cd ~/.config/opencode && bun add @opencode-ai/plugin

Same instruction as above. Notes stay in app storage. Never in your repo.

Option 3 · Shell hook for anything else

scripts/tachyon-intent.sh --path <file> --why "..." \
  --decision "..." --what "..." --risks "..." --score 80 \
  --agent my-agent --kind unstaged

Needs --path plus at least one of --why / --decision / --problem / --what / --risks. Score is optional (0 = none yet). Run it from an after-edit hook.

05 / Why? cards

Your agent explains itself. Tachyon proves it.

No AI runs at review time. As your agent edits, it leaves a short note per file: why, the decision, what changed, the risks. Tachyon locks each note to the exact code and shows a ✓ verified card on the diff. If the code moves, the card says so.

Verify (30 sec)

Edit one file with the agent.
Open tachyon Review. The file shows a ◔ badge.
Open the diff: Why? card with What / Why / Decision / Problem / Risks, score bar, and ✓ verified · g-N · abc123→def456.
Edit again: card flips to ○ stale, changed since. That's correct: records bind to bytes, not paths.

A Why? card above a diff in tachyon Review, showing what changed, why this changed, the decision, problem context, risks, and a verified provenance line — A real Why? card on a real diff: What, Why, Decision, Problem, Risks, and the `✓ verified` line. Select the image to view full size.

What's in the card

What: what changed in this file
Why: why the change was needed
Decision: the key decision taken, with alternatives rejected
Problem: the problem being solved
Risks: risks for the reviewer

Plus a score bar (the agent's 0 to 100 merge-readiness, omitted when unsure) and a ✓ verified · g-N · abc123→def456 line.

On what basis it shows that

✓ verified: the file is byte-for-byte what the agent described. You can trust this card.
○ stale, changed since: something moved after the note was written. The card says so instead of pretending.
score: the agent's own 0 to 100 guess at readiness. Treat it as an opinion, not a measurement.

Notes cap at 2KB each. New notes default to the unstaged view.

What tachyon keeps (and how)

Each note is locked to the exact code it describes: the file, the kind of change, and a fingerprint (SHA-256) of both sides. unstaged means working file vs index, staged means index vs HEAD, branch means your branch vs where it forked.

Your agent never touches fingerprints. It just drops a note, and tachyon matches it against the current code when you open the diff. Only matches are shown; anything else shows as stale. Notes live in one small file outside your repo (capped at 512 notes, 2KB each). A score of 0 means “not scored yet”. And notes the agent didn't write are labeled generated-from-diff. Never passed off as its words.

Something missing? Notes wait in $TACHYON_REVIEW_STATE/intent/incoming, otherwise ~/.local/state/tachyon/intent/incoming.

Notes can mention ticket numbers and private reasoning. They stay on your machine, outside the repo. Never uploaded, never committed.

06 / Updating

Updates take ten seconds.

Re-run the installer any time. It picks the fastest binary for your machine.

Update to the latest release

curl -fsSL https://www.tachyon.run/install.sh | bash

Or, if tachyon is already installed: tachyon --update.

Tachyon also checks for new releases once a day and tells you when there's something to install (run 'tachyon --update' to upgrade). Turn it off where it doesn't belong (distro packages, air-gapped machines) with TACHYON_NO_UPDATE=1.

07 / Offline packs

No server? Take a pack.

One file with everything about a change: files, symbols, references, tests, evidence score. Ready to hand to any agent.

Review pack as JSON

# Changed files + symbols + refs + tests + evidence score, as JSON
tachyon context --max-files=10 ~/src/your-repo > pack.json

# Pipe straight into your agent CLI
tachyon context --max-files=5 . | claude -p "review this change"

Flags: --max-files=N (default 10, max 30), --max-refs=N (default 10, max 30), --no-refs, --no-tests, --blame.

Evidence, not vibes

symbolsResolved: every changed symbol traced to a declaration
usageCoverage: callers and references included, not assumed
testProximity: related tests surfaced alongside the diff

Treat these as opinions to argue with. Never as grades.

08 / Benchmarks

10× faster than the slow way: 27.8s → 2.7s.

Same job three ways: track down a symbol, find every use, find its tests.

Table 1: The same job, three ways (72 GB workspace)

Way of working	Time	Tokens*	Round trips
The slow way (find + git grep + reading files)	27.8s	~2,628	3
Tachyon over MCP (6 questions, 1 setup)	6.3s	~1,969	6
Tachyon context pack (everything in 1 call)	2.7s	~5,277	1

Inside the winning pack: 20 symbols / 20 reference groups / 0 tests, evidence {symbolsResolved: 0.75, usageCoverage: 0.75, testProximity: 0, churnRisk: 0.8}, truncated: true (capped at 10 files, so larger changes need more context).

Table 2: What a pack costs vs pasting the files

Situation	Pack	Pasting the files	Saved
Mid-size repo, 10 files	16 KB ≈ 4.1k tokens	780 KB ≈ 195k tokens	48.8× smaller
72 GB workspace, 10 files	21 KB ≈ 5.3k tokens	55 KB ≈ 13.8k tokens	2.6× smaller
Per-file review, 5 files	6.7 KB ≈ 1.7k tokens	92 KB ≈ 23k tokens	13.7× smaller

*Tokens are rough estimates (bytes ÷ 4), not counts from a tokenizer, so real model usage will vary. Test ground: 72 GB workspace, 115,724 files, one symbol (SetCanvasState), 10 files max. “Warm” means the server was already up and ready before timing. Rust numbers are the default download; the Go fallback gives the same answers in ~6.3s.

09 / FAQ

A few straight answers.

Do I need API keys?

No. Tachyon contains no AI model and calls nothing in the cloud. Your own agent subscriptions do the thinking; tachyon just hands them better context.

Which is faster, Go or Rust?

Rust is the default. The installer picks it automatically. Go is the fallback for machines without a Rust build. Same features, same results either way.

What about a huge monorepo?

Don't index the whole thing at once. Run one tachyon per project, or keep the server warm and pull a context pack in a single call (~1 s on typical repos).

Does this replace my agent's search?

No. It becomes your agent's search. Keep git grep for quick tracked-file lookups. Use tachyon when you want ranked results, snippets, symbols, and evidence.

10 / Start now

Stop paying 27 seconds
for zero hits.

One command serves your repo. Your agent does the rest and shows its work.

Read the changelog

Serve your repo over MCP

tachyon mcp .

Then connect Claude Code, Cursor, Codex, or opencode. See setup above.

Back to setup

Your agent is onlyas good as its context.