Axe

Axe is a 12 MB Go binary that runs single-purpose AI agents defined in TOML files instead of behind a chat UI or a Python framework. It reads stdin and writes stdout, and is triggered from pipes, git hooks, cron or CI, so LLM steps compose like ordinary Unix commands.

Axe is an open-source command-line tool, written in Go and released under Apache-2.0, that runs single-purpose LLM agents as ordinary Unix programs rather than as a chatbot or a long-running framework. Each agent is a TOML file declaring a name, description, model, system prompt, optional skill and context files, working directory, allowed tools, sub-agents and allowed hosts, plus optional [memory], [[mcp_servers]], [params], [budget] and [retry] blocks. Because agents are plain text they can be committed to a repository and reviewed like any other configuration. The binary reads standard input and writes standard output, so agents compose through pipes — `git diff --cached | axe run pr-reviewer` is the canonical example — and are triggered from git hooks, cron or CI rather than by any scheduler Axe provides; the maintainer describes it as the executor, not the scheduler. It ships built-in tools for file operations sandboxed to the working directory, shell command execution, URL fetching and web search, and speaks MCP for external tools. Supported providers include Anthropic, OpenAI, Ollama for local models, OpenCode and AWS Bedrock. Guardrails include sub-agent nesting capped at depth five, a ceiling of 50 tool-call turns per conversation, token budgets that exit with code 4 when exceeded, exponential, linear or fixed backoff on transient provider errors, and blocking of private and reserved IP ranges regardless of the host allowlist. The repository was created in February 2026, has reached 832 stars and 29 forks, and shipped v1.10.0 in May 2026 alongside a published Docker image at ghcr.io.

Category

AI Agents & Orchestration

Pricing

Free

Target Market

Enterprise Developers, CTOs, Platform Engineers, DevOps Engineers

Deployment

Self-hosted, Open-source

Founded

2026

• ✓
  TOML agent definitions

  Each agent is a plain-text TOML file you can commit, diff and code-review like any other configuration.

• ✓
  Unix composition via stdin/stdout

  Reads standard input and writes standard output, so agents chain through pipes into existing shell tooling.

• ✓
  Multi-provider model support

  Targets Anthropic, OpenAI, Ollama local models, OpenCode and AWS Bedrock without rewriting the agent definition.

• ✓
  Sub-agent delegation with depth limits

  Parent agents delegate isolated context to sub-agents, hard-capped at nesting depth five to bound runaway fan-out.

• ✓
  Token budgets and retry backoff

  Per-agent max_tokens budgets exit with code 4 when exceeded, and transient provider errors retry with exponential, linear or fixed backoff.

• ✓
  Sandboxed built-in tools plus MCP

  File operations are confined to the working directory, private IPs are always blocked, and MCP servers extend the tool set.

• ✓
  Persistent markdown memory

  Timestamped markdown logs carry context across separate runs without requiring a database or a daemon.

• ✓
  Dry-run and JSON output modes

  Dry-run resolves context without calling an LLM, and JSON output lets shell scripts parse results deterministically.

• •
  Automated pull-request review

  A git hook pipes the staged diff into a reviewer agent that comments on the change before it ever reaches CI.

• •
  Overnight log triage

  Cron pipes an application error log into an analyzer agent nightly and forwards only the summarized anomalies to on-call.

• •
  CI quality gates with cost ceilings

  A build step runs an agent under a token budget and fails the pipeline on exit code 4 when spend is exceeded.

• •
  Local and air-gapped inference

  Pointing an agent at Ollama keeps prompts and proprietary source code on the developer's own machine, avoiding vendor API egress.

• •
  Scripted content and data pipelines

  JSON output mode lets shell scripts parse agent results and feed them into downstream deterministic tooling without glue services.

Axe itself is free under Apache-2.0 with no paid tier, no hosted plan and no commercial entity behind it; the real cost is the LLM provider tokens each agent consumes, billed directly by Anthropic, OpenAI or AWS Bedrock, or zero if you point agents at a local Ollama model. Per-agent token budgets are the only built-in spend control, and Hacker News commenters flagged sub-agent fan-out as an unaddressed way to run up cost.