RTK (Rust Token Killer): A CLI Proxy That Cuts AI Coding Assistant Token Usage by ~80%

Forum topic · 小凯 · 2026-05-13

Summary

RTK is an open-source, Rust-based CLI proxy that intercepts shell commands issued by AI coding assistants and rewrites their output to slash token consumption. According to its documentation, a 30-minute Claude Code session generating ~118,000 tokens of raw command output drops to ~23,900 tokens after RTK filtering—an ~80% saving. RTK works via a hook mechanism: AI tools like Claude Code, Cursor, Copilot, and Gemini CLI have their commands transparently rewritten (e.g., git status becomes rtk git status). Its architecture features four filter modes (Streaming, Buffered, CaptureOnly, Passthrough), a block-based filtering engine with per-ecosystem handlers for 12+ languages (Rust, Python, JS/TS, Go, etc.), and support for 100+ commands. It includes safety-first design (unknown commands pass through unmodified; Deny > Ask > Allow permission verdicts), a 10 MiB output cap, RAII child-process management, SQLite-based token savings tracking with project-level queries, and opt-in anonymous telemetry. Limitations include no coverage of built-in tools like Read/Grep, potential context loss from aggressive filtering (mitigated by tee-ing raw output on failure), and variable installation complexity across 13 supported AI tools. Repo: https://github.com/rtk-ai/rtk

RTK (Rust Token Killer) Deep Dive: How a CLI Proxy Saves AI Coding Assistants ~80% of Tokens

A structured English summary of a Chinese forum post analyzing RTK's architecture and design.

The Problem: Command Output Is a Token Black Hole

AI coding assistants (Claude Code, Cursor, etc.) frequently invoke shell tools—git status, cargo test, ls -la, docker ps—whose raw output is full of noise (permissions, timestamps, progress bars, repeated logs). Per RTK's README: a 30-minute Claude Code session consumes ~118,000 tokens of command output unfiltered, dropping to ~23,900 with RTK—roughly 80% savings, or $1–2 per session at Claude 3.5 Sonnet pricing.

Core Architecture: Four Filter Modes + Block-Level Streaming Engine

RTK is a single-binary Rust CLI implementing a command output rewriting system: identify the command, rewrite the invocation, filter output in real time.

Four FilterModes (from `src/core/stream.rs`)

| Mode | Behavior | Use case | |------|----------|----------| | Streaming | Line-by-line real-time filtering | Most commands (git status, test output) | | Buffered | Process full output after completion | Filters needing global context (dedup) | | CaptureOnly | Capture without filtering | Telemetry / token baselines | | Passthrough | Full pass-through | Safe fallback for unknown commands |

BlockStreamFilter engine

Works like a lexer, via a BlockHandler trait (should_skip, is_block_start, is_block_continuation, format_summary). For cargo test, it skips Compiling/Downloading noise, detects test result lines, collects failure stack traces, and emits a summary like FAILED: 2/15 tests.

Key implementation details:

10 MiB hard cap (RAW_CAP = 10_485_760) to prevent memory blowups
ChildGuard RAII: wait() on Drop to prevent zombie processes
Two reader threads + mpsc channel merging stdout/stderr

Per-language handlers

A Language enum covers 12 ecosystems (Rust, Python, JavaScript, TypeScript, Go, C, C++, Java, Ruby, Shell, Data, Unknown), with dozens of command modules (git, go, js, python, ruby, dotnet, cloud, jvm...). RTK handles 100+ commands by structurally understanding each tool's output format, not regex hard-matching.

Hook Mechanism: Transparent Interception

The AI tool itself rewrites commands before execution (e.g., git status → rtk git status), via rtk hook rewrite. Exit codes:

| Exit | Verdict | Behavior | |------|---------|----------| | 0 | Allow | Rewrite and allow | | 1 | Default | No RTK equivalent; pass through original | | 2 | Deny | Block execution | | 3 | Ask | Rewrite but require user confirmation |

A compile-time RULES registry with RegexSet classifies 100+ commands (Classification::Supported with estimated savings %, Unsupported, or Ignored).

Token Tracking: SQLite + Project-Level Stats

SQLite DB at ~/.local/share/rtk/tracking.db (WAL mode, 90-day retention)
Records raw/filtered token estimates, savings %, execution time, project path
rtk gain reports totals, Top-10 commands, time series, per-project filtering (uses SQL GLOB instead of LIKE to avoid _ wildcard issues)
Telemetry is opt-in, anonymous, aggregated (category distributions, savings totals); never collects source code, paths, args, or secrets; rtk telemetry forget requests server-side deletion

Multi-Tool Ecosystem: 13 AI Coding Tools

Supported integrations include Claude Code (PreToolUse hook in settings.json), GitHub Copilot, Cursor, Gemini CLI, Codex (AGENTS.md injection), Windsurf, Cline/Roo Code, OpenCode, OpenClaw, Hermes, Kilo Code, and Google Antigravity—each adapted to its extension mechanism (hooks, rules files, or plugin APIs).

Engineering practices in init.rs: atomic writes via NamedTempFile + persist(), automatic .json.bak backups, migration from legacy shell-script hooks, and idempotent installs.

Key Design Trade-offs

1. Safety model: Deny > Ask > Allow > Default—RTK never rewrites commands it doesn't understand. 2. Streaming vs. buffered: default streaming for low latency; per-command modules choose buffered where global optimization (dedup) matters. 3. Approximate token estimation: character-based estimates, sufficient for savings percentages but not billing-grade precision.

Limitations and Risks

Not a universal compressor: built-in tools like Read/Grep/Glob bypass the Bash hook entirely.
Context loss: aggressive filtering may drop useful debugging context; mitigated by a tee mechanism saving full raw output on failure (~~/.local/share/rtk/tee/) and --verbose flags.
Installation complexity: varies per tool; Windows lacks native hook support (WSL only).
Ecosystem lock-in: deep workflow integration creates dependency, though MIT licensing and simple hook mechanics keep risk manageable.

Conclusion

RTK's value is not magic compression but an engineered command-output rewriting system: structured per-ecosystem understanding, <10 ms streaming filtering, transparent hook interception, safe pass-through fallbacks, observable savings via SQLite, and cross-tool infrastructure. For heavy AI-assisted developers, ROI is clear: install once, save 60–80% of tokens per session—potentially tens to hundreds of dollars monthly. It's an auxiliary tool, not a silver bullet: uncovered commands, built-in tool calls, and full-context debugging remain out of scope.

Source repo: https://github.com/rtk-ai/rtk Project homepage: https://www.rtk-ai.app Install: brew install rtk or curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh