While a turn runs

While the agent works on a turn, its reply bubble shows what it does: the text as it is written, its thoughts and one line per tool call. You can read along, add a message, or stop the turn. This page covers those three things and what the transcript offers once the turn is over.

The live reply #

The running turn has one bubble at the bottom of the transcript. From top to bottom it holds:

• a header with Stop on the left and three follow buttons on the right,
• 💭 Thoughts, an open section with the agent's reasoning as it arrives,
• the reply text, which grows as the agent writes it,
• three moving dots while the turn is working,
• the tool activity: one line per tool call, such as Tool (Bash): npm test, with an emoji for the kind of tool (🛠️ for a tool without one of its own),
• a nested bubble for every sub-agent the turn starts, with its own thoughts, activity and text.

A long reply keeps its header, and so Stop, pinned at the top of the chat while it scrolls.

The transcript follows new rows while you are at its end, and nowhere else. Scrolled up, you stay where you are reading while the turn goes on, and a round ⌄ button above the composer shows what arrived below and takes you back to the end. See Scrolling. Added in 0.9.12 Opened far up in the history, at a pin or a search result, the reply waits below until you scroll down to it; see Reading far up.

When the turn ends, the bubble becomes the reply. The thoughts stay in a folded 💭 Thoughts (3) section above it, with the number of thought blocks, and the tool lines stay in a folded 🔧 Tool activity (5) section below it.

Following a section #

A long thought stream pushes the answer and the tool lines away. The three buttons in the bubble's header keep one section in view as the reply grows:

The followed section's bottom edge stays just above the composer. Press the lit button again to switch following off, or press another one to switch to it. Scrolling the transcript by hand, with the wheel, touch, the keys or the scrollbar, also switches it off; typing in the composer does not.

The choice is remembered per conversation, but only until you reload the page.

Sending while the agent works #

You can type while a turn runs. What the send button reads tells you what will happen to the message:

With an empty composer the button reads Send and is disabled. The send button never turns into Stop; that button is on the reply bubble.

Which providers steer is in By provider. A message that is queued waits and runs next; the queue is on Sending while a turn runs. A message that steers carries a hidden note telling the model to deal with it in addition to the request it is already working on; you see only your own text.

What a steered message looks like #

The agent decides how it takes a steered message, and the transcript shows which of three things happened:

• Folded in. The agent answered it inside the running turn. Your message stays where you sent it, and a compact marker under it reads Handled together with the previous reply — this message was steered into that turn. The answer is in the reply of the turn.
• Answered on its own. The agent finished the running reply first and then answered your message. The reply is split around your message, and the steered message and its answer are drawn together with the part before it.
• Cut off. You pressed Stop, or the turn failed, before the agent got to it. The marker reads Stopped with the turn — not answered. or Steered into the turn above, which failed — not answered. and offers Resend.

You can steer more than one message into the same turn. After a reload the transcript draws them the same way.

When the button reads Queue #

Sometimes a turn cannot take a message right now. The button then reads Queue and its tooltip says why:

The message does not get lost or skip the card. It sits in the transcript as an ordinary queued message with Cancel, and goes into the turn on its own once the hold ends. A question card is never answered or dropped because you sent a message; answer it as usual.

The button follows the agent within about a second.

Taking a steer back #

A message that waits as a queued message has Cancel until the agent picks it up; see Cancelling one queued message.

On Copilot's SDK engine, the newest message you steered into the turn keeps its Cancel until the runtime takes it up. Cancelling pulls it back out, so the agent never answers it. Older steered messages lose Cancel once they are pushed. On Claude and DeepSeek, a message loses Cancel as soon as it is pushed into the turn.

Stopping a turn #

Stop is on the running reply's bubble. A conversation's right-click menu in the list has Stop turn too, so you can stop one without opening it.

1. Press Stop. A window asks Stop this turn?, with the note The agent stops after its current step, and explains: Work already done stays; anything the agent was about to do is cut short.
2. Press ⏹ Stop turn, or Keep running to leave things as they are.
3. The button reads Stopping… until the agent has stopped.

The turn then ends with a short system note as its reply:

System note: This turn was stopped from the relay UI before completion. Error code: relay.turn-aborted. Send a new message to continue when you are ready.

The text the agent had streamed so far is not kept: the note is the whole saved reply. The thoughts and tool lines of the turn stay, in their folded sections. Files the agent changed and commands it ran before the stop stay as they are. The conversation itself goes on: a new message starts a new turn in the same session.

What a stop leaves running depends on the provider:

• Background work. On Claude, DeepSeek and Copilot's SDK engine, Stop ends only the reply. Background tasks the turn started, such as a command running in the background or a background agent, keep running. Each has its own Stop in the composer's task panel. On Copilot, if the runtime cannot interrupt the reply on its own, the fallback also cancels its background agents.
• Steered messages. A message you steered into the turn before the stop is not run later by itself. It settles as Stopped with the turn — not answered. with Resend.

On a turn that is stuck, Stop still works. On Copilot's SDK engine, a runtime that does not answer the stop within 10 seconds is not waited for any longer: the turn ends as stopped.

After the turn #

Resend #

Resend appears under a steered message that the agent never answered because the turn was stopped or failed. One press sends the original text and attachments again as a new message, with the model, reasoning effort, context size and mode that are selected in the composer now. Attachments that are no longer available are left out, and a notice says so. If another message with the same text was sent a few minutes ago, nothing is sent and the button stays. The button then reads Resent, on every device and after a reload. Each message can be resent once; if that Resend is cancelled or fails, the button is available again.

Resend is not offered on an ordinary failed turn. There you send the message again yourself. See When a turn fails.

Buttons on a failed reply #

Where a failure has a fix in the OAR interface, the failed reply carries a button for it:

Copying #

Every code block in a reply or in the thoughts has a Copy button in its corner. It copies the block's text and reads ✓ Copied for a moment, or Copy failed when the browser refuses. To copy a whole reply, select its text.

When a turn ends while you are away #

With push notifications on for a device (Settings → Notifications), a finished turn sends a Turn completed notification, and a failed one Turn failed; a turn you stopped counts as failed. They are sent only while no device has OAR in the foreground, and show generic text unless you allow message previews on that device.

By provider #

Steering is the same on Copilot and on OpenAI, because OpenAI is the Copilot agent pointed at your own endpoint. The reply text of Claude Cloud also arrives a block at a time. The other differences in what the live bubble shows, such as how much of a sub-agent is recorded, are in Providers at a glance.