Axe CLI
Axe in Go: single-purpose AI agents defined in TOML and run from a terminal, pipes, cron and git hooks, with memory, sub-agents and MCP
- 898 ★ on the repository
- Last commit
- Apache-2.0
Broad access
Why this level
- An agent with the `run_command` tool executes shell commands in the working directory, and `write_file` and `edit_file` change files
- `url_fetch` and `web_search` go out to the network, and provider keys sit in `config.toml` or environment variables
- Runs from cron and git hooks proceed without your approval of each step
Install
In your terminal, with SkillFoxx CLI
npx skillfoxx add cli/axeDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- An agent with the `run_command` tool executes shell commands in the working directory, and `write_file` and `edit_file` change files
- `url_fetch` and `web_search` go out to the network, and provider keys sit in `config.toml` or environment variables
- Runs from cron and git hooks proceed without your approval of each step
This is third-party code. Review the repository files before installing.
What it does
Axe runs AI agents like ordinary Unix commands. An agent is described in a TOML file: model, system prompt, a `SKILL.md` skill file, context files, working directory, memory and a list of sub-agents. The `axe run agent-name` command executes it once and prints the result. Input comes through a pipe, for example `git diff --cached | axe run pr-reviewer`, or with the `-p` flag. There is no scheduler inside: running on a schedule is left to cron, git hooks, CI and other tools. If the agent is given tools, it enters a call loop of up to `max_turns` turns, 50 by default. Available are `list_directory`, `read_file`, `write_file`, `edit_file` inside the working directory, `run_command` through `sh -c`, `url_fetch` and `web_search`. Sub-agents are called through `call_agent` with a depth limit and parallel execution. External tools connect from MCP servers over SSE or streamable-HTTP. Agent memory is stored as timestamped markdown entries, and `axe gc` trims it with the help of a model. Providers are Anthropic, OpenAI, Atlas Cloud, Ollama, OpenCode and AWS Bedrock. A token budget caps a run, output can be wrapped in a JSON envelope, and `--dry-run` shows the assembled context without calling the model.
Who it is for. For developers and administrators who want to embed small AI agents into pipelines: diff review, log analysis, commit messages, scheduled jobs.
Good fit when
- You need an agent that checks `git diff` before a commit and runs from a git hook
- Logs need to be analyzed on a schedule from cron by one focused agent
- A task fits a chain of sub-agents with a depth limit and parallel execution
- Agents should live in the repository as version-controlled TOML files
- You need a local model through Ollama or an agent run inside a hardened Docker container
Not a fit when
- You need an interactive chat with a long session: Axe runs an agent once and keeps no dialog
- You need a built-in scheduler or workflow orchestrator: Axe only executes and the schedule stays with cron
- You build from source on Go older than 1.25: that version or a prebuilt binary is required
Example request
Set up a pr-reviewer agent on Axe so that `git diff --cached | axe run pr-reviewer` reviews my changes before a commit and prints findingsLimitations
- Axe calls itself an executor, not a scheduler: schedules, file watching and job chains have to be built from cron, git hooks and pipes.
- The path sandbox applies to the file tools, while `run_command` runs commands through `sh -c` in the agent's working directory. `url_fetch` and `web_search` can be limited with an `allowed_hosts` list, and private addresses are always blocked.
- `web_search` needs a `TAVILY_API_KEY`, and each cloud provider needs its own key in an environment variable or in `config.toml`.
- Scripts from `SKILL.md` are called by absolute paths: `run_command` works in the agent's working directory, so a relative path to a skill script will not resolve.
- Retries on 429 and 5xx responses are off by default, the request timeout is 120 seconds, and `response_format` is honored only by OpenAI and Ollama.
How to disable. Delete the `axe` binary and the config directory whose path `axe config path` prints. Agent memory lives under `~/.local/share/axe` and can be erased too. Hooks and cron jobs that called `axe run` are removed by hand.
FAQ
How does Axe differ from a chat agent like Claude Code?
It does not hold a long session with shared context. Each agent is narrow, described in TOML and run as a command, takes data from stdin and returns a result, and agents are glued together with shell tools.
How do I cap the cost of a run?
Set `[budget] max_tokens` in the TOML or the `--max-tokens` flag: it counts input and output tokens across all turns and sub-agents. When it is exceeded the current answer is returned, no more tools are called and the exit code is 4.
How do I connect external tools?
Add an `[[mcp_servers]]` block to the TOML with a name, URL, transport `sse` or `streamable-http` and headers whose values are filled from environment variables like `${MY_TOKEN}`. At startup Axe requests `tools/list` from the server and passes the tools to the model.
How does agent memory work?
With memory enabled each run appends a timestamped markdown entry, and later runs read the last `last_n` entries, ten by default. `axe gc agent-name` trims the entries with a model, and a warning appears when `max_entries` is exceeded.
Can I run Axe in a container?
Yes, the repository has a Dockerfile and a `docker-compose.yml`. The container runs as UID 10001 with a read-only filesystem and no privileges, and it does not restrict network access. For Ollama a separate service comes up beside it.
What does the dry-run flag check?
`axe run name --dry-run` shows the assembled context: system prompt, skill, context files and model. No provider call is made.
Discussion
No questions or reviews yet.
Related
CLI toolsA Rust terminal task board: every task runs in its own git worktree and tmux window while Claude Code, Codex, Gemini CLI and other agents work in parallel
Ten design principles for CLIs that agents use, and a skill that guides an agent building or reviewing such tools
A Go CLI that configures the AI coding agents you already use: it gives them shared memory, a workflow and deterministic steps without replacing the agents them
A team of AI agents from one request: it plans the task, writes code in parallel branches, tests, reviews and opens a pull request
A CLI to run several coding agents: one config, a session console, local memory and a set of engineering skills
A multi-agent harness that verifies results by artifacts: stop hooks, an independent judge and an event log for Claude Code, Codex, Cursor and more
README in short
The repository holds Go code, agent examples in `examples/` (a code reviewer, a commit message generator, a text summarizer), smoke-test agent configs for GitHub Actions, a Dockerfile with a compose file, goreleaser settings, a changelog and contribution rules. The main page describes the principles, features, installation, quick start, a command and flag reference, the TOML format, tools, skills, providers and exit codes.