Cómo reducir el uso de tokens en agentes de codificación con IA: 4 herramientas que te ayudarán

Si alguna vez has alcanzado el límite de uso de tokens de tu plan de agente de código con IA tras solo unas pocas peticiones, quizá te preguntes a dónde se fueron todos esos tokens. 

Le pides al agente que corrija un bug, que refactorice una funcionalidad o que inspeccione un repositorio y, de repente, desaparece una gran parte de tu cupo de uso.

Esto no tiene por qué ser un problema de tu proveedor o de tu suscripción. 

Los agentes de codificación con IA consumen muchos más tokens que un chatbot normal. No se limitan a responder tu prompt. Pueden leer varios archivos, buscar en la base de código, inspeccionar logs, ejecutar tests, llamar a herramientas, generar código, revisar sus propios cambios y repetir el proceso varias veces antes de completar una tarea.

La buena noticia es que puedes recortar gran parte de ese uso innecesario de tokens.

Hay herramientas que hacen a los agentes menos verbosos, evitan que sobredimensionen tareas simples, comprimen la salida ruidosa del terminal y evitan que respuestas voluminosas de herramientas llenen la ventana de contexto.

En esta guía veremos cuatro herramientas para reducir el uso de tokens en agentes de codificación con IA: Caveman, Ponytail, RTK y Context Mode. 

Veremos qué hace cada una, cómo configurarlas y cómo puedes combinarlas para exprimir más tus suscripciones, como Claude Code y Codex, antes de alcanzar los límites de uso.

¿Por qué los flujos agentic usan tantos tokens?

Un chatbot normal puede tomar un prompt y devolver una sola respuesta. Un agente suele hacer mucho más.

Puede leer archivos, llamar a herramientas, inspeccionar logs, recuperar documentos, escribir código y repetir este proceso varias veces antes de terminar. 

Cada paso añade más información al contexto, y gran parte de ese contexto se vuelve a enviar al modelo en llamadas posteriores.

Un bucle de agente simplificado se ve así:

La petición va al modelo, el modelo llama a una herramienta, la herramienta devuelve una salida y esa salida se vuelve a plegar en el contexto antes del siguiente paso. La flecha de retorno es donde está el coste: en cada pasada se arrastran los resultados previos, así que una tarea que requiere seis llamadas de herramienta envía casi todo ese historial al modelo seis veces.

Esto genera varias fuentes habituales de derroche de tokens:

• Respuestas verbosas: el agente explica demasiado cuando bastaría una respuesta corta.
• Código sobredimensionado: una tarea pequeña se convierte en archivos extra, abstracciones y dependencias nuevas.
• Salidas de herramientas muy grandes: logs, tests, diffs de Git y comandos de terminal pueden devolver miles de tokens.
• Demasiado contexto: documentos recuperados, definiciones de herramientas y resultados previos llenan la ventana de contexto rápidamente.
• Sesiones largas: cuanto más tiempo trabaja el agente, más historial y resultados intermedios tiene que arrastrar.

Así que el reto no es solo cuántos tokens genera un agente, sino cuántos lee, arrastra y vuelve a procesar a medida que avanza el flujo.

Eso es justo lo que herramientas como Caveman, Ponytail, RTK y Context Mode buscan reducir, cada una atacando una fuente distinta de desperdicio de tokens.

1. Caveman: haz que tu agente diga menos

Caveman es una forma sencilla de hacer que los agentes de código sean más concisos. 

En lugar de dejar que el agente narre cada paso, repita obviedades o añada relleno, lo orienta hacia la información que realmente importa.

Es especialmente útil en sesiones largas de codificación, donde las respuestas verbosas no solo incrementan los tokens de salida. 

Esas respuestas también pasan a formar parte del historial de la conversación y se arrastran a turnos posteriores.

Cómo funciona Caveman

Caveman tiene dos partes separadas.

La Caveman skill cambia cómo escribe el agente. 

