Cuánto cuesta programar con agentes de IA: medí 7 970 millones de tokens en 35 días

Un agente de código consume, por cada respuesta que te da, unas 44 veces más tokens que un mensaje de chatbot. Lo medí en mi propia máquina: entre el 23 de junio y el 28 de julio de 2026 acumulé 311 sesiones de Claude Code y 7 969 840 885 tokens facturables. A precios oficiales de la API, ese mes habría costado 6 146 USD. Sin caché de prompt, 39 781 USD. Pagando suscripción, 200 USD.

Esos tres números son el artículo entero. Aquí te explico de dónde salen, por qué la diferencia es tan brutal y cómo estimar tu propio caso antes de contratar nada.

Si lo que buscas es cuánto cuesta llamar a la API de un modelo para un chatbot o una integración, eso ya lo desglosé en la guía de precios de OpenAI, Claude y Gemini. Este artículo es sobre lo otro: los agentes que programan por ti, que se facturan igual pero se comportan de forma completamente distinta.

Por qué un agente no se factura como un chatbot

En un chatbot la cuenta es sencilla: mandas un prompt, recibes una respuesta, pagas ambos. Un agente de código —Claude Code, Codex, Cursor en modo agente, Cline— hace algo muy distinto: trabaja en bucle.

Le pides “arregla este bug” y el agente lee archivos, ejecuta comandos, mira la salida, corrige, vuelve a ejecutar, lee los tests. Cada uno de esos pasos es una llamada nueva al modelo, y cada llamada arrastra todo lo anterior: las instrucciones del sistema, la definición de sus herramientas, tu CLAUDE.md, los archivos que ya leyó y la salida de cada comando que ya ejecutó.

Dicho de otro modo: el contexto no se envía una vez, se reenvía en cada turno. Una tarea de veinte pasos no cuesta veinte veces un prompt; cuesta la suma de un contexto que va creciendo. Por eso las cifras se disparan tan rápido.

En mis datos eso se ve con toda claridad. En el mismo mes tenía corriendo dos cargas de trabajo distintas contra modelos de IA:

44 veces más tokens por llamada. 882 veces más en volumen total del mes. La segunda carga es un agente de copywriting que genera textos cortos: entra un brief, sale un párrafo. La primera lee repositorios enteros. Es la misma tecnología y la misma tarifa por token, pero no tienen nada que ver a la hora de presupuestar.

Los datos: 35 días de uso real

Estos son los números crudos, extraídos de los registros locales de sesión (solo contadores de tokens; ni una línea de código ni de conversación):

Una aclaración importante antes de seguir: yo no pagué 6 146 USD. Ese uso corrió sobre una suscripción de tarifa plana, donde los tokens se cuentan pero no se cobran. Los 6 146 USD son lo que habría costado el mismo trabajo facturado por token, calculado con los precios públicos de la API a julio de 2026. Esa distinción es justamente el tema de la sección de más abajo.

El reparto que casi nadie espera

Cuando enseño esta gráfica, la reacción siempre es la misma: ¿solo el 0,36 % es salida? Sí. Todo el código que escribió el modelo en 35 días —cada diff, cada explicación, cada script— cabe en 28,7 millones de tokens. El otro 99,6 % es contexto entrando.

Y dentro de ese contexto, casi todo es relectura de caché: 7 771 millones de tokens que el modelo ya había visto y que se le vuelven a presentar en el turno siguiente. Es exactamente el bucle del que hablábamos, medido.

Esto tiene una consecuencia práctica que te va a servir aunque nunca toques un agente: en trabajo agéntico, optimizar la salida no sirve de nada. Pedirle al modelo que sea más breve te ahorra un porcentaje de un 0,36 %. Lo que mueve la aguja es el contexto.

Y el reparto por modelo

Fíjate en las dos filas que se salen de la diagonal. Fable 5 consumió el 4,1 % de los tokens pero se llevó el 8,7 % del coste, porque cuesta el doble por token que Opus. Y Sonnet 5 hizo el 9,1 % del trabajo por el 3,5 % del gasto. Ahí está, en una tabla, el argumento de elegir modelo por tarea: mismo volumen, factura muy distinta.

El caché: el 97 % de tus tokens y el 84 % de tu ahorro

El caché de prompt es lo que hace que los agentes sean económicamente viables. La idea es simple: si el proveedor ya procesó ese bloque de contexto hace un momento, no te lo cobra a precio de entrada, te lo cobra al 10 %.

Según la página oficial de precios de Anthropic a julio de 2026, para Opus 5:

• Entrada normal: 5 USD por millón de tokens
• Escritura de caché: 6,25 USD por millón (1,25×, o 2× si pides que dure una hora)
• Lectura de caché: 0,50 USD por millón
• Salida: 25 USD por millón

Como el 97,52 % de mi volumen fueron lecturas de caché, la tarifa media que me salió al mezclar todos los modelos fue de 0,77 USD por millón de tokens. Sin caché habría sido de 4,99 USD. Traducido a dinero:

