zerostack: Best AI Coding Agents for Hardcore Developers in 2026

What Is zerostack?

zerostack is a Rust-based AI coding agent built by gi-dellav that bundles multi-provider model access, session management, permissions, and a crossterm terminal UI into an 8.9MB binary. zerostack is one of the best AI Coding Agents tools for terminal-first developers, indie hackers, and CTOs who want OpenRouter, OpenAI, Anthropic, Gemini, or Ollama without hauling around a 300MB Node runtime. The repo reports about 9k LoC, which explains why the agent stays small, fast, and easy to reason about.

It is inspired by pi and opencode, but it adds a tighter Rust-native runtime, configurable prompt modes, and session safety features that are useful when you are iterating on real code rather than demoing a workflow.

Quick Overview

Who Should Use zerostack?

• Solo builders shipping MVPs who want an interactive coding agent in the terminal without a heavyweight desktop app or browser wrapper.
• Platform and infra teams that need permission modes, session allowlists, and per-tool policy controls before letting an agent touch files or run shell commands.
• Rust-first developers who prefer a native binary, low memory usage, and predictable process behavior over a large JavaScript stack.
• Editor-centric teams using MCP or ACP who want to connect external tooling or let editors such as Zed talk to the agent directly.

Not ideal for:

• Windows-first shops that need a fully tested cross-platform experience, because Windows support is explicitly untested.
• Teams that want cloud-hosted collaboration with shared web dashboards and remote workspace orchestration.
• Users who dislike terminal workflows and expect a browser-based agent UI with richer visual controls.

Key Features of zerostack

• Multi-provider model routing — zerostack talks to OpenRouter, OpenAI, Anthropic, Gemini, Ollama, and custom providers. That matters when you want to swap models for cost, latency, or code quality without rewriting your workflow.
• Permission system with four modes — restrictive, standard, accept-all, and yolo let you decide how much autonomy the agent gets. Per-tool glob patterns, session allowlists, and external directory rules provide a finer control surface than a single global approval toggle.
• Session persistence and auto-compaction — sessions can be saved, loaded, resumed, and compacted to stay inside context windows. That is useful for long debugging or refactor sessions where prompt history would otherwise balloon and degrade output quality.
• Crossterm-based TUI — the interface supports markdown rendering, mouse selection and copy, scrollback, and a reasoning visibility toggle. The result is a usable terminal UX instead of a bare REPL.
• Runtime prompt modes — built-in modes like code, plan, review, debug, ask, brainstorm, frontend-design, review-security, simplify, and write-prompt let you switch behavior without hand-editing prompt files. This is a cleaner model than juggling separate skills folders for every task.
• MCP and ACP support — zerostack can connect to MCP servers for extended tooling, and the optional acp feature exposes an Agent Communication Protocol server for editor integration. That makes it easier to plug the agent into richer dev environments.
• Integrated search and long-horizon loops — built-in Exa search powers WebFetch and WebSearch, while the experimental loop system can repeatedly plan, edit, test, and continue until a task is done. For deeper agentic workflows, this overlaps well with orchestration tools like OpenSwarm and prompt-centric systems such as Claude Context Mode.

zerostack vs Alternatives

Pick Claude Code Canvas if your team lives inside Claude and wants a more opinionated editing surface. Pick Claude Context Mode if prompt shaping and context packaging matter more than local process control.

Pick OpenSwarm when you need to coordinate multiple agents or distribute work across tasks. Pick zerostack when you want one small Rust binary that can run locally, gate every dangerous command, and still talk to multiple model providers.

How zerostack Works

zerostack uses a terminal-first agent loop built around a session model, a permission engine, and a provider abstraction layer. The provider layer routes requests to OpenRouter, OpenAI, Anthropic, Gemini, Ollama, or custom backends, while the session layer stores conversation state under $XDG_DATA_HOME/zerostack/sessions/ so work can be resumed instead of restarted.

The design philosophy is straightforward: keep the runtime small, keep the state local, and make every risky operation explicit. That is why the agent exposes permission modes, session allowlists, doom-loop detection, and optional sandboxing via bubblewrap for shell command isolation.

export OPENROUTER_API_KEY=your_api_key_here
zerostack --provider openrouter --model deepseek/deepseek-v4-flash

That command starts an interactive coding session using OpenRouter and a specific model. In practice, zerostack will open the TUI, load the default code prompt, and begin accepting tool calls through the configured permission policy. If you want tighter control, use -R for restrictive mode, -c to resume the latest session, or --features acp at install time if you need editor integration.

The architecture is intentionally simple enough to audit. A lightweight core manages prompt switching, command execution, and session compaction, while optional features such as MCP, ACP, Exa search, and Git worktree movement stay behind explicit flags or commands rather than being forced on every user.

Pros and Cons of zerostack

Pros:

• Very small runtime footprint — the repo reports an 8.9MB binary, roughly 10MB RAM on an empty session, and about 13MB while working.
• Low idle overhead — reported idle CPU is 0.0%, which matters when the agent stays open all day in a terminal.
• Strong permission controls — per-tool globbing, session allowlists, and multiple approval modes give you better control than a single yes/no prompt.
• Provider flexibility — OpenRouter, OpenAI, Anthropic, Gemini, Ollama, and custom providers reduce lock-in.
• Good long-session ergonomics — save/resume, auto-compaction, and loop support make it usable for refactors and debugging sessions that last hours.
• Editor integration path — ACP support gives teams a route into Zed or other compatible editors without rewriting the agent.

Cons:

• Windows is unproven — the repo explicitly says Windows support is not tested.
• Experimental features need caution — the loop system is marked experimental, so you should not treat it as stable automation for production changes.
• No visible hosted collaboration layer — zerostack is local and terminal-centric, which is great for speed but not for teams that want shared web-based control planes.
• License and release metadata are unclear from the repo snapshot — that makes due diligence a bit slower for orgs with strict procurement rules.
• MCP and ACP add complexity — the optional integrations are useful, but they also increase configuration surface area for teams that only want a simple chat-and-edit loop.

Getting Started with zerostack

# Install the core agent
cargo install zerostack

# Optional: install ACP support for editor integration
cargo install zerostack --features acp

# Optional: sandbox shell commands on Debian/Ubuntu
apt install bubblewrap

# Set your provider key and launch
export OPENROUTER_API_KEY=your_api_key_here
zerostack

# Useful follow-ups
zerostack -p "Explain this project"
zerostack -c

After the install, zerostack launches directly into the TUI and reads your default prompt mode, which is code. If you enable sandboxing, shell actions run in an isolated environment, which is the right default for unknown repositories or generated patch sets. Configuration lives in CONFIG.md, and custom prompt files can be dropped into $XDG_CONFIG_HOME/zerostack/prompts/.

Verdict

zerostack is the strongest option for terminal-native AI coding when you want local control, low memory usage, and multiple provider backends. Its biggest strength is the Rust runtime plus granular permissions, and its main caveat is that Windows and some advanced flows are still immature. Choose zerostack if you value speed, auditability, and shell-first workflows over a polished hosted UI.