https://github.com/AntigmaLabs/ante-preview
Ghost in your shell. Ante is a self-contained agent harness with a highly optimized core. It works like Claude Code or Codex, with none of their dependencies or model constraints.
https://github.com/AntigmaLabs/ante-preview
agent agentic-ai ai-agents artifical-life rust terminal
Last synced: 1 day ago
JSON representation
Ghost in your shell. Ante is a self-contained agent harness with a highly optimized core. It works like Claude Code or Codex, with none of their dependencies or model constraints.
- Host: GitHub
- URL: https://github.com/AntigmaLabs/ante-preview
- Owner: AntigmaLabs
- License: apache-2.0
- Created: 2025-12-23T23:42:44.000Z (8 months ago)
- Default Branch: main
- Last Pushed: 2026-07-29T19:57:58.000Z (8 days ago)
- Last Synced: 2026-07-29T20:10:05.215Z (8 days ago)
- Topics: agent, agentic-ai, ai-agents, artifical-life, rust, terminal
- Language: Rust
- Homepage: https://antigma.ai
- Size: 80 MB
- Stars: 582
- Watchers: 2
- Forks: 8
- Open Issues: 6
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Awesome Lists containing this project
- awesome-cli-coding-agents - Ante - Bench 2.1 results. Core agent ships as a prebuilt binary. (Terminal-native coding agents / Closed Source)
README
# Ante
> **Alpha preview**: expect breaking changes and incomplete functionality. macOS and Linux only; on Windows we suggest [WSL](https://learn.microsoft.com/windows/wsl/install).
**A ghost in your shell.** Ante is a self-contained coding agent that lives in your terminal and self-organizes. One ~15MB Rust binary from [Antigma Labs](https://antigma.ai), 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.
```sh
curl -fsSL https://ante.run/install.sh | bash
ante
```
Every agent claims to be good. Here are numbers you can check:
### 🥇 Continuously evaled and evolved, in public
Ante runs [Terminal-Bench 2.1](https://antigma.ai/eval) continuously under official leaderboard constraints. For every model we run, Ante is the **#1 same-model agent**. Each result pins the exact build you can download and links the raw Harbor run for independent audit. With open-weight **GLM 5.2, Ante scores 74.6%**: a top-7 slot on the public verified leaderboard.
**[Live results →](https://antigma.ai/eval)** · [Methodology →](https://docs.antigma.ai/benchmarks/eval)
### 🪶 A fraction of the footprint
Ante is hand-written Rust with the heavy parts (`Grep`, `git`, local inference) embedded in one binary, one process. 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 →](https://docs.antigma.ai/benchmarks/compare_table)** · [Benchmark details →](https://docs.antigma.ai/benchmarks/eval)
### 🔌 Natively offline
Ante ships its own inference engine. Point it at a GGUF file and the whole loop runs on your machine: no API key, no account, no internet.
```sh
ante --offline-model ~/.ante/models/Qwen3.5-9B-Q4_K_M.gguf \
-p "add error handling to src/main.rs"
```
**[Offline mode →](https://docs.antigma.ai/usage/offline)**
---
The three 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
**[Models, Providers & Thinking](https://docs.antigma.ai/usage/models-and-thinking)**
**[Providing Context: Files & Folders](https://docs.antigma.ai/usage/providing-context)**
**[Interrupting & Steering](https://docs.antigma.ai/usage/steering)**
**[Subscription Login](https://docs.antigma.ai/usage/login)**
[See all cookbook guides](https://docs.antigma.ai/usage/providers)
## Quick Start
### Installation
Ante is a single, self-contained binary with no external dependencies: download and run.
```sh
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
| Mode | Command | Use it for |
|------|---------|------------|
| [Interactive TUI](https://docs.antigma.ai/usage/tui) | `ante` | day-to-day work in the terminal |
| [Headless](https://docs.antigma.ai/usage/headless) | `ante -p "..."` | one-shot tasks, scripts, CI |
| [Server](https://docs.antigma.ai/usage/serve) | `ante serve` | editor plugins and integrations, over a JSONL protocol |
| [Gateway](https://docs.antigma.ai/usage/gateway) | `ante gateway` | running Ante as a Slack or Discord bot |
### Headless examples
```sh
# 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.5 -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
```sh
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.33
```
## Beyond the headline numbers
- **Zero vendor lock-in**: bring your own API key, subscription, or local model. Switch between 12+ providers freely. No account required, not even with us.
- **Multi-agent orchestration**: spawn sub-agents and coordinate complex tasks across independent, decentralized, and centralized architectures. [See the patterns →](https://docs.antigma.ai/experimental/agent-org)
- **Channel integrations**: run Ante as a Slack or Discord bot with `ante gateway`.
- **Extensible**: custom skills, sub-agents, MCP, and persistent memory across sessions.
## Supported Providers
Ante works with 12+ providers out of the box:
| Provider | Example Models |
|----------|---------------|
| Anthropic | Claude Sonnet 4.5, Opus 4.6 |
| OpenAI | GPT-5 family |
| Google Gemini | Gemini 3 family |
| Grok (xAI) | Grok 4 |
| Open Router | Multiple providers |
| Local (GGUF) | Any GGUF model via built-in llama.cpp |
| ...and more | Vertex AI, Zai, Antix, OpenAI-compatible |
Configure providers via environment variables (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, etc.) or OAuth. Add custom providers in `~/.ante/catalog.json`.
## What's in this repo
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/`](docs-site) is the source for [docs.antigma.ai](https://docs.antigma.ai): a precise description of what the harness does and how to drive it.
2. **The protocol, the algorithm of the core.** [`crates/protocol-shape`](crates/protocol-shape) defines the schema and wire messages spoken by `ante serve`; [`crates/agent-sdk`](crates/agent-sdk) is the Rust SDK and client for building against agent runtimes.
3. **The eval pipeline, constraint and continuous improvement.** [`ante-harbor/`](ante-harbor) is the Harbor agent adapter behind our Terminal-Bench results: use it to reproduce any run at [antigma.ai/eval](https://antigma.ai/eval). [`CHANGELOG.md`](CHANGELOG.md) records the improvement, release by release.
The core harness itself is developed in a private repository during the alpha and ships as a prebuilt binary via [releases](https://github.com/AntigmaLabs/ante-preview/releases). Core libraries from it are included here progressively as they stabilize; [`crates/exec`](crates/exec), standalone process execution, is the first.
The protocol surface maps to Ante's client-daemon architecture:
```
┌─────────────────────────────────────────────────────────────┐
│ Clients │
│ │
│ ┌───────────┐ ┌───────────┐ ┌────────────────────┐ │
│ │ TUI │ │ Headless │ │ ante serve │ │
│ │ (ante) │ │ (ante -p) │ │ (stdio / ws) │ │
│ └─────┬─────┘ └─────┬─────┘ └─────────┬──────────┘ │
└─────────┼────────────────┼─────────────────────┼────────────┘
│ │ │
▼ ▼ ▼
┌─────────────────────────────────────────────────────────────┐
│ Daemon │
│ │
│ Session ──▶ Turn ──▶ Step │
│ │
│ ┌──────────┐ ┌──────────────┐ ┌───────────────────┐ │
│ │ Tools │ │ Permission │ │ Skills / Agents │ │
│ └──────────┘ └──────────────┘ └───────────────────┘ │
└────────────────────────┬────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ LLM Providers │
│ │
│ Anthropic · OpenAI · Gemini · Grok · Open Router · Local │
└─────────────────────────────────────────────────────────────┘
```
## The bigger picture
> **We care about the harness, not the model or the prompts.**
>
> **Documentation is the new source code.**
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](https://docs.antigma.ai/start/philosophy) and [agent organization patterns](https://docs.antigma.ai/experimental/agent-org).
## FAQ
### Why another terminal agent?
The name is the answer: **An**other **Te**rminal 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.
How is Ante different from other agents?
Ante has most of the features you expect from agents like Claude Code or Codex: multi-agents, skills, MCP, persistent memory. The difference is the build philosophy.
- Built from scratch in Rust. Core components like `Grep` (fully rebuilt and customized) and `git` are embedded in the same ~15MB binary and run in the same process at runtime, so nothing is shelled out and no resources leak. Most similar projects ship on Node.js or CPython and carry an order-of-magnitude larger footprint.
- We built our own inference engine from the ground up (see [nanochat-rs](https://github.com/AntigmaLabs/nanochat-rs) for a toy version of that work), so a local GGUF model is all Ante needs to run without any provider.
- No vendor lock-in, not even to ourselves: no account needed, reuse your existing API credentials. An opt-in, fully integrated server-side experience lives at [antix.antigma.ai](https://antix.antigma.ai).
- Every claim is backed by public, reproducible benchmarks of the exact builds we ship: [antigma.ai/eval](https://antigma.ai/eval).
Beyond the footprint it comes down to agent architecture, and ultimately to *who* is building it and with what philosophy. Anyone can fork a binary; taste and engineering rigor don't copy. Those differences leak into every detail of the product.
Why care about runtime optimization like memory and I/O if model inference is usually the biggest bottleneck?
For one-on-one agent interactions, runtime overhead like memory usage and I/O is often less important than model inference.
But our vision is much bigger: millions of agents self-organizing and communicating at massive scale. At that point, even small inefficiencies get multiplied millions or billions of times, so runtime optimization becomes economically significant.
Can I run Ante completely offline?
Yes. Ante has a built-in llama.cpp engine that runs GGUF models locally. It handles engine installation, model discovery, and memory management automatically. No API keys or internet connection required.
Can I use my own custom models or providers?
Yes. Create a `~/.ante/catalog.json` file to add or override providers and models with custom endpoints, API keys, and configurations. Any OpenAI-compatible API works.
What is the ante serve mode for?
Server mode runs Ante as a long-lived daemon that communicates over a structured JSONL protocol. It's ideal for building editor plugins, web UIs, and custom integrations on top of Ante.
## Documentation
Full documentation is available at [docs.antigma.ai](https://docs.antigma.ai).
## License
Source code in this repository (including the SDK and protocol crates) is
licensed under the [Apache License 2.0](LICENSE).
The prebuilt `ante` binary is free to use — including commercially — during
the alpha preview under the [Binary Preview Terms](BINARY-TERMS.md). The core
harness is currently developed in a private repository and shipped as a
binary; the SDK and protocol surface you build against here will remain
permissively licensed.