How I Turned My Commute Into a Coding Session (6 AI Agents Running From My Phone)

There's a developer named mgranda who runs six Claude Code agents in parallel. From his phone. No laptop, no desktop. Just Termius on iOS and a cloud VM.

The workflow: kick off a task, pocket the phone, get a push notification when Claude needs input. Respond, pocket the phone again. Repeat.

He's literally building software while walking his dog.

When I first saw this setup, my reaction was "that's ridiculous." Then I thought about all the dead time in my day. The commute. Waiting for coffee. Those 15-minute gaps between meetings that aren't long enough to start anything real but feel wasteful to just scroll Twitter.

What if all of that could be productive?

The Setup (It's Simpler Than You'd Think)

The core architecture is almost boring:

Termius (iOS/Android): SSH client with a decent mobile keyboard
Mosh: SSH alternative that survives network switches (WiFi to cellular, dead zones, phone sleep)
Tailscale: VPN for secure access to your machine
tmux: Keeps terminal sessions alive across disconnects
Cloud VM or home machine: Where Claude Code actually runs

The magic ingredient is push notifications. Using a webhook service called Poke, mgranda set up a hook that fires whenever Claude asks a question. His phone buzzes, he responds, Claude keeps working.

Without notifications, you'd be constantly checking the terminal. With them, you can actually walk away.

Why Mosh Changes Everything

Regular SSH connections die constantly on mobile. Switch from WiFi to cellular? Dead. Walk through a parking garage? Dead. Phone goes to sleep for 30 seconds? Probably dead.

Mosh was designed for exactly this. It survives network transitions. Put your phone to sleep, reopen the app an hour later, and your session is still there. No reconnecting, no "where was I," no lost context.

One gotcha: mosh doesn't forward SSH agent, so for git operations that need GitHub auth, you'll want regular SSH inside tmux. But for the actual Claude Code interaction, mosh is the difference between "this works" and "this is unbearable."

The Parallel Agent Trick

Here's where it gets interesting. mgranda doesn't run one agent. He runs six.

Each agent lives in its own tmux window. Ctrl-a c creates a new window, Ctrl-a n cycles through them. You can have one agent refactoring the auth module, another writing tests, another fixing that CSS bug that's been bugging you for weeks.

They all run simultaneously. You're not waiting for one to finish before starting the next. You're orchestrating.

The cost model actually makes this practical. Using a pay-per-use VM (Vultr at $0.29/hour in mgranda's case), you only pay when you're working. Two scripts handle the lifecycle:

vm-start  # Start VM, wait for Tailscale, connect via mosh
vm-stop   # Halt VM

He even has an iOS Shortcut that calls the Vultr API directly. Start the VM from his phone before he even opens Termius.

The Security Angle (Because I Know You're Thinking It)

Running AI agents on cloud VMs accessible from personal devices is... a thing to think about.

mgranda's approach:

The VM's public IP has no SSH listener. All access goes through Tailscale's private network.
Cloud firewall blocks everything except Tailscale coordination
Local nftables as backup
fail2ban for good measure

Defense in depth. The VM is essentially invisible to the public internet. You can only reach it if you're authenticated to his Tailscale network.

Is it as secure as an air-gapped machine in a bunker? No. Is it secure enough for side projects and personal development? For most threat models, yes.

The Simpler Version (Use Your Own Mac)

If running a cloud VM feels like overkill, there's an even simpler approach: just SSH into your own machine.

One developer described his setup as "a boring trio that feels like a cheat code":

Tailscale gives private access to his Mac from anywhere
tmux keeps sessions alive across disconnects
Termius makes SSH feel normal on a phone

Claude Code runs on his Mac, inside tmux. His phone just attaches to that running session. No cloud costs, no VM management. The machine he already owns becomes the server.

The key insight: "The point is not tmux. It is not Tailscale. It is not Termius. The point is removing friction between an idea and a working prototype."

What This Actually Looks Like Day-to-Day

The mental model shift is significant. Development stops being a place (your desk) and becomes a rhythm (a sequence of decisions).

Practical scenarios:

Waiting for coffee: Check on the refactoring task you kicked off this morning. Claude has a question about error handling. Answer it. Get your coffee.
On the train: Start three agents on different features. Give each one clear instructions. Pocket the phone. Read a book. Get notified when they need input.
Between meetings: Review the PR that Claude opened. The Vercel preview deploy shows the changes. Approve it from your phone. Done.

One developer put it perfectly: "I can be standing in line somewhere, open a preview URL, and see the idea come to life."

The Caveats (Because Nothing Is Perfect)

Don't start new projects from your phone. Initial scaffolding, creating repos, configuring environment files, setting up CLAUDE.md instructions... all of that is way easier on a full keyboard. Mobile is great for iteration, not initialization.

Cognitive load is real. Asynchronous development means context-switching. You need to design tasks that agents can handle independently, which requires upfront planning. If you're constantly being pulled back into the terminal, you haven't scoped the tasks well enough.

The phone keyboard is still a phone keyboard. Termius lets you customize the shortcut bar (add Ctrl, Tab, Esc, common symbols). Spend 5 minutes configuring this. It makes a huge difference.

Battery life. Termius isn't exactly light on battery. If you're doing this seriously, bring a charger.

Try It This Weekend

Here's the minimum viable version:

Install Tailscale on your computer and phone (free tier is fine)
Install tmux on your computer (brew install tmux on Mac)
Install Termius on your phone
Start a tmux session: tmux new -s claude
Run Claude Code inside that session
SSH in from your phone via Tailscale's private IP

That's it. No cloud VMs, no webhooks, no complex infrastructure. Just your existing machine, accessible from anywhere.

If you want notifications, add the Poke webhook. If you want multiple agents, learn Ctrl-a c and Ctrl-a n. If you want pay-per-use cloud VMs, spin one up on Vultr or Hetzner.

But start simple. See if the workflow clicks. Because the real unlock here isn't the tech stack. It's the realization that all those dead minutes in your day could be building something.

Have you tried mobile development with AI agents? I'm curious what's working for people and what's still too painful. The tooling is evolving fast.