A Code Agent in 15 MB: 7× Less Memory Than Claude Code (And the License Asterisk)
By Devy · Category: AI Dev Tools — General
Ante is a code agent for the terminal that ships as a single Rust binary of around 15 MB, with no runtime dependencies. No Node, no Python, nothing to install underneath. Grep—rewritten from scratch in the ripgrep style—and git run embedded inside the same process, so the agent never shells out for its two most frequent operations. Point it at a GGUF file and the complete loop runs on your machine: no account, no API key, no vendor.
Antigma Labs published resource consumption numbers against Claude Code, and those numbers are the reason to look at this today. They also published something else, more quietly, in the second paragraph of the README: Ante’s core is closed. That combination is the whole story, so let’s take both halves seriously.
The Footprint Numbers
Twenty tasks running in parallel, each inside Docker under identical constraints, measured against Ante, Claude Code, and Opencode. The raw figures:
| Ante | Claude Code | |
|---|---|---|
| Peak memory | 1.968 MiB | 13.877 MiB |
| Average CPU | 1.3% | 12.1% |
| Total disk I/O | 2.809 MB | 32.560 MB |
That works out to roughly 7× on memory, 9× on CPU, and 5× on I/O. The disk breakdown deserves a second look: Ante reads 24 MB and writes 2.785 MB; Claude Code reads 17.444 MB and writes 15.116 MB. The read column is where you notice an embedded toolchain—there’s nothing re-reading a node_modules tree on each invocation.
Two caveats. First, these are vendor-reported numbers, measured with the vendor’s harness. Second—and this one matters more—the comparison page doesn’t say which version of Claude Code they tested, what model each agent was running, or what the Docker constraints were. Same number of tasks isn’t the same as the same workload. Take the order of magnitude as the claim, not the specific multiple.
The honest framing: these numbers describe where Ante fits, not how fast it finishes. A peak of 2 GB means twenty agents fit on a machine where three used to fit. It doesn’t mean your task completes faster—that’s still defined by the model’s clock.
Reading the Benchmarks Table Against the Vendor
Ante runs Terminal-Bench 2.1 continuously under the official leaderboard constraints—89 tasks, 5 trials each—and publishes each run with the exact pinned build and the raw Harbor run linked for audit. That’s more transparency than most agent projects offer, and it’s worth saying.
It also means the leaderboard isn’t what it looks like at first glance:
| Model | Score | Ante Build | Cost |
|---|---|---|---|
| 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 |
Each row is a different Ante build. The 82.7% run used 0.preview.71; the GLM 5.2 one used 0.preview.43, twenty-eight releases earlier. So this table can’t tell you which model is better inside Ante—it tells you what the best result was the day each one ran. The harness improved between rows, and the harness is exactly the variable Antigma is optimizing.
The cost column is the part nobody’s going to screenshot. DeepSeek V4 Flash 0731 hit 82.7% at around $68 of inference. GLM 5.2 spent $260 to hit 74.6%. Grok 4.5 spent $242 to hit 80.9%. If your interest in a lightweight agent is that you plan to run a lot of them, that’s the column that scales with you.
And the local row: Qwen3.6 27B at 56.2%, zero dollars. That’s the number to keep in mind during the offline section below—it’s a real gap against the frontier, published by the vendor unsolicited, which plays in their favor.
Installing It
MacOS and Linux only. On Windows, use WSL.
curl -fsSL https://ante.run/install.sh | bash
ante
Two variants worth knowing:
# nightly channel
curl -fsSL https://ante.run/install.sh | bash -s -- nightly
# install to a directory already in your PATH
curl -fsSL https://ante.run/install.sh | ANTE_INSTALL_DIR=/usr/local/bin bash
Updates and rollbacks are handled by the binary itself:
ante update
ante update --channel nightly
ante update --version v0.preview.71 # pin to an exact release
That last one isn’t a side note. This is an alpha preview with breaking changes between releases, and pinning is how you keep something that works working.
There are four modes:
| Mode | Command | For |
|---|---|---|
| Interactive TUI | ante |
daily terminal work |
| Headless | ante -p "..." |
one-shot tasks, scripts, CI |
| Server | ante serve |
editor plugins, over a JSONL protocol |
| Gateway | ante gateway |
running Ante as a Slack or Discord bot |
Headless is where the footprint argument pays off, because that’s what you put in a 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"
Providers are configured by environment variable (ANTHROPIC_API_KEY, OPENAI_API_KEY, and so on) or by OAuth, and you can add your own in ~/.ante/catalog.json. Any OpenAI-compatible endpoint works. There’s no Antigma account anywhere in that flow.
Running It Offline—and the One Thing the Pitch Leaves Out
This is the headline feature, and it works, but the original README wording sparked a discussion on Hacker News that’s worth understanding before you plan around it.
Ante does not contain an inference engine. It manages one. The engine is a pinned build of llama.cpp—currently b10217—that Ante downloads and installs for you, with SHA-256 verification, atomic versioned installations, GPU tier selection, and a fallback mirror if the primary download fails. That’s genuinely careful supply chain work, and it’s better engineering than bundling it inside the binary. But it means the first run needs network access. Once the engine and model are on disk, inference is completely local and stays that way. “No internet” describes the permanent regime, not day one.
A commenter on the Show HN thread flagged exactly this against the README’s phrase, “ships its own inference engine”, and the maintainer updated the docs. Worth knowing if you’re planning an air-gapped install: prep the engine and model first on a connected machine.
Point it at a model:
ante --offline-model ~/.ante/models/Qwen3.5-9B-Q4_K_M.gguf \
-p "add error handling to src/main.rs"
```Within the TUI, `/offline-mode` does the same thing interactively. Ante scans four directories looking for GGUF files, so if you're already running local models you probably have nothing to download:
* `~/.ante/models` (the default, configurable)
* `~/.cache/llama.cpp`
* `~/.cache/huggingface/hub`
* `~/.llama/models`
It also detects llama-compatible servers already listening on localhost and hooks into them instead of spinning up its own — it validates against `/v1/models` before connecting. If you keep a llama-server running, Ante will use it.
Per-model settings (context window, temperature, thinking mode) live in `~/.ante/offline-config.json`. Vision works on local GGUF models when a multimodal projector file is present. Ctrl+E stops the server, Ctrl+O shows its logs.
Start with a small model. The 56.2% of Qwen3.6 27B is what a local model gives you today on Terminal-Bench, and a 9B is going to fall quite a bit short of that. Offline mode is worth setting up for the class of task where "this doesn't leave this machine" is the requirement, not for the class where you need the best possible patch.
## Measure the footprint yourself
Vendor numbers don't specify their comparison setup, so if the resource argument is what's convincing you, measure it against your own workload. The comparison only makes sense if both agents run the same task with the same model.
terminal 1 — sample the container while it works
docker stats --no-stream --format
“table {{.Name}}\t{{.MemUsage}}\t{{.CPUPerc}}\t{{.BlockIO}}”
For a one-shot measurement, `/usr/bin/time -v` gives you the peak resident set directly:
/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` is the figure comparable to the "peak memory" column above. Run the identical prompt through your current agent, same model, same repo, and compare. Two runs of each one, minimum — the first ones pay cache costs that aren't representative.
*(These commands are put together from documentation and standard tools; I didn't run them in a measured environment, and I won't publish numbers I didn't take myself. If you run it, the numbers you get are worth more than the ones above.)*
## The asterisk: this is not an open source agent
Calling Ante open source would be a factual error, and that's what needs to be clear before recommending it to someone.
What is Apache-2.0, in the public repo:
* `docs-site/` — the documentation source
* `crates/protocol-shape` — the schema and wire messages that `ante serve` speaks
* `crates/agent-sdk` — the Rust SDK and client for building against agent runtimes
* `ante-harbor/` — the Harbor adapter behind the Terminal-Bench results, so you can reproduce any published run
* `crates/exec` — standalone process execution, the first core library released
* `CHANGELOG.md`
What isn't: **the harness.** The core is developed in a private repository during alpha and distributed as a precompiled binary under separate Binary Preview Terms — free to use, even commercially, during the preview.
This dominated the Show HN thread (116 points, 71 comments). The sharpest version, from user `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."* That's not a license purity argument, it's a supply chain one, and it's the correct objection to raise to a binary you're handing write permission over your repo to.
The maintainer conceded it head-on instead of dodging it: *"Will figure out a way to ship with source first to address the security and concern,"* also naming the real tension: *"how to make the project sustainable especially when one has no distribution."* The mitigation the README itself suggests for now is to run Ante in a sandbox, something the single-binary design makes easy: you throw it in a container or on a remote machine.
Telemetry got the same treatment. It comes on by default and turns off with `ANTE_TELEMETRY=off`; what it sends is a random, resettable installation ID plus per-process run IDs, never your user, hostname, or machine ID. Several commenters pointed out that opt-out telemetry looks bad in a tool whose star feature is running without network. The maintainer's answer was that it's a *"carry over from the preview dev build."* Put the variable in your shell profile and move on, but be clear you have to do it.
## What I take away
Ante's pitch is three properties: an agent you can *verify*, *cost out*, and *run anywhere*. Two of those are delivered and checkable today. The footprint is real, the benchmark methodology is more auditable than almost anyone's, and the offline path works once you've set the engine up.
The third is the interesting gap. "Verify" is exactly the property you can't exercise right now, on the component where it would matter most — and the project knows it, says so in the second paragraph of its own README, and conceded the point publicly instead of arguing it. That's better posture than most alpha projects manage. It's still a closed binary that wants write permission over your code.
So: it's fine to install, fine to measure it against what you use today, fine to put it in a container while you do. It's not fine to call it open source, or recommend it to a team on that basis until the harness reaches public.
---
**And you? If a code agent used a seventh of the memory but you couldn't read its code, would you run it — or does that trade only work inside a container?**
---
**Sources:**
* [`AntigmaLabs/ante` — GitHub](https://github.com/AntigmaLabs/ante) (release `v0.preview.76`, Aug 11 2026)
* [Terminal-Bench 2.1, live results — antigma.ai/eval](https://antigma.ai/eval)
* [Resource comparison — docs.antigma.ai](https://docs.antigma.ai/benchmarks/compare_table)
* [Show HN thread — Hacker News](https://news.ycombinator.com/item?id=49245437)
https://github.com/AntigmaLabs/ante