Queue prompts for coding agents

This guide covers the Prompt Queue in Otty 1.6.2 for macOS. It lets you prepare follow-up messages for an integrated coding agent, including Claude Code, Codex, or OpenCode, while its current turn is running. The pending messages stay visible in the terminal pane until Otty sends them.

That is useful when you already know the next question but do not want to send it into the current turn. You might ask an agent to inspect a parser, then queue a request to explain its findings. Or you might finish drafting a test plan while the agent is still making an agreed change. The queue gives those messages an explicit order and a place where you can revise them.

How do you queue a prompt in Otty?

Focus the pane containing the agent, then press ⌘⇧M. This opens the queue input bar at the bottom of that pane. Type one prompt and press Return to add it. The input clears so you can add another prompt without reopening the bar. Each submitted entry becomes its own pending item.

For example, while an agent is investigating a failing test, you could add these as two separate entries:

Explain the cause of the failing parser test, referring to the relevant functions.
Summarize the smallest regression test that would demonstrate the problem.

Enter the first sentence, press Return, then enter the second sentence and press Return again. Otty sends the first pending entry when the integrated agent reports that it is idle. The second waits for a later idle transition after that next turn. The queue belongs to this pane; adding prompts here does not distribute work to other agents.

You can read the compact controls reference in the Prompt Queue documentation. If your goal is to work on two independent tasks at the same time, use separate panes or tabs and the task monitoring controls instead.

What must be set up before automatic sending works?

Otty needs to know when an agent has finished a turn. Install the integration for the CLI you use under Settings → Agents, then restart that agent so it loads the integration. You keep running the agent's own CLI and using its existing login. The integration supplies state signals to the terminal.

For OpenCode, send a message after restarting so the plugin reports the session. For Codex, respond to its trust prompt if one appears after installing or updating the integration. A CLI that starts successfully is not, by itself, proof that its state reporting is working. Check that Otty distinguishes active work from waiting or idle before relying on a longer queue.

The agent setup guide explains what the integrations install. In Otty 1.6.2, Settings also provides a Config home for agents whose configuration lives somewhere other than the usual folder. If you use a custom home, make sure the integration is installed for that configuration rather than another unused copy.

For ordinary shell commands, the readiness signal is different: Otty uses shell integration to recognize a fresh, empty prompt. Integrated agents report their state through their own hooks or plugin. These are two paths into the same queue, so troubleshooting should start by identifying what is actually running in the pane.

How do you queue a longer, multiline prompt?

Open the Composer with ⌘⇧E. Write the prompt using paragraphs, code, or a short checklist, then press ⌥⌘Return to enqueue the draft. In the normal Composer, ⌘Return sends immediately, while Return inserts a newline. Check the action shown beside the Composer button before submitting.

Enqueueing a Composer draft in Otty 1.6.2 keeps the whole draft as one queue entry. Use paragraph breaks to organize one detailed message. To schedule three separate turns, submit three queue entries and verify that the pending list shows three rows.

A useful single entry might look like this:

Review the parser change you just made.

Check empty input, a truncated escape sequence, and a complete sequence.
Describe which cases are covered by existing tests and which need a new test.
Keep the review focused on the changed parser functions.

This keeps the request and its constraints together when it reaches the agent. It also makes the queue easier to inspect: each row represents one intended turn, rather than one fragment of a prompt whose other paragraphs might arrive later.

When does the next queued message send?

For an integrated agent, automatic dispatch follows its transition into idle. A permission request is a separate state, so waiting for approval does not release the next prompt. For a plain shell, Otty waits for the running command to finish and for an empty prompt it can recognize. A shell pane containing a full-screen application is not an idle shell prompt.

The queue checks readiness rather than the meaning of the previous result. An agent can finish a turn by explaining that it could not complete a task. That still differs from an agent actively processing the task. Write follow-ups that remain sensible if the preceding turn reports a problem, or leave the decision until you review its answer.

How do you change or cancel pending work?

The queue strip appears above the Composer when prompts are pending. Click a row's pencil to edit it in place. Press Return to save, Option-Return to insert a line break, or Escape to cancel the edit. Automatic sending pauses while you are editing, so the entry is not dispatched with its old text halfway through a revision.

Use the trash control to remove a pending prompt. Removing an entry changes what will be sent next; it does not retract a message already delivered to the agent. If the agent has already started working on that request, use the agent's own interaction controls to stop or correct it.

