A widely shared claim that RTK (Rust Token Killer) can cut AI coding token costs by up to 60% — reaching 313,000 views on X — does not hold up under systematic benchmarking. Quesma tested RTK 0.45.0 on Terminal-Bench 2.1, a benchmark heavy on terminal interaction, running 1,740 attempts across Claude Code with Anthropic's Fable 5.0 and OpenCode with DeepSeek V4 Pro 0813 via OpenRouter. The results, published September 11, 2026, show that compressing terminal output rarely reduces the final bill and can increase it.
This screenshot captures one of the viral sources behind the 313,000-view claim that RTK dramatically reduces AI coding costs, which Quesma's systematic benchmark on Terminal-Bench 2.1 was designed to test against real billing data.
### How RTK works and what it actually touches
RTK intercepts shell commands (Bash in Claude Code, bash in OpenCode) and returns terser output. For example, `ls -la` normally shows owner, date, and permissions; RTK keeps only permissions, file names, and sizes. However, RTK only rewrites shell commands. Both platforms expose file reading and searching as separate Read, Grep, and Glob tools that bypass RTK entirely. About half of Claude Code's Bash calls already limit their own output with `head`, `tail`, or `wc`.
The benchmark chart visualizes how RTK's reported 89% token reduction translates to negligible or negative cost savings across 1,740 attempts with Fable 5.0 and DeepSeek V4 Pro, with Fable showing only 5% total cost reduction and DeepSeek showing 5% cost increase.
### The headline numbers
Across 85 Fable tasks and 89 DeepSeek tasks (five runs each, with and without RTK):
- **Fable 5.0**: Total cost fell 5% with RTK ($596 → $546), pass rate dropped 1% (84% → 83%). - **DeepSeek V4 Pro**: Total cost rose 5% ($26 → $31), pass rate dropped 2% (71% → 69%).
When cost is divided by successful passes (accounting for failures), Fable was 3% cheaper with RTK; DeepSeek was 7% more expensive. But a task-level measure — averaging each task's cost change rather than pooling all attempts — tells a different story: Fable was 1% more expensive (no clear difference from zero), while DeepSeek's task cost rose **17% on average**. Even across the 36 DeepSeek tasks where all ten attempts passed, the increase persisted at 18%.
### One task drove all of Fable's savings
Nearly all of Fable's apparent savings came from a single task, `winning-avg-corewars`. Both configurations passed every attempt, but RTK finished in about half the turns. Across the remaining 84 tasks, savings were under 1%. DeepSeek showed the reverse on that same task: RTK took more turns and cost more. Removing that task left DeepSeek's costs higher with RTK.
### The `rtk gain` metric is not a cost metric
RTK documents `rtk gain` as "raw minus filtered command output in bytes, divided by 4" — not a count of billed tokens. Across 445 DeepSeek RTK attempts, RTK reported 349.2 million tokens "saved" (an 89% reduction). Yet tasks became more expensive.
The metric can credit savings for output the agent never would have seen. In the `train-fasttext` task, the model ran `head -1 train.txt` twice. RTK credited 120.5 million tokens saved each time by comparing those limited reads against the whole file — 69% of the run's reported savings — even though the commands would never have returned the full file. `rtk gain` also ignores the cost of extra turns that compression may induce.
### Bugs can multiply costs
One DeepSeek `git-multibranch` attempt entered a loop: the agent ran a `find` command with a flag unsupported by `rtk find` 0.45.0. The plugin rewrote it to `rtk find`, which failed with "Use find directly." Every retry was rewritten again, producing 339 consecutive errors over ~12 minutes. The attempt still passed but cost **about 9×** the matching baseline. RTK fixed this in 0.46.0, after Quesma's runs.
### Terminal output is a small share of the bill
Without RTK, tool output constituted ~11% of Fable's input tokens and ~40% of DeepSeek's. In RTK runs, only 31% of Claude Code's terminal calls and 51% of OpenCode's used RTK. The rest bypassed it via dedicated tools or self-limiting flags.
Moreover, agentic coding caches context after each turn. Later reads of terminal output mostly appear as cache reads — costing 1/10 of regular input tokens for Fable, 1/30 for DeepSeek. Cache reads made up 94–98% of input tokens and 26–30% of the total bill in RTK runs.
For DeepSeek, RTK reduced terminal-output characters by 9%, yet prompt tokens **rose 9%**. Uncached input fell 1% while cached input rose 9%. Model output (including reasoning) accounted for 56–57% of cost regardless of RTK.
### Extra turns erase compression savings
When RTK caused the agent to take more turns, task cost usually rose with them. DeepSeek's RTK attempts took more turns on 58 tasks; 44 of those cost more. They took fewer turns on 28 tasks; 23 cost less. The average DeepSeek turn had 7% less input with RTK, but there were 18% more turns overall. Smaller turns did not add up to less total input. One extra agent turn can cost more than the compression saved — the same "tokenflation" problem in another form. JetBrains observed the same pattern on SkillsBench: RTK added turns at low effort and did not lower cost at high effort.
### Why the mismatch between reported savings and actual cost
Frontier models already use the terminal efficiently. Only ~7% of Fable's context was terminal output without RTK. Models employ techniques like `head -n` and `tail -n` themselves. RTK likely helped more with older models; today it is a niche optimization, not a general source of savings. Quesma does not recommend RTK as a generic cost-saving tool.
Trajectories are available on request for follow-up research. Quesma plans a future benchmark of Headroom, another terminal-output filter.