84,5 % de ahorro. Un factor de 6,5×. Y no es algo que tengas que activar: los agentes serios ya lo hacen solos. Pero sí es algo que puedes romper sin darte cuenta, y esa es la parte accionable.

El caché se invalida cuando cambia el principio del contexto. Si tu herramienta inyecta la hora actual en el system prompt, o reordena la lista de archivos abiertos, o metes un servidor MCP nuevo a mitad de sesión, el prefijo deja de coincidir y vuelves a pagar todo a precio de entrada. En una sesión de 80 millones de tokens, romper el caché una vez cuesta más que toda la salida del mes.

Suscripción o API: dónde está el punto de cruce

Aquí está la decisión que de verdad importa, y se resuelve con una sola cuenta.

Las herramientas de agentes se pagan de dos formas. Tarifa plana: Claude Code va incluido en todos los planes de pago de Claude (Pro, 20 USD al mes; Max, desde 100 USD; Max 20×, 200 USD), y OpenAI Codex en Plus (20 USD) y Pro (200 USD). Cursor y Windsurf van de 20 a 200 USD según el cupo. Por token: conectas tu clave de API y pagas exactamente lo que consumes, sin límite de throughput.

La tarifa plana no te da tokens infinitos: te da un cupo por ventana de tiempo. En Claude son ventanas móviles de cinco horas más topes semanales, y ese cupo lo comparten el chat y el terminal. Cuando lo agotas no recibes un cargo, esperas al reinicio. Ese es todo el intercambio: cambias dinero impredecible por tiempo de espera predecible.

Con mi tarifa media de 0,77 USD por millón, el punto de equilibrio de un plan de 200 USD al mes está en unos 260 millones de tokens mensuales. Por encima de eso, la tarifa plana sale ganando. Yo consumí 7 970 millones: treinta veces por encima del punto de cruce.

Traducido a una regla que puedes aplicar hoy:

• Menos de ~30 millones de tokens al mes (uso ocasional, un par de sesiones por semana): la API por token sale más barata que cualquier suscripción, y no pagas los días que no programas.
• Entre 30 y 260 millones: un plan de entrada (20 USD) es lo más rentable, salvo que los topes te frenen.
• Por encima de 260 millones (uso diario intensivo, sesiones largas, subagentes): la tarifa plana alta es una ganga y no hay discusión.
• Si necesitas paralelismo real —cinco agentes a la vez, integración continua, procesos desatendidos—, la API es el único camino, porque el cupo de una suscripción se agota entre todos.

Una advertencia sobre el mercado, porque cambió hace poco: GitHub Copilot pasó a facturación por consumo el 1 de junio de 2026. Todos sus planes incluyen ahora una bolsa mensual de créditos (1 crédito = 0,01 USD) calculada sobre tokens de entrada, salida y caché; el autocompletado sigue ilimitado, pero el chat y las funciones de agente se descuentan de ahí. Si elegiste Copilot precisamente por tener una tarifa fija, conviene que rehagas la cuenta.

No todas las sesiones cuestan igual (ni de lejos)

Si te quedas con un solo gráfico de este artículo, que sea este:

La sesión mediana consumió 6,5 millones de tokens: unos 5 USD equivalentes. La del percentil 90 consumió 85,7 millones: 66 USD. Y la peor de las 311 llegó a 206 millones de tokens, casi 159 USD en una sola sesión.

Trece veces la mediana en el percentil 90, treinta y una veces en el máximo. El gasto de un agente no es una media, es una cola larga. Presupuestar multiplicando “coste medio por sesión × sesiones al mes” te va a dar un número que no se parece en nada a la realidad, porque un puñado de sesiones se come la mitad del presupuesto.

La consecuencia operativa es directa: no optimices el caso medio, corta la cola. Cerrar una sesión que se está atascando y volver a empezar con contexto limpio ahorra más que cualquier ajuste de prompt.

Qué dispara la factura de verdad

Después de mirar las sesiones caras una por una, estos son los patrones que se repiten:

1. Sesiones eternas. Es el factor número uno, con diferencia. Cada turno de una sesión larga arrastra todo lo acumulado. Una sesión de tres horas no cuesta el triple que una de una hora: cuesta mucho más, porque el contexto crece en cada paso. Abre una sesión por tarea y ciérrala al terminar.
2. Subagentes en paralelo. Lanzar cinco agentes a revisar cinco cosas multiplica el gasto por cinco, cada uno con su propio contexto completo. Es dinero muy bien gastado cuando el trabajo lo justifica y una sangría cuando no.
3. Servidores MCP de más. Cada herramienta conectada añade su esquema al contexto de cada llamada. Diez servidores MCP que casi no usas son un impuesto fijo sobre todos los turnos de todas tus sesiones. Desconecta los que no toques.
4. El modelo caro para tareas tontas. Renombrar variables, formatear, escribir un commit: eso lo hace un modelo pequeño por una fracción del precio. En mis datos, Haiku resolvió 533 respuestas por 4,47 USD equivalentes.
5. Reintentos silenciosos. Cuando un comando falla y el agente lo vuelve a intentar, pagas el intento fallido, la salida del error y el intento nuevo. Un test que falla en bucle es una fuga de tokens.
6. Leer archivos enormes enteros. Un .json de 20 000 líneas o un log completo entran al contexto y se quedan ahí, cobrándose en cada turno restante de la sesión.
7. Romper el caché sin querer. Ya lo vimos: cualquier cambio en el prefijo del contexto invalida la caché entera y multiplica el coste del turno por diez.

