01 · Alive

Your work outlives the window, the app and the network.

Sessions outlive the window

Each session is its own background process. Close the terminal, quit the app or drop the connection: your build, your server or your agent carries on, and comes back where it was, scrollback included. After a reboot, each one shows its last screen and a Run again button that resumes the Claude Code or Codex conversation.

# the app quit an hour ago
$ alto ls
1  48211  2h  working  claude
2  48230  2h  done     codex
3  48262  1h  idle     pnpm dev

Nothing takes the rest down

Every session runs on its own, so a problem in one never reaches the others. The service that finds and starts sessions holds nothing it can't rebuild, so it can restart while every session keeps running.

The full architecture

Update without losing work

After you install a new build, alto reload moves the service and your running sessions onto it in place, their programs still running (not yet on Windows). Idle sessions move at once, working ones once they go idle.

$ alto reload --dry-run
# only say what would happen
$ alto reload
# a new build, programs still running

How updates keep sessions

02 · Addressable

Every session on every machine, one address away.

Build boxes, GPU servers, cloud VMs, the machines in your homelab rack: each one becomes a device with one command, and every session on it has a name, machine:id, that works from anywhere. Over Tailscale, with nothing listening where the internet can find it.

Any session, by name

alto attach studio:3 brings the desktop's session to the terminal you're in. Open a tab on any machine from the app's + menu, or drive one from a script with --on gpu-1.
Add a machine in a minute

Setup is one command, alto install, and needs nobody at the machine. Put it in cloud-init, an image or a container and every new machine arrives ready.
New machines show up on their own

Trust a Tailscale tag (tag:gpu), a person or a whole domain once, and every machine carrying it is yours to open sessions on. No pairing machine by machine; short-lived VMs join and leave by themselves.
Work goes where it fits

Say what a session needs, alto new --in 'os:linux has:docker', and Alto picks the machine.

cloud-init · a GPU box joins itself

runcmd:
  - tailscale up --authkey=… --advertise-tags=tag:gpu
  - curl -fsSL -o /usr/local/bin/alto $ALTO_URL
  - su - agent -c 'alto install --trust "*@example.com"'

$ alto --on gpu-1 new -- claude
4
$ alto --on gpu-1 ls
1  9120  5h  working    claude
2  9188  5h  needs-you  codex
4  9311  1s  working    claude
$ alto attach gpu-1:2

Running Alto on many machines

Tailscale built in

Secure remote access from anywhere in the world.

Your sessions are reachable from a café, a train or the other side of the world, over Tailscale's encrypted network. No ports to open, no SSH server to run, no keys to copy.

  your laptop, anywhere          your phone
          │                              │
          │   encrypted, device to device, by Tailscale
          ▼                              ▼
  ┌─────────────────── your tailnet ───────────────────┐
  │                                                    │
  │   studio        gpu-1         build-2       nas    │
  │   ● 4 sessions  ● 6 sessions  ● 2 sessions  ● 3    │
  │                                                    │
  └────────────────────────────────────────────────────┘
     nothing listens on the LAN or the internet

Nothing exposed to the internet. Alto listens only on your private Tailscale network, never the LAN or the public internet, so there's no port for anyone to find.
Your own devices just work. Signed in to the same Tailscale account, they're trusted with no setup. Share with someone else by pairing their device once with a six-digit code, and revoke it any time.
Can't be fooled by an impostor. Each device has its own key and must prove who it is before any code or token is sent to it.
Works on bad connections. On hotel wifi or a train, you see the current screen at once instead of waiting on a backlog. A dropped connection comes back by itself, and your session never notices.

Coming for organizations Planned · Phase 9

Groups, not rows

Devices grouped by tag ("gpu", "linux-build"), each showing what's working, waiting and done.

Say what, not where

Start a profile in a group and Alto picks the machine. Drain one for maintenance.

Rules and a record

Who may read, type into or start sessions in which group, single sign-on, and an audit log you export.

No hub to fall over

An optional hub for the overview. If it's down, every machine keeps running its own sessions.

03 · Legible

Every session says what it's doing, and when it needs you.

A mark on every session

Working, needs you (a prompt, a question, a bell), done or idle, for any program. Coding agents are first-class: with alto agents install, Claude Code and Codex report exactly what they're doing. Marks come from signals, never from reading the screen.

api infra web dev

Allow claude to run terraform plan?
1 Yes   2 No

One list of what's waiting

alto ls --waiting asks every device you reach and lists every session waiting on a person (a prompt, a question, an agent asking permission), newest first. alto fleet shows what needs you, sessions, machines, devices and activity in one view, in any terminal.

$ alto ls --waiting
# everything waiting on you,
# on every machine, newest first
$ alto fleet
# the whole fleet, in this terminal

Told wherever you are

A notification finds you while you're elsewhere, so nothing sits waiting unnoticed. On your phone it comes from the machine itself, whether or not any window is open. The iPhone app is in TestFlight.

How status works

04 · Open

You, your phone and your agents all plug in.

A session isn't tied to a window. Any terminal can show it, so can Alto's app and your phone, and an agent can read it, type into it and wait on it. Everyone sees the real, live screen, not a copy.

The terminal you already use

alto new --attach starts a session right there, Ctrl-\ detaches, and alto attach studio:3 brings back any session from any machine. Alto takes no other key.

Keep your terminal

Alto's app, if you like

