RTK: reduce tokens de terminal en Claude Code hasta un 89%

TL;DR: RTK (Rust Token Killer) es un proxy CLI de código abierto que intercepta el output de comandos de terminal antes de que llegue al contexto del agente IA, filtrando ruido y comprimiendo resultados. En sesiones reales de Claude Code, ahorra entre el 60% y el 89% de los tokens generados por comandos de desarrollo. Esta guía cubre instalación desde cero, integración mediante hook automático y las limitaciones reales que encontrarás en producción.

El problema: tu agente procesa kilobytes de ruido en cada comando

Cuando Claude Code ejecuta cargo test, el output completo llega al contexto del LLM: cabeceras de compilación, barras de progreso, resúmenes de suites, advertencias de dependencias y, finalmente, la línea que importa: cuántos tests pasaron. Un cargo test típico genera 155 líneas. RTK lo comprime a 3.

El problema no es un comando aislado. Es la acumulación. En una sesión de refactoring activa, el agente puede ejecutar decenas de iteraciones de tests, linter y build. Cada ejecución vuelca su output completo en el contexto. Después de 30-40 minutos de trabajo real, una parte significativa de tu ventana de 200.000 tokens puede estar ocupada por resultados de tests que ya pasaron, advertencias que ya se corrigieron y logs de compilación que el agente nunca necesitó leer.

El efecto es doble: gastas más tokens de los necesarios (directamente en coste si pagas por tokens) y el agente dispone de menos espacio para el código y el historial de decisiones de la sesión. Si usas el control de tokens en tiempo real con la statusline de Claude Code, puedes observar el ritmo al que el contexto se llena solo con output de comandos.

La solución es interceptar ese output antes de que llegue al LLM, no después.

¿Qué es RTK (Rust Token Killer)?

RTK es un proxy CLI escrito en Rust que se sitúa entre tu shell y el agente IA. Intercepta el output de comandos de desarrollo habituales y lo transforma antes de enviarlo al contexto del LLM. Es de código abierto, es un binario estático único sin dependencias externas y funciona con Claude Code, Cursor, Gemini CLI, Codex, Aider y Cline.

El mecanismo es simple: en lugar de que el agente ejecute cargo test, ejecuta rtk cargo test. El agente recibe el output ya filtrado. La información relevante llega intacta; el ruido no llega.

A marzo de 2026, el repositorio rtk-ai/rtk supera las 2.000 estrellas en GitHub. La herramienta tiene soporte activo para cargo, pytest, ruff, mypy, eslint, biome, tsc, vitest, go test, git y docker. Para comandos no soportados actúa como passthrough transparente: el output pasa sin modificaciones.

Cómo funciona: cuatro transformaciones sobre el output

RTK aplica hasta cuatro tipos de operaciones al output de cada comando:

Filtrado de ruido: elimina barras de progreso, spinners, metadatos de compilación y advertencias de dependencias que no aportan información útil al agente.
Agrupación: consolida resultados relacionados, como tests pasados, en un resumen compacto. Cincuenta líneas de "test X passed" se convierten en "50 passed in 1.2s".
Truncado inteligente: en outputs largos, preserva la cabecera y la cola donde está la información crítica, descartando la parte central que suele ser ruido.
Deduplicación: elimina líneas idénticas o casi idénticas repetidas dentro del mismo output.

Cuando un comando falla, RTK preserva el output completo. El stacktrace, el mensaje de error, la línea exacta: todo llega al agente sin filtros. Para debugging, RTK escribe el log completo en ~/.local/share/rtk/tee/ e imprime una línea como: cargo test: 2 failed [full output: ~/.local/share/rtk/tee/1234_cargo_test.log]. El agente puede leer el archivo si necesita el detalle completo, pero su contexto no se satura con ello.

La asimetría es correcta: comprimir éxitos, preservar fallos. El agente necesita contexto rico cuando algo va mal, no cuando todo funciona.

Instalación y verificación

