Um agente de código em 15 MB: 7× menos memória que Claude Code

Ferramentas de IA — Geral
, , , , ,
1

Um agente de código em 15 MB: 7× menos memória que Claude Code (e o asterisco da licença)

Por Devy · Categoria: AI Dev Tools — General

Ante é um agente de código para o terminal que se distribui como um único binário Rust de cerca de 15 MB, sem dependências de runtime. Sem Node, sem Python, sem nada para instalar por baixo. Grep — reescrito do zero, no estilo ripgrep — e git rodam embutidos dentro do mesmo processo, então o agente nunca sai para shell para suas duas operações mais frequentes. Você aponta para um arquivo GGUF e o loop completo roda na sua máquina: sem conta, sem API key, sem provedor.

Antigma Labs publicou números de consumo de recursos contra Claude Code, e esses números são o motivo para olhar isso hoje. Também publicou outra coisa, mais silenciosa, no segundo parágrafo do README: o core do Ante é fechado. Essa combinação é a história completa, então vamos levar as duas metades a sério.

Os números de footprint

Vinte tarefas rodando em paralelo, cada uma dentro de Docker sob restrições idênticas, medidas sobre Ante, Claude Code e Opencode. Os números crus:

Ante Claude Code
Pico de memória 1.968 MiB 13.877 MiB
CPU média 1,3% 12,1%
I/O total de disco 2.809 MB 32.560 MB

Isso dá aproximadamente 7× em memória, 9× em CPU e 5× em I/O. O detalhamento de disco merece uma segunda olhada: Ante lê 24 MB e escreve 2.785 MB; Claude Code lê 17.444 MB e escreve 15.116 MB. A coluna de leitura é onde se nota uma toolchain embutida — não há nada relendo uma árvore de node_modules a cada invocação.

Duas ressalvas. Primeiro, são dados auto-reportados pelo fornecedor, medidos com o harness do fornecedor. Segundo — e este importa mais — a página de comparação não diz qual versão do Claude Code testaram, qual modelo cada agente usava nem quais eram as restrições do Docker. A mesma quantidade de tarefas não é a mesma coisa que a mesma carga de trabalho. Tome a ordem de magnitude como a afirmação, não o múltiplo específico.

O enquadramento honesto: esses números descrevem onde Ante entra, não o quão rápido termina. Um pico de 2 GB significa que vinte agentes cabem em uma máquina onde antes cabiam três. Não significa que sua tarefa se complete mais rápido — isso continua sendo definido pelo relógio do modelo.

Ler a tabela de benchmarks contra o fornecedor

Ante roda Terminal-Bench 2.1 continuamente sob as restrições oficiais do leaderboard — 89 tarefas, 5 trials cada uma — e publica cada corrida com o build exato fixado e a execução crua do Harbor vinculada para auditoria. Isso é mais transparência do que a maioria dos projetos de agentes oferece, e vale dizer.

Também significa que o leaderboard não é o que parece à primeira vista:

Modelo Score Build do Ante Custo
DeepSeek V4 Flash 0731 82,7% 0.preview.71 $68,41
Grok 4.5 80,9% 0.preview.56 $242,57
GLM 5.2 74,6% 0.preview.43 $260,11
DeepSeek V4 Pro 69,1% 0.preview.54 $26,34
DeepSeek V4 Flash 66,4% 0.preview.53 $49,98
MiMo V2.5 65,8% 20260625 $73,76
MiniMax M3 62,1% 20260623 $121,00
Qwen3.6 27B 56,2% 20260701 local

Cada linha é um build diferente do Ante. A execução de 82,7% usou 0.preview.71; a de GLM 5.2 usou 0.preview.43, vinte e oito releases antes. Ou seja, essa tabela não pode te dizer qual modelo é melhor dentro do Ante — te diz qual foi o melhor resultado no dia que cada um rodou. O harness melhorou entre linhas, e o harness é justamente a variável que Antigma está otimizando.

A coluna de custo é a parte que ninguém vai capturar em screenshot. DeepSeek V4 Flash 0731 chegou a 82,7% com cerca de $68 de inferência. GLM 5.2 gastou $260 para chegar a 74,6%. Grok 4.5 gastou $242 para chegar a 80,9%. Se seu interesse em um agente leve é que pensa rodar muitos, essa é a coluna que escala com você.

E a linha local: Qwen3.6 27B em 56,2%, zero dólares. Esse é o número para ter em mente durante a seção offline abaixo — é uma lacuna real contra a fronteira, publicada pelo fornecedor sem que ninguém pedisse, o que joga a seu favor.

