⚠️ Alpha Preview Ante is currently in alpha and provided as a research preview. Expect breaking changes and incomplete functionality. macOS and Linux only.
Ante is an AI-native, cloud-native, local-first agent runtime built by Antigma Labs. A single ~15MB Rust binary with zero runtime dependencies — designed from the ground up for security, performance, and resistance to AI-generated slop.
- Lightweight agent core — ~15MB binary, zero dependencies. Built for minimal overhead and maximum throughput.
- Native local models — Built-in local inference integration. No API keys, no internet, no data leaving your device.
- Zero vendor lock-in — Bring your own API key or local model. Switch between 12+ providers freely. No account required.
- Client-daemon architecture — Run as an interactive TUI, headless CLI, or long-lived server (
ante serve). - Channel integrations — Run Ante as a Slack or Discord bot with
ante gateway. - Multi-agent orchestration — Spawn sub-agents, coordinate complex tasks across independent, decentralized, or centralized architectures.
- Extensible — Custom skills, sub-agents, and persistent memory across sessions.
- Benchmark proven — Topped the Terminal Bench 1.0 and 2.0 leaderboards. Public, reproducible evals.
We care about the harness not the model nor the prompts.
Ante is designed for the cellular-native thesis: agents lightweight enough to run hundreds of replicas in parallel on a single machine. Its ~15MB Rust core uses a fraction of the memory, CPU, and disk I/O of comparable agents — making mass parallelism practical without specialized infrastructure.
Docker resource usage across 20 parallel tasks (Ante vs Claude Code vs Opencode):
Across 20 parallel tasks, Ante uses ~7× less peak memory, ~9× less average CPU, and generates ~5× less total disk I/O than Claude Code — while completing the same workload. See the comparison table and the benchmark details for the evaluation methodology and results.
Ante is distributed as a single, self-contained binary with no external dependencies — just download and run.
curl -fsSL https://ante.run/install.sh | bashante# 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.4 -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"ante serveante gatewayante update|
Providing Context: Files & Folders
|
|
|
|
|
┌─────────────────────────────────────────────────────────────┐
│ Clients │
│ │
│ ┌───────────┐ ┌───────────┐ ┌────────────────────┐ │
│ │ TUI │ │ Headless │ │ ante serve │ │
│ │ (ante) │ │ (ante -p) │ │ (stdio / ws) │ │
│ └─────┬─────┘ └─────┬─────┘ └─────────┬──────────┘ │
└─────────┼────────────────┼─────────────────────┼────────────┘
│ Op │ │
▼ ▼ ▼
┌─────────────────────────────────────────────────────────────┐
│ Daemon │
│ │
│ Session ──▶ Turn ──▶ Step │
│ │
│ ┌──────────┐ ┌──────────────┐ ┌───────────────────┐ │
│ │ Tools │ │ Permission │ │ Skills / Agents │ │
│ └──────────┘ └──────────────┘ └───────────────────┘ │
└────────────────────────┬────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ LLM Providers │
│ │
│ Anthropic · OpenAI · Gemini · Grok · Open Router · Local │
└─────────────────────────────────────────────────────────────┘
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.
Ante is fast, lightweight, and the only terminal agent with native local inference support built in. We believe this self-contained agent core that self organize is the centre of the future of agent economy.
It is just built different.
How is Ante different than other agents
On the high level, it has most of your favorite features (Multi-agents, skills, etc.) of your favorite agents (like Claude Code, Codex, etc.)-
Ante is built from scratch in native Rust, we are obsessed with being self contained, so only essential libraries without framework or runtime dependencies.
-
You only need a llm provider configured to run it. Actually if you have the hardware, you don't even need a llm provider because Ante natively support private inference engine.
-
This resulted in ~15MB self-contained binary and multi-agent orchestration designed to run hundreds of replicas in parallel at scale. See the benchmark details across 20 parallel tasks for concrete numbers.
-
No vendor lock-ins, not even ourself. You don't need an account and can reuse your favorite api credentials.
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.
How do I configure Ante?
Settings live in ~/.ante/settings.json. You can set your default model, provider, theme, and permission policy. CLI flags override settings for individual sessions. See the configuration docs for details.
Can I extend Ante with custom skills or sub-agents?
Yes. Drop skill files in ~/.ante/skills/ (user-level) or .ante/skills/ (project-level) using the Open Agent Skills format. Custom sub-agents go in ~/.ante/agents/ with their own prompts, tool sets, and model overrides.
Full documentation is available at docs.antigma.ai.
The source code is in docs-site/docs