Show HN：Ante，一款可离线运行的单二进制编码 Agent

Alpha 预览版：预计会有破坏性变更和未完成的功能。仅支持 macOS 和 Linux；Windows 用户建议使用 WSL。

许多人会问两件事：

源代码在哪里？ 核心 harness 目前以预编译二进制形式发布；这个仓库包含文档、协议、SDK 和评测流水线（详见下文）。我们正研究一种可将源代码与二进制一同发布的方式，首先解决安全和隐私顾虑，同时花时间探索在 Agent 时代开源应如何运作。如果你目前有所顾虑，请在沙箱中运行 Ante：它是一个运行时依赖极少的单一二进制文件，旨在轻松部署到容器或远程机器中。

有遥测吗？ 有，且采用退出机制：设置 ANTE_TELEMETRY=off 即可完全禁用数据导出。RUST_LOG 过滤器同样会应用于导出的日志，这是从 Rust 生态系统沿用而来的便利功能。更好的用户体验正在开发中。详情 →

---

你 Shell 中的幽灵。 Ante 是一个自包含、可在终端中运行并能自组织的编码 Agent。它由 Antigma Labs 推出，是一个约 15MB 的 Rust 二进制文件，零运行时依赖，旨在充分发挥任意模型的能力。

它的工作方式类似 Claude Code 或 Codex，但没有它们的依赖与模型限制。它还可以作为优化核心，用于构建你自己的 harness 和高性能助手。

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

每个 Agent 都声称自己优秀。以下是你可以核查的数据：

🥇 持续公开评测与演进

Ante 在官方排行榜约束条件下持续运行 Terminal-Bench 2.1：89 个任务，每项进行 5 次试验。每个结果都会锁定可下载的确切构建版本，并链接原始 Harbor 运行记录，以供独立审计。最新完整运行结果为：使用开放权重模型 DeepSeek V4 Flash 0731 达到 82.7%（445 次试验中完成 368 次，Ante 0.preview.71，推理成本约 68 美元）。DeepSeek 报告称，该模型在最简模式下使用其尚未发布的 DeepSeek Harness 测得同样的 82.7%。

实时结果 → · 方法论 →

🪶 仅占用一小部分资源

Ante 由手写 Rust 实现，将重型组件（Grep、git）嵌入一个二进制文件、一个进程之中；本地推理由固定版本、受管理的 llama.cpp 处理。在 Docker 中并行执行相同的 20 个任务时，Ante 的峰值内存约少 7 倍、平均 CPU约少 9 倍、磁盘 I/O约少 5 倍，相较于 Claude Code。

原始数据 → · 基准测试详情 →

Ante 的推理引擎是固定版本、受管理的 llama.cpp。将其指向一个 GGUF 文件，整个循环便可在你的机器上运行：不需要 API key、账户或互联网。

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

离线模式 → · 用于学习的玩具引擎 nanochat-rs →

---

这三者是一项设计决策。一个可以验证、能够负担且能随处运行的 Agent 足够轻量，可运行至 数千个：这便是自组织智能的底座。

查看所有 cookbook 指南

Ante 是没有外部依赖的单一自包含二进制文件：下载即可运行。

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

# 安装特定发布通道
curl -fsSL https://ante.run/install.sh | bash -s -- nightly

# 安装到已位于 PATH 中的目录
curl -fsSL https://ante.run/install.sh | ANTE_INSTALL_DIR=/usr/local/bin bash

模式	命令	用途
交互式 TUI	ante	终端中的日常工作
无头模式	ante -p "..."	一次性任务、脚本、CI
服务器	ante serve	通过 JSONL 协议服务编辑器插件和集成
网关	ante gateway	将 Ante 作为 Slack 或 Discord 机器人运行

# 修复一个 bug
ante -p "find and fix the failing test in src/auth"

# 审查一个 diff
git diff | ante -p "review this for security issues"

# 使用其他提供商
ante --provider openai --model gpt-5.5 -p "refactor the database module"

# 恢复已保存的会话
ante --resume ses_01ARZ3NDEKTSV4RRFFQ69G5FAV -p "now add tests"

# 使用本地 GGUF 模型完全离线运行
ante --offline-model ~/.ante/models/Qwen3.5-9B-Q4_K_M.gguf \
  -p "add error handling to src/main.rs"


