En el último mes, los agentes de código que estoy construyendo procesaron 13 mil millones de tokens entre entrada y salida, con una tasa de acierto de caché del 97.24 % y un costo efectivo de aproximadamente R$ 0.04 por millón de tokens.
Cuando menciono estas cifras, la primera reacción suele ser desconfianza—y eso es saludable. El costo es la razón número uno por la que las empresas abandonan los agentes autónomos: el piloto funciona, llega la factura, el proyecto muere. Así que este artículo trata sobre cómo se logran estos números. No hay un truco único; hay una arquitectura donde cada token que entra y sale es comprimido, enrutado y medido.
Esto es Velua Code, el agente que estamos construyendo en una nueva startup que decidí iniciar, Velua AI (https://velua.aihttps://velua.ai/)). Antes de la arquitectura, la tesis.
La Tesis: Tres Problemas, Resueltos Juntos
Los agentes de código fallan en tres lugares, y resolver solo uno no es suficiente.
Costo. Un agente autónomo consume tokens a una escala que asusta a cualquier CFO. Si cada iteración es costosa, nadie deja que el agente itere—y un agente que no itera realmente no resuelve nada.
Contexto. La ventana de contexto es finita y costosa. La implementación típica llena el prompt con archivos completos y resultados de grep, pagando por miles de tokens irrelevantes en cada llamada.
Memoria. Cada sesión comienza desde cero. El agente redescubre el martes lo que ya había aprendido el lunes—y paga (en tokens y errores) por redescubrirlo.
Los tres se retroalimentan: el contexto inflado aumenta el costo, la falta de memoria infla el contexto. Por eso Velua Code ataca los tres a la vez.
Costo: Compresión en Origen + Enrutamiento Activo
La primera decisión arquitectónica: comprimir el contexto en origen, no al final. Cada salida de herramienta—lectura de archivos, resultados de búsqueda, registros de compilación—pasa por un pipeline de compresión antes de entrar al historial de la sesión. El núcleo es un modelo de compresión propietario que se ejecuta localmente en ONNX, en la máquina del desarrollador o en el contenedor del agente. No hay una llamada de red para comprimir: los ahorros no cuestan tokens.
A su alrededor, capas más simples hacen el trabajo pesado: deduplicación de lecturas (¿el agente volvió a leer el mismo archivo? la versión antigua sale del contexto), compresión JSON estructural, elisión del cuerpo del código manteniendo las firmas, y un umbral adaptativo que ajusta la compresión a medida que el contexto crece. Todo se mide con el tokenizador real del modelo objetivo—los ahorros se cuentan en tokens reales, no en estimaciones.
Y hay una decisión sobre lo que no hacer: nunca tocamos el prompt del sistema en tiempo de ejecución. Un prompt estable es lo que sustenta la tasa de acierto de caché del 97.24 %—y el acierto de caché es la palanca de costo más barata que existe, porque un token en caché cuesta una fracción de un token completo.
La segunda decisión: el agente no elige el modelo. Un clasificador local preclasifica cada tarea por categoría y complejidad, y Velua Gateway—que ve más de 50 modelos con precio y rendimiento en tiempo real—enruta al modelo más capaz dentro de lo necesario, además de aplicar barreras de seguridad y enriquecer con RAG. Renombrar una variable no necesita un modelo de frontera; diseñar una migración de esquema sí. Con el enrutamiento activo, la mayoría de las llamadas van a modelos más pequeños, y el costoso solo entra cuando la complejidad lo exige.
La puerta de enlace también mide el costo real de cada solicitud. Esto permite algo que considero innegociable para agentes en producción: el presupuesto como condición de parada. El bucle autónomo funciona con un límite de costo en moneda, no con esperanza.
Es la combinación—compresión en origen, alta tasa de caché, enrutamiento entre modelos más pequeños—la que produce los R$ 0.04 por millón. Ninguna de las tres piezas por sí sola se acerca.
Contexto: Un Grafo en Lugar de Grep
La forma estándar en que un agente "entiende" un código fuente es grep y lectura de archivos—costosa y ciega. Velua Code mantiene un grafo de conocimiento del código: funciones, clases, rutas y las relaciones entre ellas (quién llama a quién, quién implementa qué).
Esto cambia ambos extremos del bucle. En la entrada, el agente ensambla un paquete de contexto ligero consultando el grafo—la vista arquitectónica del proyecto y los nodos relevantes para la tarea—en lugar de volcar archivos en el prompt. En la salida, cambia la verificación: cuando el agente modifica una función, el grafo enumera exactamente los puntos de llamada impactados, y un agente revisor—con contexto limpio, sin el sesgo de quien escribió el código—verifica cada uno de ellos, además de ejecutar pruebas, linter y compilación. "Cambiaste la firma de processOrder; siete lugares la llaman" es un tipo de verificación que grep no proporciona.
Memoria: El Bucle Que Aprende
La pieza que cierra el sistema. Al final de cada iteración verificada, el agente registra decisiones de ingeniería: qué se decidió, por qué, qué alternativas se consideraron, qué falló. Y cada decisión está vinculada a los nodos de código que explica, dentro del propio grafo.
En la siguiente iteración, la fase de recolección de contexto recupera estas decisiones—incluyendo enfoques que ya han fallado, para no repetirlos. El bucle deja de ser un ejecutor que repite tareas y se convierte en un sistema que acumula conocimiento sobre el código fuente. También es el mejor amortizador de costos que existe: la memoria barata reemplaza al redescubrimiento costoso.
El bucle completo, entonces: recolectar contexto (grafo + memoria + RAG), planificar con el modelo adecuado para el tamaño del problema, actuar con subagentes, verificar con un revisor de contexto limpio y conciencia del grafo, aprender registrando decisiones—y repetir, con un límite de costo. Es el bucle canónico de agente, con cada fase genérica reemplazada por su propia capacidad.
Por Qué el Primer Cliente Somos Nosotros
La estrategia de producto es deliberadamente contraintuitiva: antes de vender a cualquier cliente, Velua Code se ejecuta internamente en SIGE Cloud. Dogfooding real—un ERP en producción, con equipos reales operando agentes en código real, todos los días.
Fue este uso interno el que generó los 13 mil millones de tokens, y es lo que está dando forma al producto. Los agentes autónomos en producción exponen problemas que ningún benchmark expone: permisos, costos acumulados, tareas que se estancan, contexto que se pudre. Prefiero que madure donde el dolor es nuestro.
Lo Que Viene: Memoria Unificada para Empresas
Hoy, la memoria de decisiones vive por proyecto. El próximo paso es lo que más me entusiasma: elevarla a una capa de memoria de ingeniería unificada para empresas.
Imagina la decisión registrada por el agente del equipo A—"migramos a X por Y; evitamos Z porque rompió W"—recuperable por el agente del equipo B, y por los desarrolladores humanos que operan estos agentes, con control de acceso, procedencia y auditoría. La pregunta "¿por qué este código es así?" respondida con la decisión original, vinculada al código, para cualquier persona o agente en la organización. Incorporación más rápida, consistencia entre equipos, y el conocimiento de ingeniería de la empresa que ya no vive solo en las cabezas de las personas.
Servida por la puerta de enlace, esta memoria se convierte en infraestructura: cualquier agente en la empresa, en cualquier herramienta, hereda el aprendizaje acumulado.
Los agentes autónomos serán una mercancía. El conocimiento que acumulan sobre
tu
sistema no lo será.
Esa es la apuesta.
Si estás construyendo con agentes en producción—o rompiéndote la cabeza con los costos de contexto—mi DM está abierto.
