# More agents

URL: https://docs.hanzo.ai/docs/guides/coding/agents

> Gemini CLI, Qwen Code, OpenCode, Kilo Code, Crush, Pi, GitHub Copilot CLI, Amp, Grok Build, Goose, Aider, Hermes Agent, OpenHands, Open Interpreter, Cline, Continue, Kimi Code, Oh My Pi, Letta Code and Kode from `hanzo --<agent>`: how each takes the Hanzo toolset and Hanzo's models.

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

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

- **Toolset:** added once, `gemini mcp add -s user hanzo ~/.local/bin/hanzo-mcp`. Gemini CLI reads a run's settings file only when root owns it, so `hanzo` cannot hand it one, and it loads MCP servers only in folders you have trusted.
- **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

```bash
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

```bash
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

```bash
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

```bash
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

```bash
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

```bash
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

```bash
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

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

xAI's Grok Build. Its installer also links a binary named `agent`, to Grok, as Cursor's does to Cursor. `hanzo --cursor` runs `cursor-agent` and never a bare `agent`, so the two never trade places. To keep `agent` meaning Cursor in your shell, leave `~/.grok/bin` off your PATH and link only `grok`: `ln -sfn ~/.grok/bin/grok ~/.local/bin/grok`.

- **Acts without asking:** `--always-approve`. Headless runs use `-p`.
- **Toolset:** added once, `grok mcp add --scope user hanzo ~/.local/bin/hanzo-mcp`. Grok Build reads servers only from its saved configuration.
- **Models:** your xAI account (`grok login` or `XAI_API_KEY`). `--cloud` does not apply.

## Goose

```bash
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

```bash
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

```bash
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

```bash
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

```bash
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

```bash
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

```bash
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

```bash
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

```bash
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

```bash
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

```bash
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](https://docs.hanzo.ai/docs/guides/coding#what-a-session-used) shows the tokens the agent reported and counts every toolset call either way.