Cuando empezamos a trabajar con agentes en Claude Code, es fácil pensar que el consumo de tokens depende solo de lo que escribimos en el prompt. Pero en la práctica, nosotros mismos comprobamos que el gasto real viene de algo mucho más amplio: todo el contexto que el agente arrastra en cada interacción.
- Qué consume tokens realmente en Claude Code
- Gestionar el contexto de forma activa
- Elegir el modelo adecuado en cada tarea
- Reducir el uso innecesario de herramientas (MCP)
- Leer menos archivos, pero mejor
- Optimizar CLAUDE.md y la memoria
- Aprovechar el prompt caching y la compresión automática
- Medir antes de enviar
- Reducir salidas innecesarias
- Separar tareas en sesiones independientes
- Nuestra conclusión tras probarlo
A medida que los proyectos crecen, también lo hacen los costes y el rendimiento empieza a resentirse. Por eso, entender cómo optimizar el uso de tokens no es solo una cuestión económica, sino también de eficiencia y calidad en las respuestas.
En este artículo vamos a explicar, desde nuestra experiencia y apoyándonos en la documentación oficial de Anthropic, cómo reducir de forma real el consumo de tokens en Claude Code, con estrategias que sí marcan la diferencia.
Qué consume tokens realmente en Claude Code
Antes de optimizar nada, hay que entender de dónde viene el gasto. En nuestras pruebas, uno de los errores más comunes es pensar que solo cuentan los mensajes del chat.
En realidad, Claude Code incluye en cada llamada:
- El historial completo de la conversación
- Archivos leídos del proyecto
- Resultados de comandos ejecutados
- Definiciones de herramientas (tools)
- Instrucciones persistentes como
CLAUDE.md - Memoria automática del sistema
Esto significa que incluso un prompt corto puede terminar siendo caro si el contexto es grande. De hecho, hemos visto sesiones donde el usuario escribe una sola línea, pero el sistema envía miles de tokens por detrás.
Por eso, la optimización empieza por una idea clave: reducir el contexto innecesario.
Gestionar el contexto de forma activa
Una de las prácticas que más impacto tiene es controlar el contexto manualmente. Claude Code incluye varios comandos diseñados justo para esto, y usarlos bien cambia completamente el consumo.
En nuestro caso, lo que mejor nos ha funcionado es adoptar este flujo de trabajo:
- Usar
/contextpara revisar qué está cargado - Ejecutar
/clearcuando cambiamos de tarea - Aplicar
/compacten conversaciones largas - Consultar
/costregularmente
El comando /compact es especialmente útil porque resume la conversación manteniendo lo importante. Esto permite seguir trabajando sin arrastrar todo el historial.
También recomendamos usar /rename antes de limpiar una sesión y /resume si necesitas volver más adelante. Es una forma sencilla de mantener orden sin pagar tokens de más.
Elegir el modelo adecuado en cada tarea
Aquí hay una de las optimizaciones más infravaloradas. No todos los tokens cuestan lo mismo.
En nuestras pruebas, cambiar de modelo tiene un impacto inmediato en el coste total. Por ejemplo:
| Tipo de tarea | Modelo recomendado |
|---|---|
| Desarrollo general | Claude Sonnet |
| Razonamiento complejo | Claude Opus |
| Subagentes o tareas simples | Claude Haiku |
La clave está en no usar siempre el modelo más potente. Muchas tareas cotidianas funcionan perfectamente con modelos más ligeros.
Nosotros hemos visto reducciones importantes simplemente delegando tareas repetitivas a Haiku en lugar de Sonnet u Opus. Es una optimización sencilla, pero muy efectiva.
Reducir el uso innecesario de herramientas (MCP)
Uno de los mayores “consumidores invisibles” de tokens son las herramientas, especialmente cuando trabajamos con servidores MCP.
Cada herramienta añade su definición al contexto, aunque no se utilice. Esto significa que cuantos más servidores activos tengamos, mayor será el coste base de cada interacción.
En la práctica, esto se traduce en varias recomendaciones claras:
- Desactivar servidores MCP que no estés usando
- Evitar cargar múltiples herramientas redundantes
- Usar herramientas CLI cuando sea posible
- Revisar regularmente
/mcpy/context
Nosotros comprobamos que simplificar el entorno de herramientas puede reducir bastante el consumo sin afectar al flujo de trabajo.
Además, cuando las herramientas devuelven resultados grandes (logs, JSON, etc.), el impacto en tokens puede dispararse. Aquí es importante limitar salidas o procesarlas antes de enviarlas al modelo.
Leer menos archivos, pero mejor
Otro punto crítico es cómo el agente explora el código. En proyectos grandes, Claude puede abrir múltiples archivos buscando contexto, y cada lectura suma tokens.
Aquí es donde vimos una mejora clara al usar herramientas de análisis más inteligentes, especialmente en lenguajes tipados.
En lugar de hacer búsquedas amplias, lo ideal es:
- Navegar por símbolos concretos
- Ir directamente a definiciones relevantes
- Evitar abrir archivos innecesarios
- Reducir exploraciones “a ciegas”
Este cambio puede parecer pequeño, pero en sesiones largas de depuración puede ahorrar miles de tokens.
Optimizar CLAUDE.md y la memoria
Las instrucciones persistentes son otro factor importante. Archivos como CLAUDE.md o MEMORY.md se cargan automáticamente en las sesiones.
Esto significa que cualquier contenido innecesario se convierte en un coste recurrente.
Nuestra recomendación es clara: mantener estos archivos lo más concisos posible.
Algunas buenas prácticas que seguimos:
- Evitar explicaciones largas o redundantes
- Incluir solo reglas realmente útiles
- Revisar periódicamente su contenido
- Eliminar información obsoleta
Es especialmente importante en el caso de MEMORY.md, ya que parte de su contenido se carga automáticamente en cada sesión.
Aprovechar el prompt caching y la compresión automática
Claude Code ya incluye optimizaciones internas que conviene entender.
Por un lado, el prompt caching permite reutilizar partes del contexto, reduciendo el coste en contenidos repetidos.
Por otro, el sistema aplica compresión automática (auto-compaction) cuando la conversación crece demasiado. Esto sustituye partes del historial por resúmenes.
Aunque estas funciones ayudan, no son suficientes por sí solas. Nosotros comprobamos que confiar únicamente en la automatización no evita que el contexto crezca demasiado.
Por eso, lo ideal es combinarlas con gestión manual.
Medir antes de enviar
Una práctica más avanzada, pero muy útil, es estimar el uso de tokens antes de hacer una llamada.
La API de Claude permite calcular los tokens de un mensaje antes de enviarlo. Esto es especialmente útil cuando trabajamos con prompts grandes o sistemas complejos.
En nuestro flujo de trabajo, esto nos permite:
- Ajustar prompts antes de ejecutarlos
- Decidir qué modelo usar
- Evitar errores por límites de contexto
- Controlar costes de forma más precisa
No siempre es necesario, pero en sistemas de producción marca una gran diferencia.
Reducir salidas innecesarias
Otro punto que muchas veces se pasa por alto es el tamaño de las respuestas generadas por herramientas.
Cuando un comando devuelve un output grande, todo ese contenido se añade al contexto. Esto puede multiplicar el consumo sin que nos demos cuenta.
Aquí lo mejor es:
- Limitar logs extensos
- Filtrar resultados antes de enviarlos
- Evitar outputs redundantes
- Trabajar con versiones resumidas
En nuestras pruebas, este simple ajuste redujo significativamente el consumo en tareas de debugging.
Separar tareas en sesiones independientes
Una de las estrategias más efectivas que hemos probado es dividir el trabajo en sesiones más pequeñas.
En lugar de hacer todo dentro de una única conversación larga, es mejor separar tareas:
- Una sesión para análisis
- Otra para implementación
- Otra para debugging
Esto evita que el contexto crezca sin control y mejora también la calidad de las respuestas.
Además, Claude responde mejor cuando el contexto está enfocado en una única tarea.
Nuestra conclusión tras probarlo
Después de trabajar bastante con Claude Code, hay una idea que se repite constantemente: el problema no es el prompt, es el contexto.
Reducir el consumo de tokens no consiste en escribir menos, sino en gestionar mejor todo lo que el modelo ve en cada interacción. Desde limpiar sesiones hasta elegir herramientas, cada decisión suma.
Si tuviéramos que resumirlo en algo práctico, diríamos esto: controla el contexto, usa el modelo adecuado, simplifica herramientas y evita arrastrar información innecesaria.
Aplicando estos principios, no solo reduces costes, sino que consigues agentes más rápidos, precisos y manejables. Y eso, en proyectos reales, se nota mucho más que cualquier optimización puntual.
