How to queue messages while Claude Code or Codex is busy (from your phone)

When your Claude Code / Codex session is running, use pending messages and steering so you don’t lose your thought (or derail the run).

Based on
CLI
0.2.17
Preview ref
a2c45c8

A very specific mobile problem:

A session is in the middle of a long turn (Claude Code or Codex is busy), and you’re on your phone.

You have something important to add (a constraint, a file to avoid, a correction), but you don’t want to:

  • lose the message,
  • spam the session with half-baked follow-ups,
  • or accidentally interrupt a turn that was doing the right thing.

So you need two behaviors that work well from mobile:

  • “Save this thought and send it when the agent is ready.”
  • “No, actually — I need to correct the current turn right now.”

That’s basically what pending messages and steering/interrupt are for.

TL;DR

  • If you want the agent to keep running and you just don’t want to forget: use Pending until ready (pending queue).
  • If you need to correct the current turn immediately: use Steer immediately (when supported) or Interrupt.
  • If you’re unsure: queue it. It’s easier to edit/reorder a pending message than to undo a rushed interruption.

Common approaches and their trade-offs

  • Just send the message and hope: sometimes it lands at the wrong time, or it forces an interruption you didn’t mean.

  • Wait and send later: works… until you forget the key detail.

  • Keep SSH open on the phone: doable, but it turns a 10-second follow-up into terminal work on mobile.

  • Happier: an open-source app for running and orchestrating coding agents cross-device. It has a real “pending queue” and “steer/interrupt” controls, so you choose whether a message should wait or affect the current turn. Trade-off: steering depends on the backend/runtime, and pending queue behavior depends on both server + agent support.

If you’re new to Happier (what it is, and where to get it)

If you haven’t seen Happier before: it’s an open-source companion app (mobile/web/desktop) for AI coding agents like Claude Code, Codex, and OpenCode.

The session still runs on a machine you trust (laptop/server/dev box). Happier is where you monitor, steer, approve, review, and keep going from your phone.

Get set up:

The two knobs: steering vs pending queue

When a session is busy, you’re usually choosing between:

1) Steering / interrupting (affects the current turn)

Steering means: “inject this message into the active turn” (when supported).

Interrupt means: “abort the current turn, then send a new turn.”

2) Pending queue (waits until ready)

Pending queue means: “store this message with the session; I’ll decide when/how it runs.”

Step-by-step: set your busy-send behavior

On your phone:

  1. Open Settings
  2. Open Session
  3. Open Message sending
  4. Find When the agent is busy (steer-capable)

You’ll usually see choices like:

  • Steer immediately
  • Pending until ready (pending queue)

A good default when away from a keyboard is Pending until ready. Queuing a message and editing it is better than accidentally derailing a good run.

Step-by-step: manage pending messages from your phone

When a session has pending messages:

  • the session list shows a pending count badge
  • inside the session, you’ll see a Pending (N) indicator

Tap it to open the pending sheet.

From there, you can:

  • Move up / Move down (ordering matters)
  • Edit (fix wording before it runs)
  • Remove (drop it entirely)
  • Send now (stop the current turn and send immediately)

Step-by-step: steer or interrupt when you need to correct the current turn

If the backend supports steering:

  • choose Steer immediately to inject the message into the active turn

If steering isn’t available (or you need a hard change):

  • choose Interrupt (or “Send now” in the pending sheet)

Why this works (and what breaks)

This works because it separates two different needs:

  • “don’t lose my message” (pending queue)
  • “change what’s happening right now” (steer/interrupt)

What still breaks sometimes:

  • if steering isn’t supported, you can’t truly inject into the current turn
  • if the server/agent pair doesn’t support pending queues, the UI has to fall back

Troubleshooting

Symptom: I don’t see a Pending (N) indicator anywhere

Likely causes:

  • pending queue isn’t supported by your server/agent versions
  • the session has no pending messages

Fix:

  • try setting busy-send to Pending until ready, send a message while busy, then check again

Symptom: I hit “Send now” but it didn’t send

Likely causes:

  • the session is offline/resuming and the message is still staged

Fix:

  • leave it queued; it should deliver once the agent is ready

Symptom: I expected steering, but it queued instead

Likely cause:

  • steering isn’t supported for this session/runtime

Fix:

  • treat it as a pending queue workflow for this session

FAQ

Should I always steer?

No. If you steer too often, you can thrash the agent.

If the turn is doing the right thing, queue the thought instead and let it apply cleanly.

When is pending queue better than just waiting?

When you want to preserve the exact thought, and you want the ability to edit/reorder it before it runs.

mobilesessionsmessagingsteeringworkflows
Last updated: 2026-10-26