TL;DR

Ante is a terminal coding agent from Antigma Labs that ships as one ~15MB Rust binary with no runtime dependencies — and with a llama.cpp inference engine inside it, so the entire loop can run on your laptop with no API key, no account, and no internet. Highlights:

  • 1,791 GitHub stars, 58 forks, repo opened December 23, 2025; currently at v0.preview.81 (August 15, 2026)
  • ~15MB single binary: TUI, a rebuilt Grep, git, local PDF/OCR, and a managed llama.cpp all live in one process
  • Terminal-Bench 2.1: 82.7% with the open-weight DeepSeek V4 Flash 0731 model (368/445 trials, ~$68 of inference), run under official leaderboard constraints with publishable raw runs
  • ~7× less peak memory, ~9× less average CPU, ~5× less disk I/O than Claude Code across 20 parallel Dockerized tasks
  • Four modes: interactive TUI, headless (ante -p), server (ante serve, JSONL protocol), and gateway (Slack/Discord bot)
  • The honest catch: the core harness is a closed prebuilt binary — the repo holds docs, protocol, SDK, and eval pipeline. Telemetry is opt-out, not opt-in. It’s an alpha preview, macOS/Linux only, and it was actually slower in wall time than Claude Code on the same benchmark.

If you run agents by the dozen in containers, or need a coding agent that works air-gapped, Ante is the most interesting thing in this category right now. If “open source” is a hard requirement, read the licensing section first.

What is Ante?

Ante is Antigma Labs’ answer to a specific complaint about the current generation of terminal coding agents: they’re heavy. Claude Code and Codex are excellent, but they arrive as Node.js applications with a node_modules tree, shell out to external binaries for search and version control, and assume a live connection to a hosted model.

Ante inverts all three assumptions. It’s hand-written Rust compiled to a single self-contained executable. The parts other agents shell out to — ripgrep-style search, git, PDF and OCR handling — are compiled into the binary and run in the same process. The inference engine is a pinned, checksum-verified official llama.cpp build that Ante installs and manages for you, matched to your hardware (Metal on Apple silicon; CUDA, Vulkan, or CPU on Linux).

The name is a double pun the team owns up to in their FAQ: Another Terminal agent, and ante, the stake you put on the table to play. Installation is a one-liner:

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

The thesis behind it is what the team calls cellular-native agents — “tiny, expendable, massively replicated,” like cells in an organism. That framing explains the engineering priorities better than any feature list: if you intend to run thousands of agents at once, a 3.6GB average memory footprint per agent is a budget problem, not a detail.

Ante hit the Hacker News front page on August 10, 2026 with a Show HN that collected 169 points and 90 comments, the founder (ubermon) answering the hard questions rather than the easy ones. The timing matters: open-weight models got genuinely good at agentic coding in 2026, and enough people now run parallel agent fleets that per-agent overhead is a real line item. Ante targets that intersection.

The benchmarks, with caveats attached

Ante makes two quantitative claims. Both are checkable, which is more than most agent projects offer — and both need context.

Terminal-Bench 2.1: 82.7%

Ante runs Terminal-Bench 2.1 continuously under official leaderboard constraints — 89 tasks, 5 trials each — pinning each result to the exact downloadable build and linking the raw Harbor run for audit. Latest full run: 82.7% (368/445 trials) on Ante 0.preview.71 with DeepSeek V4 Flash 0731, at roughly $68 of inference.

The number that makes this credible rather than promotional: DeepSeek independently reports the same 82.7% for that model using its own unreleased harness in minimal mode. Ante isn’t inflating the model’s score — but it isn’t beating it either. The parity demonstrates that Ante’s harness doesn’t lose points relative to the model vendor’s own scaffolding, which is a reasonable thing for a harness to prove.

Resource footprint: the real story

The team ran 20 parallel tasks through Ante, Claude Code, and OpenCode in Docker under identical constraints. The headline is 7×/9×/5×. The actual numbers:

MetricAnteClaude CodeOpenCode
Peak memory (MiB)1,96813,87712,944
Avg memory (MiB)6833,6852,077
Avg CPU (%)1.312.13.8
P99 CPU (%)12.343.462.3
Total disk read (MB)2417,4442,224
Total disk write (MB)2,78515,11631,427
Wall time (s)9406271,076

The memory and I/O gaps are enormous and clearly real — 24MB of total disk reads versus 17.4GB comes from architecture, not tuning. That’s what “embedded Grep in the same process” buys you.

