> ## Documentation Index
> Fetch the complete documentation index at: https://docs.runanywhere.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Integrations

> Use Wally from coding agents, assistants and editors.

One command points a tool at a model and starts it. There is nothing to configure by hand:

```bash theme={null}
wally opencode --cloud -m glm-5.3-flash
```

That runs a model we host, so sign in first with `wally account login`. Everywhere else, `-m` takes
either kind of id: Wally looks for the model on this machine first and falls back to the hosted
catalog. Without `-m` the tool starts the way you already have it configured, and Wally wires
nothing.

## Code in the terminal

<CardGroup cols={2}>
  <Card title="Claude Code" icon="terminal" href="#claude-code">
    Anthropic's terminal agent, pointed at any model you can run.
  </Card>

  <Card title="OpenCode" icon="code" href="#opencode">
    An open-source coding TUI, local or hosted.
  </Card>

  <Card title="Hermes Agent" icon="robot" href="#hermes-agent">
    Nous Research's agent, with its own tools and memory.
  </Card>

  <Card title="DeepSeek Harness" icon="microchip" href="#deepseek-harness">
    The `dsh` harness and its browser UI.
  </Card>
</CardGroup>

## Connect an assistant

<CardGroup cols={2}>
  <Card title="Claude Desktop" icon="desktop" href="#claude-desktop">
    The desktop app's chat and Cowork tabs, on your model.
  </Card>

  <Card title="OpenClaw" icon="comments" href="#openclaw">
    A personal agent that runs its own runtime locally.
  </Card>
</CardGroup>

## How the wiring works

Every integration gets the same thing: one OpenAI-compatible base URL. The tool never learns
whether the model behind it is on this machine or on the console — for a local model the URL is
a server Wally starts and stops around the session, and for a hosted one it is the console's own
endpoint. That is why none of these tools needs a Wally plugin.

Two tools speak Anthropic's Messages API rather than OpenAI's, so a translator sits between
them and the model. It carries tool definitions out, tool calls back, and tool results out
again, which is what lets the agent actually run the tools it was given.

None of it outlives the session. A config Wally writes is scoped to the child process, and a
desktop app it reconfigures is put back when the app quits.

## Flags

<ParamField path="-m, --model" type="string">
  The model to run against. Wally resolves it on this machine first and falls back to the hosted
  catalog, so a console model id works here on its own. Omit it and the tool starts on whatever it
  is already configured for.
</ParamField>

<ParamField path="--cloud" type="flag">
  `wally opencode` only. Go straight to the signed-in hosted endpoint, and never route a local
  model.
</ParamField>

<ParamField path="--serve" type="flag">
  `wally claude-code` and `wally claude-desktop` only. Hold the endpoint open and print it instead
  of launching anything. This is how you wire up a tool Wally has not been taught about.
</ParamField>

<ParamField path="--restore" type="flag">
  `wally claude-desktop` only. Put Claude Desktop back the way it was and start nothing. A normal
  run already undoes its own configuration when the app quits, so this is for the run that was
  interrupted first.
</ParamField>

Anything after the flags is passed through to the tool untouched.

Set the model a harness uses when you pass no `-m`:

```bash theme={null}
wally models default glm-5.3-flash   # set it
wally models default --clear         # forget it
```

## Claude Code

```bash theme={null}
wally claude-code -m glm-5.3-flash
```

Needs the `claude` binary on your PATH. Wally sets the Anthropic base URL and auth token for the
child process only, so your normal `claude` sessions are untouched, and the translator handles
the Messages API.

## OpenCode

```bash theme={null}
wally opencode --cloud -m glm-5.3-flash   # a model we host
wally opencode -m qwen3-0.6b              # a model on this machine
```

Install it with `npm i -g opencode-ai` if it is missing. The provider block goes through
`OPENCODE_CONFIG_CONTENT` rather than `~/.config/opencode`, so nothing about your own opencode
setup changes. `--cloud` asks for the hosted model explicitly and refuses to fall back to a
local one.

## Hermes Agent

```bash theme={null}
wally hermes -m glm-5.3-flash
```

Starts the TUI. Hermes takes no context-window hint from Wally, so if you want it to budget a
session against the full window, add `model.context_length` to your own `~/.hermes/config.yaml` —
Wally prints the number to use when it starts.

## DeepSeek Harness

```bash theme={null}
wally deepseek -m glm-5.3-flash                  # opens the web UI
wally deepseek -m glm-5.3-flash "fix the test"   # headless
```

Ships as `dsh` on your PATH. Passing a prompt runs it headless instead of opening the browser
UI.

## Claude Desktop

```bash theme={null}
wally claude-desktop -m glm-5.3-flash
wally claude-desktop --restore
```

Covers both the chat and Cowork tabs. The model is advertised to the app under a name it
recognises, while the picker shows the real one.

## OpenClaw

```bash theme={null}
wally openclaw -m glm-5.3-flash
```

Runs `tui --local`, which embeds the agent runtime in the same process. Plain `openclaw` expects
a gateway daemon and shows "not connected to gateway" on a machine that never installed one.

Your existing `openclaw.json` is merged rather than replaced, so your wizard state, agents and
gateway token survive.

## Anything else

A tool Wally has not been taught about still works. Ask for the endpoint and point the tool at
it yourself:

```bash theme={null}
wally claude-code --serve -m glm-5.3-flash
```

That prints an OpenAI-compatible base URL and holds it open until you stop it. Any client that
takes a base URL works against it unchanged.