Cómo estimar tu caso antes de pagar

No hace falta que midas 35 días como yo. En veinte minutos puedes tener un número decente:

1. Mide tu contexto base. Junta lo que va en todas tus llamadas: el CLAUDE.md (o .cursorrules, o el archivo equivalente), los esquemas de tus servidores MCP y las instrucciones de sistema que puedas ver. Pégalo en un contador de tokens. Ese número es tu piso por turno.

2. Multiplica por la forma de la tarea. Una tarea sencilla son 10-15 turnos; un refactor serio pasa de 60. Como el contexto crece, una regla conservadora es: tokens ≈ contexto_base × turnos × 1,8.

3. Aplica la tarifa mezclada. Si tu herramienta cachea (todas las serias lo hacen), usa entre 0,5 y 1 USD por millón de tokens para un modelo tope de gama. Si no cachea, usa el precio de entrada completo.

4. Multiplica por tus sesiones reales al mes y añade un 40 % para la cola larga.

5. Compara con las suscripciones. Si el resultado supera los 200 USD, la tarifa plana casi seguro te conviene.

Para los pasos 1 y 3 uso mi propia herramienta, que cuenta tokens en el navegador —tu texto no sale de tu equipo— y compara el coste en todos los modelos a la vez:

Errores comunes al presupuestar agentes

• Estimar en palabras. El código tokeniza fatal: la puntuación, la indentación y los identificadores raros disparan el ratio. Un archivo de 300 líneas puede pasar de 4 000 tokens. Mídelo, no lo calcules a ojo.
• Contar solo lo que escribes tú. En mis datos, la entrada fresca fue el 0,03 % del total. Lo que tú tecleas es estadísticamente irrelevante frente a lo que el agente lee.
• Suponer que el precio por token es el precio real. Entre la lectura de caché (10 %), la escritura (125-200 %) y la salida (500 %), el coste efectivo de un token varía cincuenta veces según de qué tipo sea.
• Extrapolar desde una prueba pequeña. La demo bonita de “arréglame esta función” consume 400 000 tokens. El trabajo real son sesiones de 30 millones.
• Olvidar los días que no programas. La suscripción se paga los 30 días del mes; yo tuve 34 días activos de 35, pero si trabajas tres días por semana el cálculo cambia por completo.
• Ignorar el coste de los reintentos. Si tu suite de tests tarda y falla a menudo, el agente pagará por leer esos fallos una y otra vez.

Conclusión

Programar con agentes de IA no es caro ni barato en abstracto: es una función del contexto que reenvías, y eso lo controlas tú.

Los tres números con los que me quedo después de medir 35 días son estos. El 97,5 % de lo que consume un agente es contexto releído, no código escrito. El caché convierte esos 39 781 USD en 6 146, y una suscripción los convierte en 200. Y el 10 % de las sesiones más pesadas decide tu factura mucho más que cualquier ajuste de prompt.

Antes de contratar un plan o conectar una clave de API, haz la cuenta con tus propios números: mide tu contexto base con la calculadora de tokens y costos de IA, multiplícalo por tus turnos y tus sesiones reales, y compáralo con las suscripciones. Veinte minutos ahí te dicen si tu caso está por encima o por debajo del punto de cruce, que es la única pregunta que hay que responder.

Si quieres profundizar en cómo funcionan estos agentes por dentro y qué papel juega el protocolo MCP, lo cuento en la guía de IA agéntica en 2026. Y si te preocupa la otra factura —la de arreglar lo que el agente rompe—, tengo una guía de vibe coding seguro.

¿Estás metiendo agentes de IA en tu equipo o en tu producto y quieres que la cuenta salga? Puedo ayudarte con la automatización e integración de IA en tu negocio. Cuéntame qué estás construyendo.

---

Metodología: los datos provienen de los registros locales de sesión de Claude Code en mi equipo (23 de junio a 28 de julio de 2026), de los que solo se extrajeron contadores de tokens agregados por modelo y por sesión. Los mensajes repetidos se deduplicaron por identificador. El coste equivalente se calculó con los precios públicos de la API de Anthropic a julio de 2026, aplicando 0,1× a las lecturas de caché, 1,25× a las escrituras de cinco minutos y 2× a las de una hora, y el precio introductorio de Sonnet 5 vigente en ese periodo. Los precios de las APIs y de los planes cambian con frecuencia: verifica siempre en la página oficial del proveedor antes de decidir.