Everything axion
can do.

Interactive chat REPL.

The default axion command opens a Claude Code–like REPL with streaming Markdown output, 19 slash commands (/help, /clear, /compact, /model, /cost, /diff, /status, /resume, /config, /new, /fork, /archive, /skills, /copy, /mcp, /storage, /apps, /arch, /exit), multiline input with full CJK support, and session persistence. Rich terminal rendering includes syntax highlighting for 16 languages, streaming Unicode tables, diff-colored code blocks, Markdown extensions (strikethrough, task lists, clickable links), child task/subagent progress summaries, and clearer external MCP tool categorization with readable wide-table layouts. The prompt bar shows real-time context usage %, cumulative cost, turn count, and git branch. /copy sends the last response to clipboard, /mcp browses configured MCP servers with redacted details, /storage opens storage cleanup workflows, /apps lists uninstall candidates, /arch audits Intel-only apps and packages, /status shows a rich dashboard, and pause_for_human events open an interactive confirmation gate. Slash popup completion with Tab; cross-session history via ↑↓ and Ctrl+R.

axion                    # start interactive chat (default)
axion --accept-edits     # auto-approve file edits
axion resume             # resume last session
> refactor UserService to use async/await
> /cost                   # token usage breakdown
> /diff                   # git diff summary for this session
> /status                 # session state card
> /copy                   # copy last response to clipboard
> /mcp                    # browse configured MCP servers
> /storage                # storage scan, organize, large files, undo
> /apps                   # list uninstallable apps
> /arch                   # audit Intel-only apps and packages

Context-aware file editing.

Diff-based approval flow shows exactly what changes before applying. Tracks file modifications per turn with /diff summary. Supports read, write, and targeted edit operations across any file type. Edit approval shows unified diff with accept/reject/edit options.

> fix the memory leak in Sources/App/Cache.swift
# → shows diff preview:
#   - func load() -> Data? {
#   + func load() async -> Data? {
#   Apply changes? [y/n/e]

Code search & intelligence.

Grep for regex content search, Glob for file name patterns, and LSP for go-to-definition, find-references, hover info, and document symbols. Full code intelligence without leaving the terminal.

> find all functions that access the database
> where is UserServiceProtocol defined?
> show me all references to CacheManager
> what does fetchUser do?

Web search & fetch.

Search the web and fetch/read web pages directly from conversations. Look up documentation, check API references, or pull in real-time data — all without context switching.

> search the web for Swift 6.2 concurrency changes
> fetch and summarize the docs at docs.swift.org/...
> what's the latest version of Vapor?

Shell command execution.

Execute any shell command through Bash. Run tests, build projects, manage git operations, install packages — full terminal access with output captured and fed back into the conversation.

> run the test suite and fix any failures
> git stash and checkout the main branch
> compress ~/Downloads/video.mp4 using ffmpeg

Safe storage, app cleanup & architecture audit.

Axion treats Mac maintenance as a reviewable workflow. /arch and axion arch scan installed apps, Homebrew packages, and MacPorts packages to find Intel-only software before you decide what to upgrade. /storage large finds hidden space usage, storage_scan collapses rebuildable developer caches such as node_modules and DerivedData, /storage organize builds approval-backed file organization plans, and /apps starts an uninstall flow with app detail and support-data review. Execution uses the system Trash by default and writes manifests for undo.

> /storage large
> /storage large --home 1GB
> /storage organize ~/Downloads
> /storage undo
> /apps Xcode
> /arch --packages-only
axion arch --all

Native macOS desktop automation.

When CLI tools aren't enough, Axion controls macOS GUI apps natively via Accessibility APIs. 21 MCP tools covering app management, window management, mouse, keyboard, screen capture, and accessibility tree inspection. The engine runs a plan-execute-verify loop with automatic replanning on failure.

axion run "Open Calculator and compute 123 + 456"
axion run --dryrun "..."     # plan only, no execution
axion run --fast "..."        # fewer LLM calls for simple tasks
axion run --max-steps 10 "..."

Cross-run memory.

Two complementary memory systems: App operation facts (auto-extracted menu paths, control positions, sequences from tool calls) and Universal Memory (environment knowledge in MEMORY.md + user profile in USER.md). Both injected into context on subsequent runs. Memory files are scanned for security threats before loading.

axion memory list
axion memory show memory    # MEMORY.md content
axion memory show user      # USER.md content
axion memory clear --app com.apple.calculator
axion memory export --output ~/axion-memory.json
axion run --no-memory "Open Calculator"

pause_for_human confirmation gate.

When the agent emits a pause_for_human event, the REPL opens an interactive confirmation gate instead of stalling. Press Enter to continue, type a free-form note to add context for the next step, type skip to drop the pending action, or abort to terminal the run. Works for both takeover requests and explicit confirmation prompts, and the response is recorded as Memory so similar moments resolve faster next time.

HTTP API server.

Run Axion as a long-lived service. Submit tasks over REST, stream progress via SSE, cap concurrency, gate access with an auth key. Skill endpoints let you list and execute skills over the API.

axion server --port 4242 --auth-key mysecret --max-concurrent 3

GET  /v1/health
POST /v1/runs                 {"task": "..."}
GET  /v1/runs/{id}
GET  /v1/runs/{id}/events     # SSE event stream
GET  /v1/skills               # list all skills
POST /v1/skills/{name}/run    # execute a skill

