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
    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.