← Back to Blog

Slash LLM Token Costs by 80% with RTK — The Rust CLI Proxy Every AI Developer Needs

2026-05-05

Slash LLM Token Costs by 80% with RTK — The Rust CLI Proxy Every AI Developer Needs

If you use AI coding tools like Claude Code, Cursor, or Codex daily, you've probably noticed something: a huge chunk of your tokens go to noise. Directory listings, git status output, test runner logs, build error walls — your LLM reads every single line, and you pay for every token.

RTK (Rust Token Killer) is a lightweight CLI proxy that sits between your AI agent and the shell. It transparently rewrites commands, filters output, and compresses results — delivering 60-90% token savings with no changes to your workflow.

In this tutorial, you'll learn what RTK is, how it works, and how to set it up in under 5 minutes.

What Is RTK?

RTK is a single Rust binary (no dependencies, <10ms overhead) that acts as a transparent proxy for shell commands executed by AI coding agents. When your AI tool runs a command like git status or cargo test, RTK intercepts it, runs the actual command, then filters and compresses the output before it reaches the LLM context window.

Key features:

  • 100+ supported commands — git, cargo, npm, docker, kubectl, AWS CLI, test runners, linters, and more
  • Smart filtering — strips noise (comments, whitespace, boilerplate) while keeping semantics
  • Grouping & deduplication — aggregates similar items, collapses repeated log lines
  • Auto-rewrite hook — one rtk init -g command hooks into your AI tool transparently
  • Built-in analytics — rtk gain shows your token savings in real time

Architecture Overview

RTK Architecture

The diagram above shows the key difference:

Without RTK (left): Your AI agent sends a command to the shell, gets back a raw, verbose output (~2,000 tokens for git status), and feeds all that noise back into the LLM context. Over a 30-minute session, this adds up to ~118,000 tokens — and you pay for every one.

With RTK (right): Your AI agent sends the same command, but the RTK auto-rewrite hook transparently routes it through the RTK proxy. The proxy executes the real command, applies four filtering strategies (smart filtering, grouping, truncation, deduplication), and returns a compact output (~200 tokens for git status). The AI agent never knows the difference — it just gets cleaner, cheaper results. Total: ~23,900 tokens per session (~80% savings).

Why It's Trending

RTK exploded from launch to 41,600+ GitHub stars in just a few months. Why?

  • AI coding adoption is skyrocketing — everyone using Claude Code, Cursor, Codex, or Windsurf burns tokens on shell output
  • Token costs matter — at API pricing, saving 80% of ~118K tokens per session adds up fast
  • Zero friction — single binary, one command to install, zero config for most users
  • Active development — pushed daily, 808 issues tracked, 12 supported AI tools

Prerequisites

  • A Unix-like system (Linux, macOS) or WSL on Windows
  • An AI coding tool: Claude Code, Cursor, Codex, Gemini CLI, Windsurf, or any of the 12 supported agents
  • curl or brew for installation
  • Rust toolchain (optional — only needed if installing via Cargo)

Installation

RTK offers multiple installation methods. Pick one:

Homebrew (macOS / Linux)

brew install rtk

Quick Install Script (Linux / macOS / WSL)

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

This installs to ~/.local/bin. Add to your PATH if needed:

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

Cargo (if you have Rust installed)

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

Verify Installation

rtk --version   # Should show "rtk 0.28.2" or later

If you see rtk gain showing stats, you're good.

Setting Up the Auto-Rewrite Hook

The real magic is the auto-rewrite hook. It transparently intercepts every Bash command your AI tool runs and rewrites it to its rtk equivalent.

For Claude Code / GitHub Copilot (default)

rtk init -g

Then restart Claude Code. That's it.

For Other AI Tools

rtk init -g --gemini            # Gemini CLI
rtk init -g --codex             # Codex (OpenAI)
rtk init --agent cursor         # Cursor
rtk init --agent windsurf       # Windsurf
rtk init --agent cline          # Cline / Roo Code
rtk init --agent kilocode       # Kilo Code

After restarting your AI tool, run a simple command like git status. The output should be much more compact than usual.

How It Works — The Four Strategies

