How to steer a busy Claude Code or Codex session from your phone
Send a correction while the agent is mid-turn — when steering works, when it falls back to queueing, and how to avoid thrashing the run.
- CLI
- 0.2.17
- Preview ref
- a2c45c8
A common timing problem:
A session is mid-turn. The agent is doing work. And you notice something that should change now (wrong directory, wrong files, wrong plan).
At the laptop, you can steer the session quickly.
On a 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 to 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 Pending until ready.
- If you must stop what’s happening and restart from new context: use Interrupt.
Common approaches and their trade-offs
-
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 a phone: works, but it turns into terminal work on mobile.
-
Happier: an open-source app for running and orchestrating coding agents cross-device. It has explicit steering/interrupt behavior and a pending queue fallback, so you 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 to 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) Pending until ready
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 Pending until ready and use the Pending (N) sheet to edit/reorder/send now.
Since 0.2.16 a queued message also has Steer now. It delivers that message to the agent without interrupting the turn, even while the agent is idle. If steering stops being available before the message goes out, it waits for the next safe input. Send now keeps its interrupting behavior. See the steering docs.
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 Pending until ready and queue the message. When you decide it should land now, use Steer now on the queued 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.