No último mês, os agentes de código que estou construindo processaram 13 bilhões de tokens entre entrada e saída, com 97,24% de cache hit e um custo efetivo de aproximadamente R$ 0,04 por milhão de tokens.
Quando falo esses números, a primeira reação costuma ser desconfiança — e ela é saudável. O custo é a razão número um pela qual empresas desistem de agentes autônomos: o piloto funciona, a conta chega, o projeto morre. Então este artigo é sobre como esses números acontecem. Não tem truque único; tem uma arquitetura em que cada token que entra e sai é comprimido, roteado e medido.
Esse é o Velua Code, o agente que estamos construindo em uma nova startup com que decidi começar, a Velua AI (https://velua.ai) . Antes da arquitetura, a tese.
A tese: três problemas, resolvidos juntos
Agentes de código quebram em três lugares, e resolver um só não adianta.
Custo. Um agente autônomo consome tokens em uma escala que assusta qualquer CFO. Se cada iteração custa caro, ninguém deixa o agente iterar — e um agente que não itera não resolve nada de verdade.
Contexto. A janela de contexto é finita e cara. A implementação típica enche o prompt de arquivos inteiros e resultados de grep, pagando por milhares de tokens irrelevantes em cada chamada.
Memória. Cada sessão começa do zero. O agente redescobre na terça o que já tinha aprendido na segunda — e paga (em tokens e em erros) para redescobrir.
Os três se retroalimentam: contexto inflado aumenta custo, falta de memória infla contexto. Por isso o Velua Code ataca os três de uma vez.
Custo: compressão na fonte + roteamento ativo
A primeira decisão de arquitetura: comprimir o contexto na fonte, não no final. Todo output de ferramenta — leitura de arquivo, resultado de busca, log de build — passa por um pipeline de compressão antes de entrar no histórico da sessão. O núcleo é um modelo próprio de compressão rodando localmente em ONNX, na máquina do dev ou no container do agente. Não há chamada de rede para comprimir: a economia não custa tokens.
Em volta dele, camadas mais simples fazem trabalho pesado: deduplicação de leituras (o agente releu o mesmo arquivo? a versão antiga sai do contexto), compressão estrutural de JSON, elisão de corpo de código mantendo assinaturas, e um threshold adaptativo que aperta a compressão conforme o contexto cresce. Tudo medido com o tokenizer real do modelo de destino — economia contada em tokens de verdade, não estimada.
E há uma decisão do que não fazer: nunca tocamos no system prompt em runtime. Prompt estável é o que sustenta os 97,24% de cache hit — e cache hit é a alavanca de custo mais barata que existe, porque token cacheado custa uma fração do token cheio.
A segunda decisão: o agente não escolhe o modelo. Um classificador local pré-classifica cada tarefa em categoria e complexidade, e o Velua Gateway — que enxerga 50+ modelos, com preço e desempenho em tempo real — roteia para o modelo mais capaz dentro do necessário, além de aplicar guardrails e enriquecer com RAG. Renomear uma variável não precisa do modelo de fronteira; desenhar uma migração de schema precisa. Com roteamento ativo, a maioria das chamadas vai para modelos menores, e o caro só entra quando a complexidade exige.
O gateway ainda mede o custo real de cada request. Isso permite algo que considero inegociável para agentes em produção: budget como condição de parada. O loop autônomo roda com teto de custo em moeda, não com esperança.
É a combinação — compressão na fonte, cache alto, roteamento entre modelos menores — que produz os R$ 0,04 por milhão. Nenhuma das três peças sozinha chega perto.
Contexto: um grafo em vez de grep
A forma padrão de um agente "entender" um codebase é grep e leitura de arquivos — caro e cego. O Velua Code mantém um grafo de conhecimento do código: funções, classes, rotas e as relações entre elas (quem chama quem, quem implementa o quê).
Isso muda as duas pontas do loop. Na entrada, o agente monta um pacote de contexto enxuto consultando o grafo — a visão de arquitetura do projeto e os nós relevantes à tarefa — em vez de despejar arquivos no prompt. Na saída, muda a verificação: quando o agente altera uma função, o grafo lista exatamente os pontos de chamada impactados, e um agente revisor — com contexto limpo, sem o viés de quem escreveu o código — checa cada um deles, além de rodar testes, lint e build. "Você mudou a assinatura de processOrder; sete lugares a chamam" é um tipo de verificação que grep não entrega.
Memória: o loop que aprende
A peça que fecha o sistema. Ao final de cada iteração verificada, o agente registra decisões de engenharia: o que foi decidido, por quê, quais alternativas foram consideradas, o que falhou. E cada decisão é linkada aos nós de código que ela explica, dentro do próprio grafo.
Na iteração seguinte, a fase de coleta de contexto recupera essas decisões — inclusive as abordagens que já falharam, para não repeti-las. O loop deixa de ser um executor que repete tarefas e vira um sistema que acumula conhecimento sobre o codebase. É também o melhor amortizador de custo que existe: memória barata substitui redescoberta cara.
O loop completo, então: coletar contexto (grafo + memória + RAG), planejar com o modelo certo para o tamanho do problema, agir com sub-agentes, verificar com revisor de contexto limpo e consciência do grafo, aprender registrando decisões — e repetir, com teto de custo. É o loop canônico de agentes, com cada fase genérica substituída por uma capacidade própria.
Por que o primeiro cliente somos nós
A estratégia de produto é deliberadamente contraintuitiva: antes de vender para qualquer cliente, o Velua Code roda internamente no SIGE Cloud. Dogfooding de verdade — um ERP em produção, com times reais operando agentes em código real, todos os dias.
Foi esse uso interno que gerou os 13 bilhões de tokens, e é ele que está moldando o produto. Agente autônomo em produção expõe problemas que nenhum benchmark expõe: permissões, custo acumulado, tarefas que travam, contexto que apodrece. Prefiro que ele amadureça onde a dor é nossa.
O que vem depois: memória unificada para empresas
Hoje a memória de decisões vive por projeto. O próximo passo é o que mais me anima: elevá-la a uma camada unificada de memória de engenharia para empresas.
Imagine a decisão registrada pelo agente do time A — "migramos para X por causa de Y; evitamos Z porque quebrou W" — recuperável pelo agente do time B, e pelos devs humanos que operam esses agentes, com controle de acesso, proveniência e auditoria. A pergunta "por que esse código é assim?" respondida com a decisão original, linkada ao código, para qualquer pessoa ou agente da organização. Onboarding mais rápido, consistência entre times, e o conhecimento de engenharia da empresa deixando de morar só na cabeça das pessoas.
Servida pelo gateway, essa memória vira infraestrutura: qualquer agente da empresa, em qualquer ferramenta, herda o aprendizado acumulado.
Agentes autônomos vão ser commodity. O conhecimento que eles acumulam sobre o
seu
sistema, não.
É essa a aposta.
Se você está construindo com agentes em produção — ou quebrando a cabeça com custo de contexto — minha DM está aberta.
