Nell'ultimo mese, gli agenti di coding che sto costruendo hanno processato 13 miliardi di token tra input e output, con un tasso di cache hit del 97,24% e un costo effettivo di circa 0,04 R$ per milione di token.
Quando menziono questi numeri, la prima reazione è solitamente di sfiducia—ed è salutare. Il costo è la ragione numero uno per cui le aziende abbandonano gli agenti autonomi: il pilota funziona, arriva la fattura, il progetto muore. Quindi questo articolo spiega come si ottengono questi numeri. Non c'è un singolo trucco; c'è un'architettura in cui ogni token che entra ed esce viene compresso, instradato e misurato.
Questo è Velua Code, l'agente che stiamo costruendo in una nuova startup che ho deciso di avviare, Velua AI (https://velua.aihttps://velua.ai/)). Prima dell'architettura, la tesi.
La Tesi: Tre Problemi, Risolti Insieme
Gli agenti di coding si rompono in tre punti, e risolverne solo uno non è sufficiente.
Costo. Un agente autonomo consuma token a una scala che spaventa qualsiasi CFO. Se ogni iterazione è costosa, nessuno lascia iterare l'agente—e un agente che non itera non risolve davvero nulla.
Contesto. La finestra di contesto è finita e costosa. L'implementazione tipica riempie il prompt con interi file e risultati di grep, pagando per migliaia di token irrilevanti in ogni chiamata.
Memoria. Ogni sessione parte da zero. L'agente riscopre martedì ciò che aveva già imparato lunedì—e paga (in token ed errori) per riscoprirlo.
I tre si alimentano a vicenda: un contesto gonfiato aumenta il costo, la mancanza di memoria gonfia il contesto. Ecco perché Velua Code li attacca tutti e tre contemporaneamente.
Costo: Compressione alla Fonte + Routing Attivo
La prima decisione architetturale: comprimere il contesto alla fonte, non alla fine. Ogni output degli strumenti—lettura di file, risultati di ricerca, log di build—passa attraverso una pipeline di compressione prima di entrare nella cronologia della sessione. Il cuore è un modello di compressione proprietario eseguito localmente in ONNX, sulla macchina dello sviluppatore o nel contenitore dell'agente. Non c'è chiamata di rete per comprimere: i risparmi non costano token.
Intorno, strati più semplici fanno il lavoro pesante: deduplicazione delle letture (l'agente ha riletto lo stesso file? la vecchia versione esce dal contesto), compressione strutturale JSON, elisione del corpo del codice mantenendo le firme, e una soglia adattiva che stringe la compressione man mano che il contesto cresce. Tutto viene misurato con il tokenizer effettivo del modello target—i risparmi sono contati in token reali, non in stime.
E c'è una decisione su cosa non fare: non tocchiamo mai il system prompt a runtime. Un prompt stabile è ciò che sostiene il tasso di cache hit del 97,24%—e il cache hit è la leva di costo più economica che esista, perché un token in cache costa una frazione di un token completo.
La seconda decisione: l'agente non sceglie il modello. Un classificatore locale pre-classifica ogni attività per categoria e complessità, e il Velua Gateway—che vede 50+ modelli con prezzi e prestazioni in tempo reale—instrada verso il modello più capace entro ciò che è necessario, oltre ad applicare guardrail e arricchire con RAG. Rinominare una variabile non ha bisogno di un modello frontier; progettare una migrazione di schema sì. Con il routing attivo, la maggior parte delle chiamate va a modelli più piccoli, e quello costoso entra in gioco solo quando la complessità lo richiede.
Il gateway misura anche il costo reale di ogni richiesta. Questo permette qualcosa che considero non negoziabile per gli agenti in produzione: il budget come condizione di arresto. Il ciclo autonomo funziona con un limite di costo in valuta, non con la speranza.
È la combinazione—compressione alla fonte, cache alta, routing tra modelli più piccoli—che produce gli 0,04 R$ per milione. Nessuno dei tre pezzi da solo si avvicina.
Contesto: Un Grafo Invece di Grep
Il modo standard per un agente di "comprendere" un codebase è grep e lettura di file—costoso e cieco. Velua Code mantiene un grafo della conoscenza del codice: funzioni, classi, route e le relazioni tra di esse (chi chiama chi, chi implementa cosa).
Questo cambia entrambe le estremità del ciclo. In input, l'agente assembla un pacchetto di contesto snello consultando il grafo—la visione architetturale del progetto e i nodi rilevanti per l'attività—invece di scaricare file nel prompt. In output, cambia la verifica: quando l'agente modifica una funzione, il grafo elenca esattamente i punti di chiamata impattati, e un agente revisore—con contesto pulito, senza il bias di chi ha scritto il codice—controlla ciascuno di essi, oltre a eseguire test, lint e build. "Hai cambiato la firma di processOrder; sette posti la chiamano" è un tipo di verifica che grep non fornisce.
Memoria: Il Ciclo che Impara
Il pezzo che chiude il sistema. Alla fine di ogni iterazione verificata, l'agente registra decisioni ingegneristiche: cosa è stato deciso, perché, quali alternative sono state considerate, cosa ha fallito. E ogni decisione è collegata ai nodi di codice che spiega, all'interno del grafo stesso.
Nell'iterazione successiva, la fase di raccolta del contesto recupera queste decisioni—inclusi gli approcci che hanno già fallito, per non ripeterli. Il ciclo smette di essere un esecutore che ripete compiti e diventa un sistema che accumula conoscenza sul codebase. È anche il miglior ammortizzatore di costo che esista: la memoria a buon mercato sostituisce la riscoperta costosa.
Il ciclo completo, quindi: raccogli contesto (grafo + memoria + RAG), pianifica con il modello giusto per la dimensione del problema, agisci con sotto-agenti, verifica con un revisore a contesto pulito e consapevolezza del grafo, impara registrando le decisioni—e ripeti, con un limite di costo. È il ciclo canonico dell'agente, con ogni fase generica sostituita dalla propria capacità.
Perché il Primo Cliente Siamo Noi
La strategia di prodotto è volutamente controintuitiva: prima di vendere a qualsiasi cliente, Velua Code viene eseguito internamente presso SIGE Cloud. Reale dogfooding—un ERP in produzione, con team reali che operano agenti su codice reale, ogni giorno.
È stato questo uso interno a generare i 13 miliardi di token, ed è ciò che sta plasmando il prodotto. Gli agenti autonomi in produzione espongono problemi che nessun benchmark espone: permessi, costo accumulato, attività che si bloccano, contesto che si deteriora. Preferisco che maturi dove il dolore è nostro.
Cosa Succede Dopo: Memoria Unificata per le Aziende
Oggi, la memoria delle decisioni vive per progetto. Il passo successivo è ciò che mi entusiasma di più: elevarla a un livello di memoria ingegneristica unificata per le aziende.
Immagina la decisione registrata dall'agente del team A—"siamo migrati a X a causa di Y; abbiamo evitato Z perché rompeva W"—recuperabile dall'agente del team B, e dagli sviluppatori umani che operano questi agenti, con controllo degli accessi, provenienza e audit. La domanda "perché questo codice è così?" risolta con la decisione originale, collegata al codice, per chiunque o qualsiasi agente nell'organizzazione. Onboarding più veloce, coerenza tra i team e la conoscenza ingegneristica dell'azienda che non vive più solo nelle teste delle persone.
Servita dal gateway, questa memoria diventa infrastruttura: qualsiasi agente nell'azienda, in qualsiasi strumento, eredita l'apprendimento accumulato.
Gli agenti autonomi saranno una commodity. La conoscenza che accumulano sul
tuo
sistema non lo sarà.
Questa è la scommessa.
Se stai costruendo con agenti in produzione—o stai sbattendo la testa contro i costi del contesto—la mia DM è aperta.
