Introducing Ante: A Lightweight, Offline-Capable Coding Agent

Ante is a high-performance, self-organizing coding agent designed to reside directly in your terminal. Developed by Antigma Labs, it is delivered as a single, optimized Rust binary of approximately ~15MB with zero runtime dependencies.

While it shares functional similarities with tools like Codex or Claude Code, Ante removes the ~~heavy dependencies~~ and ~~model restrictions~~ associated with those platforms. It can serve as a standalone agent or as the high-efficiency core for your own custom AI assistants.

🚀 Performance & Verification

Unlike many agents that make vague claims, Ante provides verifiable data. It is continuously evolved and evaluated using Terminal-Bench 2.1 under strict official constraints (89 tasks, 5 trials each).

"An agent you can verify, afford, and run anywhere is light enough to run by the thousands: the substrate for self-organizing intelligence."

The Numbers

Latest Benchmark: Achieved a score of $82.7\%$ using the open-weight DeepSeek V4 Flash 0731 (368/445 successful trials).
Cost Efficiency: This run cost approximately $\$ 68$ in inference.
Auditability: Every result is pinned to a specific build and linked to a raw Harbor run for transparency.

Resource Efficiency

Ante is written in hand-optimized Rust, embedding essential tools like git and grep into a single process. When compared to Claude Code across 20 parallel Docker tasks, the efficiency gains are significant:

Metric	Ante vs. Claude Code	LaTeX Representation
Peak Memory	$\approx 7\times$ Less	$\text{Mem}_{\text{Ante}} \approx \frac{1}{7} \text{Mem}_{\text{Claude}}$
Average CPU	$\approx 9\times$ Less	$\text{CPU}_{\text{Ante}} \approx \frac{1}{9} \text{CPU}_{\text{Claude}}$
Disk I/O	$\approx 5\times$ Less	$\text{IO}_{\text{Ante}} \approx \frac{1}{5} \text{IO}_{\text{Claude}}$

🔌 Native Offline Capabilities

Ante features a built-in, managed version of llama.cpp. By pointing the agent to a .gguf file, the entire operational loop runs locally.

Benefits of Offline Mode:

No API keys required.
No account registration.
No internet connection necessary.

# Example: Running a local Qwen model for error handling
ante --offline-model ~/.ante/models/Qwen3.5-9B-Q4_K_M.gguf \
     -p "add error handling to src/main.rs"

🛠️ Installation & Usage

Quick Start Checklist

Install the binary via curl
Configure your preferred LLM provider
Run your first headless task

Installation Commands:

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

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

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

Operational Modes

Mode	Command	Primary Use Case
Interactive	`ante`	Standard TUI for daily terminal work
Headless	`ante -p "..."`	One-off tasks, CI/CD pipelines, or scripting
Server	`ante serve`	Integration with editors via JSONL protocol
Gateway	`ante gateway`	Deploying Ante as a Discord or Slack bot

Headless Examples

Bug Fixing: ante -p "find and fix the failing test in src/auth"
Security Review: git diff | ante -p "review this for security issues"
Custom Model: ante --provider openai --model gpt-5.5 -p "refactor the database module"
Session Recovery: ante --resume ses_01ARZ3NDEKTSV4RRFFQ69G5FAV -p "now add tests"

Maintenance

Update: ante update
Switch Channel: ante update --channel nightly
Pin Version: ante update --version v0.preview.71

🌐 Ecosystem & Extensibility

Ante is designed to prevent vendor lock-in. You can bring your own local models, subscriptions, or API keys.

Supported Providers

Ante supports over 12 providers out of the box:

Provider	Example Models
Anthropic	Claude Sonnet 4.5, Opus 4.6
OpenAI	GPT-5 family
Google	Gemini 3 family
xAI	Grok 4
Open Router	Various aggregated providers
Local	Any GGUF model (via `llama.cpp`)
Others	Vertex AI, Zai, Antix, OpenAI-compatible APIs

Configuration is handled via OAuth or environment variables (e.g., ANTHROPIC_API_KEY).

Advanced Features

Multi-Agent Orchestration: Ability to spawn and coordinate sub-agents across decentralized or centralized architectures.
Extensibility: Supports persistent memory across sessions, custom skills, and the Model Context Protocol (MCP).

📦 Repository Structure

The project is open-sourced under the Apache 2.0 license. While the core harness is currently in a private alpha repository (shipped as a binary), the following components are public:

docs-site/: Source for the official documentation.
crates/protocol-shape: Defines the wire messages and schema for ante serve.
crates/agent-sdk: The Rust SDK for building against agent runtimes.
ante-harbor/: The adapter used to reproduce the results found at antigma.ai/eval.
crates/exec: Standalone process execution libraries.