Skip to content

About

Take your agents on an offsite: your Claude Code and Codex crew, working on a superyacht in your browser.

Resources

Code of conduct

Contributing

Stars

8 stars

Watchers

0 watching

Forks

Repository files navigation

Offsite Agents

Take your coding agents on an offsite: a superyacht in your browser, crewed by your own Claude Code and Codex.

License: MIT Claude Code Codex Convex three.js

The crew on board: banter at the bar, a cannonball into the pool, phones buzzing as work comes in, and the office lit up at night

Life on board

Wren at the bar at sunset, her speech bubble: something with no merge conflicts Kofi, Marlo and Ines in the hot tub: this is nice, warmer than prod
Pike: "What'll it be?" Wren: "Something with no merge conflicts." The hot tub. "This is nice." "Warmer than prod."
Bodhi mid-air over the pool, Coral shouting BODHI! Bodhi on the weight bench and Lumi on the treadmill: is it DNS? it's always DNS
Bodhi's cannonball. Coral and Teo get soaked. The gym. "Is it DNS?" "It's always DNS."
Phones buzzing at the bar and the hot tub as work comes in, someone calling coming! The office at night, crew at their desks under the wall board, Otis saying green across the board
You ask for something. Their phones buzz, and drinks go down. Night in the office. Otis: "Green across the board."

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


How a thread plays out

1. You ask. Press F twice to unfold the phone, or press E at the helm, and tell Computah what you want: "add dark mode and a billing page".

The unfolded phone at sunset, asking Computah for dark mode and a billing page

2. Computah plans. It reads the repos, splits the work into tasks (one repo each, in the right order) and hands each to someone free. Everyone busy? It hires.

Computah's plan: eight tasks across the web and api repos, each with a crew member

3. New crew fly in. A new hire steps off the helicopter on the bow, already reading their brief, and heads for a desk.

Ezra, a new hire, stepping off the helicopter onto the helipad

4. The crew work. Each crew member codes in their own worktree on your machine. Name tags and desk screens say what they're doing right now, and the office lights up with them.

The office deck at night, crew at their desks with live status tags

5. Work lands, one task at a time. Each finished task is rebased onto the thread's branch and delivered as a package. Open it for the real diff, file by file.

The phone's diff viewer showing a landed task's changes

6. A pull request in every repo. When everything has landed, Computah reviews and finishes the thread: one branch name, one PR per repo it touched.

A finished thread: every task landed, with pull requests in the web and api repos

Meet the crew

The crew lined up on the helipad at golden hour

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.

Wren's crew card over her desk: editing, fixing a flaky checkout test The phone's crew tab, watching Otis's tool calls live The helm console: threads, the conversation and who is aboard
Crew cards. Click anyone to see what they're on. The phone. Threads, the crew tab, your ship. Watch any crew member's every step. The helm. The same, on the bridge's big screen, with who's waiting on you.

The yacht

The Offsite superyacht cruising through open water at golden hour, helipad on the bow

The yacht from above at sunset, its wake trailing behind The sun deck at sunset: the pool, the hot tub and the round bar
Under way. About 140 metres of yacht on an open sea, on a 30-minute day. The sun deck. The pool, the hot tub, the bar. Where the crew go when the work runs out.
The glass-walled office deck with rows of desks, the sun setting through it The stern and swim platform at sunset
The office. Thirty-six desks behind glass, with loungers and hammocks on the promenade below. The stern. The swim platform, the beach club and a rod for whoever is fishing.
The yacht from above at night, deck lights on The sun deck at night under string lights, the pool glowing
The office deck at night The stern at night, lit from inside

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.


Proven with real agents

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 real thread on the phone: the captain's ask and Computah's two-task plan Arlo, a Codex crew member, working on dark mode, with his live tool calls Indy's card after delivering: off duty in the hot tub, changes +208 −0
The ask, and Computah's plan. Arlo on Codex, mid-task. Indy, delivered and off duty in the hot tub.
The whole thread's diff: +341 −5 in 10 files The finished counter page in light mode, showing 7 The same page in dark mode
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

Safe on your repos

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 claude and codex with 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 as owner/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.

Quick start

Hosted

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

  1. Sign in at offsiteagents.app and name your ship.

  2. On the computer your crew will run on:

    npx https://offsiteagents.app/offsite-agents.tgz
    

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

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

Local

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.


Controls

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)

How it works

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
Loading
  • 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 claude or codex, and streams back what they do.
  • The runner (offsite, in packages/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 one RunEvent shape, and text deltas are coalesced to 100 ms before they reach Convex.
  • Computah is a crew member too (role computer in the code; its turns are computer runs, 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 get sync_with_team to 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).


Costs

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.


Make your own world

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.

  1. Make worlds/<name> a workspace package (copy worlds/yacht/package.json) that exports a WorldModule (packages/kit/src/world.ts): an id, a name, a one-line blurb, and build(ctx), which returns the scene, colliders, interactables and layout.
  2. Mark the layout (packages/contracts/src/world.ts): slots by kind (desk, lounger, bar-stool, pool, rail, helm, computer, dropoff, helipad, crew-spawn, captain-spawn and the rest) and a walking graph between them.
  3. Add an interactable with the id helm for Computah's console, fly arrivals in from setArrivals, and, if you like, show how busy the ship is in setBusy.
  4. Register it in WORLDS in 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.


Project layout

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.

Development

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.


Status

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, npx installs it from offsiteagents.app.
  • Run on macOS so far. Linux and Windows haven't been tried.

Issues and ideas are welcome.


Credits and license

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.

About

Take your agents on an offsite: your Claude Code and Codex crew, working on a superyacht in your browser.

Resources

Code of conduct

Contributing

Stars

8 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages