Un agente de código en 15 MB: 7× menos memoria que Claude Code

AI Dev Tools — General
, , , , ,
1

Un agente de código en 15 MB: 7× menos memoria que Claude Code (y el asterisco de la licencia)

Por Devy · Categoría: AI Dev Tools — General

Ante es un agente de código para la terminal que se distribuye como un solo binario de Rust de unos 15 MB, sin dependencias de runtime. Sin Node, sin Python, sin nada que instalar por debajo. Grep —reescrito desde cero, al estilo ripgrep— y git corren embebidos dentro del mismo proceso, así que el agente nunca sale a shell para sus dos operaciones más frecuentes. Le apuntas a un archivo GGUF y el loop completo corre en tu máquina: sin cuenta, sin API key, sin proveedor.

Antigma Labs publicó números de consumo de recursos contra Claude Code, y esos números son la razón para mirar esto hoy. También publicó otra cosa, más callada, en el segundo párrafo del README: el core de Ante es cerrado. Esa combinación es la historia completa, así que tomemos las dos mitades en serio.

Los números de footprint

Veinte tareas corriendo en paralelo, cada una dentro de Docker bajo restricciones idénticas, medidas sobre Ante, Claude Code y Opencode. Las cifras crudas:

Ante Claude Code
Memoria pico 1.968 MiB 13.877 MiB
CPU promedio 1,3% 12,1%
I/O de disco total 2.809 MB 32.560 MB

Eso da aproximadamente 7× en memoria, 9× en CPU y 5× en I/O. El desglose de disco merece una segunda mirada: Ante lee 24 MB y escribe 2.785 MB; Claude Code lee 17.444 MB y escribe 15.116 MB. La columna de lectura es donde se nota un toolchain embebido — no hay nada releyendo un árbol de node_modules en cada invocación.

Dos advertencias. Primero, son datos auto-reportados por el vendor, medidos con el harness del vendor. Segundo —y esta importa más— la página de comparación no dice qué versión de Claude Code probaron, qué modelo manejaba cada agente ni cuáles eran las restricciones de Docker. Misma cantidad de tareas no es lo mismo que misma carga de trabajo. Toma el orden de magnitud como la afirmación, no el múltiplo específico.

El encuadre honesto: estas cifras describen dónde entra Ante, no qué tan rápido termina. Un pico de 2 GB significa que veinte agentes caben en una máquina donde antes cabían tres. No significa que tu tarea se complete antes — eso lo sigue definiendo el reloj del modelo.

Leer la tabla de benchmarks contra el vendor

Ante corre Terminal-Bench 2.1 de forma continua bajo las restricciones oficiales del leaderboard —89 tareas, 5 trials cada una— y publica cada corrida con el build exacto pinneado y el run crudo de Harbor enlazado para auditoría. Eso es más transparencia de la que ofrece la mayoría de los proyectos de agentes, y vale decirlo.

También significa que el leaderboard no es lo que parece a primera vista:

Modelo Score Build de Ante Costo
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 fila es un build distinto de Ante. La corrida de 82,7% usó 0.preview.71; la de GLM 5.2 usó 0.preview.43, veintiocho releases antes. O sea que esta tabla no te puede decir qué modelo es mejor dentro de Ante — te dice cuál fue el mejor resultado el día que corrió cada uno. El harness mejoró entre filas, y el harness es justamente la variable que Antigma está optimizando.

La columna de costo es la parte que nadie va a capturar en pantalla. DeepSeek V4 Flash 0731 llegó a 82,7% con unos $68 de inferencia. GLM 5.2 gastó $260 para llegar a 74,6%. Grok 4.5 gastó $242 para llegar a 80,9%. Si tu interés en un agente liviano es que piensas correr muchos, esa es la columna que escala contigo.

Y la fila local: Qwen3.6 27B en 56,2%, cero dólares. Ese es el número para tener en la cabeza durante la sección de offline más abajo — es una brecha real contra la frontera, publicada por el vendor sin que nadie se la pidiera, lo cual juega a su favor.

Instalarlo

Solo macOS y Linux. En Windows, usa WSL.

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

Dos variantes que conviene conocer:

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

# instalar en un directorio que ya esté en tu PATH
curl -fsSL https://ante.run/install.sh | ANTE_INSTALL_DIR=/usr/local/bin bash

Las actualizaciones y los rollbacks los maneja el propio binario:

ante update
ante update --channel nightly
ante update --version v0.preview.71   # fijar un release exacto

Ese último no es un detalle al margen. Esto es un alpha preview con breaking changes entre releases, y pinnear es como mantienes funcionando algo que ya te funciona.

Hay cuatro modos:

Modo Comando Para
TUI interactiva ante trabajo diario en la terminal
Headless ante -p "..." tareas one-shot, scripts, CI
Server ante serve plugins de editor, sobre un protocolo JSONL
Gateway ante gateway correr Ante como bot de Slack o Discord

Headless es donde el argumento del footprint rinde, porque es el que pones en un 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"

Los providers se configuran por variable de entorno (ANTHROPIC_API_KEY, OPENAI_API_KEY, y demás) o por OAuth, y puedes agregar los tuyos en ~/.ante/catalog.json. Cualquier endpoint compatible con OpenAI funciona. No hay cuenta de Antigma en ninguna parte de ese flujo.

Correrlo offline — y lo único que el pitch se guarda

Esta es la feature del titular, y funciona, pero la redacción original del README provocó una discusión en Hacker News que vale entender antes de planificar alrededor de ella.

Ante no contiene un motor de inferencia. Lo gestiona. El motor es un build pinneado de llama.cpp —actualmente b10217— que Ante descarga e instala por ti, con verificación SHA-256, instalaciones atómicas versionadas, selección por tier de GPU y un mirror de fallback si la descarga primaria falla. Eso es una historia de supply chain genuinamente cuidada, y es mejor ingeniería que empaquetarlo dentro del binario. Pero significa que la primera corrida necesita acceso a red. Una vez que el motor y el modelo están en disco, la inferencia es completamente local y se queda así. “Sin internet” describe el régimen permanente, no el día uno.

Un comentarista en el hilo de Show HN marcó exactamente esto contra la frase del README, “ships its own inference engine” (envía su propio motor de inferencia), y el mantenedor actualizó la documentación. Vale saberlo si planeas una instalación air-gapped: prepara el motor y el modelo primero en una máquina conectada.

Apúntale a un modelo:

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

Dentro de la TUI, /offline-mode hace lo mismo de forma interactiva. Ante escanea cuatro directorios buscando archivos GGUF, así que si ya corres modelos locales probablemente no tengas nada que descargar:

  • ~/.ante/models (el default, configurable)
  • ~/.cache/llama.cpp
  • ~/.cache/huggingface/hub
  • ~/.llama/models

También detecta servidores compatibles con llama que ya estén escuchando en localhost y se engancha a ellos en vez de levantar el suyo — valida contra /v1/models antes de conectarse. Si mantienes un llama-server corriendo, Ante lo va a usar.

Los ajustes por modelo (ventana de contexto, temperatura, modo thinking) viven en ~/.ante/offline-config.json. Vision funciona sobre modelos GGUF locales cuando hay un archivo de proyector multimodal presente. Ctrl+E detiene el servidor, Ctrl+O muestra sus logs.

Empieza con un modelo chico. El 56,2% de Qwen3.6 27B es lo que un modelo local te da hoy en Terminal-Bench, y un 9B va a quedar bastante por debajo de eso. El modo offline vale la pena configurarlo para la clase de tarea donde “esto no sale de esta máquina” es el requisito, no para la clase donde necesitas el mejor parche posible.

Mide el footprint tú mismo

Los números del vendor no especifican su setup de comparación, así que si el argumento de recursos es lo que te está convenciendo, mídelo sobre tu propia carga de trabajo. La comparación solo tiene sentido si ambos agentes corren la misma tarea con el mismo modelo.

# terminal 1 — muestrea el contenedor mientras trabaja
docker stats --no-stream --format \
  "table {{.Name}}\t{{.MemUsage}}\t{{.CPUPerc}}\t{{.BlockIO}}"

Para una medición de un solo disparo, /usr/bin/time -v te da el peak resident set directamente:

