rtk: reduce hasta 90% los tokens de Claude Code en 2026

TL;DR: rtk (Rust Token Killer) es un proxy de línea de comandos que comprime la salida de comandos como git status, cargo test o pytest antes de que entre al contexto de Claude Code, recortando entre un 60 y un 90% los tokens consumidos. Se instala como un único binario sin dependencias y se engancha mediante un hook que reescribe los comandos de forma transparente. En esta guía verás cómo instalarlo, cómo funciona por dentro y qué vigilar antes de meterlo en tu flujo diario.

Por qué tu agente quema tokens en comandos triviales

El problema no es el modelo, es la basura que le metes en el contexto. Cada vez que Claude Code ejecuta un comando en tu terminal, la salida completa entra al contexto: 155 líneas de un cargo test que pasa, el árbol entero de git status, logs de build con barras de progreso. El agente solo necesita saber "los tests pasan" o "hay 3 ficheros modificados", pero recibe el ruido entero.

En sesiones largas eso se acumula rápido. Un git push son unos 200 tokens en 15 líneas cuando la información útil es "ok, rama main". Multiplica eso por decenas de comandos por sesión y entiendes por qué el límite de tu plan se agota a media tarde. Ya cubrí cómo medir el consumo de tokens y el coste de Claude Code en VS Code; rtk ataca una de las fuentes de gasto más invisibles, que es la salida verbosa de las herramientas.

Esto importa por dos motivos concretos: pagas menos (o agotas el límite mucho más tarde) y, como hay menos tokens en el contexto, las respuestas llegan antes. Menos contexto significa menos latencia, sobre todo con Opus.

¿Qué es rtk?

rtk es un proxy CLI escrito en Rust que intercepta comandos de desarrollo y comprime su salida antes de que llegue al contexto del LLM. Se distribuye como un binario estático único, sin runtime ni dependencias externas, y añade menos de 10 ms de sobrecarga por comando.

La idea es sencilla: en lugar de que el agente ejecute git status directamente, ejecuta rtk git status. rtk recibe la salida original, la filtra y devuelve una versión compacta con la misma señal útil. Desde el punto de vista del agente, nada cambia: ve una respuesta limpia en vez del volcado completo.

No es un wrapper exclusivo de Claude Code. Funciona también con Cursor, Copilot, Gemini CLI, OpenCode, Windsurf y Cline. Es código abierto y, a junio de 2026, va por la versión 0.42.1.

Cómo comprime: las 4 estrategias

rtk no borra a ciegas, aplica cuatro estrategias según el tipo de comando. Entender qué hace cada una te ayuda a confiar en el resultado (o a desconfiar cuando toca).

Estrategia	Qué hace	Ejemplo
Filtrado inteligente	Elimina ruido, comentarios, espacios y boilerplate	Oculta los tests que pasan, deja solo los que fallan
Agrupación	Agrega elementos similares por directorio o tipo de error	Ficheros agrupados por carpeta en vez de uno a uno
Truncado	Conserva el contexto relevante y quita la redundancia	Diffs condensados
Deduplicación	Colapsa líneas repetidas con un contador	"warning x40" en vez de 40 líneas

El resultado en números reales que publica el proyecto: cargo test pasa de 155 líneas a 3 (98% menos), git log -n 10 baja un 86%, y leer un fichero de 1.295 líneas con rtk read en modo agresivo cae un 95%. La salida de comandos de test es donde está el ahorro gordo, porque casi todo lo que importa es qué falla.

Instalación paso a paso

Instalar rtk y engancharlo a Claude Code son dos comandos.

1. Instala el binario. Tienes tres vías según tu entorno:

# Homebrew (macOS, Linux): la opcion recomendada
brew install rtk

# Script de instalacion directo (Linux/macOS)
curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh

# Desde fuente con cargo: usa --git para evitar un paquete homonimo en crates.io
cargo install --git https://github.com/rtk-ai/rtk

2. Engancha el hook a Claude Code. Este comando escribe la configuración en tu settings.json automáticamente:

# Registra el hook PreToolUse global para Claude Code
rtk init -g

# Para otros agentes:
rtk init -g --gemini          # Gemini CLI
rtk init -g --codex           # Codex
rtk init -g --agent cursor    # Cursor

3. Reinicia Claude Code y verifica. A partir de la siguiente sesión, cuando el agente lance git status, el hook lo reescribe a rtk git status de forma transparente:

# Confirma version y revisa el ahorro acumulado
rtk --version    # rtk 0.42.1
rtk gain         # tokens totales, ahorrados y % por comando

El comando rtk gain es tu panel de control: muestra cuántos tokens has ahorrado y qué comandos rinden más. Es la forma más rápida de validar que está haciendo su trabajo en tu repo, no en el benchmark de otro.

Comandos soportados y dónde rinde

La cobertura es amplia, pero el ahorro se concentra en comandos verbosos y repetitivos.

Git y GitHub CLI: status, log, diff, push, pull, pr list, issue list.
Test runners: cargo test, pytest, go test, jest, vitest, playwright, rspec. Aquí está el grueso del ahorro.
Build y lint: tsc, cargo build/clippy, ruff, golangci-lint, next build.
Infra: docker ps/logs/compose, kubectl, y comandos de AWS (ec2, lambda, logs, s3).
Ficheros: ls, find, grep, y rtk read para leer ficheros largos comprimidos.

