RTK Rust Token Killer: What a Real Benchmark Found

Your AI coding bill is now a real budget line. Claude Code runs roughly $13 per developer per active day. Agentic sessions — where the agent reads files, runs tests, and self-corrects across dozens of turns — push that higher, sometimes past $500 a month per engineer. RTK (Rust Token Killer) launched in January 2026 with a compelling pitch: a single Rust binary that cuts token consumption by 60 to 90 percent, no workflow changes required. It now has 77,000 GitHub stars. Then JetBrains ran a controlled benchmark. The results are more nuanced than the headline numbers suggest — and understanding the nuance is worth your time before you add another tool to your stack.

What RTK Actually Does

RTK sits between your shell and your AI coding agent. When the agent runs a Bash command — git status, cargo test, npm install — RTK intercepts the output and compresses it before it enters the LLM context window. It applies four strategies: smart filtering (strips boilerplate and comments), grouping (aggregates similar lines by category), truncation (keeps errors and diffs, drops the rest), and deduplication (collapses repeated log entries into a count). Zero dependencies. Less than 10ms overhead per command.

Setup takes two commands:

brew install rtk
rtk init -g   # hooks into Claude Code automatically

For Cursor, add --agent cursor. For Cline, --agent cline. RTK supports 16 AI coding tools including Claude Code, Cursor, GitHub Copilot, Gemini CLI, Codex, and Windsurf. Run rtk gain after a session to see your token savings dashboard.

The Numbers RTK Reports

RTK’s own analytics, aggregated from opted-in users, show 89.2 percent compression across nearly 3,000 measured commands. The gains are real on specific commands:

• cargo test: 91.8 percent reduction — a 200-line failure log becomes 20 lines focused on the actual failure
• git status: 80.8 percent reduction
• find: 78.3 percent reduction
• grep: 49.5 percent reduction

In a typical 30-minute Claude Code session, RTK reportedly reduces command-generated tokens from around 118,000 to 23,900 — an 80 percent drop. One developer reported saving 138 million tokens over several weeks of heavy use across 15,720 commands.

These numbers are not fabricated. For Bash-heavy workflows, RTK does what it claims. The complication is that Bash output is not the whole story.

What the JetBrains Benchmark Found

In July 2026, JetBrains published a controlled benchmark worth reading carefully. They ran 86 tasks across 425 billed trials using Claude Code 2.1.201 with claude-sonnet-5 and RTK v0.43.0 — roughly $320 in compute. This is the most rigorous independent test of RTK published so far.

The headline finding: RTK only touched approximately 20 percent of tool-result characters in real sessions. The remaining 80 percent came from Claude Code’s built-in tools — Read, Grep, Glob — which use Claude’s native file-reading capabilities and bypass RTK’s hooks entirely. As a result, input token reduction was just 3.2 percent, statistically indistinguishable from noise.

At low reasoning effort, the RTK arm cost 7.6 percent more per task and required 13.8 percent more turns. At high reasoning effort, the penalty vanished: statistically identical performance. Task quality was the same across both arms.

RTK’s built-in analytics had reported 96.2 million tokens saved in the benchmark period — but actual billing increased. The explanation: RTK counted savings on file reads that never went through it, and ignored prompt caching that already makes repeated reads ten times cheaper.

When RTK Helps (and When It Does Not)

The JetBrains benchmark is not a reason to dismiss RTK. It is a reason to understand where it applies.

RTK helps most when your workflow is shell-heavy: test runners, CI scripts, Docker builds, npm installs, git operations called from the terminal. Rust projects with long cargo build and cargo test cycles benefit the most. If you are shelling out constantly through your AI agent, RTK’s compression on those outputs is real and meaningful.

RTK has limited impact when your agent reads files natively: If most of your Claude Code sessions involve the agent reading source files, grepping codebases, and navigating directories via built-in tools, RTK will not touch those tokens. Prompt caching does more work here — repeated file reads at one-tenth the price — and you likely already have it enabled.

What Actually Moves the Needle on AI Coding Costs

Given what we now know about where tokens actually go in agentic sessions, here is the honest cost reduction hierarchy:

1. Session discipline. By turn 30 to 50 in an agentic session, the context window carries 25,000 to 35,000 input tokens per API call. Starting fresh after completing a task costs far less than continuing in an accumulated context. This single change outweighs every other optimization.
2. Model routing. A 10x price difference exists between the cheapest and most expensive models. Route background tasks and repetitive operations to smaller models.
3. Prompt caching. Repeated file reads — which dominate many agentic sessions — cost one-tenth as much with caching enabled. This directly competes with RTK for the file-read use case.
4. RTK. Real, measurable impact for shell-heavy workflows. Worth installing if you spend hours daily running builds, tests, and git operations through AI agents.

Should You Install RTK?

Yes, if your AI coding workflow is shell-heavy. The install is two commands, the overhead is under 10ms, and the savings on build and test output are real. Run rtk gain after a week and look at your actual numbers — not RTK’s estimates.

Skip it — or at least do not expect much — if your Claude Code sessions are primarily reading and editing files through the agent’s native tools. In that case, prompt caching and session discipline do more, and you already have them.

RTK earned its 77,000 stars. Just know what you are buying: a deterministic output compressor for Bash-generated tokens, not a wholesale solution to AI coding costs. The JetBrains benchmark clarifies the scope. That is exactly the kind of independent analysis the AI tooling ecosystem needs more of.