Elimina relleno, cortesías, titubeos y narración innecesaria, dejando intactos los elementos importantes como bloques de código, comandos, nombres de APIs y mensajes de error exactos. 

También relaja el estilo lacónico cuando la claridad es clave, por ejemplo en avisos de seguridad o acciones irreversibles. 

Además, hay un proxy local opcional que ataca la otra cara del problema: lo que lee el agente. 

Se sitúa entre el agente de código y el proveedor del modelo y comprime el contexto elegible antes de enviar la petición. 

La skill y el proxy funcionan de forma independiente, así que puedes empezar con la skill ligera y añadir el proxy más tarde si necesitas una reducción de contexto más agresiva. 

Una forma sencilla de entenderlo se ve en el diagrama siguiente:

A la izquierda, el agente envuelve su código con un preámbulo y luego vuelve a explicar lo mismo. A la derecha, obtienes la respuesta útil y el código, y nada más. El mismo trabajo, con muchos menos tokens gastados en narrarlo.

Primeros pasos con Caveman

La forma más fácil de instalar la skill es:

npx skills add JuliusBrussee/caveman

Luego actívala dentro de tu agente de código con:

/caveman

Puedes volver a las respuestas normales con:

/caveman off

Caveman también ofrece opciones de instalación nativas para herramientas como Claude Code, Codex, Gemini CLI, Cursor y OpenCode.

Si también quieres reducir el contexto que se envía al modelo, instala la CLI:

npm install -g @caveman-ai/cli
caveman setup --install

Luego inicia un agente compatible a través de ella, por ejemplo:

caveman claude

Esto arranca el proxy local de Caveman y enruta el agente por su capa de compresión de contexto. 

Para la mayoría, empezaría con la skill primero. 

Es fácil de añadir, no cambia tu flujo de trabajo habitual y ataja una de las fuentes más simples de despilfarro de tokens: un agente que habla mucho más de lo necesario.

2. Ponytail: evita que tu agente sobredimensione

Ponytail está pensado para otro tipo de despilfarro de tokens: agentes que escriben más código del que la tarea requiere.

Una petición sencilla a veces acaba en nuevas dependencias, clases helper, componentes wrapper y configuración adicional. 

Ponytail intenta evitarlo guiando al agente hacia la solución más pequeña y sensata primero.

Cómo funciona Ponytail

Antes de escribir código, Ponytail hace que el agente pase por una sencilla escalera de decisiones:

Cada peldaño le da al agente la oportunidad de parar antes de escribir nada nuevo. Solo llega al último paso —escribir el mínimo código que funcione— cuando se han descartado la librería estándar, las funciones nativas de la plataforma y las dependencias existentes.

Por ejemplo, en lugar de instalar una librería de date-picker y construir un componente wrapper, Ponytail puede decidir que el navegador ya tiene:

<input type="date">

El objetivo no es acortar todo a ciegas. 

Ponytail mantiene fuera del recorte cosas como validación, seguridad, accesibilidad y protección contra pérdida de datos. 

Su idea es ser perezoso en la implementación, no descuidado en la corrección.

En su propio benchmark agentic, Ponytail produjo alrededor de un 54% menos de código y un 22% menos de tokens en 12 tareas de programación frente al mismo agente sin la skill. 

Un benchmark independiente también encontró implementaciones sustancialmente más pequeñas, aunque señaló que ajustes muy agresivos a veces pueden sacrificar robustez ante casos límite no especificados.

Primeros pasos con Ponytail

Para Claude Code, añade el marketplace:

/plugin marketplace add DietrichGebert/ponytail

Luego instala Ponytail:

/plugin install ponytail@ponytail

Envíalos como dos comandos separados.

Una vez instalado, puedes controlar lo agresivo que es Ponytail al simplificar:

/ponytail lite
/ponytail full
/ponytail ultra
/ponytail off

full es el valor por defecto y probablemente el mejor punto de partida. lite sigue construyendo lo que pides, pero te señala alternativas más simples, mientras que ultra aplica YAGNI de forma mucho más agresiva. 