RTK applies four strategies depending on the command type:

1. Smart Filtering

Removes noise: comments, whitespace, boilerplate headers, progress bars, non-essential metadata.

2. Grouping

Aggregates similar items: files by directory, errors by type, test results by status.

3. Truncation

Keeps the relevant context (e.g., failure details) while cutting redundancy (passing tests, successful steps).

4. Deduplication

Collapses repeated log lines with counts instead of printing them hundreds of times.

Commands You'll Use Daily

Here are the most impactful RTK commands:

File operations:

rtk ls .                        # Compact directory tree
rtk read file.rs                # Smart file reading
rtk find "*.rs" .               # Compact find
rtk grep "pattern" .            # Grouped search results

Git operations (huge savings):

rtk git status                  # Compact status (~200 vs ~2,000 tokens)
rtk git log -n 10               # One-line commits
rtk git diff                    # Condensed diff (~500 vs ~2,000 tokens)
rtk git push                    # -> "ok main" (~10 vs ~200 tokens)

Test runners:

rtk cargo test                  # Failures only (-90%)
rtk pytest                      # Python tests (-90%)
rtk go test                     # Go tests (-90%)
rtk jest                        # Jest compact

Build & lint:

rtk cargo build                 # Compact (-80%)
rtk cargo clippy                # Compact (-80%)
rtk tsc                         # TypeScript errors grouped by file
rtk lint                        # ESLint grouped by rule/file

Containers & cloud:

rtk docker ps                   # Compact container list
rtk docker compose ps           # Compose services
rtk kubectl pods                # Compact pod list
rtk kubectl logs                # Deduplicated logs
rtk aws ec2 describe-instances  # Compact instance list

Tracking Your Savings

RTK's analytics show exactly how much you're saving:

rtk gain                        # Summary stats
rtk gain --graph                # ASCII graph (last 30 days)
rtk gain --history              # Recent command history
rtk gain --daily                # Day-by-day breakdown
rtk gain --all --format json    # JSON export

You can also discover missed opportunities:

rtk discover                    # Find commands RTK could optimize
rtk discover --all --since 7    # All projects, last 7 days

Configuration

RTK is zero-config by default, but you can customize it:

~/.config/rtk/config.toml:

[hooks]
exclude_commands = ["curl", "playwright"]  # skip rewrite for these

[tee]
enabled = true          # save raw output on failure
mode = "failures"       # "failures", "always", or "never"

When a command fails, RTK saves the full unfiltered output so the LLM can read it without re-executing.

Verification Checklist

  • rtk --version shows a version number
  • rtk init -g completed without errors
  • After restarting your AI tool, git status output is compact
  • rtk gain shows token savings across recent sessions
  • Auto-rewrite works: you didn't have to type rtk manually
  • For WSL users: hook works natively inside WSL

Comparison: RTK vs Alternatives

Approach Token Savings Setup Time Dependencies
RTK 60-90% 1 minute Zero (single Rust binary)
Manual prompt engineering Variable Hours None
Custom shell scripts 20-50% 30 minutes Shell tools
No optimization 0% 0 minutes None

RTK wins on every metric — highest savings, fastest setup, no runtime dependencies.

Resources

← Retour au Blog

Réduisez vos coûts de tokens LLM de 80% avec RTK — Le Proxy CLI en Rust que tout développeur AI doit connaître

2026-05-05

Réduisez vos coûts de tokens LLM de 80% avec RTK — Le Proxy CLI en Rust que tout développeur AI doit connaître

Si vous utilisez quotidiennement des outils de codage IA comme Claude Code, Cursor ou Codex, vous avez probablement remarqué ceci : une énorme partie de vos tokens part en bruit. Listes de répertoires, sorties git, logs de tests, murs d'erreurs de compilation — votre LLM lit chaque ligne, et vous payez pour chaque token.

RTK (Rust Token Killer) est un proxy CLI léger qui se place entre votre agent IA et le shell. Il réécrit les commandes de manière transparente, filtre la sortie et compresse les résultats — offrant des économies de 60 à 90 % sur les tokens sans rien changer à votre workflow.

