I kept running into a very specific mobile problem:

A session is in the middle of a long turn (Claude Code or Codex is busy), and I’m on my phone.

I have something important to add — a constraint, a file to avoid, a correction — but I 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 I needed 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.

What I mean by “queue messages while an agent is busy”

I don’t mean “draft a note in Apple Notes and hope I remember later.”

I mean:

• your message is stored with the session
• you can edit/reorder/remove it before it runs
• the agent processes it when it’s ready (or you force it to send now)

What I tried first (and where I bounced off)

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

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

• Keep SSH open on my phone: doable, but it turns a 10-second follow-up into “now I’m doing terminal work on mobile.”

• Happier: gives me a real “pending queue” and “steer/interrupt” set of knobs, so I can choose whether a message should wait or should 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:

• How to run Happier from your phone
• GitHub: https://github.com/happier-dev/happier
• Install/download: https://github.com/happier-dev/happier#how-it-works
• Discord (community + support): https://discord.gg/W6Pb8KuHfg

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
• Server pending (pending queue)

My default if I’m away from a keyboard is usually Server pending. I’d rather queue a message and edit it than accidentally derail 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 Server pending, 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, I 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.

Related guides

• How to monitor Claude Code from your phone
• How to approve Claude permissions from your phone
• How to resume AI coding sessions from your phone