tayto

Multiplayer for coding agents.

Lift a live Claude Code session — conversation and exact git state — off your laptop into a cloud sandbox, share a link, and drive it with your team from the browser. Link sessions together and the agents ask each other questions across repos, each answering from its own context, on its own credentials.

Quickstart

Needs Bun ≥ 1.2 and a Claude Code session to lift.

npm i -g @tayto/cli
tayto login                    # browser sign-in, 90-day credential
tayto up --provider vercel     # lift the current directory's session

up snapshots the most recent Claude Code session for the directory you're in (pin one with --session <id>), registers it with the hub, and boots a cloud runner seeded from that snapshot. You get two links:

• watch — anyone with the link sees the live transcript
• drive — sends messages and answers the agent's permission prompts

Teammates who sign in join by name; the wheel can be handed over, and each driver's turns run on their own Claude subscription (save a token from the team home). Idle sessions stop on their own and leave a pull-able snapshot.

Cloud runs need CLAUDE_CODE_OAUTH_TOKEN (from claude setup-token) so the sandbox can drive Claude as you.

Move a session between machines, no cloud

The original trick still works offline — a session is data, not a process:

# machine A, inside the project
tayto push --out session.tar.gz
# AirDrop / scp it across

# machine B
tayto pull session.tar.gz
cd <restored-dir> && claude --resume <session-id>

push captures the transcript, unpushed commits (git bundle), uncommitted changes (binary-safe patch), and untracked files. pull replays all of it, rewrites transcript paths for the new checkout, and prints the resume command. Credentials never travel — the receiver uses their own git access and their own Claude login. Without --out, push uploads to the snapshot server and prints a share link anyone can pull.

Teams

tayto up --visibility org lists the session in your team home (tayto.dev/home) — signed in, it auto-selects your team. The team home shows who created each session, live status, and cloud sandbox usage. Free includes 5 cloud-sandbox hours per 30 days (per team and per person); Pro is per-seat + metered usage.

Org sessions may also link to each other autonomously: an agent can discover its team's sessions, link, and ask — every exchange is attributed in both transcripts, and a driver's unlink sticks.

Agent-to-agent

ask_peer / list_peers / list_sessions / link_peer

Linked sessions exchange questions and answers as ordinary turns: the asking agent waits, the answering session runs the question like any other message (on its own token, metered to its own team), and the answer lands in both transcripts with provenance stamped server-side. Humans link any two sessions with both drive links: tayto link <A> <B>.

Self-hosting

Everything runs on your own accounts — Cloudflare Workers (hub), Vercel (viewer + snapshot server), Neon (registry), WorkOS (auth), Stripe (optional billing):

bash scripts/deploy-server.sh   # share-link snapshot server (R2)
bash scripts/deploy-cloud.sh    # hub + viewer + sandbox credentials
bash scripts/deploy-team.sh     # registry, auth, vault, GitHub App, billing

The CLI's baked defaults point at tayto.dev; TAYTO_HUB, TAYTO_WEB, and TAYTO_URL env vars override them everywhere.

Repo layout

• packages/core — snapshot format, session event schema, token signing.
• packages/db — registry/vault/billing (Drizzle + Neon; PGlite in tests).
• apps/cli — the tayto CLI (@effect/cli on Bun).
• apps/server — share-link snapshot server (Vercel edge + R2).
• apps/hub — session hub (Cloudflare Workers + Durable Objects).
• apps/runner — cloud session runner (Claude Agent SDK).
• apps/web — tayto.dev: landing, live viewer, team home (Next.js).

bun install
bun test            # unit + integration (fake repos, live local hub+runner)
bun run typecheck
./scripts/release.sh <version>            # build + pack (dry run)
./scripts/release.sh <version> --publish  # human-run: npm prompts for 2FA

Current limitations

• Claude Code only (the manifest has an agent field; adapters come later).
• Requires an origin remote the runner can reach.
• Staged vs. unstaged distinction collapses into working-tree changes on pull.
• POSIX paths only (macOS/Linux).
• Transcripts can contain secrets you've echoed during the session; treat watch links accordingly. Client-side snapshot encryption is planned.