This is a persona page. It describes how Cosyra is used by one kind of engineer. For feature breakdown see the mobile coding terminal guide. For the comparison landscape see other Cosyra use cases.
Short answer. A commute is 20 to 60 minutes of forced stillness with your phone in your hand. If your job is shipping code, that is one to two real hours a day. Cosyra is a mobile cloud terminal with Claude Code, Codex CLI, OpenCode, and Gemini CLI pre-installed, you give the agent a task at the station, it runs while you stand, you review the diff at the next stop, and you push before you get off. The container runs in the cloud, so tunnels and thermals do not kill the work.
What breaks if you just "work on your phone" normally
People try this every year, and the same three things break every time:
- SSH disconnects on tunnels. You reconnect and your tmux session is there, but only if you had tmux set up right. Cosyra runs the shell in a cloud container, files and history persist there, not on the phone, so a reconnect reattaches to the same container.
- Typing is the bottleneck. Two thumbs on a phone keyboard is not how you write code. With an AI coding agent, you describe the change, the agent writes it, you approve the diff. Typing volume collapses to commands and natural language.
- The phone heats up and throttles. Any real compilation or type-checking on a phone's own CPU turns it into a heater. Cosyra runs the work in a cloud container; the phone is a thin client.
A real commute, narrated
Here is a workflow a backend engineer on a 25-minute train ride uses. No special setup, just the app.
$ # 07:42, platform, waiting for the train.
$ cd ~/work/checkout-service && git pull
Already up to date.
$ claude
> in src/pricing/tax.ts, refactor calculateTax() to accept a Locale
> and move the inline rate table into config/tax-rates.json
# Claude Code reads the files, plans, writes the diff.
# You tap the phone three times to approve the plan.
$ # 07:55, two stops in. Review the diff.
$ git diff --stat
src/pricing/tax.ts | 24 +++++++++++-------
config/tax-rates.json | 18 +++++++++++++++
$ # 08:03, one stop out. Ship.
$ git commit -am "refactor: tax.ts takes Locale"
$ git push origin refactor/tax-locale && gh pr create --fill
https://github.com/acme/checkout-service/pull/8847
$ # 08:08, arriving at the office. PR is up for review.
The part that used to be hard, running the actual refactor, is delegated to the agent. The part that is still yours, deciding what to change, reading the diff, taking responsibility for the commit, is exactly as easy on a phone as on a laptop, because reading diffs is a reading task.
Try it on your next commute. 10 hours of free trial, no credit card. Install, paste your Anthropic API key, and see whether the 20-minute ride is enough to ship a real PR.
Setup that takes two minutes
Three one-time steps before your first commute:
- Install Cosyra from the App Store or Google Play.
-
Sign in. An Ubuntu 24.04 container spins up for you in about ten seconds.
Claude Code, Codex CLI, OpenCode, and Gemini CLI are already on
$PATH. -
Clone your main repo once (
gh repo clone owner/nameorgit clone). It stays there, 30 GB of persistent storage, survives app close.
On commutes you are just opening the app and running the agent. The boring bootstrap is already done.
The specific features that make this work
- Session hibernation on Pro, your container pauses after ten minutes of inactivity and resumes exactly where you left off when you reopen the app. No "where was I" tax on the return leg.
- 30 GB persistent storage, clone the repo once, it lives in the container. Signal drops don't reset state.
- Native iOS + Android apps, no PWA limitations. The keyboard behaves like a real terminal keyboard, not a web-textarea approximation. Voice dictation is first-class.
- BYOK encryption, your Anthropic, OpenAI, and Google API keys are stored on-device with platform-native encryption and transmitted over TLS to the container. A public Wi-Fi coffee-shop stop on the way doesn't change the threat model.
What not to try on a commute
We have tried, so you do not have to:
- Big migrations. A database schema change or a 30-file codebase-wide rename takes more cognitive load than the environment can give you. Save those for a desk.
- First-time setup of a new tool. Reading a new CLI's docs, making your first mistakes, recovering, all that is better done where interrupting to google something is cheap.
- Security-sensitive work with other people watching. A full Linux terminal on a phone screen is legible to the person next to you. Keep API key rotations and incident response that shows real secrets out of crowded commutes.
Commuting engineer FAQ
What happens to my session when the tunnel kills my signal?
The cloud container keeps running. When your phone reconnects, the terminal reattaches exactly where it was, the Claude Code agent did not stop, the shell's working directory did not reset, and the current diff is still in view. Hibernation after idle is a Pro feature.
Can a Claude Code refactor actually finish on a 20-minute ride?
Yes, for most small-to-medium refactors. The agent runs on real compute in the cloud, so speed is not gated by your phone's CPU. You describe the change, it runs, you review. We have done this on 15-to-30-minute rides routinely. Larger refactors, multi-service renames, schema changes, are better on a desk.
Do I need a Bluetooth keyboard?
No. Voice dictation is in the terminal toolbar, and the on-screen keyboard handles command-length input fine. A foldable Bluetooth keyboard helps if you are writing longer-form anything, but is not required for the commute workflow.
What if I want to keep going when I get home?
Your container is accessible from any device logged into your account. Pick it up on a laptop web client, same Ubuntu, same repository state, same Claude Code history.
tl;dr
A 20-minute commute is a real PR with a mobile cloud terminal and an AI coding agent. Cosyra gives you both in one app, no SSH, no laptop, no session loss at tunnels.