También puedes revisar un cambio existente para detectar complejidad innecesaria:

/ponytail-review

O escanear una base de código más grande:

/ponytail-audit

Ponytail funciona especialmente bien con agentes de codificación porque reducir código innecesario tiene un efecto dominó: el agente escribe menos tokens ahora, crea diffs más pequeños y se deja a sí mismo menos código que volver a leer después.

3. RTK: recorta la salida ruidosa de las herramientas

RTK, siglas de Rust Token Killer, se centra en otra fuente de derroche de tokens: todo lo que tu agente de código recibe del terminal.

Comandos como git status, ejecuciones de tests, logs, búsquedas y la salida del gestor de paquetes pueden devolver cientos o miles de líneas. 

Para una persona en un terminal, mucha de esa información es útil, pero un agente a menudo solo necesita las partes importantes.

RTK se interpone entre el comando y el agente y comprime la salida antes de que la vea el modelo. 

Cómo funciona RTK

RTK usa filtrado específico por comando, agrupación, truncado y desduplicación para eliminar ruido manteniendo información útil como errores, fallos, archivos cambiados y resúmenes. 

Por ejemplo:

En el flujo normal, el agente ejecuta pytest y lee cada línea impresa, la mayoría de las cuales son tests que pasan y que no necesita ver. Con RTK en medio, la misma ejecución vuelve como fallos más un resumen, así que el agente lee unas decenas de líneas en lugar de varios cientos.

Con agentes compatibles, RTK puede engancharse automáticamente a las llamadas al shell. Un comando como:

git status

puede reescribirse por detrás como:

rtk git status

El agente recibe entonces la salida reducida sin tener que pedir explícitamente RTK cada vez. 

RTK reporta alrededor de un 60–90% menos de tokens de salida de comandos para comandos comunes de desarrollo. Eso no significa que tu factura total del LLM baje un 60–90%; se refiere solo a la salida de terminal que RTK comprime. 

Primeros pasos con RTK

En macOS o Linux, puedes instalarlo con Homebrew:

brew install rtk-ai/tap/rtk

O usar el script de instalación:

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

Luego verifica que instalaste el RTK correcto:

rtk --versionrtk gain

El comando rtk gain muestra el panel de ahorro de tokens. Esta comprobación es útil porque otro proyecto no relacionado también usa el nombre rtk. 

Para Claude Code, inicializa RTK globalmente con:

rtk init -g

Para Codex:

rtk init -g --codex

Y para Gemini CLI:

rtk init -g --gemini

RTK también es compatible con Cursor, OpenCode, Copilot, Cline, Windsurf y varios agentes de código más. 

Una vez configurado, puedes seguir usando tus comandos de terminal habituales. 

RTK gestiona la compresión en segundo plano, lo que lo hace especialmente útil para agentes que pasan mucho tiempo ejecutando tests, buscando en el código, inspeccionando cambios de Git y leyendo logs.

4. Context Mode: mantén las salidas masivas fuera del contexto

Context Mode se centra en lo que ocurre después de que un agente empiece a usar herramientas.

Una captura de navegador, una lista de issues de GitHub, una búsqueda de archivos o la salida de un comando grande pueden volcar una enorme cantidad de información directamente en la ventana de contexto. 

Aún peor, esa información puede arrastrarse a turnos posteriores.

Context Mode intenta evitarlo manteniendo los datos en bruto voluminosos fuera del contexto activo del LLM y trayendo solo las partes que el agente realmente necesita.

Cómo funciona Context Mode

Context Mode se ejecuta como un servidor MCP y ofrece herramientas en sandbox para operaciones que normalmente generan salidas grandes.

La información en bruto puede almacenarse localmente en un índice de búsqueda con FTS5, para que el agente pueda volver a consultarla sin volcar todo el resultado en la conversación. 

