How to steer a busy Claude Code or Codex session from your phone

I kept hitting the same timing problem:

A session is mid-turn. The agent is doing work. And I notice something that should change now (wrong directory, wrong files, wrong plan).

If I’m at my laptop, I can steer the session quickly.

If I’m on my phone, it’s easy to do the wrong thing:

send a follow-up that gets queued too late,
interrupt too aggressively and thrash the run,
or wait until the end and then pay for the mistake.

This is how I steer from mobile in a way that’s predictable.

TL;DR

If you have a small correction that should affect the current turn: Steer immediately (when supported).
If steering isn’t supported (or you want ordered, editable messages): use Server pending.
If you must stop what’s happening and restart from new context: use Interrupt.

What I mean by “steer a busy session”

Steering means sending a message while the main lead session is already busy, and having it affect the in-flight work.

If steering is not available for that runtime/backend, the correct fallback is to queue the message (pending) or interrupt.

What I tried first (and where I bounced off)

Wait until the end: safe, but you often discover the scope mistake too late.
Send follow-ups and hope: sometimes it lands after the damage is already done.
SSH from my phone: works, but it turns into terminal work on mobile.
Happier: gives me explicit steering/interrupt behavior and a pending queue fallback, so I can choose the right tool for the moment. Trade-off: steering is capability-driven — if the backend/runtime doesn’t support it, the app can’t force it.

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 three modes (and when I use each)

1) Steer immediately

Use this when you want a small correction to affect the current turn.

In the app, open:

Settings → Session → Message sending → When the agent is busy (steer-capable)
Choose Steer immediately

Behavior (as implemented):

if the backend supports in-flight steering, Happier injects the message into the active turn
otherwise it falls back to the normal busy-send behavior

2) Server pending

Use this when:

you want ordering (multiple thoughts)
you want to edit before it runs
you don’t want to thrash the current turn

Choose Server pending and use the Pending (N) sheet to edit/reorder/send now.

3) Interrupt

Use this when you really need to stop what’s happening.

Interrupt aborts the current turn and starts a new one. It does not necessarily “stop the run forever” — it just changes the current turn.

Step-by-step: a phone-safe steering workflow

If the correction is small, try Steer immediately.
If it’s not steer-capable (or you’re unsure), set busy-send to Server pending and queue the message.
If the run is actively doing the wrong thing and you need to stop it: Interrupt.

Troubleshooting

Symptom: I expected steering, but it queued instead

Likely cause:

steering isn’t supported for this runtime/backend

Fix:

treat it as a pending-queue workflow for this session

Symptom: I’m interrupting and the agent keeps redoing work

Likely cause:

you’re interrupting frequently without giving a stable new target

Fix:

send one clear correction, then let it run; use pending for additional thoughts

FAQ

Is steering always available?

No — it’s capability-driven by backend/runtime.

If steering isn’t available, the safest behavior is pending queue.