<!-- mobian-agent-page publisher="dailydev" canonical="https://daily.dev/posts/github---antigmalabs-ante-ghost-in-your-shell-ante-is-a-self-contained-agent-harness-with-a-highly-zsc0maucx" -->

---
title: GitHub - AntigmaLabs/ante: Ghost in your shell. Ante is...
description: Ante is a self-contained, ~15MB Rust binary coding agent for the terminal, positioned as an alternative to Claude Code and Codex. It requires zero runtime...
canonical: https://daily.dev/posts/github---antigmalabs-ante-ghost-in-your-shell-ante-is-a-self-contained-agent-harness-with-a-highly-zsc0maucx
twitter:card: summary_large_image
twitter:site: @dailydotdev
og:type: website
og:site_name: daily.dev
og:title: GitHub - AntigmaLabs/ante: 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 constr | daily.dev
og:description: Ante is a self-contained, ~15MB Rust binary coding agent for the terminal, positioned as an alternative to Claude Code and Codex. It requires zero runtime...
og:url: https://daily.dev/posts/github---antigmalabs-ante-ghost-in-your-shell-ante-is-a-self-contained-agent-harness-with-a-highly-zsc0maucx
og:image: https://api.daily.dev/og/posts/ZSC0maucx.png
og:image:alt: GitHub - AntigmaLabs/ante: 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 constr
og:image:width: 1200
og:image:height: 630
og:locale: en
---

> ## Documentation Index
> Fetch the complete documentation index at: https://daily.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# GitHub - AntigmaLabs/ante: 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 constr