En un ejemplo del proyecto, 315 KB de salida en bruto se redujeron a 5,4 KB de contexto, lo que equivale a una reducción del 98%. 

Es un ejemplo de la propia carga de trabajo del proyecto, no una garantía para cada llamada de herramienta. 

Primeros pasos con Context Mode

Para Claude Code, la configuración más sencilla es mediante el marketplace de plugins:

/plugin marketplace add mksglu/context-mode
/plugin install context-mode@context-mode

Reinicia Claude Code y verifica la instalación con:

/context-mode:ctx-doctor

El doctor comprueba que el plugin, los hooks, los runtimes y los componentes de búsqueda local funcionan correctamente. 

También puedes instalar Context Mode globalmente:

npm install -g context-mode

y registrarlo como servidor MCP en clientes compatibles como Cursor, Gemini CLI, GitHub Copilot CLI, JetBrains y otros. 

Una vez en marcha, puedes ver cuánto contexto está ahorrando con sus herramientas de estadísticas.

Context Mode es especialmente útil para agentes de larga duración y muy dependientes de herramientas, donde resultados de navegador, logs, lecturas de archivos, respuestas MCP y otros datos intermedios llenarían la ventana de contexto.

Comparativa de las cuatro herramientas para ahorrar tokens

Estas cuatro herramientas apuntan a partes distintas del flujo de trabajo del agente de código, desde lo que el agente escribe hasta cuánto arrastra de salida de herramientas en el contexto.

La forma más sencilla de ver la diferencia es: 

• Caveman reduce lo que dice el agente
• Ponytail reduce lo que construye
• RTK reduce lo que devuelve el terminal
• Context Mode reduce qué resultados de herramientas se quedan en contexto

¿Puedes usar estas herramientas juntas?

Sí, pero no apilaría todo desde el principio.

Un enfoque mejor es empezar con Ponytail. 

Es sencillo de añadir a los agentes de código y, para muchos flujos, reducir el código innecesario ya es suficiente. Yo lo uso con herramientas como Zcode, Claude Code y Codex, y estoy contento con la reducción que me da.

Si quieres ir más allá, prueba Ponytail + Caveman. Ponytail reduce el código innecesario y Caveman reduce la explicación innecesaria, así que se complementan bien.

Si tu flujo sigue generando mucha salida pesada en tokens de tests, logs, Git o comandos de terminal, prueba Ponytail + Caveman + RTK.

Si RTK no encaja con tu flujo —especialmente si usas muchas herramientas MCP, herramientas de navegador, APIs u otras salidas grandes—, prueba en su lugar Ponytail + Caveman + Context Mode.

No hay una combinación perfecta que funcione para todo el mundo. 

La idea es experimentar y encontrar la configuración que te dé menos uso de tokens sin perjudicar el rendimiento de tu agente. Para algunas personas, Ponytail bastará. Para otras, funcionará mejor combinar dos o tres de estas herramientas.

Otras formas de reducir uso de tokens y coste

No siempre necesitas otra herramienta. 

Claude Code ya incluye varias funciones que te ayudan a mantener el contexto más pequeño y reducir gastos innecesarios.

Desactiva la memoria cuando no la necesites

Claude Code puede almacenar y recargar recuerdos automáticamente de sesiones anteriores. Para tareas cortas o aisladas, esto puede añadir contexto que no necesitas.

Ejecuta:

/memory

Desde ahí puedes desactivar la memoria automática o eliminar información que ya no sea útil.

Compacta sesiones largas

A medida que una sesión crece, Claude arrastra historial de conversación, contenido de archivos y salidas de herramientas. Claude Code compacta automáticamente, pero puedes forzarlo antes:

/compact

También puedes indicar qué importa:

/compact keep the implementation plan and latest test results

Esto es especialmente útil cuando has terminado una parte de una tarea, pero quieres continuar en la misma sesión. 

Empieza de cero cuando la tarea cambie

A veces no compensa compactar. Si pasas a una tarea completamente distinta, ejecuta:

