Um binário de 15MB que faz o que o Claude Code faz (com 7x menos memória)

Imagina abrir o terminal, rodar um único comando, e ter um agente de IA escrevendo código por você. Sem instalar Node.js. Sem Python. Sem dependências. Sem nem precisar de internet, se você quiser.

Isso é o Ante, da Antigma Labs. Um agente de código escrito em Rust, empacotado num binário de 15MB, que roda offline com modelos locais ou conectado a mais de 12 provedores de IA na nuvem.

E antes que você pense “mais um wrapper de API com terminal bonito”, os benchmarks contam outra história: em 20 tarefas paralelas, o Ante usa 7x menos memória, 9x menos CPU e 5x menos I/O de disco que o Claude Code. Mantendo a mesma acurácia.

Eu testei e fui pesquisar. Aqui está tudo que você precisa saber.

Por que mais um agente de código?

A resposta curta: porque os que existem são pesados demais.

O Claude Code roda sobre Node.js. O Codex da OpenAI puxa Python. O GitHub Copilot precisa de um editor inteiro. Todos funcionam, todos entregam resultado. Mas quando você quer rodar 10, 20, 50 agentes em paralelo (pense em CI/CD, pipelines de teste, orquestração multi-repo), cada instância consumindo gigabytes de RAM vira um problema real.

A Antigma Labs chamou isso de “tese celular”: agentes precisam ser como células, leves, descartáveis e massivamente replicáveis. Se cada réplica custa gigabytes de memória, o modelo não escala. Simples assim.

O Ante nasceu como um projeto paralelo para rodar modelos open-source em hardware heterogêneo. A equipe percebeu que o gargalo não era o modelo, era o harness, a infraestrutura ao redor que conecta o modelo ao seu sistema de arquivos, ao git, ao terminal.

Pensa no seguinte cenário: você tem um monorepo com 15 microserviços. Quer rodar um agente por serviço, cada um fazendo refactoring, escrevendo testes ou atualizando dependências. Com o Claude Code, isso são 15 processos Node.js, cada um puxando centenas de megabytes de RAM. Com o Ante, o consumo total de memória seria equivalente a dois ou três processos do Claude Code. Essa é a diferença prática.

Instalação em 10 segundos (literalmente)

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

Pronto. Um binário de ~15MB no seu PATH. Sem npm install, sem pip install, sem Docker, sem nada. Funciona no macOS e Linux (Windows via WSL).

Para atualizar:

ante update
ante update --channel nightly

Se você quer uma versão específica:

ante update --version v0.preview.71

A simplicidade é proposital. O time da Antigma embarcou funcionalidades como grep e git diretamente no binário. Tudo roda num processo único, eliminando aqueles vazamentos de recursos que acontecem quando você fica spawando subprocessos a cada operação.

Quatro modos de operação

O Ante não é só um chatbot de terminal. Ele tem quatro modos distintos:

O modo headless é onde a mágica acontece pra automação:

# Encontrar e corrigir um teste falhando
ante -p "find and fix the failing test in src/auth"

# Code review de segurança
git diff | ante -p "review this for security issues"

# Retomar uma sessão anterior
ante --resume ses_01ARZ3NDEKTSV4RRFFQ69G5FAV -p "now add tests"

Perceba que você pode encadear sessões. O Ante mantém memória persistente entre sessões, então ele lembra do contexto do que estava fazendo.

O modo gateway é o mais curioso: você transforma o Ante num bot de Slack ou Discord. Imagina um canal #code-review onde o time posta diffs e o Ante responde com análises de segurança. Ou um canal #deploy onde ele monitora logs e sugere fixes. Tudo rodando num binário de 15MB num container mínimo.

Rodar IA offline: de brinquedo a ferramenta real

Aqui é onde o Ante se diferencia de verdade. Ele traz uma versão embarcada e gerenciada do llama.cpp. Você aponta para qualquer arquivo GGUF e tudo roda localmente:

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