**[Hacker News](https://daily.dev/sources/hn)** · 9 min read · 0 upvotes · 0 comments

## Summary

Ante is a self-contained, ~15MB Rust binary coding agent for the terminal, positioned as an alternative to Claude Code and Codex. It requires zero runtime dependencies, supports 12+ LLM providers, and includes a built-in llama.cpp inference engine for fully offline operation with GGUF models. On Terminal-Bench 2.1 (89 tasks, 5 trials each), Ante achieves 82.7% with DeepSeek V4 Flash 0731. Compared to Claude Code running 20 parallel tasks in Docker, Ante uses ~7× less peak memory, ~9× less average CPU, and ~5× less disk I/O. It supports interactive TUI, headless, server (JSONL protocol), and gateway (Slack/Discord) modes, plus multi-agent orchestration, MCP, custom skills, and persistent memory. The core harness is closed-source during alpha but ships as a free prebuilt binary; the SDK, protocol crates, and eval pipeline are Apache 2.0.

## Full article

daily.dev links to this article rather than hosting it. Read it at the original source: <https://github.com/AntigmaLabs/ante>

## Questions this post answers

### What score did Ante achieve on Terminal-Bench 2.1 and with which model?

Ante scored 82.7% on Terminal-Bench 2.1 (368 of 445 trials across 89 tasks, 5 trials each) using the open-weight DeepSeek V4 Flash 0731 model, running Ante build 0.preview.71 at a cost of about $68 in inference. DeepSeek independently reports the same 82.7% score for this model using its own unreleased minimal-mode harness.

_Developers comparing coding agent benchmarks can track new agent releases and results on daily.dev._

### Can I run a coding agent completely offline without an API key?

Yes, Ante includes a built-in llama.cpp inference engine that runs GGUF models locally, handling engine installation, model discovery, and memory management automatically with no API key or internet connection required. It can be pointed at a local GGUF file such as Qwen3.5-9B-Q4_K_M with a command like ante --offline-model.

_Anyone evaluating offline-capable AI coding tools can follow agent tooling updates on daily.dev._

### How does Ante's resource usage compare to Claude Code?

Ante uses roughly 7x less peak memory, 9x less average CPU, and 5x less disk I/O than Claude Code when running the same 20 parallel tasks in Docker. This is attributed to being hand-written in Rust with heavy components like Grep and git embedded in a single ~15MB binary and process, unlike Node.js or CPython-based agents with larger footprints.

_Teams weighing coding agent efficiency and cost can keep up with these comparisons on daily.dev._

## Community take

How the wider developer community reacted, aggregated from 1 discussion and 77 comments across hackernews (as of 2026-09-14).

**TL;DR:** The community is intrigued by Ante's self-contained, dependency-free design and benchmark numbers, but significant concerns about the closed-source binary, opt-out telemetry, and security risks dominate the thread — with the developer actively responding and promising changes.

**Sentiment:** 25% positive · 40% mixed · 35% skeptical

**The case for**

- The self-contained ~15MB binary with no runtime dependencies is genuinely appealing for bare-metal or offline deployments.
- Support for 12+ LLM providers plus local GGUF inference gives flexible model mixing between frontier and local models.
- The developer is responsive in the thread, acknowledging feedback and committing to fixes like opt-in telemetry and open-sourcing.

**The pushback**

- The core harness is closed-source, making it impossible to audit for malware or supply-chain attacks — a serious concern for a tool with broad system access.
- Telemetry defaults to opt-out rather than opt-in, which commenters found especially contradictory for a tool marketed for offline/private use.
- The README's claim of a 'built-in inference engine' was misleading — it actually downloads and manages a pinned llama.cpp build rather than shipping its own.
- The curl-pipe-to-bash install pattern was flagged as insecure.
- An open-source alternative (hax, written in C, MIT-licensed) was surfaced as a leaner, fully auditable option.

**By community**

- hackernews (mixed): Developers are split between genuine interest in the lean, offline-capable design and strong objections to the closed-source binary, opt-out telemetry, and security implications of granting an unauditable agent broad system access.

**Hottest debate:** Whether a closed-source binary agent that requires broad system permissions can be trusted at all, and whether the project should be fully open-sourced before asking users to run it.

**Open questions**

- Will the core harness ever be fully open-sourced, and on what timeline?
- How does Ante handle AI-generated PR spam and sustainability concerns that the developer cited as blockers to open-sourcing?
- Is there a plan for Windows CUDA support or a Cosmopolitan/llamafile-style universal binary?

**Highlights**

> It has to be 100% open source public code or we will have no way of proving this is not malware, or secretly swapped out for malware later when your CI/CD system or laptop is compromised. Supply chain attacks happen all the time and with closed code no one will be equipped to spot it when it happens. Also, security aside, engineers want the freedom to modify and experiment with the tools we rely on. Tools like this are too important to be closed. Do you want to be Internet Explorer or Firefox?
> — [lrvick on hackernews · 2 comments](https://news.ycombinator.com/item?id=49248652)

> Opt-out telemetry is a hard no for me, sorry.
> — [majorchord on hackernews · 3 comments](https://news.ycombinator.com/item?id=49246381)

> Hi HN, I'm Mohan from Antigma Labs. Ante is a coding agent that ships as one self-contained ~15MB binary: the TUI, an embedded ripgrep, local PDF/OCR, and a natively managed llama.cpp engine are all inside. No runtime dependencies, no node_modules, no account. - Ante installs a pinned, checksum-verified official llama.cpp build matched to your machine (Metal on Apple silicon; CUDA, Vulkan, or CPU on Linux) and handles upgrades when the pin changes. - It discovers GGUF files already on disk (~/.ante/models, the llama.cpp and Hugging Face caches), attaches to llama servers already running on local ports, and estimates RAM/VRAM from model size and context window before anything loads. - `ante --offline-model /path/to/model.gguf "prompt"` boots the server, runs the session, and shuts it down. `/offline-mode` does the same interactively; `ante serve --offline-model` loads a model once for many clients. - No API key, no account. Once the model is on disk, inference needs no network at all; set ANTE_TELEMETRY=off and no telemetry is exported either. On capability, we'd rather publish the number than oversell: we benchmark local models with the same harness and auditable runs as frontier ones, and Qwen3.6 27B (a 17 GB download) scores 56.2% on Terminal-Bench 2.1 across 445 trials (live results: https://antigma.ai/eval). That's a real gap from frontier models. The design bet is that you mix: hosted providers and local live in the same catalog, `/providers` switches mid-session, so sensitive repos or high-volume work go local and hard problems go frontier. Hosted models work with your own keys or subscription. But nothing about trying Ante requires signing up for anything: download the binary, point it at a GGUF. Offline mode is under active development and has rough edges with the overview at https://ante.run/local/overview. I'll be in the comments.
> — [ubermon on hackernews · 6 comments](https://news.ycombinator.com/item?id=49245475)

> Here you say:   > Ante installs a pinned, checksum-verified official llama.cpp But in README:   > Ante ships its own inference engine May I suggest you use the first phrasing in both places. I took it as Ante devs had written their own engine and I doubt I'm the only one.
> — [felooboolooomba on hackernews · 2 comments](https://news.ycombinator.com/item?id=49247576)

> I will leave this here: https://usehax.dev/ GitHub repo: https://github.com/OleksandrChekhovskyi/hax This is a coding agent implementation I am working on, which delivers what this promises (at least on the "lean" part), except it's actually fully open source, and even more lean (few MBs of runtime memory usage). MIT-licensed, written in C, multi-provider / multi-model, minimalist approach to system prompt and tools (think kinda like pi, but with a bit more "batteries included", like subagents and background tasks out of the box), polished presentation, inspectable (usable transcript view), etc.
> — [OleksandrC on hackernews · 1 comments](https://news.ycombinator.com/item?id=49246919)

**Source threads**

- [hackernews](https://news.ycombinator.com/item?id=49245437) · 111 points · 77 comments

## Similar posts on daily.dev

- [CLI-First Agency: Why Claude Code Lives in Your Terminal](https://daily.dev/posts/cli-first-agency-why-claude-code-lives-in-your-terminal-rxkh06ypl) · SitePoint · 0 upvotes · 0 comments
- [Evaluating DeepAgents CLI on Terminal Bench 2.0](https://daily.dev/posts/evaluating-deepagents-cli-on-terminal-bench-2-0-cgrg1pnyi) · LangChain · 1 upvotes · 0 comments
- [What I learned building an opinionated and minimal coding agent](https://daily.dev/posts/what-i-learned-building-an-opinionated-and-minimal-coding-agent-myqj9tthj) · Hacker News · 1 upvotes · 0 comments

---

Tags: [#ai-agents](https://daily.dev/tags/ai-agents), [#rust](https://daily.dev/tags/rust), [#agentic-ai](https://daily.dev/tags/agentic-ai)

[View this post on daily.dev](https://daily.dev/posts/github---antigmalabs-ante-ghost-in-your-shell-ante-is-a-self-contained-agent-harness-with-a-highly-zsc0maucx)

```json
{"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]}
{"@context":"https://schema.org","@type":"TechArticle","headline":"GitHub - AntigmaLabs/ante: 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 constr","url":"https://daily.dev/posts/github---antigmalabs-ante-ghost-in-your-shell-ante-is-a-self-contained-agent-harness-with-a-highly-zsc0maucx","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/github---antigmalabs-ante-ghost-in-your-shell-ante-is-a-self-contained-agent-harness-with-a-highly-zsc0maucx"},"datePublished":"2026-08-10T17:17:39.665Z","dateModified":"2026-09-14T07:41:36.510Z","description":"Ante is a self-contained, ~15MB Rust binary coding agent for the terminal, positioned as an alternative to Claude Code and Codex. It requires zero runtime...","image":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/b79c662a991624d7650a23608397642e?_a=AQAEuop","thumbnailUrl":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/b79c662a991624d7650a23608397642e?_a=AQAEuop","isAccessibleForFree":true,"articleSection":"Hacker News","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"Hacker News","logo":"https://media.daily.dev/image/upload/t_logo,f_auto/v1/logos/hn","url":"https://daily.dev/sources/hn"},"commentCount":0,"discussionUrl":"https://daily.dev/posts/github---antigmalabs-ante-ghost-in-your-shell-ante-is-a-self-contained-agent-harness-with-a-highly-zsc0maucx","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":0},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":0}],"keywords":"ai-agents,rust,agentic-ai","timeRequired":"PT9M"}
{"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Hacker News","item":"https://daily.dev/sources/hn"},{"@type":"ListItem","position":3,"name":"GitHub - AntigmaLabs/ante: 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 constr"}]}
{"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/github---antigmalabs-ante-ghost-in-your-shell-ante-is-a-self-contained-agent-harness-with-a-highly-zsc0maucx#faq","mainEntity":[{"@type":"Question","name":"What score did Ante achieve on Terminal-Bench 2.1 and with which model?","acceptedAnswer":{"@type":"Answer","text":"Ante scored 82.7% on Terminal-Bench 2.1 (368 of 445 trials across 89 tasks, 5 trials each) using the open-weight DeepSeek V4 Flash 0731 model, running Ante build 0.preview.71 at a cost of about $68 in inference. DeepSeek independently reports the same 82.7% score for this model using its own unreleased minimal-mode harness. Developers comparing coding agent benchmarks can track new agent releases and results on daily.dev."}},{"@type":"Question","name":"Can I run a coding agent completely offline without an API key?","acceptedAnswer":{"@type":"Answer","text":"Yes, Ante includes a built-in llama.cpp inference engine that runs GGUF models locally, handling engine installation, model discovery, and memory management automatically with no API key or internet connection required. It can be pointed at a local GGUF file such as Qwen3.5-9B-Q4_K_M with a command like ante --offline-model. Anyone evaluating offline-capable AI coding tools can follow agent tooling updates on daily.dev."}},{"@type":"Question","name":"How does Ante's resource usage compare to Claude Code?","acceptedAnswer":{"@type":"Answer","text":"Ante uses roughly 7x less peak memory, 9x less average CPU, and 5x less disk I/O than Claude Code when running the same 20 parallel tasks in Docker. This is attributed to being hand-written in Rust with heavy components like Grep and git embedded in a single ~15MB binary and process, unlike Node.js or CPython-based agents with larger footprints. Teams weighing coding agent efficiency and cost can keep up with these comparisons on daily.dev."}}]}
```