MCP server and configurable clients.

Expose Axion as an MCP stdio server for other agents, or let Axion connect to additional MCP servers from config.json across all three transports — stdio, SSE, and HTTP — with per-server auth headers for remote endpoints. /mcp browses the enabled servers, /mcp --all prints full configuration, and both views redact sensitive fields: headers and env values render as <redacted> while keys, url, command, args, and transport stay visible so you can verify wiring without leaking secrets.

axion mcp
> /mcp
> /mcp --all

{
  "mcpServers": {
    "linear": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@linear/mcp"]
    },
    "remote-docs": {
      "type": "http",
      "url": "https://example.com/mcp",
      "headers": { "Authorization": "Bearer ..." }
    },
    "events": {
      "type": "sse",
      "url": "https://example.com/sse",
      "headers": { "Authorization": "Bearer ..." }
    }
  }
}

Telegram gateway.

Always-on remote control via Telegram bot. Streaming responses with live updates, interactive approval keyboards for file edits and destructive operations, and skill browsing with paginated inline keyboards. Telegram API failures are classified so transient 5xx/network errors retry with backoff, 429 rate limits honor Retry-After, 401/403 auth failures stop with a token-configuration hint, and repeated 409 polling conflicts degrade gracefully. Commands: /help, /status, /skills, /new, /stop.

axion setup                     # configure bot token & allowed users
axion gateway start             # start gateway
axion daemon install --port 4242 --gateway  # auto-start on login

Record and replay skills.

Record a workflow once, compile it into a deterministic skill, then replay it without any LLM calls. Skills are JSON in ~/.axion/skills and can take --param values.

axion record "open_calculator"
# ...perform desktop operations, Ctrl-C to stop
axion skill compile open_calculator
axion skill run open_calculator
axion skill list

Multi-window workflows.

Coordinate operations across apps — copy from Safari to TextEdit, tile windows side by side, chain end-to-end workflows. The arrange_windows tool supports tile-left-right, tile-top-bottom, and cascade.

axion run "Copy the page title from Safari and paste it into TextEdit"
axion run "Put Safari and TextEdit side by side, Safari on the left"

Completion notifications.

When a task finishes, Axion sends a macOS desktop notification with the status (done/failed/cancelled), an AI-generated one-line summary, and stats — time, LLM calls, estimated cost. For UI tasks, it automatically brings the terminal back to the foreground.

SDK skills and subagents.

Three skill types work alongside Claude Code-compatible Agent, Task, and Skill tools. Prompt Skills load from SKILL.md files, Recorded Skills compile from user recordings, and Built-in Desktop Skills cover screenshot-analyze, data-extract, and form-fill. Direct skill runs, chat, and axion run share consistent tool registration, inheritance, permission diagnostics, and child task rendering. Skills integrate with memory — successful runs record affordance facts, failures record avoid facts, and up to 3 relevant memories are injected before execution.

axion run "/screenshot-analyze analyze the current screen layout"
axion run "/data-extract extract all prices from the table"
axion skill list          # prompt + recorded + built-in
axion run --no-skills "Open Calculator"

Daemon mode & crash recovery.

Install as a launchd agent that auto-starts on login and restarts on crash. All running task state is persisted to disk — in-flight tasks are automatically recovered after an unexpected termination. ThrottleInterval prevents restart storms.

axion daemon install --port 4242 --auth-key mysecret
axion daemon status
axion daemon uninstall --keep-logs

Budget control & safety nets.

Fine-grained spending limits and per-run cost tracking keep LLM bills predictable. Desktop Activity Detection pauses automation when you return to your seat. Visual Delta Check captures screen changes between steps so the verifier can spot unexpected state shifts.

Self-evolution — Review & Curator.

After each run, a background review agent inspects the conversation, extracts new memory facts, and evolves skill definitions — no user action required. An intelligent curator periodically manages skill lifecycle: archiving stale skills (>30 days unused), consolidating overlapping ones, and pruning redundancies. Every skill invocation is tracked to feed curator decisions. Review runs as a detached task so it never blocks the terminal.

axion run --no-review "Open Calculator"      # skip review for this run
axion run --review-model claude-haiku-4-5-20251001 "Open Calculator"
axion curator status                          # next run time & config
axion curator run                             # force-run immediately
axion curator run --dry-run                   # preview changes only

Session management & resume.

Every run is persisted as a session with full conversation history. List past sessions with status, steps, and duration. Resume any previous session to continue exactly where you left off — the SDK restores the complete transcript and re-injects memory context. Sessions survive process restarts.

axion sessions                          # list historical sessions
axion sessions --active                 # show only running sessions
axion sessions --limit 10               # limit output
axion resume abc123                      # resume a previous session
axion resume abc123 --fast               # fast mode resume
axion resume abc123 --no-review          # skip review on resume

GLM via OpenAI-compatible provider.

Beyond Anthropic, Axion's full feature set — chat, editing, search, desktop automation, MCP, skills, review — runs end-to-end against Zhipu GLM models through the OpenAI-compatible provider. Point baseURL at the GLM endpoint, drop in your API key, and pick a GLM model id. Same applies to other OpenAI-compatible gateways.

# ~/.config/axion/config.json
{
  "provider": "openai-compatible",
  "baseURL": "https://open.bigmodel.cn/api/paas/v4",
  "apiKey": "your-glm-key",
  "model": "glm-4.6"
}