Zero API keys. Zero conta em serviço nenhum. Zero internet.

“Tá, mas modelos locais são ruins.” Essa era a verdade até pouco tempo atrás. Hoje, modelos open-weight de 27B a 35B estão alcançando o que os modelos de fronteira faziam 6 a 8 meses atrás no Terminal-Bench. Pra equipes que precisam de privacidade total ou trabalham em ambientes air-gapped, rodar localmente deixou de ser compromisso e virou escolha legítima de engenharia.

O próprio time da Antigma reconhece que existe um gap entre modelos locais e os de fronteira. No Terminal-Bench 2.1, um Qwen 27B local atinge 56.2%, enquanto o DeepSeek V4 Flash (via API) bate 82.7%. A estratégia recomendada é híbrida: tarefas sensíveis ou de alto volume ficam locais, problemas complexos vão para provedores na nuvem.

Benchmarks: os números que importam

Vamos aos dados. O Ante publica benchmarks reproduzíveis no Terminal-Bench 2.1:

Os benchmarks rodam 89 tarefas com 5 tentativas cada, builds fixados e reproduzíveis. Qualquer pessoa pode verificar. O custo por avaliação completa é de aproximadamente $68.

O diferencial técnico vem da arquitetura: como tudo roda num processo Rust único (grep, git, execução de comandos), não existe o overhead de criar processos filhos, parsear stdout, gerenciar pipes. Cada operação é uma chamada de função interna.

Para colocar em perspectiva: quando o Claude Code precisa fazer um grep no seu projeto, ele spawna um processo filho, aguarda o resultado via stdout, parseia a saída e segue. São syscalls, context switches, alocações de memória. Multiplica isso por centenas de operações numa sessão longa e o custo acumula. O Ante faz a mesma busca como uma chamada de função Rust dentro do mesmo processo. A diferença parece pequena numa operação, mas numa sessão de 30 minutos com dezenas de file reads, greps e git diffs, o impacto é significativo.

É o tipo de otimização que só faz sentido quando você reescreve tudo do zero numa linguagem de sistemas. O time da Antigma fez exatamente isso.

12+ provedores suportados

O Ante não te prende a nenhum provedor. Ele suporta:

Configurar é simples: variáveis de ambiente ou um arquivo ~/.ante/catalog.json para provedores customizados. Qualquer API compatível com OpenAI funciona. Isso inclui servidores locais como vLLM, Ollama ou qualquer outro que exponha a interface OpenAI-compatible. Você aponta o endpoint e pronto.

O catálogo de provedores é extensível: dá pra adicionar quantos endpoints quiser, com diferentes modelos e API keys, e trocar entre eles com uma flag no CLI.

# Trocar provedor e modelo na hora
ante --provider openai --model gpt-5.5 -p "refactor database module"

Arquitetura: cliente-daemon

Por baixo, o Ante segue um modelo cliente-daemon:

• Clientes: TUI, modo headless, servidor JSONL
• Daemon: Gerencia sessões, turnos, steps, permissões de ferramentas e invocação de skills/agentes
• Provedores: Roteamento para LLMs locais ou na nuvem

A separação permite que múltiplos clientes compartilhem o mesmo daemon, economizando recursos. O daemon orquestra o acesso a ferramentas, gerencia permissões e roteia para o provedor de LLM configurado.

Os crates públicos incluem:

• crates/protocol-shape: Schema e mensagens wire para ante serve
• crates/agent-sdk: SDK Rust para construir contra runtimes de agentes
• crates/exec: Execução de processos standalone (biblioteca publicada separadamente)

Multi-agent: orquestração distribuída

Uma das features mais ambiciosas do Ante é a orquestração multi-agent. Você pode spawar sub-agentes que trabalham em paralelo, em três arquiteturas:

1. Independente: Cada agente opera sozinho, sem coordenação
2. Descentralizada: Agentes se comunicam entre si peer-to-peer
3. Centralizada: Um agente mestre coordena os demais

