Todos los artículos

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.

También en Português, English, Français

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 log por rtk git log y 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 gain registró 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:

  1. 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.
  2. Abrir archivos para descubrir dónde está algo. Para responder "¿quién llama a esta función?", el agente hace un grep y luego abre archivo por archivo para entender cada uso.

rtk ataca lo primero. graphify ataca lo segundo.

El mismo git log -10, sin y con rtk. El hook cambia el comando antes de que se ejecute

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í:

~/.claude/settings.json
{
  "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 pideLo que se ejecuta
git log -10rtk git log -10
npx jestrtk jest
cat src/root.tsxrtk read src/root.tsx
cd src && git statuscd src && rtk git status
git log | head -5rtk 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 rscovery

Con 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:

CaracteresTokens (estimados)
npx jest src/modules/game, sin rtk8.6032,1 mil
el mismo comando, con rtk2.288570

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.6

142 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:

Lo que rtk gain registró hasta el 16/11/2026. La barra de jest se mide contra el JSON que pide el propio rtk
  • 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. grep corrió 45 mil veces con un promedio del 24,9%.
  • Leer archivos casi no cambia nada. cat se convirtió en rtk read 24 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: EXTRACTED cuando está escrito en el código, INFERRED cuando graphify lo dedujo, AMBIGUOUS cuando 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-out

Tardó 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 edges

Coincide 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 misma pregunta, respondida abriendo archivos o consultando el grafo

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:

~/.claude/CLAUDE.md
# 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.tsx llama a articlesPath() 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 con grep.
  • INFERRED a veces es solo un nombre parecido. En la sección de "conexiones sorprendentes" del informe, enlazó un describe() del plugin de imágenes con un resolve() del servidor de preview. No tienen nada que ver: es una deducción por el nombre. Mi regla confía en INFERRED, y este caso me hizo repensarlo.
  • Las preguntas en lenguaje natural funcionan mal con el código. graphify query hace 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.

El hook solo ve lo que pasa por Bash

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 rtk
rtk init -g
pipx install graphifyy
graphify 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#

  • Infra
  • claude-code
  • ia
  • tokens
  • rtk
  • graphify
  • rust

Escrito por

Ingeniera de software y diseñadora. Escribo sobre lo que encuentro construyendo apps, APIs y productos.