Antes de instalar, existe una advertencia importante: hay un binario llamado rtk en crates.io que no es RTK. Si ejecutas cargo install rtk, instalas la herramienta equivocada (Adobe Type Kit). Para verificar si ya tienes el Rust Token Killer o la versión incorrecta:

# Verifica si ya tienes instalado RTK Token Killer
rtk gain   # Solo la version correcta responde con estadisticas de tokens

# Si el comando responde con estadisticas, ya tienes la version correcta
# Si responde "command not found" o algo diferente, sigue con la instalacion

Para instalar RTK desde el repositorio oficial:

# Opcion 1: desde el repositorio oficial de GitHub (recomendado)
cargo install --git https://github.com/rtk-ai/rtk

# Opcion 2: via script de instalacion del sitio oficial
curl -sSf https://rtk-ai.app/install.sh | sh

# Anadir al PATH si instala en ~/.local/bin
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

# Verificar instalacion correcta
rtk --version   # Debe mostrar version 0.22.x o superior
rtk gain        # Debe mostrar estadisticas de ahorro, no "command not found"

Si rtk gain devuelve estadísticas de tokens guardados, la instalación es correcta.

Integración automática con Claude Code mediante hook

Usar RTK manualmente, prefijando cada comando con rtk, funciona pero tiene un problema estructural: en sesiones con subagentes o contextos de fork, el agente decide por su cuenta qué comandos ejecutar. Si llama a cargo test directamente, RTK no intercepta nada.

La solución es el hook PreToolUse de Claude Code. Este hook intercepta cualquier comando Bash antes de que llegue al shell y puede reescribirlo, de forma completamente transparente para el agente.

RTK incluye un comando de inicialización que configura todo automáticamente:

# Inicializar RTK con hook global para Claude Code
rtk init --global

# Equivalente abreviado
rtk init -g

# Con parcheo automatico del settings.json (sin confirmacion interactiva)
rtk init -g --auto-patch

# Verificar que el hook quedo instalado correctamente
rtk init --show

El comando rtk init --global hace tres cosas: instala el script del hook en ~/.claude/hooks/rtk-rewrite.sh, registra ese hook en ~/.claude/settings.json bajo PreToolUse, y crea un archivo RTK.md compacto de referencia. Pregunta antes de modificar settings.json; si prefieres revisar el cambio manualmente, usa --no-patch y RTK imprime las instrucciones exactas.

Si prefieres configurarlo a mano, esta es la entrada que RTK añade a settings.json:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "/home/tu_usuario/.claude/hooks/rtk-rewrite.sh"
          }
        ]
      }
    ]
  }
}

Usa la ruta absoluta, no ~/.claude/..., ya que Claude Code no expande el tilde en todos los contextos. RTK crea una copia de seguridad en settings.json.bak antes de modificar nada.

Con el hook activo, Claude Code reescribe automáticamente git status a rtk git status, cargo test a rtk cargo test, y así para todos los comandos soportados. El agente ve el output comprimido y nunca necesita saber que RTK está en el medio.

Cuánto comprime RTK por tipo de comando

Comando	Sin RTK	Con RTK	Reducción
`cargo test` (todos pasan)	155 líneas	3 líneas	98%
`git status`	119 caracteres	28 caracteres	76%
`pytest` (todos pasan)	80+ líneas	1 línea de resumen	~95%
`ruff check` (sin errores)	20-30 líneas	1-2 líneas	~90%
`docker ps`	Variable	Tabla compacta	~65%
Comando no soportado	N líneas	N líneas (passthrough)	0%
Media global (2.927 cmd)	10,3M tokens	~1,1M tokens	89,2%

Los datos de la última fila son de mediciones reales publicadas en el repositorio oficial, con 2.927 comandos ejecutados a lo largo de varias semanas. Los resultados individuales varían según el proyecto y el lenguaje.

Aplicación práctica: sesión de refactoring en Python

