Chat with an agent
This content is not available in your language yet.
This guide shows you how to work with an agent in a space.
Create a space
Section titled “Create a space”- Navigate to Spaces in the sidebar
- Click the + button beside the Spaces heading
- Type a name — this is required. An empty name is refused; the dialog stays open
- Optionally add agents from the workspace
- If the workspace has any repo, a repo picker appears. It starts with every repo selected; narrow it (including deselecting a single repo) to the repos this space should provision worktrees for
- 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 becomes a queued steering card in the strip above the composer and is injected into the live run at the next turn boundary. There is no toast — the card is the feedback.
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
- A message with an attachment is always sent as a message — the steering queue is text-only
- 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. If you have that conversation open, the request
appears in the chat, above the composer, as the same numbered-option card
used for ask_user (deny, approve, and optionally approve for eight hours).
There is no skip: a blocked agent is waiting on a decision.
If you are somewhere else in the app, an always-on-top panel in the shell still lists what is waiting, so you can unblock the agent without hunting for the space. The overlay hides a request the moment that space’s conversation is on screen, so you never answer the same prompt twice.
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.
Answer an agent’s question
Section titled “Answer an agent’s question”An agent that needs a preference, a missing requirement, or a genuine fork
must call ask_user. Writing the question as a chat message ends the turn
and you have to re-prompt. The tool renders a numbered card in the conversation
— options, optional free text, or both — and the run waits on your answer.
Tap a single option to send it (the trailing number becomes an arrow on hover).
Multi-select and typed answers use Continue (⌘↵ / Ctrl↵). Skip
tells the agent to pick a reasonable default and not ask again.
It is a separate mechanism from the approval card above: an approval is “may I do this?”, a question is “which of these did you mean?”. Asking is available on the built-in harness in every mode, including the read-only ones (it 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. 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.
Related guides
Section titled “Related guides”- Use spaces
- @-mention agents
- Use plan mode
- Set up Slack integration to do the same from Slack