_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](/content/guides/mobile-coding-terminal.html). For the comparison landscape see [other Cosyra use cases](/content/use-cases.html)._

**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](/content/site-root.html) 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  
gent 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.

cosyra, morning commute

$ # 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:

1. Install Cosyra from the App Store or Google Play.
2. 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`.
3. Clone your main repo once (`gh repo clone owner/name` or  
   `git 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.