A terminal of its own, and entirely optional. It's fast and correct because it's built on libghostty: images, the Kitty keyboard protocol, native selection and search all just work, with no second terminal in between redrawing them.

libghostty
tabs + splits
profiles
Kitty keyboard
Sixel
search
zsh · bash · fish

Your phone

Native iPhone and Android apps: a notification when something needs you, and the terminal itself to read the output, answer a prompt or approve a step. The iPhone app is in TestFlight.

Your agents

A command line made for them: alto run gives back one command's output and exit status, and send, wait, capture and events do the rest, on any machine. alto guide teaches an agent how.

The guide for agents

People and agents, one terminal

Watch it work. Take the keyboard whenever.

Talk to Claude Code in one pane. It runs its commands in a work pane beside it, a real terminal you can see and type into, here or on another machine.

See every command it runs. ⌘⇧K opens a work pane beside the agent, and its commands run there in front of you, not hidden in a transcript.
The agent gets clean results. alto run -- cargo test hands back just the output and exit status, so it doesn't misread a screen or wait on the wrong thing.
Step in any time. Type there whenever you like: the agent waits until you've stopped. ⌘⇧P pauses agents in that pane until you say so.

Prefer tools to shell commands? claude mcp add alto -- alto mcp gives the agent run, wait, read_screen and more. How work panes work

claude · conversation

> the build is slow again, find out why

● Bash(alto run -- cargo build --timings)
  ⎿ Compiling aws-sdk-s3 v1.4.0 …
    Finished dev in 48.2s

● Most of it is aws-sdk rebuilding on every change. The dev profile's default features pull it in.

work pane · zsh

~/src/api $ cargo build --timings typed by claude
   Compiling aws-sdk-s3 v1.4.0
   Compiling api v0.9.2
    Finished dev in 48.2s
      Timing report saved
~/src/api $ ▌

Reliable by design

Built so nothing you start dies by accident.

   Alto app · alto command               another computer
       (this computer)                    over Tailscale
             │                                  │
             │                   ┌──────────────▼─────────────┐
             │                   │ service: finds and starts  │
             │                   │ sessions, pairs devices,   │
             │                   │ keeps the computer awake,  │
             │                   │ passes remote clients      │
             │                   │ through, untouched         │
             │                   └──────────────┬─────────────┘
             │ local socket,                    │ passed
             │ straight to the session          │ through
             ▼                                  ▼
   ─────┬───────────────────┬──────────────────────┬──────────
        ▼                   ▼                      ▼
   ┌──────────┐        ┌──────────┐           ┌──────────┐
   │ session 1│        │ session 2│     …     │ session N│
   │ terminal │        │ terminal │           │ terminal │
   │ state    │        │ state    │           │ state    │
   └────┬─────┘        └────┬─────┘           └────┬─────┘
        ▼                   ▼                      ▼
     claude               zsh                    codex

How it's built

A process per session. Each session owns its program's terminal and a full copy of its state in libghostty: screen, scrollback, modes. That's why a problem in one never reaches the others.
A server that holds nothing it can't rebuild. It finds and starts sessions and passes remote clients through; clients on this computer talk to their session directly. So it can restart or be replaced while sessions keep running. It starts at login, so your sessions are there before you open the app.
Every client is equal. The app, alto attach, a script and another machine attach the same way and draw the real terminal state, so nothing is a degraded view.
Status from signals, never screen-scraping. Marks come from the bell, notifications, progress, shell integration and agent hooks, so they don't break when a tool changes how it looks.

Nothing to run yourself.

What Alto adds

The same convenience on machines you own, with any agent.

Small on purpose

Stays out of your way

No repo, worktree or browser panels. The tools you have already manage those.
No planner or scheduler of its own. You and your agents decide the work.
No environment templates to write before you can start. Any machine you already have is enough.
No lock-in: any program, any agent, any tab.

Honest costs

What it asks of you

A small service runs on each machine you want sessions on.
Tab marks, work panes and picking fonts by sight need Alto's app. Everything else works in any terminal.
Reaching other machines needs Tailscale on each one.
Rules, single sign-on and an audit log for organizations aren't built yet.
It's early. macOS is used daily; Linux and Windows are checked less.

Status

What's built, and what's next

Built

The terminal: tabs, splits, profiles, themes, search, images, Kitty keyboard
Sessions that outlive the window, and come back after a reboot
Agent status, marks and notifications; work panes and alto mcp
Other devices over Tailscale: tabs, the command line, pairing, device keys
Fleets: alto install, trust by tag, one queue across devices, placement (alto new --in)
The fleet view, alto fleet: what needs you, sessions, machines, devices and activity, in any terminal
Phone apps for iPhone (in TestFlight) and Android, with notifications
Updates that keep sessions running

Agents that run agents Planned · Phase 7
A boss session hands tasks to others and hears back, with every brief and result kept on disk.

Later

Groups, rules and audit for fleets Planned · Phase 9
Agents in a box, per session Planned · Phase 7
Homebrew and packages Soon
Open source, most likely GPL-3.0 Planned · Phase 8

You and your agents, on every machine, securely, from anywhere.

$ brew install alto soon

Star on GitHub Build from source

The Backplanefor People and Agents

Your work outlives the window, the app and the network.

Sessions outlive the window

Nothing takes the rest down

Update without losing work

Every session on every machine, one address away.

Any session, by name

Add a machine in a minute

New machines show up on their own

Work goes where it fits