ante update

# 从不同通道进行一次性更新
ante update --channel nightly

# 回滚或固定到准确的发布版本
ante update --version v0.preview.71

超越标题数字

• 零厂商锁定：使用你自己的 API key、订阅或本地模型。可自由切换 12 家以上提供商。无需账户，甚至不需要我们的账户。
• 多 Agent 编排：生成子 Agent，并在独立、去中心化及中心化架构中协调复杂任务。查看模式 →
• 频道集成：通过 ante gateway 将 Ante 作为 Slack 或 Discord 机器人运行。
• 可扩展：支持自定义技能、子 Agent、MCP，以及跨会话持久记忆。

Ante 开箱即支持 12 家以上提供商：

提供商	示例模型
Anthropic	Claude Sonnet 4.5、Opus 4.6
OpenAI	GPT-5 系列
Google Gemini	Gemini 3 系列
Grok（xAI）	Grok 4
Open Router	多家提供商
本地（GGUF）	通过内置 llama.cpp 运行任意 GGUF 模型
……以及更多	Vertex AI、Zai、Antix、OpenAI-compatible

可通过环境变量（ANTHROPIC_API_KEY、OPENAI_API_KEY 等）或 OAuth 配置提供商。在 ~/.ante/catalog.json 中添加自定义提供商。

我们以 Apache 2.0 许可证开源了 Agent 编码时代真正重要的内容：

1. 详细文档，即描述性真相。 docs-site/ 是 docs.antigma.ai 的源文件：精确描述 harness 的功能及其驱动方式。
2. 协议，即核心的算法。 crates/protocol-shape 定义 ante serve 使用的 schema 和线协议消息；crates/agent-sdk 则是用于基于 Agent 运行时进行开发的 Rust SDK 和客户端。
3. 评测流水线，即约束与持续改进。 ante-harbor/ 是支撑我们 Terminal-Bench 结果的 Harbor Agent 适配器：可用它复现 antigma.ai/eval 上的任何一次运行。CHANGELOG.md 逐个发布版本记录改进情况。

核心 harness 本身在 Alpha 阶段于私有仓库中开发，并通过 releases 以预编译二进制形式发布。其中的核心库会在稳定后逐步纳入此处；用于独立进程执行的 crates/exec 是第一个。

协议接口对应 Ante 的客户端—守护进程架构：

┌─────────────────────────────────────────────────────────────┐
│                         客户端                              │
│                                                             │
│   ┌───────────┐    ┌───────────┐    ┌────────────────────┐  │
│   │    TUI    │    │ 无头模式  │    │    ante serve      │  │
│   │  (ante)   │    │ (ante -p) │    │  (stdio / ws)      │  │
│   └─────┬─────┘    └─────┬─────┘    └─────────┬──────────┘  │
└─────────┼────────────────┼─────────────────────┼────────────┘
          │                │                     │
          ▼                ▼                     ▼
┌─────────────────────────────────────────────────────────────┐
│                        守护进程                             │
│                                                             │
│   会话 ──▶ 轮次 ──▶ 步骤                                   │
│                                                             │
│   ┌──────────┐  ┌──────────────┐  ┌───────────────────┐     │
│   │   工具   │  │    权限      │  │  技能 / Agents    │     │
│   └──────────┘  └──────────────┘  └───────────────────┘     │
└────────────────────────┬────────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────────────┐
│                       LLM 提供商                            │
│                                                             │
│   Anthropic · OpenAI · Gemini · Grok · Open Router · 本地   │
└─────────────────────────────────────────────────────────────┘

我们关心的是 harness，而不是模型或提示词。

文档是新的源代码。

Ante 专为细胞原生（cellular-native） Agent 设计：如同有机体中的细胞一样，微小、可替换、可大规模复制。这一论点正是上述三项核心主张存在的原因。细胞尺度的 Agent 必须可被 验证（可靠性会在规模化中累积）、足够 小（每一个字节都会被数千倍复制），并且 自包含（无需安装运行时，也无需回连服务）。请在我们的理念和 Agent 组织模式中阅读更多内容。

为什么还要再做一个终端 Agent？

