Zero: a terminal coding agent that puts model choice and permissions in your hands

What Zero solves and who it is for

Zero addresses a specific gap: most coding agents are tied to one vendor's model or to a hosted service that collects your prompts. Zero is a local terminal agent that lets you bring your own model, your own machine, and your own permission rules. It is for developers who want to run an AI assistant inside a terminal, keep session history on disk, and avoid telemetry. The README states that sessions are 'never uploaded as telemetry by Zero.' That is a strong claim for privacy-conscious users. The target user is someone who already lives in a terminal, uses tools like tmux or plain shell, and wants scriptable access to an agent without leaving that environment.

How it works: local sessions, permission policy, and extensibility

Zero works as a single Go binary that runs in two modes: an interactive TUI and a headless exec command. The TUI provides model and provider pickers, slash commands, image input, and a permission mode that you can cycle with Shift+Tab. The exec mode reads prompts from arguments or from a stream-JSON input, and can output text, JSON, or stream-JSON. The documentation describes a safety model where file writes, shell commands, network access, and out-of-workspace writes go through a permission and sandbox policy. On Linux, a separate helper binary, zero-linux-sandbox, provides native sandboxing. The agent can use MCP servers, skills, plugins, hooks, and subagents, all from the same CLI. Sessions are stored on disk, and you can resume or rewind them with /resume and /rewind.

Getting it running: install paths and first-run setup

You can install Zero via npm with npm install -g @gitlawb/zero, then run zero. The npm package is a wrapper that pulls a platform-specific binary as an optional dependency, with no install scripts. If you skip optional dependencies, the wrapper fetches the binary from GitHub Releases. There are also curl and PowerShell install scripts. For source builds, you need Go 1.26.6+, then clone the repo and run go run ./cmd/zero. On Linux, you must also build zero-linux-sandbox and put it on PATH for native sandboxing. First run starts a setup wizard to pick a provider and model. You can also configure providers from the command line with zero setup, zero providers list, and zero models list. For API providers, you set environment variables like OPENAI_API_KEY or ANTHROPIC_API_KEY. Local models work by running Ollama or LM Studio and then using zero setup or zero providers detect.

Headless exec and CI integration

The exec mode is where Zero shows its scripting value. You can run zero exec "explain internal/agent/loop.go" or pass a model flag like --model claude-sonnet-4.5. For CI, there is --use-spec to draft and review a plan before building, and --worktree to run in an isolated worktree. The stream-JSON protocol, documented in docs/STREAM_JSON_PROTOCOL.md, allows programmatic input and output, which is suitable for pipelines. The README claims 'meaningful exit codes for CI,' which is essential for automated checks. This mode is a clear differentiator: many agents only offer a chat interface, but Zero treats the agent as a command-line tool that can be composed with other Unix tools.

A genuine limitation: sandboxing is platform-dependent

The most obvious limitation is that native sandboxing is not uniform across platforms. On Linux, you must build an extra helper binary, zero-linux-sandbox, and place it on PATH. Without it, the sandbox policy may not be enforced as described. macOS does not need an extra helper, but that also means the sandbox behavior on macOS is different. Windows on ARM runs the x64 build under emulation, which may have performance or compatibility issues. If you are on a platform where the sandbox helper is missing or incomplete, you are relying on the permission prompts alone, which is weaker than a real sandbox. This is a case where Zero is the wrong tool if you need strong isolation on a platform that lacks a native helper.

Alternatives and the difference in approach

A direct alternative is a hosted coding agent like GitHub Copilot or a cloud-based agent such as OpenAI Codex. The difference is fundamental: those services run on their own infrastructure, send your code to their servers, and limit you to their models. Zero runs entirely on your machine, stores sessions locally, and lets you use any compatible endpoint, including local models via Ollama. Another alternative is an open-source agent like Aider, which also runs locally but focuses on git-based workflows and pairs with specific models. Aider is more opinionated about using a terminal diff interface, while Zero emphasizes a full TUI with slash commands, sessions, and a broader provider list. The choice comes down to whether you want a full-featured terminal environment (Zero) or a simpler, more constrained tool that integrates tightly with git (Aider).

Maintenance and upgrade cost

Zero is under active development, with releases v0.6.0, v0.7.0, and v0.8.0 in the months before the last push. The version numbers below 1.0 suggest that APIs and configuration may change between releases. The README references docs like docs/NPM_PACKAGING.md and docs/STREAM_JSON_PROTOCOL.md, which suggests a commitment to documenting internals, but you should expect to track release notes for breaking changes. The license is MIT, which gives you broad freedom to modify and redistribute, but you are responsible for maintaining any local patches. The build requires Go 1.26.6+, which is a recent version, so you need to keep your Go toolchain updated if you build from source. The npm wrapper simplifies updates, but the optional dependency mechanism means you need to ensure your package manager does not skip it unintentionally.

Editorial conclusion

Adopt Zero if you want a terminal-first coding agent that keeps sessions on disk, lets you pick any model from OpenAI to local Ollama, and enforces permission checks before file writes or shell commands. Skip it if you need a fully managed cloud service or if you expect out-of-the-box Windows ARM support without emulation. Before committing, verify that your preferred provider's API is compatible with Zero's OpenAI or Anthropic endpoints, test the sandbox helper on Linux, and review the stream-JSON protocol if you plan to script exec runs.

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes