Noureddine RAMDI / rtk: A Rust CLI proxy that cuts LLM token usage by up to 90% with transparent command rewriting

Created Wed, 06 May 2026 18:58:37 +0000 Modified Sat, 23 May 2026 20:41:27 +0000
996 Words
github-stars rust cli llm proxy token-optimization bash

rtk-ai/rtk

Working with AI coding assistants often means hitting frustrating token limits when these tools ingest the full output of shell commands like git status or test runs. rtk tackles this pain point with a clever approach: it acts as a transparent CLI proxy implemented in Rust that sits between your AI assistant and your shell commands, applying aggressive filtering and deduplication to shrink the output the AI actually receives. The trick lies in a Bash hook that rewrites commands silently so the AI thinks it’s just running the original command, while rtk intercepts and compresses the output by 60-90%.

What rtk does and how it works

rtk is a high-performance command line proxy written in Rust designed specifically for optimizing token consumption in AI coding assistance workflows. It supports over 100 common developer commands spanning git, test runners, linters, package managers, and cloud tools like AWS, Docker, and Kubernetes.

The core architectural idea is that rtk installs a transparent Bash hook which intercepts shell commands before they execute. When you run a command like git status through your AI assistant, rtk actually runs it but captures and filters the output before passing it back to the language model. This filtering includes grouping related lines, truncating output intelligently, removing duplicates, and applying heuristics to reduce verbosity without losing essential information.

From the AI’s perspective, it sees the result of git status as usual, but the actual output is dramatically smaller — often reduced by 60-90% in token count. This helps maintain rich context windows for AI models, allowing them to reason better without bloating token budgets.

Under the hood, rtk is shipped as a single Rust binary with zero dependencies, which makes it lightweight and easy to deploy. Its codebase focuses on performance and minimal runtime overhead, which is critical for shell workflows where latency matters.

Technical strengths and tradeoffs

What sets rtk apart is its seamless integration via the Bash hook. Unlike wrappers that require explicit command changes, rtk’s hook makes the proxy invisible to both the user and the AI. This means no change in developer habits or AI prompts — the proxy works transparently.

The filtering logic is sophisticated, supporting a wide range of commands and tailoring output compression strategies per command type. This command-specific optimization is key because the token reduction depends heavily on the command’s verbosity and output format.

The project’s Rust implementation is a strong choice for CLI tools where speed, safety, and binary size are priorities. The single binary approach avoids external dependencies, enhancing portability across environments.

On the flip side, this design also means that integrating with shells other than Bash or handling less common commands might be limited or require additional work. The filtering heuristics, while effective, might occasionally remove output details that some users find important, so there’s a tradeoff between token savings and completeness.

Another subtle challenge is maintaining the hook and proxy in sync with evolving command-line tools and AI client expectations. As tools and AI assistants update, rtk needs ongoing maintenance to ensure compatibility and correctness.

Lastly, the analytics feature with ASCII graphs and JSON export is a nice touch, providing visibility into token savings and helping users understand the proxy’s impact.

Quick start

Installation is straightforward with multiple options:

brew install rtk

Quick install (Linux/macOS)

curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh

If installed via script, add rtk to your PATH:

echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc  # or ~/.zshrc

Cargo

cargo install --git https://github.com/rtk-ai/rtk

Pre-built binaries

You can download platform-specific binaries from the official releases for macOS, Linux, and Windows. Windows users are advised to run rtk under WSL for full hook support.

After installation, verify with:

rtk --version   # Should show "rtk 0.28.2"
rtk gain        # Should show token savings stats

Initialization of rtk for your shell is done by:

rtk init -g

This sets up the Bash hook globally.

verdict

rtk is a practical tool for developers using AI coding assistants who want to maximize the usefulness of their token budgets without changing workflows. Its transparent Bash hook and command-specific output filtering deliver substantial token savings, which is valuable in real-world development contexts where commands like git, test runners, and linters generate verbose output.

The Rust implementation and single binary distribution simplify deployment and reduce runtime overhead. However, the solution leans heavily on Bash shell integration, which might limit adoption in environments using other shells or Windows native terminals without WSL.

The filtering tradeoff means some output details could be lost, so users needing full command output might need to disable or bypass rtk for certain tasks. Maintenance to keep up with CLI tool updates and AI client changes is another consideration.

Overall, rtk is worth exploring if token efficiency in AI coding workflows is a bottleneck for you. It’s especially relevant for teams using Claude Code, GitHub Copilot, or other AI assistants that run shell commands as part of their process and want to cut down on wasted tokens with minimal friction.

→ GitHub Repo: rtk-ai/rtk ⭐ 42,886 · Rust