TOKEN INTELLIGENCE

Index your codebase once. Every agent session benefits.

When five agents read the same files independently, you pay five times. Token Intelligence builds a local semantic graph of your codebase and shares it across every parallel session — so the work happens once.

64%

reduction in context token consumption across parallel sessions

58%

fewer tool calls per agent session on indexed codebases

The redundancy problem

Every AI coding agent reads files to understand the codebase it's working in. It reads the files directly relevant to its task, plus the supporting context — imports, type definitions, shared utilities, configuration. Each read costs tokens.

In five parallel sessions working on the same repository, this happens five times in parallel. Three agents all need to understand the same core module? That module gets sent to three separate model contexts, billed three times. The redundancy compounds as you add more sessions.

How Token Intelligence works

Token Intelligence is powered by Atlas — a local, offline semantic index of your project. Atlas builds a graph of every symbol in your codebase: functions, types, classes, and the relationships between them — who calls what, what imports what, what depends on what.

When Token Intelligence is enabled, Tempest injects an Atlas MCP server into every agent session. Agents query the graph directly for symbol definitions, call chains, and cross-file relationships. A query that would otherwise require reading an entire file returns in milliseconds, using a fraction of the tokens.

The index is built once and kept current by a file watcher. When a file changes, only that file is re-indexed — the rest of the graph is untouched. The entire process runs locally on your machine. Your code never leaves.

Setup: one toggle, no configuration

Enable Token Intelligence in Settings → Token Intelligence. On first open of a project, Tempest asks whether to index it. Indexing runs in the background; a progress toast in the corner tracks it.

Once indexed, every agent session in that project gets the Atlas MCP server injected automatically. Tempest writes the MCP configuration file for each tool it supports:

Claude Code (.mcp.json)
Cline (.mcp.json)
Cursor (.cursor/mcp.json)
Gemini CLI (.gemini/settings.json)
Kiro / AWS Q (.kiro/settings/mcp.json)
opencode (opencode.jsonc)
Roo / Zed / Windsurf (.mcp.json)

All generated config files are gitignored automatically. The index lives at <project>/.tempest/atlas/.

Why local-only matters

The knowledge graph is built from your files, stored on your machine, and never transmitted to any server. This is not only a privacy guarantee — it means the index is always current. There is no propagation delay, no cache invalidation lag from a remote service, no stale data. The graph reflects your codebase as it is right now.

The economics of parallel agents with Token Intelligence

Without Token Intelligence, running five agents costs roughly five times what running one agent costs in tokens — because each agent does the same foundational reading independently. With Token Intelligence, that foundational reading happens once and the cost is shared. The more sessions you run, and the more they work in the same codebase, the larger the savings.

This makes parallel agents economically viable for a much wider range of work. When the token cost ceiling is high, you ration parallelism. When the ceiling is lower, you use it freely. Token Intelligence moves the ceiling.