Ojo con un detalle clave de alcance: el hook solo intercepta llamadas al tool Bash. Las herramientas nativas de Claude Code (Read, Grep, Glob) no pasan por el hook, así que si quieres comprimir esas operaciones tienes que llamar a rtk read o rtk grep de forma explícita por shell.

Caso real: pipelines multi-agente

Donde rtk se nota de verdad es cuando varios agentes ejecutan comandos en paralelo. Si trabajas con un esquema multi-agente, cada subagente corre su propio git status, su npm test, su build. El ahorro se multiplica por el número de agentes.

En un pipeline de varios agentes resolviendo una misma feature, hablamos de cientos de miles de tokens recortados en una sola tarea. Si ya estás montando flujos con varios agentes coordinados en VS Code, rtk es una capa transparente que no toca tu orquestación pero baja el coste de cada turno. Encaja con la idea de que en los agentes de código la configuración pesa más que el modelo elegido: el mismo Opus rinde distinto según cuánto ruido le metas en el contexto.

En Producción

rtk es un binario rápido, pero introduce un punto intermedio y compresión con pérdida. Mídelo antes de fiarte.

Rendimiento. Menos de 10 ms por comando es despreciable frente a lo que tarda el modelo. El beneficio en latencia (menos tokens en contexto, respuestas más rápidas) compensa de sobra esa sobrecarga.

Coste. Si pagas API por token, el ahorro es directo en la factura. Para un desarrollador con un gasto típico de 10 a 50€ al mes en APIs, recortar un 60-90% de los tokens de comandos no es anecdótico. Si vas con plan de suscripción, el efecto es que el límite te dura mucho más. Combínalo con vigilar otras fugas, como el cache miss que dispara tu factura en Claude Code.

El riesgo real: compresión con pérdida. rtk descarta información por diseño. No hay garantía de que la salida filtrada conserve el 100% de lo diagnósticamente útil. La red de seguridad es el sistema tee: cuando un comando falla, rtk guarda la salida completa en disco y le indica al modelo dónde leerla, para que no tenga que reejecutar. Puedes ajustar su comportamiento en el config.toml:

# ~/.config/rtk/config.toml
[hooks]
exclude_commands = ["curl", "playwright"]  # no reescribir estos

[tee]
enabled = true
mode = "failures"   # "failures" | "always" | "never"

Qué cambia entre el tutorial y producción. En Windows nativo el auto-rewrite no funciona: cae a un modo de inyección en CLAUDE.md y los comandos no se reescriben solos. Para soporte completo necesitas WSL. Y recuerda que es una herramienta de terceros con un hook custom, no una feature oficial de Anthropic. Mantener el contexto limpio es parte de la misma higiene que la gestión de memoria por capas en Claude Code.

Errores comunes y depuración

Error: instalas con cargo install rtk y obtienes otra herramienta. Causa: existe un paquete homónimo en crates.io. Solución: usa cargo install --git https://github.com/rtk-ai/rtk o Homebrew.
Error: el agente lanza un comando dentro de un skill y choca con el hook. Causa: combinar comandos Bash en skills puede colisionar con la reescritura. Solución: usa rtk proxy <cmd> para pasar sin filtrar, o añade el comando a exclude_commands.
Error: no ves ahorro en rtk gain. Causa: no reiniciaste Claude Code tras rtk init, o tus operaciones van por Read/Grep nativos que saltan el hook. Solución: reinicia y fuerza comandos por shell o con rtk read.

Preguntas frecuentes

¿rtk puede hacer que el agente pierda información importante?

Sí, en teoría, porque la compresión es con pérdida. En la práctica el riesgo se concentra en errores, y para eso existe el sistema tee que guarda la salida completa cuando un comando falla. Aun así, conviene revisar rtk gain y validar en tu repo antes de adoptarlo a ciegas.

¿Funciona solo con Claude Code?

No. rtk soporta oficialmente Claude Code, Cursor, Copilot, Gemini CLI, OpenCode, Windsurf y Cline. Para cualquier otro agente, basta con anteponer rtk a los comandos manualmente para obtener el mismo efecto.

¿Cuánto ahorra de verdad?

El proyecto reporta entre un 60 y un 90% según el comando, con casos extremos como cargo test al 98%. El ahorro real depende de tu mezcla de comandos: cuantos más test runners y logs verbosos, más recortas. Mídelo con rtk gain --history en tu propio flujo.

Conclusión

Hemos visto cómo rtk se cuela entre tu agente y la shell para comprimir la salida de comandos y recortar el grueso de los tokens que se desperdician en ruido. La clave está en que es transparente: no cambias cómo trabajas, solo dejas de pagar por líneas que el modelo no necesita leer. El punto a vigilar es la compresión con pérdida, así que mide el ahorro real con rtk gain y apóyate en el tee para no quedarte sin contexto cuando algo falla.

¿Has medido cuántos tokens se te van en salida de comandos, o lo das por hecho? Cuéntame tu experiencia en los comentarios o en Twitter @sergiomarquezp_. En el próximo post quiero entrar en las capas de memoria persistente entre sesiones, otro de los grandes agujeros de contexto en los agentes de código.