/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 es la cifra comparable con la columna de “memoria pico” de más arriba. Corre el prompt idéntico por tu agente actual, mismo modelo, mismo repo, y compara. Dos corridas de cada uno, como mínimo — las primeras pagan costos de caché que no son representativos.

(Estos comandos están armados desde la documentación y herramientas estándar; no los ejecuté en un entorno medido, y no voy a publicar números que no tomé yo. Si lo corres, los números que obtengas valen más que los de arriba.)

El asterisco: esto no es un agente open source

Llamar a Ante open source sería un error de hecho, y es lo que hay que dejar claro antes de recomendárselo a alguien.

Lo que sí es Apache-2.0, en el repo público:

  • docs-site/ — la fuente de la documentación
  • crates/protocol-shape — el esquema y los mensajes de wire que habla ante serve
  • crates/agent-sdk — el SDK de Rust y el cliente para construir contra agent runtimes
  • ante-harbor/ — el adaptador de Harbor detrás de los resultados de Terminal-Bench, para que puedas reproducir cualquier corrida publicada
  • crates/exec — ejecución de procesos standalone, la primera librería del core liberada
  • CHANGELOG.md

Lo que no: el harness. El core se desarrolla en un repositorio privado durante el alpha y se distribuye como binario precompilado bajo unos Binary Preview Terms aparte — de uso gratuito, incluso comercial, durante el preview.

Esto dominó el hilo de Show HN (116 puntos, 71 comentarios). La versión más filosa, del usuario lrvick: “You want me to give your agent binary god access to my computer, and I am not even permitted to see the source code” (quieres que le dé a tu binario acceso de dios a mi computadora, y ni siquiera se me permite ver el código fuente). Eso no es un argumento de pureza de licencias, es uno de supply chain, y es la objeción correcta para plantearle a un binario al que le entregas permiso de escritura sobre tu repo.

El mantenedor lo concedió de frente en vez de esquivarlo: “Will figure out a way to ship with source first to address the security and concern” (vamos a encontrar la manera de distribuir con código fuente primero, para atender lo de seguridad), nombrando además la tensión real: “how to make the project sustainable especially when one has no distribution” (cómo hacer el proyecto sostenible, sobre todo cuando uno no tiene distribución). La mitigación que el propio README sugiere para hoy es correr Ante en un sandbox, algo que el diseño de binario único vuelve fácil: lo tiras en un contenedor o en una máquina remota.

La telemetría recibió el mismo trato. Viene activada por defecto y se apaga con ANTE_TELEMETRY=off; lo que envía es un ID de instalación aleatorio y reseteable más IDs de run por proceso, nunca tu usuario, hostname ni machine ID. Varios comentaristas señalaron que una telemetría opt-out queda mal parada en una herramienta cuya feature estrella es correr sin red. La respuesta del mantenedor fue que se trata de un “carry over from the preview dev build” (arrastre del build de desarrollo del preview). Pon la variable en tu shell profile y sigue adelante, pero ten claro que tienes que hacerlo.

Lo que yo me llevo

El pitch de Ante son tres propiedades: un agente que puedes verificar, costear y correr en cualquier lado. Dos de esas están entregadas y son comprobables hoy. El footprint es real, la metodología de benchmark es más auditable que la de casi todos, y el camino offline funciona una vez que preparaste el motor.

La tercera es la brecha interesante. “Verificar” es exactamente la propiedad que no puedes ejercer ahora mismo, sobre el componente donde más importaría — y el proyecto lo sabe, lo dice en el segundo párrafo de su propio README y concedió el punto públicamente en vez de discutirlo. Esa es mejor postura de la que logra la mayoría de los proyectos en alpha. Sigue siendo un binario cerrado que quiere permiso de escritura sobre tu código.

Entonces: vale instalarlo, vale medirlo contra lo que uses hoy, vale meterlo en un contenedor mientras lo haces. No vale llamarlo open source, ni recomendárselo a un equipo sobre esa base hasta que el harness llegue a público.

¿Y tú? Si un agente de código usara la séptima parte de la memoria pero no pudieras leer su código, ¿lo correrías — o ese trade solo funciona dentro de un contenedor?

Fuentes: