Infra15 min de lectura
Cómo ahorrar tokens en Claude Code con rtk y graphify
Cómo gasto menos tokens en Claude Code con rtk, que resume la salida de la terminal, y graphify, que responde desde el grafo del código. Con mis números reales.

Todo agente de IA que trabaja en la terminal tiene el mismo problema: todo lo que devuelve la terminal termina en el contexto del modelo. Tests corriendo, logs leídos, archivos buscados: cada salida ocupa espacio y cuesta tokens.
Una suite de tests devuelve una línea de PASS por archivo, avisos del framework y logs que nadie va a leer. Un git log trae el hash completo, el correo y la fecha de cada commit. Una pregunta como "¿dónde se usa esto?" se convierte en diez archivos abiertos, uno detrás de otro.
Hace unos meses instalé dos herramientas para cortar ese desperdicio: rtk, que resume la salida de los comandos antes de que llegue al modelo, y graphify, que convierte el código en un grafo para preguntarle al grafo antes de abrir archivos. Las dos están de moda: el 16/11/2026, rtk pasaba de 86 mil estrellas en GitHub y graphify rondaba las 149 mil, en un repositorio creado en abril.
Este post es cómo uso las dos, con los números reales de mi máquina, y dónde no ayudan.
TL;DR#
- rtk es un binario en Rust que entra como hook en Claude Code: antes de cada comando en la terminal, cambia
git logporrtk git logy le entrega al modelo solo lo que importa. - En mi máquina, desde agosto: 148 mil comandos y 228,1 millones de tokens ahorrados, según
rtk gain. Pero cuando medí a mano, descubrí que el número de los tests está inflado. - graphify lee el código con tree-sitter, sin LLM y sin enviar nada fuera, y arma un grafo de funciones, imports y llamadas. Así,
graphify explain "articlesPath()"responde en 15 líneas lo que llevaría diez archivos abiertos. - Las dos tienen límites: el hook de rtk solo atrapa comandos de terminal (las herramientas nativas Read y Grep pasan directo), un filtro puede fallar y el grafo deja pasar referencias.
- Mide antes de creer. En una suite de tests real,
rtk gainregistró un 99,6% de ahorro. Comparado con jest a secas, fue un 73%.
A dónde van los tokens#
Todo lo que devuelve una herramienta entra en el contexto de la conversación: la salida de un comando, el contenido de un archivo, el resultado de una búsqueda. Y se queda ahí, reenviándose en cada turno, hasta que la conversación termina o se resume.
En la práctica, veo dos tipos de desperdicio:
- Salida de comandos llena de ruido. Tests que pasaron, barras de progreso, hashes de 40 caracteres, avisos repetidos. El modelo necesita el fallo, no cien líneas de
PASS. - Abrir archivos para descubrir dónde está algo. Para responder "¿quién llama a esta función?", el agente hace un
grepy luego abre archivo por archivo para entender cada uso.
rtk ataca lo primero. graphify ataca lo segundo.
rtk: la terminal resumida#
rtk (Rust Token Killer) es un único binario en Rust, con licencia Apache-2.0. Tiene filtros para más de 100 comandos: git, gh, npm, jest, vitest, tsc, eslint, pytest, cargo, docker, ls, grep y muchos más. Cada filtro sabe qué importa en esa salida. En los tests, solo los fallos con su aserción. En git log, una línea por commit. En grep, los resultados agrupados por archivo.
Cómo entra en Claude Code#
Se instala con brew install rtk y después rtk init -g, que registra un hook en ~/.claude/settings.json. El mío quedó así:
{
"hooks": {
"PreToolUse": [
{
"matcher": "Bash",
"hooks": [{ "type": "command", "command": "rtk hook claude" }]
}
]
}
}Un hook PreToolUse se ejecuta antes de cada herramienta. Este solo mira Bash: Claude Code avisa que va a correr un comando, rtk devuelve el comando reescrito y es esa versión la que se ejecuta. Puedes ver el cambio con rtk rewrite. Estas son salidas reales:
| El agente pide | Lo que se ejecuta |
|---|---|
git log -10 | rtk git log -10 |
npx jest | rtk jest |
cat src/root.tsx | rtk read src/root.tsx |
cd src && git status | cd src && rtk git status |
git log | head -5 | rtk git log | head -5 |
python3 build.py | (nada: sin filtro, corre igual) |
Los comandos compuestos también funcionan: reescribe cada parte que conoce. Y lo que no conoce pasa directo.
Antes y después: un git log de verdad#
Corrí git log -10 en el repositorio de este blog, sin y con rtk. Sin él, cada commit llega así:
commit 0785527405c98135c27f735d944f7a560279cb31
Author: Yasmin Lopes <...>
Date: Mon Nov 16 19:12:27 2026 -0300
feat(artigos): publica o post do rscoveryCon rtk, cada commit se vuelve una línea, con hash corto, fecha relativa y autor. El mensaje largo de un commit aparece recortado, con un aviso de cuántas líneas desaparecieron:
0785527 feat(artigos): publica o post do rscovery (4 minutes ago) <Yasmin Lopes>
87c3543 feat(artigos): botao de copiar nos blocos de codigo (5 minutes ago) <Yasmin Lopes>
5abcd1b feat(artigos): rascunho do post arquivo apagado nao some (rscovery) (10 minutes ago) <Yasmin Lopes>
Post sobre por que da pra recuperar arquivo apagado de HD, SSD e pendrive,
como o rscovery acha esses dados por assinatura e como apagar de verdade
antes de vender. Quatro ilustracoes, animacao da varredura, capa #20 e
[+1 lines omitted]Fueron 2.244 caracteres sin y 1.243 con: un 45% menos. En un git log es poco. La gran diferencia aparece en los tests.
Antes y después: la suite de tests de la app#
Aquí esperaba el número bonito. Corrí los 103 archivos de test del módulo más grande del backend de un proyecto mío, sin y con rtk:
| Caracteres | Tokens (estimados) | |
|---|---|---|
npx jest src/modules/game, sin rtk | 8.603 | 2,1 mil |
| el mismo comando, con rtk | 2.288 | 570 |
Alrededor de un 73% menos. Bien, pero lejos del 94,5% que rtk gain muestra para jest. Y cuando miré el historial de rtk (guarda todo en un SQLite en tu máquina), esa misma ejecución estaba registrada así:
original_cmd rtk_cmd input_tokens output_tokens savings_pct
jest run rtk jest run 142508 539 99.6142 mil tokens de entrada, frente a los 2,1 mil que devolvió jest a secas. La diferencia es que rtk no corre jest de la forma normal: pide el informe en JSON, que es mucho más grande (en este caso, 558.065 caracteres), filtra ese JSON y mide el ahorro contra él. O sea, la base de la cuenta es una salida que nunca verías sin rtk.
Y esta vez ni siquiera funcionó el filtro. Lo que llegó al modelo fue esto, seguido del comienzo del JSON recortado a 2.000 caracteres:
[RTK:PASSTHROUGH] jest parser: All parsing tiers failed
[RTK:PASSTHROUGH] Output truncated (558065 chars → 2000 chars)
[full output: ~/Library/Application Support/rtk/tee/1794868468_jest_run.log]El resumen viene al comienzo del JSON (todo pasó, 1.419 tests), así que el modelo supo el resultado. Pero si un test hubiera fallado en medio de los 103 archivos, el motivo podía quedar después del corte, y el agente tendría que abrir el log completo.
Un dato más: la suite entera de la app, con 3.088 tests que pasan, devuelve solo 1.926 caracteres con jest a secas. Cuando todo pasa, jest ya es corto. rtk marca la diferencia de verdad cuando la salida tiene ruido: console.log en medio del test, avisos del framework, un fallo con stack trace.
Mis números#
Con eso en mente, mira mi rtk gain del 16/11/2026:
RTK Token Savings (Global Scope)
════════════════════════════════════════════════════════════
Total commands: 148053
Input tokens: 405.1M
Output tokens: 177.1M
Tokens saved: 228.1M (56.3%)
Total exec time: 4661m25s (avg 1.9s)
Efficiency meter: ██████████████░░░░░░░░░░ 56.3%"Input" es el tamaño de la salida original de los comandos. "Output" es lo que leyó el modelo después del filtro. En tres meses y medio, mis agentes corrieron 148 mil comandos en la terminal y, según su propia cuenta, rtk dejó de enviar 228,1 millones de tokens al contexto.
Ahora, lo que dice por comando:
- jest es el 61% del total, pero es la barra menos confiable. Son 139,9 millones de tokens en 2.422 ejecuciones, contados contra el JSON, como mostré arriba. El ahorro real es menor, y no tengo cómo recalcular el historial.
- La búsqueda ahorra poco cada vez, pero corre mucho.
grepcorrió 45 mil veces con un promedio del 24,9%. - Leer archivos casi no cambia nada.
catse convirtió enrtk read24 mil veces, con un promedio del 4,7%. Tiene sentido: en un archivo de código, casi todas las líneas importan. - Varía mucho según el trabajo del mes. En septiembre, un mes con muchos tests, el ahorro registrado fue del 83,7%. En octubre, del 29,7%.
Una advertencia que hace el propio README: rtk estima los tokens como bytes divididos entre 4, y reduce la salida de los comandos, que es solo una parte de lo que envías al modelo. Recortar el 90% de la salida no es recortar el 90% de la factura.
graphify: preguntarle al grafo antes de abrir un archivo#
graphify lee una carpeta y arma un grafo de conocimiento: cada función, tipo, archivo e import se vuelve un nodo, y cada llamada o import se vuelve una arista. Con el grafo listo, el agente le pregunta a él en vez de ponerse a abrir archivos.
Lo que me gusta de él:
- El código se lee localmente con tree-sitter, sin LLM y sin enviar nada fuera. Documentos, PDFs e imágenes necesitan un modelo para extraer el sentido, pero el código no.
- Cada arista dice de dónde vino:
EXTRACTEDcuando está escrito en el código,INFERREDcuando graphify lo dedujo,AMBIGUOUScuando no está seguro. - No es búsqueda por embeddings. Es un grafo de verdad, que se puede recorrer: vecinos de un nodo, camino entre dos nodos, comunidades de archivos que se hablan entre sí.
Armando el grafo de este blog#
Lo instalé con pipx install graphifyy (sí, con dos "y") y lo corrí en el repositorio de este blog:
$ graphify update .
Re-extracting code files in . (no LLM needed)...
AST extraction: 170/170 files (100%) [10 workers]
[graphify watch] Rebuilt: 1049 nodes, 1410 edges, 83 communities
[graphify watch] graph.json, graph.html and GRAPH_REPORT.md updated in graphify-outTardó 1,5 segundos. En la carpeta graphify-out/ quedan el graph.json (el grafo entero), un graph.html para navegar con clics y el GRAPH_REPORT.md, un resumen con los nodos más conectados:
## God Nodes (most connected - your core abstractions)
1. `cn()` - 31 edges
2. `useI18n()` - 23 edges
3. `compilerOptions` - 20 edges
4. `compilerOptions` - 18 edges
5. `articlesPath()` - 15 edges
6. `ArticleMeta` - 14 edges
7. `absoluteUrl()` - 12 edgesCoincide con lo que sé del proyecto: cn() junta clases de Tailwind en cada componente, useI18n() traduce el sitio a los cuatro idiomas y articlesPath() arma la dirección de la lista de artículos en cada idioma.
Un ejemplo real: ¿quién usa articlesPath()?#
Es la pregunta típica antes de tocar una función. Sin el grafo, el camino del agente es un grep (23 líneas en 10 archivos) y después abrir esos archivos para entender cada uso: 30.622 caracteres, unos 7,6 mil tokens.
Con el grafo:
$ graphify explain "articlesPath()"
Node: articlesPath()
ID: articles_paths_articlespath
Source: src/features/articles/paths.ts L18
Type: code
Community: 0
Degree: 15
Connections (15):
<-- paths.ts [contains] [EXTRACTED]
<-- static-build.ts [imports] [EXTRACTED]
<-- article-page.tsx [imports] [EXTRACTED]
<-- site-pages.ts [imports] [EXTRACTED]
<-- article-seo.ts [imports] [EXTRACTED]
<-- articles-page.tsx [imports] [EXTRACTED]
<-- articlesListMeta() [calls] [EXTRACTED]
<-- articleMeta() [calls] [EXTRACTED]
<-- renderRss() [calls] [EXTRACTED]
<-- ArticlesPage() [calls] [EXTRACTED]
<-- trail-filter.tsx [imports] [EXTRACTED]
<-- ArticlePage() [calls] [EXTRACTED]
<-- TrailFilter() [calls] [EXTRACTED]
<-- routes.ts [imports] [EXTRACTED]
<-- navHref() [calls] [INFERRED]Son 798 caracteres, unos 200 tokens. Y ya dice más que el grep: qué funciones la llaman (el RSS, el SEO, la página), no solo qué archivos mencionan el nombre. Después el agente abre solo el archivo que le interesa.
La regla que le dejé a Claude#
graphify tiene un graphify claude install, que instala un hook para empujar al asistente hacia el grafo. Yo preferí escribir la regla en mi ~/.claude/CLAUDE.md, que vale para todos los proyectos. El original está en portugués; aquí va traducida al inglés:
# Token saving (default in EVERY session, EVERY project)
2. **graphify (graph-first)**: before opening a file to answer "where/how/what connects",
use the graph. At the start of every task on a codebase, silently:
- `which graphify`: if installed AND `graphify-out/graph.json` exists in the project,
navigate the graph (`GRAPH_REPORT.md`, `graphify query/path/explain`) BEFORE Read.
- Installed but no graph, in a code project I'll change: run
`graphify update .` once (AST-only, cheap) and then use the graph.
- Not installed: carry on with Grep/Read silently (don't warn, don't block).
- Never read more than 3 source files per question; if you need to, the question is
too broad, ask me to narrow it. Trust EXTRACTED/INFERRED edges; only verify AMBIGUOUS.Y un comando /econ que vuelve a activar las dos cosas en una sesión que empezó sin ellas.
El grafo también se equivoca#
Cuando comparé la respuesta de arriba con el grep, encontré tres cosas que necesitas saber:
- Se le escapó un archivo.
src/routes/articles.tsxllama aarticlesPath()dentro de un objeto (handle.alternates), y esa llamada no se volvió arista. El grafo encontró 9 de los 10 archivos. Para renombrar una función, sigo confirmando congrep. INFERREDa veces es solo un nombre parecido. En la sección de "conexiones sorprendentes" del informe, enlazó undescribe()del plugin de imágenes con unresolve()del servidor de preview. No tienen nada que ver: es una deducción por el nombre. Mi regla confía enINFERRED, y este caso me hizo repensarlo.- Las preguntas en lenguaje natural funcionan mal con el código.
graphify queryhace una búsqueda por palabras y recorre el grafo desde ellas. Pregunté cómo se elige la portada de cada idioma y empezó por los títulos de un artículo en inglés (el grafo también indexa los.mdx). Con el nombre del símbolo, como"ArticleMeta cover", acierta.
Y el grafo envejece: el informe dice de qué commit salió. ¿Cambiaste el código? Vuelve a correr graphify update ..
Límites y cuándo no usarlas#
El hook de rtk solo atrapa la terminal. Las herramientas nativas de Claude Code, como Read, Grep y Glob, no pasan por Bash, así que llegan enteras. El README de rtk dice que también se pueden comprimir con un pipeline, que yo no uso. Por eso mi regla pide: para salidas grandes (diff, logs de tests, build), prefiere correrlas por la terminal.
Un filtro puede romper el comando. Me pasó mientras escribía este post. En una app mía, npx jest se volvió rtk jest, y rtk decidió correr jest con pnpm, porque el proyecto tiene un pnpm-lock.yaml olvidado al lado del package-lock.json. El pnpm de corepack estaba roto en mi máquina. Resultado: los tests ni siquiera corrieron, el comando salió con error y el modelo recibió solo esto:
[RTK:PASSTHROUGH] jest parser: All parsing tiers failed
[full output: ~/Library/Application Support/rtk/tee/1794867612_jest_run.log]Sin rtk, los mismos tests pasaban. Y rtk gain igual registró esa ejecución como un 90% de ahorro. Un agente que lee "falló" sin ver el motivo puede ponerse a arreglar lo que no está roto. La pista estaba en el log completo, que rtk guarda y señala.
Cuando necesites la salida entera, pídela. Si el filtro recortó demasiado un error, corre el comando sin filtro: en la versión 0.43 que uso es rtk proxy git log, y en el README actual se llama rtk bypass. Sigue contando en rtk gain.
No uses el grafo para un proyecto pequeño o una pregunta sobre un solo archivo. Si ya sabes qué archivo abrir, ábrelo. El propio informe mide el proyecto primero y avisa cuando el grafo no compensa.
Cuidado con lo que sale de tu máquina.
- rtk tiene telemetría opcional. Revísala con
rtk telemetry status(la mía está apagada). - graphify no tiene telemetría, pero guarda cada pregunta en
~/.cache/graphify-queries.log. Y si le pides que lea documentos, PDFs o imágenes, ese contenido va al modelo que configures. - La carpeta
graphify-out/tiene el mapa de tu código. Yo la dejo fuera de git.
Comprueba que sea el rtk correcto. Hay otro proyecto llamado rtk en crates.io. Si rtk gain no muestra el panel de ahorro, instalaste el otro.
Cómo armar el tuyo#
brew install rtkrtk init -gpipx install graphifyygraphify update .Reinicia Claude Code después del rtk init -g. Pasados unos días, corre rtk gain para ver qué cambió de verdad en tu caso.
Lo que aprendí#
El contador mide contra su propia base. rtk gain dijo 99,6% en una suite donde la ganancia real, comparada con jest a secas, fue del 73%. Sigue siendo bueno. Pero si me guiara por el panel, pensaría que ahorro mucho más de lo que ahorro. Para saberlo de verdad, corre el mismo comando con rtk proxy y compara.
El ahorro aparece donde hay ruido. Tests con logs, lint con cientos de avisos, ps aux, git log. Los tests que pasan sin logs ya son cortos, y leer archivos casi no cambia nada.
Cada capa nueva es un lugar nuevo donde romperse. El hook es invisible a propósito, y justo por eso, cuando se equivoca, tardas en darte cuenta. Hoy, cuando un test falla de forma rara, lo primero que miro es si el comando de verdad se ejecutó.
Un grafo es un mapa, no la verdad. Responde rápido y barato el "¿quién usa esto?", y acierta casi siempre. Para cambios que no pueden dejar nada atrás, como renombrar, confirmo en el texto del código.
Referencias#
Sigue leyendo

Infra13 min de lectura
Cómo borrar un disco duro o SSD antes de venderlo

Back-end19 min de lectura
Qué es RAG: indexación, búsqueda híbrida y un caso real

Front-end17 min de lectura
SEO multilingüe en React: hreflang, prerender y sitemap