This is the closest comparison on the site. ShipIt and T3 Code (from Theo / Ping) are both open-source, bring-your-own-agent control surfaces that drive coding-agent CLIs on hardware you own, in parallel, from your phone. The real split is isolation model and depth of loop — and T3 Code genuinely wins several rows.
T3 Code is lighter and broader, and packages differently. It supports more agent backends than ShipIt — Claude Code, Codex, Cursor, Grok Build, and OpenCode — installs without Docker, and ships as native iOS and Android apps plus an Electron desktop app. ShipIt is a mobile-first PWA instead: nothing to install from an app store, at the cost of the background-push reliability a native shell gets on iOS. If you want the fastest path to driving several agents from your laptop, T3 Code is the lower-friction choice.
ShipIt goes deeper on isolation and the ship loop. Every session gets its own Docker container with its own Compose services and a live instance of your app to build and test against, plus the GitHub PR/CI/review/deploy lifecycle and your Linear and GitHub issues inline. You pay for that with Docker and real RAM. Both projects are early — T3 Code describes itself as very early alpha, ShipIt as an early public release.
| Capability | ShipIt | T3 Code |
|---|---|---|
| What it is | Self-hosted, chat-driven IDE that runs coding-agent CLIs through the full ship loop | Open-source “agent harness control surface” — a GUI for driving agent CLIs |
| License | Open source, Apache 2.0 | Open source, MIT |
| Agents / models | Claude Code or Codex, on your subscription or API key (more runtimes planned) | Claude Code, Codex, Cursor, Grok Build, OpenCode — on your subscriptions |
| Multiple accounts per provider | Yes — connect several in-app | Yes — add a provider per account with its own config/home dir, named and colour-coded in the picker |
| Switching between accounts | Automatic — rolls to the next before a usage limit stops you, without interrupting sessions in flight | Manual — pick the account in the model picker (Codex can switch mid-thread when both share a CODEX_HOME; Claude needs the same config dir). Automatic roll-over on a limit isn't documented |
| Where it runs | Your VPS or local Docker | Your own machine (npx, package managers, or desktop build); remote-ready, can run as a background service on Linux |
| Task isolation | Docker container per session — own clone, own Compose services | Git worktrees — isolated directory + branch per thread, sharing the host environment |
| Isolated services / databases | Yes — each session's Compose stack is its own | No — worktrees share host ports and services; devcontainer support is an open feature request |
| Live app to test against | Isolated Compose stack per session, with services the agent starts, stops, and tails itself | Desktop in-app browser preview and agent browser automation, but the app runs against shared host services and ports |
| GitHub PR / CI / deploy loop | Inline — PR card with CI checks, review threads, deploy status, merge gate; a session can wake on its own PR merge to ship stacked work | Worktree diffs and pull-request creation; not a full inline CI/review/deploy cockpit |
| Issue tracking | Linear + GitHub Issues inline; start a session from an issue | Not a built-in issue tracker |
| Mobile | Mobile-first PWA with voice in/out — installs to the home screen, runs standalone full-screen, always boots the latest build | Native iOS + Android apps, plus web |
| Mobile notifications | Browser notifications, plus voice notes deliverable to a webhook — route “the agent needs you” into whatever push service you already run. In-PWA background push is constrained on iOS | Native push on iOS; the relay currently targets iOS only and Android settings report notifications unavailable |
| Desktop app | No — browser-based | Yes — Electron (Windows, macOS, Linux) |
| Setup weight | Heavier — Docker required; 8 GB RAM min, 16 GB recommended on a VPS | Lighter — no Docker requirement |
| Maturity | Early public release | Alpha — “We are very very early in this project. Expect bugs.” |
T3 Code is an open-source "agent harness control surface" from Theo (t3.gg) and Ping — a purpose-built UI for driving coding agents rather than an agent of its own. It works with the subscriptions you already have on Claude Code, Codex, Cursor, Grok Build, and OpenCode, and it runs on your own machine: install it with npx t3@latest, Homebrew, winget, the AUR, or a desktop build. It's remote-ready — you can reach it from your phone or another machine, and run it as a background service on Linux — and it ships native iOS and Android apps alongside a web app and an Electron desktop app for Windows, macOS, and Linux. Parallelism is handled with git worktrees: each thread gets its own directory and branch off a shared object store, so several agents can work at once without editing the same files. It's MIT-licensed and openly alpha — the project states, "We are very very early in this project. Expect bugs."
ShipIt is a self-hosted, chat-driven IDE that runs coding agents through your real engineering loop. You bring Claude Code or Codex on your own subscription or API key, and each task runs as a session in its own isolated Docker container, with a full clone of your repo and a live instance of your app (via Docker Compose) to build and test against. The GitHub PR lifecycle — description, CI checks, review threads, deploy status, merge state — renders inline in chat, next to your Linear and GitHub issues. It's Apache-2.0, installs with one command on local Docker or an Ubuntu VPS, and is mobile-first with voice.
Substantially. Both are open source. Both are control surfaces for agent CLIs, not proprietary agents — you bring the subscription you already pay for, and neither locks you to one vendor's model. Both let you connect more than one account per provider and tell them apart when you pick one, so a second subscription isn't wasted; the difference is that T3 Code has you choose the account and ShipIt rolls over on its own when one runs out of headroom. Both run on hardware you own rather than routing your code through someone else's cloud. Both are built around running multiple agents in parallel, each on its own branch, and both are designed to be driven from a phone. If your requirement is "an open-source, bring-your-own-agent GUI that runs several coding agents at once on my own machine," both tools qualify, and you should pick on the details below rather than on principle.
Several rows go to T3 Code outright. It supports more agents — Cursor, Grok Build, and OpenCode in addition to Claude Code and Codex — where ShipIt runs two backends today. It's far lighter to run: no Docker requirement and no resource planning, against ShipIt's containerized-always model that wants 8 GB of RAM minimum and 16 GB recommended on a VPS because every active session is its own container. And it ships an Electron desktop app that ShipIt has no equivalent of. On phones the difference is packaging rather than capability — ShipIt is a mobile-first PWA with voice in and out, which installs without an app store, while a native shell gets background push for free. ShipIt's answer there is a webhook: a voice note can be delivered to an endpoint as well as played in-app, so "the agent needs you" reaches your phone through whatever notifier you already run — a workable path, but one you wire up rather than one that works out of the box. If you want minimal setup, maximum agent choice, a desktop build, or push that needs no plumbing, T3 Code is the better fit and ShipIt's extra machinery is overhead you may not need.
The case for ShipIt is depth. T3 Code does have a desktop in-app browser preview, so this isn't preview versus no preview — it's what the app runs against. Git worktrees stop agents from editing each other's files, but they share the host: the same dependencies, the same ports, the same database, which is why devcontainer-style isolation is an open feature request on T3 Code rather than a shipped capability. ShipIt starts from container isolation instead, so each session brings up its own Compose services and its own instance of your app for the agent to build against and for you to preview — and the agent drives those services itself, starting, stopping, and tailing the ones it needs rather than waiting on a click from you. The session image also bakes in a JDK, the Android SDK, and Gradle, so an agent can build a Gradle project, run Paparazzi snapshot tests, read the PNG diffs, and show a running emulator live in the preview panel. Around all of it sit a per-agent default-deny outbound firewall, brokered git credentials, and guardrails that block a commit carrying a recognized secret. The other half is the loop after the diff: ShipIt renders the whole GitHub lifecycle inline — CI checks with a failure loop back to the agent, review threads, deploy status, an approval-aware merge gate — plus a one-click sync when your branch falls behind its base, sessions that wake on their own PR merge to ship stacked work, and Linear and GitHub issues you can start a session from. T3 Code gives you worktree diffs and pull-request creation; ShipIt is trying to be the surface where the entire review-and-ship cycle happens.
They're the closest pair in this set: both are open source, both are control surfaces that drive agent CLIs rather than their own model, both run on hardware you own, both run several agents in parallel, and both work from a phone. The differences are isolation and depth of loop. T3 Code gives each task its own git worktree, supports more agent backends (Claude Code, Codex, Cursor, Grok Build, OpenCode), and ships as native iOS, Android, and desktop apps. ShipIt is a mobile-first PWA, and gives each session its own Docker container plus a live instance of your app to test against, and surfaces the full GitHub PR, CI, review, and deploy lifecycle — along with Linear and GitHub issues — inline in chat.
T3 Code. It works with your subscriptions on Claude Code, Codex, Cursor, Grok Build, and OpenCode. ShipIt currently runs Claude Code and Codex, with more runtimes planned but not shipped. If breadth of agent backends is your deciding factor, T3 Code is ahead today.
T3 Code automates git worktrees: each thread gets its own directory and branch sharing one .git object store, so parallel agents don't fight over the same files. What worktrees don't give you is environment isolation — the agents still share the host's dependencies, ports, and databases, and devcontainer/Docker support is an open feature request rather than a shipped capability. ShipIt runs each session in its own Docker container with its own clone and its own Compose services, so ports and databases don't collide, behind a per-agent default-deny outbound firewall and brokered git credentials.
Yes, honestly. T3 Code is much lighter to get going — install it with npx, Homebrew, winget, or a desktop build, with no Docker requirement — while ShipIt always runs containerized and expects real resources (8 GB RAM minimum, 16 GB recommended on a VPS, since every active session runs its own container). If you want something light on a laptop, a desktop build, and more agent choices, T3 Code is a strong pick. Choose ShipIt when container isolation, a live app per session, and the inline GitHub loop are worth the overhead.
If worktrees aren't enough and you want a live app plus the GitHub cycle inline, ShipIt installs with one command on your laptop or a VPS.