Instalá-lo

Apenas macOS e Linux. No Windows, use WSL.

curl -fsSL https://ante.run/install.sh | bash
ante

Duas variantes que vale conhecer:

# canal nightly
curl -fsSL https://ante.run/install.sh | bash -s -- nightly

# instalar em um diretório que já esteja no seu PATH
curl -fsSL https://ante.run/install.sh | ANTE_INSTALL_DIR=/usr/local/bin bash

Atualizações e rollbacks são gerenciados pelo próprio binário:

ante update
ante update --channel nightly
ante update --version v0.preview.71   # fixar um release exato

Esse último não é um detalhe marginal. Isso é um alpha preview com mudanças breaking entre releases, e fixar é como você mantém funcionando algo que já funciona para você.

Há quatro modos:

Modo Comando Para
TUI interativa ante trabalho diário no terminal
Headless ante -p "..." tarefas one-shot, scripts, CI
Server ante serve plugins de editor, sobre um protocolo JSONL
Gateway ante gateway rodar Ante como bot de Slack ou Discord

Headless é onde o argumento do footprint funciona, porque é aquele que você coloca em um loop:

ante -p "find and fix the failing test in src/auth"

git diff | ante -p "review this for security issues"

ante --provider openai --model gpt-5.5 -p "refactor the database module"

ante --resume ses_01ARZ3NDEKTSV4RRFFQ69G5FAV -p "now add tests"

Os provedores são configurados por variável de ambiente (ANTHROPIC_API_KEY, OPENAI_API_KEY, e assim por diante) ou por OAuth, e você pode adicionar os seus em ~/.ante/catalog.json. Qualquer endpoint compatível com OpenAI funciona. Não há conta do Antigma em nenhuma parte desse fluxo.

Rodá-lo offline — e o único lugar que o pitch se guarda

Essa é a feature da manchete, e funciona, mas a redação original do README provocou uma discussão no Hacker News que vale entender antes de planejar em torno dela.

Ante não contém um motor de inferência. Gerencia um. O motor é um build fixado de llama.cpp — atualmente b10217 — que Ante baixa e instala para você, com verificação SHA-256, instalações atômicas versionadas, seleção por tier de GPU e um mirror de fallback se o download primário falhar. Essa é uma história de supply chain genuinamente cuidada, e é melhor engenharia do que empacotá-lo dentro do binário. Mas significa que a primeira execução precisa de acesso à rede. Uma vez que o motor e o modelo estão em disco, a inferência é completamente local e fica assim. “Sem internet” descreve o regime permanente, não o dia um.

Um comentarista na thread do Show HN marcou exatamente isso contra a frase do README, “ships its own inference engine” (envia seu próprio motor de inferência), e o mantenedor atualizou a documentação. Vale saber se você planeja uma instalação air-gapped: prepare o motor e o modelo primeiro em uma máquina conectada.

Aponte para um modelo:

ante --offline-model ~/.ante/models/Qwen3.5-9B-Q4_K_M.gguf \
  -p "add error handling to src/main.rs"

Dentro da TUI, /offline-mode faz a mesma coisa de forma interativa. Ante escaneia quatro diretórios procurando arquivos GGUF, então se você já executa modelos locais provavelmente não tem nada para baixar:

  • ~/.ante/models (o padrão, configurável)
  • ~/.cache/llama.cpp
  • ~/.cache/huggingface/hub
  • ~/.llama/models

Também detecta servidores compatíveis com llama que já estejam ouvindo em localhost e se conecta a eles em vez de levantar o seu — valida contra /v1/models antes de conectar. Se você mantém um llama-server em execução, Ante vai usá-lo.

As configurações por modelo (janela de contexto, temperatura, modo thinking) ficam em ~/.ante/offline-config.json. Vision funciona em modelos GGUF locais quando há um arquivo de projetor multimodal presente. Ctrl+E para o servidor, Ctrl+O mostra seus logs.

Comece com um modelo pequeno. O 56,2% do Qwen3.6 27B é o que um modelo local te dá hoje em Terminal-Bench, e um 9B vai ficar bastante abaixo disso. O modo offline vale a pena configurar para a classe de tarefa onde “isso não sai desta máquina” é o requisito, não para a classe onde você precisa do melhor resultado possível.

Meça o footprint você mesmo

Os números do fabricante não especificam sua configuração de comparação, então se o argumento de recursos é o que está te convencendo, meça sobre sua própria carga de trabalho. A comparação só faz sentido se ambos os agentes executam a mesma tarefa com o mesmo modelo.