/clear

Esto arranca con un contexto de conversación vacío en lugar de arrastrar trabajo no relacionado. Anthropic también señala que empezar de cero a veces es mejor que compactar repetidamente una sesión larga.

Desactiva servidores MCP que no uses

Las herramientas MCP también consumen contexto. Claude Code ahora aplaza por defecto los esquemas completos de herramientas MCP, pero los servidores no usados pueden seguir añadiendo sobrecarga.

Usa: /mcp para revisar tus servidores conectados y desactivar los que no necesites ahora. 

También puedes ejecutar /context para ver cuánto espacio consumen las distintas partes de la sesión.

Mantén pequeño CLAUDE.md

CLAUDE.md se carga en el contexto de Claude, así que evita convertirlo en un manual gigante del proyecto. 

Incluye solo instrucciones que Claude realmente necesite entre tareas, como convenciones importantes, comandos y normas del proyecto.

Usa /context para comprobar cuánto espacio ocupan tu memoria y archivos de instrucciones. Para reglas relevantes solo en ciertas carpetas, Claude Code admite reglas más específicas en lugar de poner todo en el CLAUDE.md principal. 

Usa un modelo más barato para tareas simples

Probablemente no necesites el modelo más caro para cada edición. 

La documentación de Claude Code recomienda Sonnet para la mayoría de tareas de programación y reservar Opus para trabajo arquitectónico o de razonamiento más complejo.

Puedes cambiar con:

/model

Para subagentes con tareas sencillas, también puedes configurarlos para usar Haiku. 

Reflexión final

Una de las mejores cosas de estas herramientas es el poco esfuerzo que requieren una vez configuradas. 

Según la herramienta, puede que ni siquiera tengas que recordar un comando con barra o activarla manualmente para cada tarea. 

Ponytail puede guiar al agente hacia implementaciones más sencillas, Caveman puede mantener las respuestas concisas, RTK puede comprimir la salida del terminal y Context Mode puede evitar que grandes resultados de herramientas inunden el contexto activo. 

Tras la configuración, gran parte de esta optimización ocurre como parte de tu flujo de trabajo normal.

A menudo puedes ver el efecto en el resumen de ejecución del agente, el código generado, la salida del terminal o las estadísticas de contexto. 

El agente puede estar haciendo el mismo trabajo, pero con menos código innecesario, menos narración, salidas de herramientas más pequeñas o menos información arrastrada de un paso al siguiente.

Lo mejor es que también puedes combinar estas herramientas. 

Sin embargo, apilar las cuatro no garantiza automáticamente el menor uso posible de tokens. Atacan partes distintas del flujo de trabajo agentic, y el beneficio depende mucho de tu agente, modelo, repositorio y del tipo de tareas que ejecutes.

Te recomiendo experimentarlas en tu propio entorno. Empieza con una, mide la diferencia y añade otra si sigues viendo fuentes claras de despilfarro de tokens. 

Puede que una sola baste para tu flujo, mientras que otro montaje se beneficie de dos o tres trabajando juntas.

En mi caso, uso Ponytail en la mayoría de mis flujos de codificación porque es fácil de configurar y el agente aprende rápido a trabajar con él. 

Zcode by Z.ai es donde más lo uso, ya que ayuda a mantener las implementaciones enfocadas sin que yo tenga que cambiar mi manera habitual de pedir cosas al agente.

En definitiva, reducir el uso de tokens no va de forzar al agente a hacer menos trabajo útil, sino de eliminar el desperdicio que lo rodea. 

Prueba Caveman, Ponytail, RTK y Context Mode por separado y en distintas combinaciones, mide qué cambia en tu flujo y quédate con la configuración que te dé el mejor equilibrio entre uso de tokens, calidad de código y rendimiento del agente.

Para aprender más sobre cómo funcionan los agentes de IA, te recomiendo echar un vistazo al itinerario de aprendizaje AI Agent Fundamentals.