Dans ce tutoriel, vous découvrirez ce qu'est RTK, comment il fonctionne et comment l'installer en moins de 5 minutes.

Qu'est-ce que RTK ?

RTK est un binaire Rust unique (zéro dépendance, surcharge <10ms) qui agit comme un proxy transparent pour les commandes shell exécutées par les agents de codage IA. Quand votre outil IA exécute une commande comme git status ou cargo test, RTK l'intercepte, exécute la commande réelle, puis filtre et compresse la sortie avant qu'elle n'atteigne la fenêtre de contexte du LLM.

Fonctionnalités clés :

  • Plus de 100 commandes supportées — git, cargo, npm, docker, kubectl, AWS CLI, lanceurs de tests, linters, et plus
  • Filtrage intelligent — supprime le bruit (commentaires, espaces, code standard) tout en gardant la sémantique
  • Regroupement et déduplication — agrège les éléments similaires, réduit les lignes de log répétées
  • Hook de réécriture automatique — une seule commande rtk init -g connecte votre outil IA de manière transparente
  • Analytique intégrée — rtk gain affiche vos économies de tokens en temps réel

Architecture

Architecture RTK

Le diagramme ci-dessus montre la différence clé :

Sans RTK (gauche) : Votre agent IA envoie une commande au shell, reçoit une sortie brute et verbeuse (~2 000 tokens pour git status), et renvoie tout ce bruit dans le contexte LLM. Sur une session de 30 minutes, cela représente ~118 000 tokens — et vous payez pour chacun d'eux.

Avec RTK (droite) : Votre agent IA envoie la même commande, mais le hook de réécriture automatique de RTK la redirige de manière transparente via le proxy RTK. Le proxy exécute la commande réelle, applique quatre stratégies de filtrage (filtrage intelligent, regroupement, troncature, déduplication), et retourne une sortie compacte (~200 tokens pour git status). L'agent IA ne voit jamais la différence — il reçoit simplement des résultats plus propres et moins chers. Total : ~23 900 tokens par session (~80% d'économies).

Pourquoi c'est tendance

RTK a explosé de son lancement à plus de 41 600 étoiles GitHub en seulement quelques mois. Pourquoi ?

  • L'adoption du codage IA explose — tous ceux qui utilisent Claude Code, Cursor, Codex ou Windsurf brûlent des tokens sur les sorties shell
  • Les coûts de tokens comptent — aux tarifs API, économiser 80% de ~118K tokens par session s'additionne vite
  • Zéro friction — un binaire unique, une commande pour installer, zéro configuration pour la plupart des utilisateurs
  • Développement actif — poussé quotidiennement, 808 issues suivies, 12 outils IA supportés

