More agents

Each agent here keeps its own login, settings and sessions. For one run, hanzo --<agent> hands it the Hanzo toolset the way that agent reads servers, and under --cloud it points the agent's model calls at api.hanzo.ai. Nothing is written into the agent's own configuration. Your Hanzo token reaches the agent through its environment, never its arguments.

Install an npm agent with hanzo upgrade <agent>. It runs npm install under ~/.hanzo, so the binary lands in ~/.hanzo/bin, and hanzo --<agent> runs that copy before one on your PATH. This needs Node.js 20 or newer. An agent with its own installer is installed once with it, and then hanzo upgrade <agent> runs its own updater. hanzo upgrade with no arguments keeps every installed agent current.

Gemini CLI

hanzo upgrade gemini
hanzo --gemini "explain the build"

• Toolset: a settings file for the run, named by GEMINI_CLI_SYSTEM_SETTINGS_PATH.
• Acts without asking: --yolo. --ask leaves its prompts.
• Models: your Google account or GEMINI_API_KEY. Gemini CLI speaks only Google's API, so --cloud does not apply.

Qwen Code

hanzo upgrade qwen
hanzo --qwen --cloud "add a test for the parser"

• Toolset: --mcp-config with a file for the run.
• Acts without asking: --yolo.
• --cloud: --auth-type openai --openai-base-url https://api.hanzo.ai/v1 -m <model>, with your token in OPENAI_API_KEY.

OpenCode

hanzo upgrade opencode
hanzo --opencode --cloud "port this module"

• Toolset and provider: one config document in OPENCODE_CONFIG_CONTENT, loaded with your own config. It holds the hanzo MCP server and, under --cloud, a hanzo provider at https://api.hanzo.ai/v1 with the model set to hanzo/<model>.
• Acts without asking: --auto. Headless runs use opencode run.

Kilo Code

hanzo upgrade kilo
hanzo --kilo --cloud "fix the lint errors"

Kilo Code is built on OpenCode and takes the same document in KILO_CONFIG_CONTENT. kilocode is an accepted spelling.

Crush

hanzo upgrade crush
hanzo --crush --cloud "summarise the open issues"

• Toolset and provider: crush.json in a data directory of Hanzo's own, ~/.hanzo/crush, passed with --data-dir. Your global Crush config still loads beside it. Under --cloud the file adds a hanzo provider, and headless runs pick hanzo/<model>.
• Acts without asking: --yolo on its own screen. crush run has no such flag.

Pi

hanzo upgrade pi
hanzo --pi --cloud "rename the store"

• Toolset: Pi takes no MCP server for a single run, so the toolset is not attached.
• --cloud: a hanzo provider in models.json under ~/.hanzo/pi, used as Pi's agent directory for the run, with --provider hanzo --model <model>.

GitHub Copilot CLI

hanzo upgrade copilot
hanzo --copilot "write the changelog entry"

• Toolset: --additional-mcp-config @<file>, beside your own servers.
• Acts without asking: --allow-all-tools.
• Models: your GitHub Copilot plan. --cloud does not apply.

Amp

hanzo upgrade amp
hanzo --amp "review the diff"

• Toolset: --mcp-config with the server inline.
• Acts without asking: --dangerously-allow-all.
• Models: your Amp account (amp login). --cloud does not apply.

Grok Build

curl -fsSL https://x.ai/cli/install.sh | bash
hanzo --grok "draft the migration"

xAI's Grok Build. It installs grok, and also a binary named agent; hanzo --cursor therefore runs cursor-agent first, so the two never trade places.

• Acts without asking: --always-approve. Headless runs use -p.
• Toolset: Grok Build reads servers only from its saved configuration (grok mcp add), so the toolset is not attached for one run.
• Models: your xAI account (grok login or XAI_API_KEY). --cloud does not apply.

Goose

curl -fsSL https://github.com/aaif-goose/goose/releases/download/stable/download_cli.sh | CONFIGURE=false bash
hanzo --goose --cloud "add a test for the parser"

• Toolset: --with-extension with the server's command line. Headless runs use goose run -t, interactive ones goose session.
• Acts without asking: GOOSE_MODE=auto in its environment.
• --cloud: goose's openai provider at OPENAI_HOST=https://api.hanzo.ai, with your token in OPENAI_API_KEY and --provider openai --model <model>.

Aider