But look at the last row. Ante took 940 seconds; Claude Code took 627 — roughly 50% slower in wall-clock time. The team doesn’t hide it (it’s the first table in their own docs), but it isn’t in the headline either, and it’s the most important caveat for interactive use. Efficiency and speed are different axes: one developer at one terminal feels the 940 and never notices the 683MB; someone running 200 agents on one box sees the arithmetic flip.

This is also a vendor-run benchmark. The methodology is published and the eval adapter (ante-harbor) is open source and reproducible — better than a screenshot — but nobody independent has reproduced it yet.

Running it offline

This is the feature nothing else in the category has natively. Point Ante at a GGUF file and the loop is entirely local:

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

No API key, no account, no network. Ante handles engine installation, model discovery, and memory management itself. For regulated environments, air-gapped machines, or anyone who doesn’t want their codebase leaving the laptop, this is the whole reason to look at Ante.

Be realistic. A 9B model quantized to Q4 will not plan a multi-file refactor the way a frontier model does. The founder was blunt on HN: offline mode is “a choice — should be able to run frontier one first and then figure out how to incorporate local models as real workhorse.” Treat local as a capability floor for privacy-constrained work, not a replacement for a good model.

The four modes

ModeCommandUse it for
Interactive TUIanteday-to-day terminal work
Headlessante -p "..."one-shot tasks, scripts, CI
Serverante serveeditor plugins and integrations over JSONL
Gatewayante gatewayrunning Ante as a Slack or Discord bot

Headless mode is where the single-binary design pays off — it pipes like a Unix tool:

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

# Point at a different provider, or resume a saved session
ante --provider openai --model gpt-5.5 -p "refactor the database module"
ante --resume ses_01ARZ3NDEKTSV4RRFFQ69G5FAV -p "now add tests"

ante serve exposes a documented JSONL protocol (schema in the open-source crates/protocol-shape, Rust client in crates/agent-sdk). If you’re building an editor plugin or web UI on an agent runtime, that protocol surface is arguably more valuable than the TUI.

Profiles: one binary, many agents

Ante’s behavior lives entirely in a settings file, and --profile <name> swaps that file per run — system prompt, tool set, skills, memory. The same binary can be a full assistant in one terminal and a minimal agent in the next.

The curated pi profile is the instructive extreme: Ante stripped to four tools (Read, Write, Edit, Bash) plus one short replacement system prompt. File search goes through rg, subagents through ante -p "<task>", web access through curl:

cp curated/profiles/pi.settings.json ~/.ante/
ante --profile pi

A profile replaces the whole settings file, so anything it omits falls back to defaults, and explicit CLI flags still win. There’s also a built-in bare profile: no skills, MCP servers, session saving, or auto-memory. If you’ve ever wanted to A/B test whether your agent’s 40-tool inventory actually helps, this is a cheap way to find out.

Providers and lock-in

Ante maintains 17 built-in provider presets — Anthropic, OpenAI, Gemini, Grok, DeepSeek, OpenRouter, Zai, local GGUF, and more — each handling the per-provider quirks (wire dialect, API key vs OAuth, thinking and streaming behavior). Anything else is a config entry, not a plugin: Ante speaks four API dialects, so your own proxy or gateway is a few lines in ~/.ante/catalog.json:

{
  "providers": {
    "my-gateway": {
      "base_url": "https://gateway.example.com/v1",
      "wire_style": "OpenAiCompatible",
      "auth": { "bearer": { "env_key": "MY_GATEWAY_API_KEY" } },
      "http_headers": { "X-Org": "my-team" },
      "extra_body": { "service_tier": "priority" }
    }
  }
}

No account with Antigma is required at any point — a claim the project repeats in three places.

What the community actually said

The HN thread split cleanly into two objections, and they’re both worth taking seriously.

1. “Where is the source code?” The first substantive question asked, and the sharpest exchange in the thread. swiftcoder put it most directly: “A GitHub repo with no source code is exactly equivalent to linking the binary directly.” NitpickLawyer added that linking a GitHub repo for what is really a binary release “is a bit iffy… might confuse folks.”

The founder’s answer: only some core crates have been migrated, and it will happen “progressively.” Progress is tracked in issue #21.

A competing project surfaced in the same thread — hax, an MIT-licensed coding agent in C, pitched as “what this promises, except actually fully open source.” If the closed core is a dealbreaker, that’s the thread’s own suggested alternative.

