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

# Steer a running turn

> Send a new message to an agent while it works. The agent uses it and keeps what it was doing.

You have three options while a turn runs:

| Command | What happens to the running turn |
| - | - |
| `boat prompt` | The new prompt waits until the turn finishes |
| `boat interrupt` | The turn stops. Its work is discarded |
| **`boat steer`** | The turn gets your new message. The agent uses it and keeps all it was doing |

`boat steer` is the same as typing into a coding agent while it works.

```bash theme={null}
boat prompt "Refactor billing and run the full test suite"
boat steer "Skip the integration tests, the unit tests are enough"
boat steer --convo <id> "Also update the changelog when you are done"
```

If you omit `--convo`, `boat steer` steers the conversation that this shell prompted last. A bare `boat prompt` continues the same conversation.

```mermaid theme={null}
sequenceDiagram
  participant You
  participant Turn as The running turn
  You->>Turn: boat prompt "refactor billing, run the tests"
  Note over Turn: working, tests running
  You->>Turn: boat steer "skip the integration tests"
  Note over Turn: still the same turn, now with your instruction
  Turn-->>You: finishes the whole thing
```

## How each harness gets the message

Four of the seven harnesses accept a message during a turn natively. Nothing stops.

OpenCode, Kimi Code and Mistral Vibe have no such feature. Their protocol has "prompt" and "cancel", and nothing between them. For these harnesses, Boat uses a fallback automatically.

| Harness | Delivery | Turn interrupted? |
| - | - | - |
| Claude Code | Native. The message goes into the turn when the harness takes it in. If it does not, Boat runs it right after, as its own turn on the same session. | No |
| Codex | Native. `turn/steer` adds your message to the turn in progress. | No |
| pi | Native. The message goes in at the next model call of the turn. This is usually right after the tool in progress finishes. | No |
| Prime Agent | Native. Same as pi. | No |
| OpenCode | Fallback. Boat stops the turn. It then starts a new turn at once on the **same** conversation, with "Continue what you were doing" plus your instruction. | Yes, and it continues by itself |
| Kimi Code | Fallback. Same as OpenCode. | Yes, and it continues by itself |
| Mistral Vibe | Fallback. Same as OpenCode. | Yes, and it continues by itself |

## Boat makes sure the agent acts on a steer

A harness can accept a message and then do nothing with it. So Boat does not trust the harness. Boat does these things:

* Where the harness has its own steering queue, Boat watches it.
* Boat waits for that queue to empty before it marks the turn finished.
* Where Boat cannot see the delivery, it runs your instruction as its own turn when the turn ends.

So when `boat steer` returns and the turn later reports `finished`, the agent did the instruction. It did not only receive it.

## Steer modes

The API response and the event both carry `native`. The event also carries the exact `mode`. It is one of `native`, `native-continued`, `fallback`, or `late`.

**`native-continued`** is the honest middle case. The harness accepted the message, but its turn ended without acting on it. So Boat ran it at once as its own turn on the same session. Nothing was interrupted and nothing was forgotten. The instruction only runs one turn boundary later.

The `fallback` path also keeps the harness session and all its memory. So nothing is forgotten. The cost is the one tool call that was in progress. The agent can redo a small part of the work it had just started.

## A steer in the event stream

A steer is its own event in the stream. It is never a queued prompt:

```bash theme={null}
boat events --convo <id>
```

```
you [prompt]: Refactor billing and run the full test suite
you [steer]: Skip the integration tests, the unit tests are enough
...
```

## Steer with no running turn

If the conversation has no turn in progress, Boat refuses the steer with `no_running_turn` (409). This is on purpose. You asked to change a running turn. A new queued turn would be a surprise. To start a new turn, use `boat prompt`.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.