Prérequis

  • Un système de type Unix (Linux, macOS) ou WSL sur Windows
  • Un outil de codage IA : Claude Code, Cursor, Codex, Gemini CLI, Windsurf, ou l'un des 12 agents supportés
  • curl ou brew pour l'installation
  • Rust toolchain (optionnel — nécessaire seulement pour l'installation via Cargo)

Installation

RTK offre plusieurs méthodes d'installation. Choisissez-en une :

Homebrew (macOS / Linux)

brew install rtk

Script d'installation rapide (Linux / macOS / WSL)

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

Ceci installe dans ~/.local/bin. Ajoutez à votre PATH si nécessaire :

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

Cargo (si vous avez Rust installé)

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

Vérifier l'installation

rtk --version   # Devrait afficher "rtk 0.28.2" ou plus récent

Si rtk gain fonctionne, tout est prêt.

Configuration du Hook de Réécriture Automatique

La vraie magie réside dans le hook de réécriture automatique. Il intercepte de manière transparente chaque commande Bash que votre outil IA exécute et la réécrit en son équivalent rtk.

Pour Claude Code / GitHub Copilot (par défaut)

rtk init -g

Puis redémarrez Claude Code. C'est tout.

Pour les autres outils IA

rtk init -g --gemini            # Gemini CLI
rtk init -g --codex             # Codex (OpenAI)
rtk init --agent cursor         # Cursor
rtk init --agent windsurf       # Windsurf
rtk init --agent cline          # Cline / Roo Code
rtk init --agent kilocode       # Kilo Code

Après avoir redémarré votre outil IA, exécutez une commande simple comme git status. La sortie devrait être beaucoup plus compacte que d'habitude.

Comment ça marche — Les Quatre Stratégies

RTK applique quatre stratégies selon le type de commande :

1. Filtrage Intelligent

Supprime le bruit : commentaires, espaces, en-têtes standard, barres de progression, métadonnées non essentielles.

2. Regroupement

Agrège les éléments similaires : fichiers par répertoire, erreurs par type, résultats de tests par statut.

3. Troncature

Garde le contexte pertinent (ex : détails d'échec) tout en coupant la redondance (tests réussis, étapes réussies).

4. Déduplication

Réduit les lignes de log répétées avec des compteurs au lieu de les imprimer des centaines de fois.

Commandes que vous utiliserez quotidiennement

Voici les commandes RTK les plus impactantes :

Opérations sur fichiers :

rtk ls .                        # Arborescence compacte
rtk read file.rs                # Lecture intelligente
rtk find "*.rs" .               # Recherche compacte
rtk grep "pattern" .            # Résultats regroupés

Opérations Git (économies énormes) :

rtk git status                  # Statut compact (~200 vs ~2 000 tokens)
rtk git log -n 10               # Commits en une ligne
rtk git diff                    # Diff condensé (~500 vs ~2 000 tokens)
rtk git push                    # -> "ok main" (~10 vs ~200 tokens)

Lanceurs de tests :

rtk cargo test                  # Échecs seulement (-90%)
rtk pytest                      # Tests Python (-90%)
rtk go test                     # Tests Go (-90%)
rtk jest                        # Jest compact

Build & lint :

rtk cargo build                 # Compact (-80%)
rtk cargo clippy                # Compact (-80%)
rtk tsc                         # Erreurs TypeScript groupées par fichier
rtk lint                        # ESLint groupé par règle/fichier

Conteneurs & cloud :

rtk docker ps                   # Liste compacte des conteneurs
rtk docker compose ps           # Services Compose
rtk kubectl pods                # Liste compacte des pods
rtk kubectl logs                # Logs dédupliqués
rtk aws ec2 describe-instances  # Liste compacte des instances

Suivi de vos Économies

L'analytique de RTK montre exactement combien vous économisez :

rtk gain                        # Statistiques résumées
rtk gain --graph                # Graphique ASCII (30 derniers jours)
rtk gain --history              # Historique des commandes récentes
rtk gain --daily                # Analyse jour par jour
rtk gain --all --format json    # Export JSON

Vous pouvez aussi découvrir les opportunités manquées :

rtk discover                    # Trouver les commandes que RTK pourrait optimiser
rtk discover --all --since 7    # Tous les projets, 7 derniers jours

Configuration

RTK est zéro configuration par défaut, mais vous pouvez le personnaliser :

~/.config/rtk/config.toml :

[hooks]
exclude_commands = ["curl", "playwright"]  # ignorer la réécriture pour ceux-ci

[tee]
enabled = true          # sauvegarder la sortie brute en cas d'échec
mode = "failures"       # "failures", "always", ou "never"

Quand une commande échoue, RTK sauvegarde la sortie complète non filtrée pour que le LLM puisse la lire sans réexécuter.

Liste de Vérification

  • rtk --version affiche un numéro de version
  • rtk init -g s'est terminé sans erreur
  • Après redémarrage de votre outil IA, git status est compact
  • rtk gain montre des économies de tokens sur les sessions récentes
  • La réécriture automatique fonctionne : vous n'avez pas tapé rtk manuellement
  • Pour les utilisateurs WSL : le hook fonctionne nativement dans WSL

Comparaison : RTK vs Alternatives

Approche Économie Tokens Temps Configuration Dépendances
RTK 60-90% 1 minute Zéro (binaire Rust unique)
Ingénierie de prompt manuelle Variable Heures Aucune
Scripts shell personnalisés 20-50% 30 minutes Outils shell
Aucune optimisation 0% 0 minutes Aucune

RTK gagne sur tous les plans — économies maximales, installation la plus rapide, aucune dépendance d'exécution.

Ressources