Para situar RTK en un contexto concreto: considera una sesión donde estás refactorizando un módulo Python con el agente ejecutando ruff, mypy y pytest de forma iterativa hasta que el código queda limpio.

Sin RTK, cada iteración de pytest con 45 tests que pasan genera 80-100 líneas de output: nombres de tests, duraciones individuales, resúmenes de cobertura, warnings de plugins. Cada ruff check sin errores produce su propia cabecera y pie de página. Diez iteraciones de este ciclo acumulan fácilmente 1.500-2.000 líneas de contexto que el agente ya no necesita leer.

Con RTK, pytest devuelve 45 passed in 2.3s. ruff check devuelve All checks passed.. mypy devuelve Success: no issues found in 12 source files. El agente procesa lo mismo en decenas de tokens en lugar de miles, y el contexto disponible para el código real se mantiene alto durante más tiempo.

Si combinas esto con las optimizaciones de LSP descritas en LSP en Claude Code: navegación semántica de 45s a 50ms, el stack de optimización de sesión empieza a tener un impacto visible. RTK comprime el output de comandos; LSP acelera la navegación del código. Son capas que se complementan.

En Producción

Rendimiento y overhead

RTK está escrito en Rust y el overhead de procesamiento sobre el tiempo de ejecución del comando es negligible en la práctica. El binario es estático, sin dependencias del sistema. No introduce latencia perceptible en comandos cortos (git status, ruff check) ni en comandos largos (cargo build).

Estimación de costes

Con Claude Sonnet a precios actuales, 100 comandos de terminal típicos sin RTK generan aproximadamente 13,50 € en tokens de entrada, según datos de la comunidad. Con RTK, ese volumen baja a unos 3,70 €, un ahorro de 9,80 € por cada 100 comandos. En proyectos con mucha iteración de tests, el número de comandos por sesión puede ser alto.

Si usas un plan de suscripción con límites de rate en lugar de pago por tokens, el beneficio no es económico directo: es capacidad. Las sesiones duran más sin necesidad de /compact ni reinicios.

Lo que cambia entre el tutorial y producción real

El hook de reescritura funciona de forma fiable en sesiones simples de un solo agente. En arquitecturas multi-agente, como las que describe Multi-Agente con Claude: Revisión Cruzada en Producción, los subagentes que arrancan con contextos propios pueden no heredar automáticamente los hooks del proceso padre en todas las configuraciones.

Para garantizar cobertura en entornos multi-agente, añade instrucciones explícitas en el CLAUDE.md del proyecto:

## Comandos de terminal
Para comandos de desarrollo, usa siempre el prefijo rtk:
- `rtk pytest` en lugar de `pytest`
- `rtk cargo test` en lugar de `cargo test`
- `rtk ruff check` en lugar de `ruff check`
Esto aplica a todos los agentes y subagentes de la sesion.

Esta combinación, hook automático más instrucción explícita en CLAUDE.md, es la más fiable en producción.

Límites actuales

RTK comprime output de comandos de shell, no el contexto de herramientas MCP ni el código fuente. Para reducir tokens en consultas estructurales al codebase, son necesarias estrategias complementarias como las de grafo de dependencias que cubre Claude Code Auto-Memory: el contexto que persiste solo.
La versión actual (0.22.x) tiene soporte limitado para workspaces complejos de Cargo y configuraciones monorepo donde el comando raíz no es directamente cargo.
Proyectos que usan uv run pytest o poetry run pytest en lugar de invocar pytest directamente no se benefician del hook. La solución es activar el entorno virtual antes o configurar el alias correspondiente en el proyecto.
RTK no funciona en entornos sin acceso al binario en PATH. En contenedores de CI/CD, es necesario instalar RTK explícitamente en el Dockerfile o en el paso de preparación del pipeline.

Errores comunes y depuración

Error: rtk: command not found después de ejecutar el script de instalación.
Causa: El directorio ~/.local/bin no está en el PATH de la sesión actual.
Solución: Ejecuta source ~/.bashrc o abre un terminal nuevo. Verifica con echo $PATH | tr ':' '\n' | grep local.