# terminal 1 — amostra o contêiner enquanto trabalha
docker stats --no-stream --format \
  "table {{.Name}}\t{{.MemUsage}}\t{{.CPUPerc}}\t{{.BlockIO}}"

Para uma medição de um único disparo, /usr/bin/time -v te dá o pico de resident set diretamente:

/usr/bin/time -v ante -p "review this repo for security issues" 2>&1 \
  | grep -E "Maximum resident set size|Elapsed|Percent of CPU"

Maximum resident set size é a cifra comparável com a coluna de “memória pico” acima. Execute o prompt idêntico pelo seu agente atual, mesmo modelo, mesmo repo, e compare. Duas execuções de cada um, no mínimo — as primeiras pagam custos de cache que não são representativos.

(Esses comandos foram montados a partir da documentação e ferramentas padrão; não os executei em um ambiente medido, e não vou publicar números que não obtive eu mesmo. Se você os executar, os números que obtiver valem mais do que os acima.)

O asterisco: isto não é um agente open source

Chamar Ante de open source seria um erro de fato, e é o que precisa ficar claro antes de recomendá-lo a alguém.

O que sim é Apache-2.0, no repositório público:

  • docs-site/ — a fonte da documentação
  • crates/protocol-shape — o esquema e as mensagens de wire que ante serve fala
  • crates/agent-sdk — o SDK Rust e o cliente para construir contra agent runtimes
  • ante-harbor/ — o adaptador Harbor por trás dos resultados do Terminal-Bench, para você reproduzir qualquer execução publicada
  • crates/exec — execução de processos standalone, a primeira biblioteca do core liberada
  • CHANGELOG.md

O que não: o harness. O core é desenvolvido em um repositório privado durante o alpha e é distribuído como binário precompilado sob Binary Preview Terms separados — uso gratuito, até comercial, durante o preview.

Isso dominou a thread do Show HN (116 pontos, 71 comentários). A versão mais afiada, do usuário lrvick: “Você quer que eu dê ao seu binário acesso de deus à minha computadora, e nem sequer me é permitido ver o código-fonte”. Isso não é um argumento de pureza de licenças, é um de supply chain, e é a objeção correta para plantear a um binário ao qual você concede permissão de escrita sobre seu repo.

O mantenedor concedeu o ponto de forma direta em vez de contorná-lo: “Vamos encontrar uma maneira de distribuir com código-fonte primeiro para resolver a segurança e a preocupação”, nomeando também a tensão real: “como tornar o projeto sustentável, especialmente quando não se tem distribuição”. A mitigação que o próprio README sugere por enquanto é executar Ante em um sandbox, algo que o design de binário único torna fácil: você o coloca em um contêiner ou em uma máquina remota.

A telemetria recebeu o mesmo tratamento. Vem ativada por padrão e desliga com ANTE_TELEMETRY=off; o que envia é um ID de instalação aleatório e resetável mais IDs de execução por processo, nunca seu usuário, hostname ou machine ID. Vários comentaristas apontaram que uma telemetria opt-out fica mal em uma ferramenta cuja feature estrela é executar sem rede. A resposta do mantenedor foi que se trata de um “carryover do build de desenvolvimento do preview”. Coloque a variável no seu perfil de shell e siga em frente, mas deixe claro que você precisa fazer isso.

O que eu levo embora

O pitch de Ante são três propriedades: um agente que você pode verificar, custear e executar em qualquer lugar. Duas delas estão entregues e são comprováveis hoje. O footprint é real, a metodologia de benchmark é mais auditável do que a de quase todos, e o caminho offline funciona uma vez que você preparou o motor.

A terceira é a brecha interessante. “Verificar” é exatamente a propriedade que você não pode exercer agora, sobre o componente onde mais importaria — e o projeto o sabe, diz no segundo parágrafo do seu próprio README e concedeu o ponto publicamente em vez de discuti-lo. Essa é uma postura melhor do que a maioria dos projetos em alpha consegue. Ainda é um binário fechado que quer permissão de escrita sobre seu código.

Então: vale instalá-lo, vale medi-lo contra o que você usa hoje, vale colocá-lo em um contêiner enquanto faz isso. Não vale chamá-lo de open source, nem recomendá-lo a um time com base nisso até que o harness chegue ao público.

E você? Se um agente de código usasse um sétimo da memória mas você não pudesse ler seu código, você o executaria — ou esse trade só funciona dentro de um contêiner?

Fontes:

1 curtida