Você começou com um agente de código. Agora o Claude Code roda em um terminal, o Codex em outro e o Gemini CLI em um terceiro. Cada um cobra do seu próprio jeito: uma assinatura aqui, uma chave de API medida ali, um plano gratuito que silenciosamente virou uso pago na semana passada. No fim do mês, você tem três faturas e nenhuma resposta para uma pergunta simples: quanto custou, de fato, construir o recurso da semana passada?
Gestão de custos de agentes de código é a prática de atribuir o gasto dos agentes ao trabalho que o gerou e, em seguida, manter esse gasto visível e revisável em todas as ferramentas que sua equipe usa. A parte difícil não é o preço por token de um agente específico. Os preços mudam, e cada fornecedor publica os seus. A parte difícil é que o gasto se fragmenta em sistemas de cobrança separados no momento em que você passa a usar mais de um agente, então ninguém consegue vincular um valor em reais a uma tarefa, um repositório ou uma pessoa.
Este artigo mostra de onde vem, de fato, o custo de cada ferramenta, quais alavancas você controla e como uma camada de gestão como o Sharkly mantém o gasto por tarefa visível sem exigir que você abandone as ferramentas que já usa. O Sharkly fica acima dos agentes. Você mantém suas assinaturas do Claude Code, Codex e Gemini, e o registro de cada execução retorna à Tarefa à qual pertence.
O que significa gestão de custos quando você roda três agentes
Com um agente, o custo é um número que você lê em um único painel. Com três, o custo se torna um problema de coordenação. O gasto é real, mas vive em três lugares que nunca se conciliam: o uso do Claude Code da Anthropic, uma página de cobrança da OpenAI para o Codex e um projeto do Google Cloud para o Gemini.
Vale deixar clara uma fronteira. Gestão de custos não é a mesma coisa que redução de custos. Reduzir gastos significa usar menos tokens. Gerenciar gastos significa saber para onde os tokens foram e decidir se isso valeu a pena. Você pode ter um mês caro de propósito, entregando três recursos em paralelo, e ainda assim estar no controle, desde que consiga atribuir o gasto e alguém tenha aprovado aquilo.
Essa atribuição é a camada que falta. A maioria das equipes que roda vários agentes consegue informar a conta total de IA e nada mais granular do que isso. Elas não conseguem dizer qual repositório, qual engenheiro ou qual tarefa puxou aquele gasto. Quando o gasto é invisível no nível da tarefa, as conversas sobre custo viram adivinhação, e a reação habitual é limitar a ferramenta que por acaso é mais fácil de enxergar, em vez da que está de fato consumindo o orçamento.
De onde vêm, de fato, os custos das três ferramentas
Cada agente cobra por basicamente a mesma coisa, tokens de entrada e tokens de saída, mas o modelo de cobrança varia o suficiente para mudar a forma como você faz seu orçamento. Comparadas em seus melhores cenários, nenhuma é simplesmente mais barata que as outras. Elas são mais baratas para formatos diferentes de trabalho.
| Ferramenta | Modelo de cobrança comum | O que faz a conta subir |
|---|---|---|
| Claude Code | Plano de assinatura ou chave de API da Anthropic | Sessões agênticas longas, janelas de contexto grandes, leituras repetidas de arquivos |
| Codex | Plano de assinatura ou chave de API da OpenAI | Tarefas com muito raciocínio, alta concorrência, loops de chamadas de ferramentas |
| Gemini CLI | Plano gratuito e, depois, uma chave de API do Google Cloud | Tarefas de contexto grande depois de esgotar a cota gratuita, chamadas de imagem e multimodais |
Os modelos de assinatura escondem o custo marginal. Um plano mensal fixo parece gratuito na margem, então os engenheiros recorrem a ele o tempo todo, e a verdadeira pergunta deixa de ser “quanto isso custou” e passa a ser “estamos atingindo os limites do plano”. Os modelos medidos por chave de API fazem o oposto: cada execução tem um preço visível, o que torna o orçamento mais claro, mas tenta as equipes a subutilizar um agente capaz para economizar centavos.
Use um plano de assinatura quando uma ou duas pessoas rodam um agente de forma constante ao longo do dia e a cobrança previsível importa mais do que o detalhe por tarefa. Use uma chave de API medida quando precisar atribuir o gasto com precisão, rodar em automação ou distribuir o trabalho por uma equipe em que alguém tem de responder pelo total. Muitas equipes acabam com os dois, e é exatamente por isso que uma visão única e conciliada importa. Se você está escolhendo qual agente cuida de qual trabalho, casar modelos com tarefas faz mais pela sua conta do que trocar de fornecedor.
As três alavancas que você realmente controla
Os preços dos fornecedores não são uma alavanca; você não consegue negociá-los a partir de um terminal. Três coisas estão genuinamente nas suas mãos, e elas importam mais do que o preço de etiqueta.
Disciplina de contexto. O maior custo evitável é reenviar contexto que o agente já tinha. Um agente que relê todo o código-fonte a cada turno paga por esse código-fonte a cada turno. Persistir o contexto entre execuções, de modo que o agente comece a partir do estado atual em vez de reconstruí-lo, costuma ser a maior economia isolada. É o mesmo mecanismo por trás da memória de código-fonte e seu custo em tokens: o que você mantém, você não recompra.
Casar modelo com tarefa. Direcionar uma renomeação de uma linha para um modelo pesado de raciocínio é desperdício de dinheiro, e direcionar uma refatoração arquitetural para um modelo pequeno e rápido é desperdício de uma tarde. A economia vem de casar o modelo com a tarefa em vez de mandar todo trabalho para o seu agente mais capaz por padrão.
Limites de paralelismo. Rodar agentes em paralelo é onde está o ganho real de produtividade e também onde o gasto se multiplica mais rápido. Cinco agentes trabalhando ao mesmo tempo custam aproximadamente cinco vezes mais por unidade de tempo de relógio. Isso é aceitável quando cinco tarefas estão prontas e valem a pena, e caro quando três delas eram especulativas. A alavanca não é “rodar menos agentes”. É decidir, antes de iniciar, qual trabalho merece uma vaga em paralelo. Monitorar agentes rodando em paralelo é o que transforma essa decisão de um chute em uma escolha que você consegue defender.
Uma tabela de decisão por tamanho de equipe
A equação de custo muda conforme quantas pessoas e agentes você coordena. O que é aceitável para um desenvolvedor solo se torna um passivo para uma equipe de plataforma.
| Formato da equipe | Onde mora o custo | O que otimizar |
|---|---|---|
| Desenvolvedor solo, um ou dois agentes | Um ou dois painéis que você lê diretamente | Cobrança previsível; um plano de assinatura costuma bastar |
| Equipe pequena, vários agentes | Fragmentado entre assinaturas e chaves por pessoa | Atribuição: saber qual trabalho gerou o gasto |
| Equipe de plataforma ou de engenharia | Muitos repositórios, muitos agentes, orçamentos compartilhados | Visibilidade, revisão e custo por tarefa que se acumula até um responsável |
Se você é solo e está confortável em um terminal com um agente, não precisa de uma camada de gestão para controlar custos. Seu painel já mostra o que você precisa. A equação muda quando o gasto supera uma visão única: vários agentes, vários repositórios e um orçamento pelo qual alguém além de você precisa responder. Nesse ponto, a pergunta deixa de ser “qual agente é mais barato” e passa a ser “quem consegue ver o quadro completo e decidir”.
Tornando o gasto por tarefa visível
Esta é a camada para a qual o Sharkly foi construído, e vale ser preciso sobre o que ele faz e o que não faz. O Sharkly não é uma ferramenta de cobrança e não substitui o Claude Code, o Codex ou o Gemini. O uso dos modelos continua pelas assinaturas ou chaves de API configuradas nessas ferramentas; você traz sua própria assinatura. O que o Sharkly acrescenta é o registro compartilhado em torno delas: cada execução de agente acontece dentro de uma Tarefa, e a execução, o progresso, os bloqueios e os resultados retornam a essa Tarefa, onde a equipe pode vê-los.
É esse registro compartilhado que torna o custo legível. Quando cada execução está vinculada a uma Tarefa com um responsável e um repositório, o gasto deixa de ser um total mensal anônimo e passa a ser um conjunto de decisões que você pode apontar. Você consegue ver qual trabalho está rodando, no Computador de quem e contra qual orçamento, da solicitação à entrega. Um painel de agentes de código que mostra o que está rodando é a diferença entre gerenciar o gasto e descobri-lo depois da fatura.
O contrato entre humanos e agentes também vale aqui. Agentes pesquisam, executam, testam e reportam. Pessoas definem a direção, concedem autoridade e decidem se o gasto valeu o resultado. A automação para onde o julgamento da equipe é necessário, o que, em termos de custo, significa que uma pessoa, não um script, decide que uma execução paralela de cinco agentes é justificada antes de ela começar.
Se você quer continuar usando vários agentes de código em vez de se comprometer com um único ecossistema para simplificar a cobrança, esse é o problema em torno do qual o Sharkly foi projetado. Rode seus agentes de código atuais pelo Sharkly e deixe o custo de cada execução retornar à tarefa que o causou.