The arrow on a row is Send now. It sends that entry immediately instead of waiting for its automatic turn. Use it only when you intend to deliver input to whatever is currently receiving input in the pane. It is not a repair button for every delay: first check whether the agent is processing, asking a question, or displaying an approval request.

Keeping the queue short helps here. Two well-defined follow-ups are easier to revise after an unexpected result than ten prompts built around an assumption that may turn out to be wrong.

How is a terminal queue different from agent steering?

A terminal-held queue delays delivery. The agent cannot act on a queued message until Otty submits it. Steering is an interaction with the agent after a message has reached it, and the agent determines how that input affects its current work. Some CLIs also provide their own pending-message features, with their own controls and timing.

Choose where to hold a follow-up deliberately. If you use Otty's queue, inspect and edit the pending list in Otty. If you use a CLI's native queue, use that CLI's interface to inspect it. A message submitted through one mechanism should not be assumed to appear in the other one's pending list.

Otty's approach is helpful when you want a consistent place to draft and review later turns across the integrated agents you use. It does not change which tools an agent may call, its model configuration, or its permission policy. For the broader relationship between terminal and agent, see Otty for coding agents.

Is the Prompt Queue the same as a shell command chain?

No. A shell chain such as cargo build && cargo test encodes a condition: the shell runs the tests only if the build succeeds. A terminal queue encodes when the next entry may be submitted. Returning to a prompt after a failed command can still make the pane ready for the next entry.

For a deterministic build-and-test step, keep the dependency inside the shell command:

cargo build && cargo test

You can submit that chain as one shell command. Splitting it into two queue entries would remove the success condition between them. The same distinction matters for agent prompts: “the previous turn ended” does not prove that a test passed, a review approved a change, or an artifact is ready to publish.

Use the queue to append a command you thought of after starting another command. Use shell logic when later execution depends on an exit code. Use a new agent turn when the next step needs interpretation of the result. The shell integration guide explains the prompt and command markers that make shell readiness observable.

Why is a queued prompt still waiting?

First inspect the current pane. If the agent is still working, waiting is expected. If it is asking for approval or clarification, answer that request. A queued instruction is not a substitute for the answer expected by a permission dialog. If a pending row is being edited, save or cancel the edit before expecting automatic dispatch.

Next check integration state. Restarting the CLI after enabling its integration is essential because an already-running process may still have the old configuration. If you changed an agent's configuration directory, check its Config home. Try a short interactive turn and confirm that Otty observes the agent returning to idle before building a queue around it.

For a shell pane, look for text already entered at the prompt and check that shell integration is enabled for the shell you are running. Otty supports integration for zsh, bash, and fish on macOS. Exiting a full-screen application also returns control to the shell, where the prompt readiness check can work again.

Finally, check that you are inspecting the pane where you added the prompts. A queue in another pane is independent of the one you are looking at. If you switch from an agent back to a shell, recheck that each pending entry is still appropriate for the program now receiving input before letting it run.

What makes a useful sequence of queued prompts?

Give each entry one clear outcome and enough context to stand alone. An investigation sequence might ask for the root cause, then a list of affected callers, then a summary of candidate regression tests. Those questions still make sense if the investigation changes direction. Avoid a sequence where every later message assumes a particular implementation succeeded.

Keep decisions visible. If a change needs your review, let the agent report back and inspect its work before adding an instruction that depends on approval. The queue can save a return to the keyboard between routine turns; it cannot evaluate whether the resulting work meets your requirements.

When work becomes independent, split it into another pane instead of extending a serial queue indefinitely. When you need to return to a conversation days later, use agent history. Pending work, concurrent work, and conversation history answer different questions, and using the appropriate control makes each easier to follow.

Does queueing approve agent tool requests?

No. Automatic dispatch excludes the agent's awaiting-input state. You still respond to the agent's permission requests and questions. A queued prompt simply waits to be submitted as a later message when the agent reports idle.

Can I queue work for any terminal application?

Do not assume that every interactive program provides the readiness signals the queue needs. This guide covers Otty's integrated coding-agent workflow and its shell-prompt workflow. A program can accept keyboard input without exposing a meaningful “ready for the next task” state to Otty.

Which version is this guide based on?

The shortcuts and queue behavior above were checked against Otty's 1.6.2 tag, including the Prompt Queue and Composer behavior. The release notes identify that version. The linked Prompt Queue and Composer documentation provides further background, but those live pages may describe later releases. These instructions cover the macOS app.