Skip to content
Control Center

Chat with an agent

This guide shows you how to work with an agent in a space.

Create a space

Section titled “Create a space”
  1. Navigate to Spaces in the sidebar
  2. Click the + button beside the Spaces heading
  3. Type a name — this is required. Leaving it empty cancels the dialog silently
  4. Add one or more agents from the workspace
  5. If the workspace has more than one repo, a repo picker appears. It starts with every repo selected; narrow it to the repos this space should provision worktrees for
  6. Confirm

Control Center opens the space and starts provisioning a copy-on-write worktree per selected repo in the background.

Send the first message

Section titled “Send the first message”

Type your message in the composer and press Enter. The agent dispatches and starts streaming its response.

If the space is still provisioning, your message is parked rather than lost — the composer holds it and sends it automatically once the worktrees are ready.

As the agent works you see its turn stream in: reasoning segments, tool calls (file reads, writes, shell commands) and answer text, all inside one agent-turn message.

Steer a running agent

Section titled “Steer a running agent”

While an agent is working, plain conversational text does not queue a new turn. It is injected into the live run at the next turn boundary and you get a “Sent to the running agent as steering.” toast.

Three things change that behaviour:

  • A message containing an @mention is always sent as a message, never as steering
  • A message starting with a slash command is always handled as that command
  • If every live run has already finished, the text falls through and is sent as a normal message

Approve a blocked action

Section titled “Approve a blocked action”

When an agent hits an action its guardrails gate — a destructive command, a privileged tool — the server blocks the run and publishes an approval request to every connected client. An always-on-top panel appears in the shell listing what is waiting; approve or deny it inline and the agent continues.

There is no timeout: a blocked agent waits until someone decides. The same request also appears in the inbox’s attention strip and on the phone client, so you can unblock it from wherever you are.

Answer an agent’s question

Section titled “Answer an agent’s question”

An agent can also just ask you something. The ask_user tool renders a form directly in the conversation — a question with options, free text, or both — and the run blocks on your answer. It is a separate mechanism from the approval panel above: an approval is “may I do this?”, a question is “which of these did you mean?”.

It is available on the built-in harness in every mode, including the read-only ones (asking mutates nothing), and it is deliberately not wrapped in an approval prompt — a dialog in front of a dialog would fail closed with no approver connected, denying the agent the act of asking. A run with no conversation to render into simply does not get the tool.

Stop an agent

Section titled “Stop an agent”

While runs are live, the composer’s send button becomes a stop button. Clear the composer and press it — this stops every agent running in that conversation.

There is no stop control in the space header and no keyboard shortcut for it. To stop just one run when several are live, open that run’s activity tab — its header carries a run-scoped pause/resume and stop (the stop asks you to confirm). Observability → Live lists every running agent in the workspace with the same control.

A stopped run is marked as stopped. Send a new message to dispatch again.

Use slash commands

Section titled “Use slash commands”

Type / in the composer to see the command list. The ones that change how the conversation behaves:

Command What it does
/plan Switches the space into plan mode. A bare /plan just arms the mode; /plan <request> arms it and sends the rest as your message
/goal <text> Records the conversation’s working goal
/loop <text> Iterates on a task until it is complete
/compact Folds older history into an anchored summary and continues on the compacted context
/todo … Views and edits this conversation’s persisted todo list

Skills appear in the same list under their own skill: namespace, so they never collide with the commands above — a skill named plan or compact stays reachable:

Command What it runs
/skill:<name> A skill installed in the workspace, or attached to the agent
/skill:<repo>:<name> A skill shipped by one of the repos checked out in this space

Repo skills are badged with the repo they came from, because a name alone does not say which service’s conventions it encodes and two repos may each ship a testing. You do not have to type the prefix to find one: typing the bare skill name matches the namespaced entries too.

An agent only ever carries the skills of the repo it is currently working in — see Repo-scoped skills. The composer is not scoped that way: you can invoke any repo’s skill by naming it.

/compact and /todo are intercepted by the client and never persisted as messages — a /compact line in the transcript would push the next compaction’s cut one turn back. /plan flips the space’s stored mode rather than travelling as text. So none of the three is “a message you send the agent”; do not expect to see them in the history.

Ask for a plan first

Section titled “Ask for a plan first”

Before a complex change, switch the space to plan mode with /plan, the mode dropdown on the composer toolbar, or Shift+Tab. The agent then researches read-only and delivers a typed plan you approve before any work starts. See Use plan mode.

Reach an agent without a dedicated space

Section titled “Reach an agent without a dedicated space”

You do not need a space per agent. In any space:

@alice can you look at the failing tests in src/auth_test.dart?

The mentioned agent is added to the space and dispatched with that space’s context. See @-mention agents for how names are matched.

Section titled “Related guides”
Section titled “Related concepts”