Driving Your Coding Agents From Your Phone While They Work

An agent working a big task often runs 15 to 20 minutes without asking you anything. It reads the code, plans, writes, runs the tests.

What are you doing meanwhile? Staring at the screen. Waiting. Refreshing your feed in a second tab, hoping you don't miss the moment it asks a question.

That's wasted time. And it's completely avoidable.

The problem is the unblock moment

An autonomous agent moves on its own until it hits a decision. "Drop this field or keep it?" "Migrate the database now or later?" "The test fails, do I fix the code or the test?"

At that point it stops and waits. And until you answer, it does nothing.

If you've stepped out for coffee, those ten minutes of waiting are ten minutes gone. Multiply by three agents over a day, and you understand why you feel stuck even though everything is "running."

The answer isn't to chain yourself to your desk. It's to be able to answer from anywhere.

A notification when an agent needs you

The shift is turning "I watch constantly" into "I get pinged when it matters."

Concretely: an agent goes idle, your phone buzzes. You glance, you see the question, you answer in two sentences, the agent moves on. You were on the train, in a meeting, or having lunch. Doesn't matter.

That's exactly what the AgentsRoom mobile app does. Every idle agent fires a push to your phone, with a clear summary of what it did and what it's waiting for. You open the app, read the question, type your answer, and it's off again.

You stop being the bottleneck. Your agents move at your pace, not the pace of your office chair.

"But it's my code, where does it go?"

The first question about driving code remotely is security. Fair.

If your phone talks to your machine through a server in the middle, does that server see your code? Your prompts? Your answers?

With AgentsRoom, no. The relay is end-to-end encrypted. The machine and the phone exchange messages the server relays without ever being able to read them. It's a passthrough, nothing more. Your code stays between your desktop and your phone, full stop.

That distinction matters. Plenty of "remote" tools route your content in clear text across their servers. Here, the server is blind by design.

What you can actually do from the phone

We're not talking about building a full app on a 6-inch screen. We're talking about keeping control of agents you launched from your desktop.

You see each agent's state in real time: who's coding, who's waiting, who finished. You read what an agent is asking and you reply. You approve or reject a plan before it runs. You restart a stuck agent.

The heavy writing stays on the desktop, where it's comfortable. The phone is your remote for the unblock moments.

The same remote for Antigravity, Codex and Claude agents

The remote is not wired to one vendor. AgentsRoom drives the terminal session, not the model, so whatever CLI you launched on your Mac appears on the phone the same way: Claude Code, Codex, Antigravity CLI, GitHub Copilot CLI, OpenCode, Aider, Grok Build, Mistral Vibe, Kimi Code.

Antigravity is worth calling out on its own, because its CLI ships as agy and it is the kind of agent people start and then walk away from. Once your phone is paired, an agy session behaves like any other: you watch its output stream in real time, you type into its terminal, you fire a saved prompt at it, you approve or reject its plan before it runs.

Two moments reach your phone from an Antigravity run. When the agent asks a question and stops, you get the question and you answer it in two taps. When it finishes a turn without asking anything, AgentsRoom pushes a short "agent has finished working" instead of letting a silent completion sit there until you come back to the desk.

Mixed fleets are the normal case, not the exception. A Claude agent on the API refactor and an Antigravity agent on the test suite show up in the same list, and you answer whichever one buzzes first. The remote agent control page walks through every surface the phone exposes.

A concrete case

Friday evening, you launch three refactors before leaving. You close the laptop.

On your commute, the first agent pings: it's done, it asks whether to open a PR. You type "yes." Over dinner, the second one hesitates on a function name. You settle it in five words. The third is still running, you let it.

Next morning you open the laptop and two features out of three are ready to merge. You didn't spend your evening at the screen. You just answered three notifications, the way you'd answer three texts.

That's the real win. Not "coding on mobile." Unblocking your agents without being a prisoner of your desk.