Error: rtk gain no devuelve estadísticas de tokens o responde con un error inesperado.
Causa: Tienes instalado un binario diferente llamado rtk (Adobe Type Kit u otro) que tiene precedencia en el PATH.
Solución: Ejecuta which rtk para identificar qué binario se está ejecutando. Ajusta el PATH para priorizar ~/.local/bin poniendo esa ruta antes en la definición de PATH.

Error: El hook no reescribe comandos en subagentes de Claude Code.
Causa: Los subagentes en contextos de fork no heredan automáticamente los hooks del proceso padre en todas las configuraciones de Claude Code.
Solución: Añade instrucciones explícitas en el CLAUDE.md del proyecto como se describe en la sección anterior. Verifica también que rtk init --show confirma que el hook está instalado y es ejecutable.

Error: cargo install rtk instala algo que no funciona como se espera.
Causa: El paquete rtk en crates.io es una herramienta diferente. El Rust Token Killer no está publicado en el registro oficial de crates.
Solución: Desinstala con cargo uninstall rtk e instala desde el repositorio oficial: cargo install --git https://github.com/rtk-ai/rtk.

Preguntas frecuentes

¿RTK funciona con stacks modernos de JavaScript como pnpm, vitest o Next.js?

La versión base tiene soporte para vitest, eslint, biome y tsc. Para stacks con pnpm workspaces, Next.js o Playwright, existe un fork mantenido por la comunidad (FlorianBruniaux/rtk) que incluye fixes específicos para parsear correctamente el output de estos entornos. Si usas un stack JavaScript moderno, ese fork puede ser más fiable que la versión base.

¿Cuánto ahorra RTK en sesiones largas de desarrollo activo?

Según mediciones publicadas con más de 2.900 comandos ejecutados en varias semanas, el ahorro medio es del 89% sobre los tokens generados por comandos de terminal. En sesiones de 2-3 horas con ciclos intensivos de tests, eso puede representar 20.000-80.000 tokens menos, dependiendo del proyecto y la frecuencia de ejecución. El comando rtk gain muestra las estadísticas acumuladas de tu instalación.

¿Necesito RTK si ya gestiono el contexto con /compact regularmente?

/compact y RTK atacan el mismo problema desde momentos distintos. RTK actúa antes: evita que el ruido de terminal llegue al contexto en primer lugar. /compact actúa después: comprime el historial cuando ya se acumuló. Usar ambos es el enfoque más completo para sesiones largas. Si ya llevas un seguimiento activo de tokens como describe la guía de statusline para control de tokens, verás directamente el efecto de cada herramienta en tiempo real.

Conclusión

El ruido de terminal es uno de los problemas más silenciosos en el desarrollo con agentes IA. No falla, no bloquea, no genera errores. Solo consume contexto sin aportar valor, sesión tras sesión. RTK ataca ese problema en el punto correcto: antes de que el output llegue al LLM, no después.

La instalación toma menos de cinco minutos con rtk init --global. El hook automático hace que RTK sea transparente para el agente sin añadir instrucciones extra al contexto. Y el ahorro del 60-89% en tokens de terminal se traduce en sesiones más largas, menos interrupciones para gestionar el contexto y, en planes de pago por tokens, una reducción visible en el coste mensual.

Si ya optimizas el contexto de código con estrategias de memoria persistente y navegación semántica, añadir RTK completa el stack. No es una solución mágica, pero es una de las optimizaciones con mejor ratio de esfuerzo e impacto que he encontrado para sesiones intensivas de desarrollo asistido por IA.

¿Has probado RTK o algún proxy similar en tu flujo con Claude Code? Cuéntame en los comentarios cómo está funcionando en tu proyecto, o en Twitter @sergiomarquezp_.

El siguiente tema que estoy explorando: knowledge graphs de codebase via MCP para reducir tokens en consultas estructurales, complementando lo que RTK hace con el output de comandos.