Na prática, isso significa que você pode ter um agente escrevendo código, outro rodando testes, e um terceiro fazendo review, tudo ao mesmo tempo. Com o overhead de memória do Ante, rodar dezenas de instâncias em paralelo é viável até em hardware modesto.

O time da Antigma usa o termo “organismos” para descrever essas colônias de agentes. A ideia é que agentes individuais são descartáveis (se um falha, substitui), mas o organismo como um todo é persistente e auto-recuperável. É um modelo inspirado em sistemas distribuídos, não em assistentes pessoais.

Isso muda a forma de pensar sobre agentes de código. Em vez de um assistente superinteligente que faz tudo, você tem um enxame de agentes especializados, cada um bom numa coisa, que juntos cobrem mais terreno do que qualquer agente único.

O elefante na sala: código fechado

A comunidade do Hacker News não perdoou: o core do Ante é proprietário. O binário é distribuído gratuitamente durante o alpha, mas o código-fonte do harness principal não está aberto.

As críticas foram diretas: “Rodar um agente com acesso god ao seu computador sem ver o código é inaceitável.” Outro usuário levantou: “Supply chain attacks acontecem o tempo todo. Com código fechado, ninguém vai conseguir detectar.”

O fundador respondeu que planeja liberar o código-fonte primeiro para resolver a preocupação de segurança. Os crates do SDK e protocolo já são Apache 2.0, e o time parece estar ouvindo o feedback.

A telemetria opt-out também pegou mal. Para uma ferramenta que se posiciona como “offline-first” e “privacidade primeiro”, enviar telemetria por padrão foi visto como contraditório. O time reconheceu que era resquício do build de preview para desenvolvedores.

É justo dizer que essas são preocupações legítimas. Se você trabalha em ambiente regulado ou com código sensível, o fato de ser closed-source é um bloqueio real, pelo menos até a equipe cumprir a promessa de abrir o código.

Quando usar (e quando não usar)

O Ante faz sentido em cenários específicos:

Usa o Ante quando:

• Precisa rodar agentes em massa (CI/CD, testes paralelos, orquestração)
• Quer inferência local sem dependências pesadas
• Trabalha em ambiente air-gapped ou com requisitos rígidos de privacidade
• Precisa de um agente leve para integrar via Slack/Discord
• Quer experimentar modelos locais GGUF sem configurar nada

Fica no Claude Code / Copilot quando:

• Precisa de ecossistema maduro com milhares de integrações
• Quer suporte enterprise com SLA
• O overhead de recursos não é problema (máquina potente, poucas instâncias)
• Precisa de auditoria de código aberto hoje (não amanhã)

O futuro dos agentes celulares

A Antigma Labs está apostando numa visão onde agentes são como containers: leves, efêmeros, orquestráveis. A analogia com Docker não é acidental. Assim como Docker democratizou a infraestrutura ao tornar servidores descartáveis, o Ante quer fazer o mesmo com agentes de IA.

O Terminal-Bench 2.1 mostra que a acurácia do Ante com modelos de fronteira é competitiva. O diferencial está no custo por instância. Se você consegue rodar 7x mais agentes com o mesmo hardware, a matemática muda completamente.

O projeto ainda está em alpha, com breaking changes esperados e funcionalidades incompletas. Mas a direção é clara: agentes precisam ser infraestrutura, não aplicações. Precisam ser baratos, rápidos e dispensáveis.

E se a equipe cumprir a promessa de abrir o código, o Ante pode se tornar o runtime padrão para quem leva a sério a ideia de agentes autônomos em escala.

Eu fico de olho. E se você tiver um monorepo pesado, uma pipeline de CI lenta, ou curiosidade sobre o que modelos locais de 27B conseguem fazer em 2026, vale gastar 10 segundos no curl e testar. Pior que pode acontecer é você descobrir que 15MB é tudo que precisava.

Fonte de inspiração: Ante no GitHub (Antigma Labs)