uv tool install aider-chat
hanzo --aider --cloud "rename the store"

• Toolset: Aider takes no MCP server.
• Acts without asking: --yes-always. Headless runs use --message.
• --cloud: OPENAI_API_BASE=https://api.hanzo.ai/v1 and your token in OPENAI_API_KEY, with --model openai/<model> and --no-show-model-warnings.

Hermes Agent

curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hanzo --hermes --cloud "summarise the open issues"

• On your own account: Hermes keeps its home, ~/.hermes, with its memory and skills, and the toolset is not attached, because Hermes reads servers only from its home.
• --cloud: Hermes runs in a home of Hanzo's own, ~/.hanzo/hermes. Its config.yaml names a hanzo provider at https://api.hanzo.ai/v1, reading your token from HANZO_API_KEY, and lists the Hanzo toolset as an MCP server.
• Acts without asking: --yolo. Headless runs use -z.

OpenHands

uv tool install openhands --python 3.12
hanzo --openhands --cloud "add a test for the parser"

• Headless: --headless -t <task>, which also acts without asking. Interactive runs take --always-approve.
• Toolset: OpenHands keeps MCP servers in its own saved configuration, so the toolset is not attached for one run.
• --cloud: LLM_BASE_URL=https://api.hanzo.ai/v1, your token in LLM_API_KEY and LLM_MODEL=openai/<model>, read under --override-with-envs.

Open Interpreter

curl -fsSL https://www.openinterpreter.com/install | sh
hanzo --interpreter --cloud "add a test for the parser"

Open Interpreter is a Codex fork and runs the way hanzo --codex does: interpreter exec for a task, the toolset as -c mcp_servers.hanzo.* for the run, and under --cloud a hanzocode provider at https://api.hanzo.ai/v1. It reads its settings from ~/.openinterpreter. oi and open-interpreter are accepted spellings.

Cline

hanzo upgrade cline
hanzo --cline --cloud "fix the failing test"

• On your own account: Cline keeps its login and data (cline auth), and the toolset is not attached.
• --cloud: Cline runs from a data directory of Hanzo's own, ~/.hanzo/cline, passed with --data-dir. Its providers.json selects Cline's openai-compatible provider at https://api.hanzo.ai/v1 with no key in it, so Cline reads your token from OPENAI_API_KEY, and cline_mcp_settings.json beside it lists the Hanzo toolset.
• Acts without asking: --yolo, and the task is Cline's first argument. Under --yolo Cline ends by submitting a summary, which hanzo prints as its answer.

Continue CLI

hanzo upgrade continue
hanzo --continue "explain the build"

cn -p on your Continue account and configuration. cn is an accepted spelling. Neither the toolset nor --cloud applies.

Kimi Code

hanzo upgrade kimi
hanzo --kimi "review the diff"

kimi -p on your Moonshot account. Kimi refuses --yolo beside a prompt, so it acts without asking only on its own screen. Neither the toolset nor --cloud applies.

Oh My Pi

hanzo upgrade omp
hanzo --omp --cloud "port this module"

• On your own account: omp -p --auto-approve on the providers you configured for it, from its own directory, and the toolset is not attached.
• --cloud: omp runs from an agent directory of Hanzo's own, ~/.hanzo/omp. Its models.yml names a hanzo provider at https://api.hanzo.ai/v1 whose apiKey is the name HANZO_API_KEY, where your token is, and its mcp.json lists the Hanzo toolset. The run picks --model hanzo/<model>.

Letta Code

hanzo upgrade letta
LETTA_API_KEY=… hanzo --letta "plan the refactor"

letta -p on your Letta account; headless runs need LETTA_API_KEY. Neither the toolset nor --cloud applies.

Kode

hanzo upgrade kode
kode                      # once: Kode's first run asks for a theme and a model
hanzo --kode "write the changelog entry"

• Toolset: --mcp-config with a file for the run.
• Acts without asking: --dangerously-skip-permissions. Headless runs use -p.
• Models: the provider you set up in Kode. --cloud does not apply.

The same for every agent

A headless task runs with the agent's own one-shot flag (-p, run, --print, -x). The output is what the agent prints. When the session is streamed to the cloud, which is the default once you are signed in, hanzo asks the agent for its own event stream and prints its replies, tool calls and results from it; an agent with no event stream is printed line by line. The session summary shows the tokens the agent reported and counts every toolset call either way.