YATS — Yet Another Token Saver — indexes your codebase into a knowledge graph. Your agent queries the graph instead of reading files one by one. Less tokens, better answers.
Every time your agent needs to understand your code, it does the same brute-force ritual: grep for keywords, read file after file, guess how things connect. That's not intelligence — that's a token bonfire. And you're paying for every spark.
We index your entire codebase into a knowledge graph: every function, class, interface, and relationship across TypeScript, C#, Python, PHP, and Go. When your agent needs answers, it queries the graph — not the raw files.
The best part: you don't index manually. When your agent connects to YATS and starts working in a directory, it checks if that project is indexed. If not, it indexes it automatically. No extra step. No remembering to run a command.
You can index manually via yats index ~/my-project if you want. But your agent handles it.
Not grep. Not regex. Actual parsers that understand your code like an IDE does.
Instead of reading 15 files, your agent calls:
| What the agent needs | Tool it calls |
|---|---|
| "How does auth work?" | search_code("authentication flow") |
| "Who calls this?" | find_callers("PaymentService.process") |
| "Show me the API" | find_routes |
| "Architecture overview?" | architecture_summary |
| "Where are the tests?" | find_tests("UserService") |
| "What's connected?" | expand_graph(symbolId) |
Every benchmark we publish comes with the full tooling to replicate it — same questions, same repos, same methodology. No cherry-picking. No black boxes.
And it works on your own code too. Unlike benchmarks that only test popular open-source repos (which LLMs might already know from training), YATS lets you measure savings on your private projects — the code your agent actually works with every day.
Same questions. Same repos. Fresh sessions. Every token counted.
| Agent | Repo indexed | Language | Without YATS | With YATS | You save |
|---|---|---|---|---|---|
| Codex | lab_hub (API backend) | Go | 100,000 tokens | 27,000 tokens | 73% |
| Copilot | lab_hub (API backend) | Go | 1.19 credits | 0.40 credits | 66% |
| Claude | lab_hub (API backend) | Go | 862k tokens · $0.21 | 541k tokens · $0.11 | 37% tokens · 49% cost |
| Gemini | Django (web framework) | Python | 115,122 tokens | 63,851 tokens | 45% |
Run yats benchmark and get your own row in this table.
More agents and repos being tested — yats benchmark supports all five agents today.
Short videos to get you from zero to saving tokens. Each one is ~3 minutes.
YATS will save you even more tokens when your agent is properly instructed to use the graph instead of reading files. That's why we include ready-to-use instruction files for every agent — they teach it to call search_code before grep, to expand the graph instead of guessing relationships, to trust the index.
| Your agent | Copy these | Into |
|---|---|---|
| Claude Code | SKILL.md + mcp.json | .claude/skills/yats/ + .mcp.json |
| Gemini CLI | GEMINI.md + mcp.json | repo root + .gemini/settings.json |
| Copilot CLI | instructions.md + mcp.json | .github/ + .copilot/ |
| Codex CLI | AGENTS.md + config.toml | repo root + .codex/ |
| Cursor | rules.mdc + mcp.json | .cursor/rules/ + .cursor/ |
YATS doesn't just index once and go stale. When you or your agent edits a file, the index updates in seconds — not minutes.
Every search tool checks if your repo has changed since the last index. If git shows new commits, YATS incrementally re-indexes only what changed — before answering.
Just edited one file? Call index_file and only that file gets re-analyzed, embedded, and stored. Under a second.
Deleted a file? Call remove_file and its symbols disappear from the graph instantly. No dead references.
Run yats watch ~/my-project and every file change triggers an automatic re-index. Your graph stays current without a single extra command.
Indexing generates embeddings — vector representations of your code. You choose who runs that computation, and what it costs.
Runs locally on your machine. No API keys, no network calls, no bills. The nomic-embed-text model is pulled automatically during setup. Indexing costs you nothing — ever.
Prefer a hosted model? Plug in your OpenAI, Mistral, or Voyage AI key. You pay your provider directly — YATS never sees your key and adds zero markup.
Switch anytime with EMBEDDING_PROVIDER. Ollama for free local dev. OpenAI for production throughput. No lock-in.
Not per seat. One flat annual fee for your entire organization. Same product, same features at every tier.
Annual subscription with auto-renewal. Cancel anytime. · Full license terms