# Ante

> Ante is a self-contained, lightweight coding agent that runs in your terminal, built in Rust with native local inference, zero runtime dependencies, and support for 12+ AI providers.

Ante is a terminal-based coding agent from Antigma Labs, built from scratch in Rust as a single ~15MB binary with zero runtime dependencies. It works similarly to Claude Code or Codex but without their dependency chains or model constraints, and it supports fully offline operation via a built-in llama.cpp inference engine. The project is currently in alpha preview, available on macOS and Linux (with WSL support on Windows).

## What It Is

Ante is a CLI coding agent designed around what Antigma Labs calls "cellular-native" architecture — agents that are tiny, expendable, and massively replicable, like cells in an organism. The core harness ships as a prebuilt binary (developed in a private repository during alpha), while the docs, protocol definitions, Rust SDK, and eval pipeline are open-sourced under Apache 2.0 in the public GitHub repo. The binary itself is free to use commercially under Binary Preview Terms during the alpha period.

## How the Agent Works

Ante operates in four modes:

- **Interactive TUI** (`ante`) — day-to-day terminal work
- **Headless** (`ante -p "..."`) — one-shot tasks, scripts, and CI pipelines
- **Server** (`ante serve`) — runs as a long-lived daemon over a JSONL protocol for editor plugins and integrations
- **Gateway** (`ante gateway`) — runs Ante as a Slack or Discord bot

The agent reads your codebase, executes tasks, and produces working output. Tools like `Grep` and `git` are embedded directly in the binary and run in the same process, so nothing is shelled out and no resources leak.

## Offline-First and Provider-Agnostic Design

Ante's built-in llama.cpp integration lets users point it at any GGUF model file and run the entire agent loop locally — no API key, no account, no internet connection required. For cloud inference, it supports 12+ providers out of the box, including Anthropic, OpenAI, Google Gemini, Grok (xAI), Open Router, Vertex AI, and any OpenAI-compatible API. Users can switch providers freely by bringing their own API keys or OAuth credentials, with no account required with Antigma itself.

## Resource Footprint and Benchmarks

Antigma publishes continuous public benchmarks via Terminal-Bench 2.1 (89 tasks, 5 trials each), with raw Harbor run data linked for independent audit. According to vendor-published benchmark results, Ante uses approximately 7× less peak memory, 9× less average CPU, and 5× less total disk I/O than Claude Code across 20 parallel tasks in Docker. The latest full benchmark run cited on the repo achieved 82.7% on Terminal-Bench 2.1 using DeepSeek V4 Flash 0731 (Ante v0.preview.71).

## Architecture and Extensibility

Ante's client-daemon architecture separates clients (TUI, headless, server) from a central daemon that manages sessions, turns, steps, tools, permissions, and skills. Key extensibility features include:

- **Multi-agent orchestration** — spawn sub-agents across independent, decentralized, and centralized architectures
- **Custom skills and persistent memory** — skills and memory persist across sessions
- **MCP support** — Model Context Protocol integration
- **Custom providers** — add or override providers via `~/.ante/catalog.json`
- **Telemetry** — opt-out via `ANTE_TELEMETRY=off`

## Update: v0.preview.75

The latest release is v0.preview.75, published on August 11, 2026, reflecting active and frequent iteration during the alpha preview phase. The public CHANGELOG tracks improvements release by release. Antigma has also open-sourced a companion project, nanochat-rs, a tiny GPT-style cognitive core written in pure Rust, as a study resource for understanding local inference engines. The project's GitHub repository has accumulated over 1,000 stars since its creation in December 2025, signaling early community traction.

## Features
- Single ~15MB self-contained Rust binary with zero runtime dependencies
- Native offline inference via built-in llama.cpp with GGUF model support
- Interactive TUI, headless, server, and gateway modes
- Support for 12+ AI providers including Anthropic, OpenAI, Gemini, Grok, and Open Router
- Multi-agent orchestration with independent, decentralized, and centralized architectures
- Custom skills and persistent memory across sessions
- MCP (Model Context Protocol) support
- Slack and Discord bot gateway mode
- Continuous public benchmarks via Terminal-Bench 2.1
- Zero vendor lock-in — bring your own API key or local model
- Opt-out telemetry via ANTE_TELEMETRY=off
- Custom provider configuration via catalog.json
- Session resume support
- Embedded Grep and git tools running in-process

## Integrations
Anthropic Claude, OpenAI GPT, Google Gemini, Grok (xAI), Open Router, Vertex AI, llama.cpp (local GGUF models), Slack, Discord, MCP (Model Context Protocol), OpenAI-compatible APIs, Zai, Antix

## Platforms
WINDOWS, MACOS, LINUX, WEB, API, DEVELOPER_SDK, CLI

## Pricing
Open Source

## Version
v0.preview.75

## Links
- Website: https://antigma.ai
- Documentation: https://docs.antigma.ai
- Repository: https://github.com/AntigmaLabs/ante
- EveryDev.ai: https://www.everydev.ai/tools/ante