Zerostack: A Unix-Inspired Coding Agent in Pure Rust

A new Rust-based coding agent called Zerostack has landed on crates.io, and it's already sparking conversation on Hacker News. Its pitch? Minimal memory, Unix-like composability, and a philosophy that says AI tools don't have to be resource hogs.

What Is Zerostack?

Zerostack is a coding agent written entirely in Rust. It draws explicit inspiration from the Unix philosophy: do one thing well, use pipes and redirection for composition, and keep a tiny footprint. The agent can interpret natural language tasks, generate shell commands, and execute them—all while consuming around 8MB of RAM on an empty session and 12MB when actively working.

Unlike Claude Code or OpenCode, which are monolithic IDE-like experiences, Zerostack is designed to be used from the command line, piped into other tools, and scripted. It doesn't have a TUI; instead, it reads from stdin and writes to stdout, making it a first-class citizen in Unix pipelines.

The author released it on crates.io as version 1.0.0, suggesting a mature enough state for public use. The codebase is small enough that one commenter noted they "handed it over to DeepSeek v4 Flash in Pi to skim through for any risky business" and found nothing concerning.

Why It's Blowing Up on HN

The Hacker News community is visibly frustrated with the memory bloat of existing AI coding tools. One commenter wrote: "Claude Code is using multiple gigabytes, which is really annoying on lowend laptops." Another added: "OpenCode slowly leak memory and end up becoming 6gbs on a large project and then get slower and slower."

Zerostack's promise of an 8MB footprint feels like a breath of fresh air. But it's not just about memory. The Unix-inspired design resonates with developers who miss the simplicity of composable command-line tools. A commenter shared a similar project called airun, which also embraces piping and redirection: "it is intended to be piped and redirected. it discovers skills, AGENTS and prompt templates from Claude Code, Pi.dev, OpenCode and others." The commenter provided a pipeline example:

$ airun -q -p 'output a shell command for linux to display the current time. output only the command with no other code fencing or prose' | airun -q -s 'review the provided shell command, determine if it is safe, run it only if it is safe, and then summarize the output from the command' --permissions-allow='bash:date *'

This shows a clear appetite for tooling that follows established Unix patterns rather than reinventing the wheel.

Why Zerostack Matters

Zerostack signals a healthy direction for AI tooling. Over the past year, we've seen a race toward feature-heavy IDEs—Claude Code, Cursor, Copilot—that bundle everything into one fat process. While powerful, they introduced friction: massive memory usage, slow startup, and tight coupling to specific editors or models.

Zerostack goes the other way. It's a return to the Unix way: small, focused, and composable. It treats the LLM as just another tool in your belt, not the entire workbench. If you've ever piped grep into awk into sed, the idea of piping a coding agent's output into another agent feels natural.

But a pure Unix approach has limitations. Modern AI workflows often require context, state, and iterative refinement—things that stateless pipes handle poorly. Zerostack may struggle with complex multi-step tasks that need to remember previous interactions. The commenter who built airun added permissions flags and a review step, hinting at the complexity needed for safe operation.

Still, the approach is worth watching. It proves that you don't need gigabytes of RAM to run an effective coding agent. The minimal footprint opens up possibilities for constrained environments: CI runners, embedded systems, or older hardware.

How to Get Started

If you're building or using AI coding tools, Zerostack suggests a lighter path. Here's how you might start experimenting.

First, install it with cargo install zerostack. Then, create a simple pipeline:

zerostack "list all Python files in this repo" | zerostack "sort by size" | zerostack "output top 5"

This chain lets each invocation focus on one task, passing results via stdout. You could insert human review steps, logging, or even non-AI tools like jq or grep between agents.

For safety, wrap the pipeline in a bash function that reviews commands before execution:

function safe_zerostack() {
  local cmd
  cmd=$(zerostack "$1" --dry-run)
  echo "Proposed command: $cmd"
  read -p "Execute? (y/N) " -n 1 -r
  echo
  if [[ $REPLY =~ ^[Yy]$ ]]; then
    eval "$cmd"
  fi
}

This keeps the Unix spirit alive—simple, transparent, composable. You can even replace the review step with a dedicated safety agent.

Zerostack also fits well into automated workflows. In a CI pipeline, you could use it to generate code, run linters, or refactor small project files without spinning up a heavyweight container.

If you're a tool developer, consider designing your agents as filters—reading from stdin, writing to stdout. This makes them compatible not only with Zerostack but with the entire Unix ecosystem.

Should You Care About Zerostack?

If you've been frustrated by the bloat of Claude Code or OpenCode on your laptop, Zerostack is worth a try. It's especially relevant for developers who love the command line and value efficiency. If you work on large enterprise projects that demand deep IDE integration, you might wait until the ecosystem matures. But for personal projects, scripting, or lightweight automation, Zerostack shows that less is often more.

For more on the Unix philosophy behind Zerostack, see the Unix philosophy article on Wikipedia and the Rust programming language official site.