While an agent works the next thought has nowhere to go — the composer is locked or sending interrupts the run, so the user waits and holds it in their head.
Follow-up Queue
Line up the next ask without stopping this one
While an agent works, chat gives the next thought two bad options: a locked composer, or a send that lands inside the run it was meant to follow. Follow-up Queue stacks messages above the composer as editable cards that fire in order when the run ends — each with two verbs, after (stay queued) and now (steer the running turn). Mid-Stream Steering is the now half; this is the after. The queue also has to be honest about time: a message written against a state the run has since changed gets flagged stale instead of firing blind, and the queue holds while the agent is waiting on a question.
Metaphor
Outbox
Interaction
Queue While Running, Reorder, Promote to Steer
Use case
Long Agent Runs, Coding Agents, Batched Follow-ups
Failure mode
Send Means Now
Control mechanisms
Queued Message Cards · Send-Now (Steer) · Edit / Delete / Reorder · Stale Flag · Hold on Question
Reference examples
Replit Agent Steer and Queue messages · OpenAI Codex queued messages · Cursor queued messages · Claude Code message queue
Interactive Example
The chat default and the pattern, against each other on the same task. The demo is the comparison.
Chat’s send button means now. Most follow-ups mean after.
Type “also add a test for the coupon path” while the agent is on step 3 of 6, and chat can only send it now: the message becomes the next turn, the run stops at the step boundary, and the snapshot rewrite and suite re-run never happen — 1 of 3 tests still failing. The alternative is holding the thought for the whole run: nine seconds here, minutes in practice.
The queue splits the verb in two. A message typed mid-run parks as a numbered card above the composer — editable, reorderable, deletable — and fires only when the run ends, in the order shown. ↳ Steer is the deliberate exception: the card leaves the queue, the log records “steered at step 3”, and the run inserts one step instead of dropping three. The footer reads 0 steps dropped throughout.
Codex, Cursor and Claude Code all ship a queue; none of the three re-checks a card before it sends. “Fix the flaky cart snapshot test”, written at step 2, is flagged stale the moment step 4 rewrites the snapshot — keep it or drop it, never fire it blind. And while the agent waits on “unit or end-to-end?”, the queue holds, so the next card cannot be misread as the answer.
A queued message is a promise about the future, written in the past — check it before you keep it.
DOPE Lens
How this pattern improves AI interaction quality.
Directability
Edit, reorder or delete any queued message, or promote it to steer the running turn with one click
Observability
The queue sits above the composer with its order and count visible, so what runs next is never a guess
PredictabilityPrimary
Queued messages fire only when the current run ends, in the order shown — typing never interrupts the work in flight
Explainability
A queued message the run has overtaken is flagged with the reason — “cart snapshot updated at step 4” — instead of firing blind
Fit
Where it earns its place.
when
Agent runs last minutes and users think of the next task before the current one has finished.
when
Runs finish in seconds, or every follow-up depends on reading the result first.
In the wild
Where this pattern already ships.
Real implementations from products users already know. Each entry shows how the pattern got applied — what shipped, where it sits in the product, what it traded off.

Replit Agent · Steer and Queue messages
Replit
A follow-up queued while Agent works sits in a Message Queue drawer above the chat input, where it can be edited, deleted, reordered by drag or moved into the active turn with Steer now. Queued messages run in order after the turn finishes, automatically only with a Project Editor session connected. Steer, not Queue, is the default. The docs page describes neither a stale flag nor a hold while Agent waits on a question.
Visit Replit ↗

OpenAI Codex queued messages
OpenAI
Captured Sep 2026: a message typed while the agent works parks as a card above the composer with ↳ Steer, delete and a menu — queue by default, steer on demand. Nothing interrupts the run until you press Steer.
Visit OpenAI ↗

Cursor queued messages
Cursor
Cursor 1.2 (July 2025): follow-ups typed while the agent works wait until the current task is done; once queued they can be reordered, or started without waiting.
Visit Cursor ↗

Claude Code message queue
Anthropic
Captured Oct 2026 in the desktop app: a message typed while the agent works parks above the composer as “1 message queued”, with send-now, edit and remove. The empty composer names both verbs — “↩ to send, ⌘↩ to queue for later”. The docs add the interesting split: a queued message reaches Claude as soon as the running tool calls finish, inside the same turn, while commands wait for the turn to end.
Visit Anthropic ↗
Research Frame
Why this pattern exists, and where it breaks.
Stack follow-ups as editable cards above the composer that fire in order when the run ends, each one promotable to steer the running turn now.
Chat has one verb, send, and one timeline, so a message typed during a run either waits outside the product or lands inside the work it was meant to follow.
A queue written against a state the run then changes fires stale instructions — fix the test, after the test is fixed — unless each item is re-checked before it sends.
Common questions
What people ask about this pattern.
When should I use the Follow-up Queue pattern?
+
Agent runs last minutes and users think of the next task before the current one has finished.
When should I avoid the Follow-up Queue pattern?
+
Runs finish in seconds, or every follow-up depends on reading the result first.
What problem does Follow-up Queue solve?
+
While an agent works the next thought has nowhere to go — the composer is locked or sending interrupts the run, so the user waits and holds it in their head.
Why is chat the wrong fit for this?
+
Chat has one verb, send, and one timeline, so a message typed during a run either waits outside the product or lands inside the work it was meant to follow.