2. Opt-out telemetry. This drew more heat than anything else. majorchord: “Opt-out telemetry is a hard no for me, sorry.” nextblock landed the argument that sticks: “When a tool is explicitly marketed for offline use, opt-out telemetry feels especially contradictory.”

To the team’s credit, the response was “feedback received, it was carry over from the preview dev build” rather than a defense. What it sends is anonymous — a random installation label you can delete and re-mint, never your username, hostname, or machine ID — and ANTE_TELEMETRY=off disables export entirely. But the default is wrong for a tool whose headline feature is not needing the network.

A smaller exchange shows the project responding well to scrutiny: felooboolooomba noticed the README claimed Ante “ships its own inference engine” while the HN post said it installs an official llama.cpp build. The README was corrected the same day.

Who should use Ante — and who shouldn’t

Good fit:

  • You run many agents in parallel in containers, where per-agent memory and I/O are a real cost
  • You need coding assistance on air-gapped or privacy-constrained machines
  • You’re building an editor plugin or custom UI and want a documented JSONL agent protocol
  • You want to experiment with minimal agent designs (pi and bare make this trivial)
  • Deployment simplicity matters — one binary, scp it, done

Look elsewhere if:

  • You need to audit or fork the agent’s core logic (it isn’t published)
  • Single-task wall-clock latency is your primary metric — Claude Code was ~33% faster here
  • You’re on Windows without WSL — macOS and Linux only
  • You need stability today; this is an alpha at v0.preview.81 with explicit breaking-change warnings
  • Opt-out telemetry violates your organization’s policy (one env var, but a default you’d manage in your image)

Versus the alternatives

AnteClaude CodeOpenCodehax
RuntimeSingle Rust binary (~15MB)Node.jsNode.jsSingle C binary
Core licenseClosed (docs/SDK Apache-2.0)ProprietaryOpen sourceMIT
Native local inference✅ embedded llama.cpp❌❌❌
Peak memory (20 tasks)1,968 MiB13,877 MiB12,944 MiB—
Model choice17 presets + any OpenAI-compatibleAnthropicMulti-providerMulti-provider

FAQ

Is Ante open source? Partially, and the distinction matters. The docs, the ante serve protocol schema, the Rust agent SDK, the eval pipeline, and the crates/exec library are Apache-2.0. The core harness is not published — it ships as a prebuilt binary from a private repo, free for commercial use during alpha under Binary Preview Terms. More crates are promised progressively (issue #21). If you need a fully open agent today, hax (MIT) or OpenCode are the honest recommendations.

Can Ante really run with no internet? Yes. The embedded llama.cpp engine runs any GGUF model locally, with automatic engine install, model discovery, and memory management. No API key or account needed. Quality is bounded by whatever local model fits in memory — this is a privacy and availability feature first, a capability feature second.

How do I turn off telemetry? Set ANTE_TELEMETRY=off to disable export entirely. It’s opt-out by default, which the maintainers acknowledged as leftover behavior from preview dev builds after HN pushback.

Is Ante faster than Claude Code? Not in wall-clock time. On the vendor’s own 20-parallel-task benchmark, Ante finished in 940 seconds versus Claude Code’s 627. Ante’s advantage is resource efficiency — ~7× lower peak memory and ~5× less disk I/O — which pays off when you multiply agents, not when you run one.

Does it support MCP, subagents, and skills? Yes to all three, plus persistent memory across sessions. The bare profile disables all of it if you want a clean baseline.

Does it run on Windows? Not natively. macOS and Linux only; WSL is the recommended path. A Windows build and a Cosmopolitan-style portable executable were both raised on HN and added to the backlog, not shipped.

Verdict

Ante is the most architecturally interesting coding agent released in 2026, and it’s honest about its numbers in ways that remain rare — publishing a wall-time table that makes you look slower than a competitor is not the behavior of a project massaging results.

The problem is the shape of the thing. Ante’s pitch is verifiability — “here are numbers you can check” — and it lands that for benchmarks while withholding the one artifact that would complete it. You can audit the eval, reproduce the run, and read the protocol; you cannot read the agent. For a tool handed filesystem and shell access, that gap isn’t pedantry, and the HN thread was right to press on it.

Install it in a container, run offline mode, and see whether the footprint numbers hold for your workload — they’re real and they’re large. Just don’t file it under “open source” until issue #21 closes.

Sources