Run autonomous coding agents in your terminal or CI pipeline

Ante

A ghost in your shell. Ante is a self-contained coding agent that lives in your terminal and self-organizes. One ~15MB compressed download from Antigma Labs that expands to a single Rust executable with zero runtime dependencies, built to get the most out of any model.

It works like Claude Code or Codex, with none of their dependencies or model constraints. It can also be the optimized core for building your own harness and high-performing assistants.

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

We care about the harness, not a co-trained model or a secret prompt. The harness and the model are a dynamic duo: they should evolve together but not be bound together. Prompts belong to the user.

Ante makes this declarative: one settings profile can define the whole agent, replacement system prompt included.

🥇 Continuously evaluated and evolved in public

We evaluate Ante as a harness across different model families instead of coupling it to one hero model. Ante runs Terminal-Bench 2.1 continuously under official leaderboard constraints: 89 tasks, 5 trials each. Each result pins the exact Ante build you can download and links the raw Harbor run for independent audit. Latest full run: 83.9% with open-weight DeepSeek V4.1 Flash (370/445 trials, Ante 0.preview.98, about $18 of inference).

Same model, different harness

Live cross-model results → · Same-model harness comparison → · Methodology →

🪶 A fraction of the footprint

Ante is hand-written Rust: the heavy parts (Grep, git) are embedded in one binary and one process, and local inference is handled by a managed llama.cpp. Across the same 20 parallel tasks in Docker, Ante uses ~7× less peak memory, ~9× less average CPU, and ~5× less disk I/O than Claude Code.

Raw numbers → · Benchmark details →

🔌 Natively offline

Ante's inference engine is a pinned, managed version of llama.cpp. Point it at a GGUF file and the whole loop runs on your machine: no API key, no account, no internet.

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

We think about the engine layer in public too. nanochat-rs is a small GPT inference core we wrote in pure Rust on candle: readable, runnable, and living in the same process as the code that calls it. It is a study project rather than part of the binary, published because in-process inference is where local models get interesting for agents.

Offline mode → · nanochat-rs → · Where this is going →

These three properties are one design decision. An agent you can verify, afford, and run anywhere is light enough to run by the thousands: the substrate for self-organizing intelligence.

See it in action

See all cookbook guides

Quick Start

Installation

Ante is a single, self-contained binary with no external dependencies: download and run.

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

# Install a specific release channel
curl -fsSL https://ante.run/install.sh | bash -s -- nightly

# Install into a directory already on PATH
curl -fsSL https://ante.run/install.sh | ANTE_INSTALL_DIR=/usr/local/bin bash

Modes

Headless examples

# Fix a bug
ante -p "find and fix the failing test in src/auth"

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

# Use a different provider
ante --provider openai --model gpt-5.6 -p "refactor the database module"

# Resume a saved session
ante --resume ses_01ARZ3NDEKTSV4RRFFQ69G5FAV -p "now add tests"

# Run fully offline with a local GGUF model
ante --offline-model ~/.ante/models/Qwen3.5-9B-Q4_K_M.gguf \
  -p "add error handling to src/main.rs"

Update Ante

ante update

# One-off update from a different channel
ante update --channel nightly

# Roll back or pin to an exact release
ante update --version v0.preview.99

One binary, many agents

Ante's behavior lives 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.

For project-specific workflows, Ante also respects .ante/settings.json at your repository root, layering team settings (such as enabled MCP servers, allowed tools, and default models) right alongside user preferences.

Curated profiles demonstrate how flexible this is:

• pi: Strips Ante down to four tools (Read, Write, Edit, Bash) and a short replacement system prompt; file search runs through rg, subagents through ante -p "<task>", web access through curl.
• plan: A read-only research and planning agent with file mutations disabled, designed to produce an implementation plan before you execute.

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

A profile replaces the whole settings file, so anything it omits falls back to Ante defaults, and explicit CLI flags still win. Ante also ships a built-in bare profile for stripped-down runs: no skills, MCP servers, session saving, or auto-memory. Share what you build in curated/.

