← Back to patterns
Agent Workflow

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.

Loading Demo

Preparing the interactive example for this pattern.

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.

DOPETRUSTWORTHYAIAUTONOMY

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.

Use it
when

Agent runs last minutes and users think of the next task before the current one has finished.

Avoid
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.

Research Frame

Why this pattern exists, and where it breaks.

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.

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.