名字就是答案：An other Te rminal agent（另一个终端 Agent），以及 ante——你参与游戏时放在桌上的赌注。Ante 快速、轻量，并且是唯一内置原生本地推理功能的终端 Agent。我们相信，一个能够自组织的自包含 Agent 核心，将成为未来 Agent 经济的基础。

Ante 与其他 Agent 有何不同？

Ante 拥有 Claude Code 或 Codex 等 Agent 所具备的大多数功能：多 Agent、技能、MCP、持久记忆。差异在于构建理念。

• 从零开始使用 Rust 构建。Grep（完全重写和定制）与 git 等核心组件嵌入同一个约 15MB 的二进制文件，并在运行时于同一进程中执行，因此不会通过 shell 调用任何组件，也不会泄漏资源。多数同类项目运行于 Node.js 或 CPython，资源占用量要大一个数量级。
• 内置本地推理：引擎是固定版本、受管理的 llama.cpp，因此只要有一个本地 GGUF 模型，Ante 就可以在不依赖任何提供商的情况下运行。如想了解这类引擎的工作方式，可参阅我们的玩具版本 nanochat-rs。
• 不受任何厂商锁定，包括我们自己：无需账户，可复用现有 API 凭据。可选加入、完整集成的服务器端体验位于 antix.antigma.ai。
• 每一项主张都由所发布确切构建版本的公开、可复现基准测试支撑：[antigma.ai/eva

Alpha preview : expect breaking changes and incomplete functionality. macOS and Linux only; on Windows we suggest WSL.

Two things many people ask about:

Where is the source? The core harness currently ships as a prebuilt binary; this repo holds the docs, protocol, SDK, and eval pipeline (details). We are working out a way to ship the source code along with the binary, to address security and privacy concerns first, while taking the time to figure out how open source should work in the agentic era. If you have concerns today, run Ante in a sandbox: it is a single binary with minimal runtime dependencies, built to be easy to deploy in a container or on a remote machine.

Is there telemetry? Yes, and it is opt-out: set ANTE_TELEMETRY=off to disable export entirely. The RUST_LOG filter also applies to exported logs, a convenience carried over from the Rust ecosystem. A better UX is in the works. Details →

---

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, 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

Every agent claims to be good. Here are numbers you can check:

🥇 Continuously evaled and evolved, in public

Ante runs Terminal-Bench 2.1 continuously under official leaderboard constraints: 89 tasks, 5 trials each. Each result pins the exact build you can download and links the raw Harbor run for independent audit. Latest full run: 82.7% with open-weight DeepSeek V4 Flash 0731 (368/445 trials, Ante 0.preview.71, about $68 of inference). DeepSeek reports the same 82.7 for this model, measured with its unreleased DeepSeek Harness in minimal mode.

Live results → · Methodology →

🪶 A fraction of the footprint

Ante is hand-written Rust with the heavy parts (Grep, git) embedded in one binary, one process, and local inference handled by a pinned, 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 →

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"

Offline mode → · nanochat-rs, a toy engine for study →

---

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 all cookbook guides

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

Mode	Command	Use it for
Interactive TUI	ante	day-to-day work in the terminal
Headless	ante -p "..."	one-shot tasks, scripts, CI
Server	ante serve	editor plugins and integrations, over a JSONL protocol
Gateway	ante gateway	running Ante as a Slack or Discord bot

# 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"


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.71

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 →
• Channel integrations : run Ante as a Slack or Discord bot with ante gateway.
• Extensible : custom skills, sub-agents, MCP, and persistent memory across sessions.

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.

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, the algorithm of the core. crates/protocol-shape defines the schema and wire messages spoken by ante serve; crates/agent-sdk is the Rust SDK and client for building against agent runtimes.
3. 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.

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 are included here progressively as they stabilize; 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  │
└─────────────────────────────────────────────────────────────┘

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 and agent organization patterns.

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.
• Local inference is built in: the engine is a pinned, managed version of llama.cpp, so a local GGUF model is all Ante needs to run without any provider. To study how such an engine works, see nanochat-rs, our toy version.
• 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.
• Every claim is backed by public, reproducible benchmarks of the exact builds we ship: 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 theante 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.

Full documentation is available at docs.antigma.ai.

Source code in this repository (including the SDK and protocol crates) is licensed under the Apache License 2.0.

The prebuilt ante binary is free to use — including commercially — during the alpha preview under the Binary Preview Terms. 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.