Named profiles → · Project settings → · Curated profiles →

Supported Providers

Bring your own API key, subscription, or local model; no account required, not even with us. Provider support comes in two layers.

Built-in presets we maintain. 17 presets, each tested and kept current, so the per-provider quirks are already handled: wire dialect, API key and OAuth flows, thinking and streaming behavior.

A config layer for everything else. Your own proxy, gateway, or inference engine is one entry in ~/.ante/catalog.json: a wire_style (Ante speaks four API dialects), an auth style (bearer, header, or query, from an env var or OAuth), plus http_headers and extra_body for whatever else the endpoint expects. The combinations cover most setups without a plugin or a code change:

{
  "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" }
    }
  }
}

Providers guide → · Catalog Reference →

What's in this repo

Documentation is the new source code.

We open sourced what really matters in the age of agentic coding, all under Apache 2.0:

1. Detailed documentation, the descriptive truth. docs-site/ is the source for docs.antigma.ai: a precise description of what the harness does and how to drive it.
2. The protocol and client SDKs. crates/protocol-shape defines the wire messages and schema spoken by ante serve; crates/ante-sdk is the async Rust SDK for controlling Ante over stdio or Unix domain sockets; ante-acp provides Agent Client Protocol support.
3. Core primitives and execution engine. As parts of the private core stabilize, they are open-sourced here: crates/exec provides bounded async process execution, and crates/llm supplies provider profiles and shared LLM primitives.
4. The eval pipeline, constraint and continuous improvement. ante-harbor/ is the Harbor agent adapter behind our Terminal-Bench results: use it to reproduce any run at antigma.ai/eval. CHANGELOG.md records the improvement, release by release.

Alongside these, curated/ is a shared space for reusable pieces from the team and community, laid out to mirror ~/.ante/: settings profiles like pi and plan, and skills.

The core harness itself is developed in a private repository during the alpha and ships as a prebuilt binary via releases. Core libraries from it continue to be extracted here as they stabilize; progress is tracked in issue #21.

The protocol surface maps to Ante's client-daemon architecture:

┌─────────────────────────────────────────────────────────────┐
│                         Clients                             │
│                                                             │
│   ┌───────────┐    ┌───────────┐    ┌────────────────────┐  │
│   │    TUI    │    │ Headless  │    │    ante serve      │  │
│   │  (ante)   │    │ (ante -p) │    │   stdio/sock/ws    │  │
│   └─────┬─────┘    └─────┬─────┘    └─────────┬──────────┘  │
└─────────┼────────────────┼─────────────────────┼────────────┘
          │                │                     │
          ▼                ▼                     ▼
┌─────────────────────────────────────────────────────────────┐
│                         Daemon                              │
│                                                             │
│   Session ──▶ Turn ──▶ Step                                │
│                                                             │
│   ┌──────────┐  ┌──────────────┐  ┌───────────────────┐     │
│   │  Tools   │  │  Permission  │  │  Skills / Agents  │     │
│   └──────────┘  └──────────────┘  └───────────────────┘     │
└────────────────────────┬────────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────────────┐
│                     LLM Providers                           │
│                                                             │
│   Anthropic · OpenAI · Gemini · Grok · Open Router · Local  │
└─────────────────────────────────────────────────────────────┘

The bigger picture

Ante is designed for cellular-native agents: like cells in an organism, tiny, expendable, massively replicated. That thesis is why the three headline claims exist. A cell-scale agent must be verified (reliability compounds at scale), tiny (every byte is multiplied by thousands), and self-contained (no runtime to install, no service to phone home to). Read more in our philosophy and agent organization patterns.

FAQ

Why another terminal agent?

The name is the answer: Another Terminal agent, and ante, the stake you put on the table to play. Ante is fast, lightweight, and the only terminal agent with native local inference built in. We believe a self-contained agent core that self-organizes is the foundation of the coming agent economy.

Documentation

Full documentation is available at docs.antigma.ai.