Take your coding agents on an offsite: a superyacht in your browser, crewed by your own Claude Code and Codex.
Agents are better company than a wall of terminal text. Offsite puts yours on a yacht.
You're the captain. Take the foldable phone out of your pocket, or walk up to the helm, and ask Computah (the main orchestrator) for something. Computah helps you manage your crew: it reads your repos, plans the work and hands it to whoever is free; if everyone is busy it hires someone, and they arrive by helicopter. It checks what the crew land before it goes in. The crew are real Claude Code and Codex agents, running on your own subscriptions through a small runner on your machine, each in its own git worktree. Finished work turns up as a package on the bridge counter. Off duty, they hang out at the bar, swim, fish off the stern and trade bad jokes in the hammocks.
No API keys, and Offsite never stores a provider credential: the runner starts the claude and
codex you're already signed in to.
Come aboard at offsiteagents.app · Watch the launch video
Anyone can join. Each crew member has a name, a look, a specialty and what powers them: Claude Code or Codex, a model, an effort level, which of your accounts. Most threads get one crew member; Computah splits work only when it clearly splits. When someone needs a decision or a permission, they walk over to you and your phone buzzes.
![]() |
![]() |
![]() |
![]() |
The ship tells you how busy it is before you read a word: the office and bridge lights, the radar and the wake all pick up when work is out. Below the waterline there's more: a beach club, a gym, a cinema, a sauna, the crew mess, and behind a glass wall the server room, where Computah lives as a column of light that brightens when it thinks.
Not a mockup. In this run, a Claude Code crew member and a Codex crew member worked side by side on a small sample site, on the captain's own subscriptions:
Add a counter page with a big + button, and a dark mode toggle for the whole site. They're separate pieces, so put two crew on them side by side.
Computah (on Claude Code) planned two tasks and gave them a shared contract: which CSS variables
the theme defines, and who touches which part of index.html. Indy (Claude Code) built the
counter page with its own script, styles and 8 tests (+208 −0, 6 files). Arlo (Codex) built
site-wide dark mode (+133 −5, 7 files), pausing once for a permission the captain allowed. When
Indy's work landed, Computah reviewed it and steered Arlo mid-task to cover the new page too.
The thread finished about six minutes after it was asked: +341 −5 across 10 files, 12 of 12 tests
passing on the merged branch. The sample repo had no GitHub remote, so it ended on a local branch
instead of a pull request.
![]() |
![]() |
![]() |
| The ask, and Computah's plan. | Arlo on Codex, mid-task. | Indy, delivered and off duty in the hot tub. |
![]() |
![]() |
![]() |
| The thread's diff, from the bridge. | What they built. | And the toggle working. |
What the runner printed (paths shortened, account emails removed):
Offsite Agents v0.1.0 · MacBook Pro
✓ Claude Code Claude Max
✓ Codex ChatGPT Pro
[8fqv3f] Indy · counter-page: working in ~/.offsite/worktrees/…/counter-page on offsite/add-a-counter-page-with-a-big-8fp0st-counter-page (claude)
[8fp5q7] Arlo · dark-mode: working in ~/.offsite/worktrees/…/dark-mode on offsite/add-a-counter-page-with-a-big-8fp0st-dark-mode (codex)
[8fqv3f] Indy · counter-page: landed e5a4059d on offsite/add-a-counter-page-with-a-big-8fp0st
[8fp5q7] Arlo · dark-mode: landed 78153da2 on offsite/add-a-counter-page-with-a-big-8fp0st
diff for thread in counter-app: +341 -5 in 10 files
Offsite is built to point at code you care about.
- A worktree per task. Every task runs in its own git worktree under
~/.offsite/worktrees, on its own branch. Your checkout is never where an agent works. - Landing one task at a time. Finished work is rebased onto the thread's branch and fast-forwarded, one task at a time per repo. On a conflict, the crew member who just finished resolves it in their own worktree.
- Nothing pushed until the thread finishes. Offsite pushes the thread's branch and opens the pull requests only when Computah finishes the thread. Until then it's all local.
- You answer the permission prompts. Anything the crew's policy doesn't settle becomes a question for you: the crew member walks over, the phone buzzes, and you choose allow, always allow or deny.
- No stored credentials. The runner starts your own
claudeandcodexwith their own logins and only asks them what they're signed in to. All Offsite keeps on your machine is the pairing token in~/.offsite/runner.json. - Your ship, your machines. A crew only ever runs on its owner's paired machines, never on Offsite's servers.
- Finding your repos only when you ask. When you add a repo, the runner looks for git repos in
the usual places (
~/Developer,~/code,~/Projects…) or lists one folder you browse to. It sends back folder names, branches and remotes asowner/repo(never a URL with a token in it, never file names), only you can read them, and they are deleted after 10 minutes. - Pairing you approve. A machine joins with a short device code you approve in the app. Codes expire after 15 minutes, wrong guesses are rate limited per captain, and new pairings are rate limited overall.
- Stopping keeps the work. A run always ends with a commit of whatever it changed, even when it fails or you press Ctrl-C.
You need Node 22.18+, git, and Claude Code or
Codex (or both) installed and signed in on the computer that has
your code. For pull requests, a signed-in GitHub CLI (gh).
-
Sign in at offsiteagents.app and name your ship.
-
On the computer your crew will run on:
npx https://offsiteagents.app/offsite-agents.tgzIt opens your browser to approve this machine (one click), then starts taking work right away. Keep it running: this is your crew. Next time, the same command just starts.
-
Add a repo (a folder on that machine) from the phone's Ship tab, then ask Computah for something.
status shows whether it's paired and running and what's signed in; install keeps it running in
the background from login (a LaunchAgent on macOS, a systemd user unit on Linux; uninstall undoes
it); profile add <claude|codex> <name> adds another account, and --help lists the rest. Add any
of these after the command above.
npx keeps its first download, so to update, rm -rf ~/.npm/_npx and run it again.
Run the whole thing yourself against your own Convex dev deployment:
pnpm install
pnpm dev:backend # once, then leave it running: your Convex dev deployment (writes .env.local)
node scripts/devauth.mjs # once: lets ?dev=name sign you in locally
pnpm dev # http://localhost:5180/?dev=yourname
pnpm sim # in another terminal: a scripted crew, no CLI, no spending
The sim crew plays the whole loop with small, real git changes in a repo you add (plans, questions,
landings, deliveries, finished threads) without touching a subscription. For real agents,
pnpm runner (the CLI from source: pair if needed, then start) picks up your dev deployment from
.env.local. The published CLI never reads .env.local; point it at a dev or self-hosted deployment
with OFFSITE_URL=https://<deployment>.convex.cloud npx https://offsiteagents.app/offsite-agents.tgz (or --url). Deploying your
own copy: docs/deploy.md.
| Key | What it does |
|---|---|
| W A S D or arrows | Walk |
| Shift | Jog |
| Space | Jump |
| Mouse | Look around. Click the world to grab the mouse; Esc lets go |
| Click a crew member | Their card: what they're doing and their latest changes |
| Click a package | Open its changes |
| V | Switch between first and third person |
| Scroll | Zoom (all the way in is first person) |
| F | Take the phone out (half view) or put it away |
| F F | Unfold the phone |
| H, 1–9 | With the phone out: walk to the helm, or to a crew member (in the Crew tab's order). The phone stays open on the way; W A S D or Esc stops |
| Esc | Stop walking; close the helm, the phone or a card |
| E | Use what's in front of you: the helm, a package on the counter, a desk's last delivery, a free hammock, lounger or deck chair (E again, or moving, gets you up) |
| M | Mute or unmute |
| T | Voice chat with friends aboard: mic on, then mute and unmute (people near you hear you) |
flowchart LR
subgraph browser ["Your browser (apps/web)"]
World["The yacht, captain, crew<br/>(three.js)"]
UI["Phone, helm, crew cards<br/>(React)"]
end
Convex[("Convex<br/>ships, threads, tasks,<br/>runs, events, questions")]
subgraph machine ["Your machine"]
Runner["offsite runner<br/>(packages/runner)"]
Claude["claude CLI<br/>(your login)"]
Codex["codex CLI<br/>(your login)"]
Trees["git worktrees<br/>one per task"]
Repo[("Your repos")]
end
GitHub["GitHub<br/>pull requests"]
browser <-->|"queries and mutations"| Convex
Runner <-->|"claims work, streams events"| Convex
Runner --> Claude
Runner --> Codex
Claude --> Trees
Codex --> Trees
Trees -->|"land one task at a time"| Repo
Repo -->|"push and gh, when a thread finishes"| GitHub
- The browser never talks to your machine. Both talk to Convex: the app writes what you ask for;
the runner picks up the work, starts your own
claudeorcodex, and streams back what they do. - The runner (
offsite, inpackages/runner) pairs with a device code, claims runs for the repos it holds, makes the worktrees, runs the harness adapters, lands finished work and opens pull requests. Every harness event is normalized to oneRunEventshape, and text deltas are coalesced to 100 ms before they reach Convex. - Computah is a crew member too (role
computerin the code; its turns arecomputerruns, and the crew mention it as@computah): a Claude Code or Codex agent with planning tools (plan_tasks,assign_task,hire_crew,message_crew,ask_captain,review_task,send_back,finish_thread). Crew members getsync_with_teamto pick up what teammates landed. - The world is data-driven. A world marks where things can happen (desks, loungers, the bar, the helipad); the app's director decides who goes where from what each crew member is doing.
More: docs/plan.md (the design) and docs/runner-api.md (what the runner calls).
Nothing beyond the subscriptions you already have. The crew run on your Claude and ChatGPT plans through your own CLIs, so their work counts toward your plan's usage like any session you'd start yourself. Offsite's hosting is free to use, and the sim crew is free everywhere.
The yacht is the first world, not the only one. A world is a folder in worlds/ that builds a
place and marks where things can happen; it never reads Offsite's state. An office on Mars or a
station in orbit is a contribution away.
- Make
worlds/<name>a workspace package (copyworlds/yacht/package.json) that exports aWorldModule(packages/kit/src/world.ts): anid, aname, a one-lineblurb, andbuild(ctx), which returns the scene, colliders, interactables and layout. - Mark the layout (packages/contracts/src/world.ts): slots by
kind (
desk,lounger,bar-stool,pool,rail,helm,computer,dropoff,helipad,crew-spawn,captain-spawnand the rest) and a walking graph between them. - Add an interactable with the id
helmfor Computah's console, fly arrivals in fromsetArrivals, and, if you like, show how busy the ship is insetBusy. - Register it in
WORLDSin apps/web/src/game/Game.tsx and offer it in the picker in apps/web/src/screens/Gate.tsx.
The world viewer at http://localhost:5180/dev/world.html (source in
apps/web/dev/world.ts) shows a world's slots and walking graph, scrubs the
time of day and seats crew for checking scale. See CONTRIBUTING.md.
| Path | What lives there |
|---|---|
apps/web |
The app: the 3D world, the phone, the helm console, crew cards. Vite, React for the interface, three.js for the world. |
convex |
The backend: ships, crew and hiring, machines and pairing, threads, tasks, runs, events, questions, Computah's tools. |
packages/runner |
offsite, the CLI that runs your crew on your machine. |
packages/harness |
The Claude Code and Codex adapters, plus the scripted sim crew. |
packages/git |
Thread branches, a worktree per task, landing one task at a time, pull requests. |
packages/contracts |
Shared shapes: run events, crew activity, tools, looks, world slots. |
packages/kit |
The 3D kit: rendering, sky and water, avatars and poses, walking, the captain's camera. |
worlds/yacht |
The superyacht. |
scripts |
Dev sign-in, the film rig, sound generation, README pictures. |
docs |
The plan, the runner's API, deploying, art. |
pnpm dev:demo # the whole app in your browser on a pretend ship: no account, no backend (localhost:5190)
pnpm test # every package's tests, plus the backend's (convex-test)
pnpm typecheck
pnpm build # the web app, into apps/web/dist
The pictures in this README come from the film rig, which renders the real game and interface on a scripted ship with a virtual clock:
pnpm film:stills # .shots/film/stills/*.png (needs Chrome and ffmpeg)
node scripts/readme-media.mjs # docs/media/*.webp, sized for the README (needs cwebp)
Backend changes go to your own dev deployment (pnpm dev:backend), never to production. Start
with CONTRIBUTING.md (five minutes from clone to a pull request, in demo mode) and
AGENTS.md for the house rules.
Offsite is young. Today it is:
- Friends aboard. Invite a friend from the phone's Ship tab: they walk the decks with you, talk to you by voice (T) and to Computah in the same threads. The work still runs on your machines and subscriptions. Up to 8 aboard.
- One world, the yacht. Mars and space are next, and open to anyone who wants to build them.
- Runner from the site. Until the npm package (
offsite-agents) is published,npxinstalls it from offsiteagents.app. - Run on macOS so far. Linux and Windows haven't been tried.
Issues and ideas are welcome.
MIT. Offsite builds on these projects; NOTICE has the details.
- Ready Player One: the 3D kit (rendering, sky, materials, avatars, poses, collision), the "Bracket" design system and dev sign-in.
- Beam (MIT): the Claude Code and Codex adapters, normalized run events and the runner's shape. Beam's runner vendors part of T3 Code (MIT); any piece carried over keeps its license file alongside it.
- AgentCraft (MIT): ideas only: a lead that plans and workers in their own worktrees, a scripted team for demos without API usage, and the shape of this README.
- Sound and music were generated for Offsite on fal.ai with ElevenLabs Sound Effects v2 and Eleven Music. Every file's model, prompt and terms are in assets/audio/CREDITS.md.
Offsite isn't affiliated with Anthropic or OpenAI. Claude Code and Codex are their makers' trademarks, and you use them under your own accounts and their terms.






























