How to run T3 Code in the cloud, and a cloud-first alternative
Published October 5, 2026
Summary
T3 Code does not offer a hosted cloud. Its agents always run on a machine you own or rent, so running it in the cloud means putting the T3 Code server on a VPS and connecting through T3 Connect, Tailscale, or SSH. Replicas offers a similar experience built cloud first. It is one app for Claude Code, Codex, Cursor, and OpenCode on your own subscriptions, and every task runs in its own managed VM. This guide covers both.
Background
What T3 Code is, and where its agents run
T3 Code is an open-source, MIT-licensed app from T3 Tools that its README calls an "agent harness control surface." It drives coding agent CLIs you have already installed and signed in to, including Claude Code, Codex, Cursor, Grok Build, OpenCode, Antigravity, and Pi. It does not resell tokens, so every agent runs on your own subscription.
T3 Code has two halves. A server runs on one machine and starts the agents there. Clients connect to that server: a desktop app for macOS, Windows, and Linux, a web app, and iOS and Android apps. Provider logins, repositories, and Git credentials all live on the server's machine, even when you are working from your phone.
- The server
- Started with t3, t3 serve, or t3 service install. Agents, terminals, and Git worktrees run on this machine.
- The desktop app
- Runs a local server by default, and can also connect to servers on other machines through T3 Connect, a private network, or SSH.
- The web and mobile apps
- Connect to a server you have paired with. The hosted web app at app.t3.codes connects directly to your server and needs an HTTPS address.
Hosted options
Does T3 Code have a cloud version?
No. T3 Code's remote access documentation says the machine running the server "must stay running and reachable while you work." T3 Connect, its free remote access feature, is a tunnel that makes that machine reachable from your other devices. It does not run agents for you.
A GitHub request for T3 Code to run managed, disposable cloud workers was closed as not planned in October 2026. Running T3 Code in the cloud therefore means running its server on a cloud machine that you rent, set up, and maintain.
Replicas, which publishes this guide, offers a similar experience that starts from the cloud. Like T3 Code, it is one app for several coding agents that runs on your own subscriptions, with web, desktop, and mobile clients. The difference is where the agents run. Every Replicas task gets its own managed Linux VM, so nothing depends on a computer of yours staying on.
Compared
Ways to run T3 Code in the cloud, and a cloud-first alternative
The table compares a T3 Code server on a cloud machine, reached three ways, with Replicas and OpenRouter Spawn. T3 Code's README describes the project as very early and it ships often, so check its documentation before you depend on a detail.
| Option | Where agents run | How you connect | Who maintains the machine | Best for |
|---|---|---|---|---|
| Replicas | A dedicated Linux VM per task, built from an environment your team defines | Web, desktop, and iOS apps, plus Slack, Linear, GitHub, GitLab, schedules, webhooks, and the API | Replicas | A T3 Code-style app where agents run in the cloud by default |
| T3 Code on a VPS with T3 Connect | A server you rent | T3 Code desktop, web, and mobile apps through the T3 Connect tunnel | You | Reaching a cloud server from any device without opening ports |
| T3 Code on a VPS over Tailscale | A server you rent | A pairing link on the server's Tailscale HTTPS address | You | Keeping traffic on your own private network |
| T3 Code on a VPS over SSH | A server you rent | The T3 Code desktop app, which starts the server and forwards the port for you | You | Desktop-only use with no extra network setup |
| OpenRouter Spawn | A VM it provisions on DigitalOcean, Hetzner, AWS Lightsail, Google Cloud, and other providers | SSH, then one of the methods above | You, after provisioning | Getting a cloud VM set up quickly |
Replicas: a cloud-first alternative to T3 Code
Replicas covers much of the same ground as T3 Code. You pick Claude Code, Codex, Cursor, OpenCode, or Pi per task, connect them with your own subscriptions or API keys, follow the agent's work as it streams, review diffs, and open pull requests from the web, desktop, and iOS apps. Where T3 Code connects you to a machine you keep running, Replicas starts a dedicated Linux VM for every task from an environment your team defines once.
There is no server to install, update, or keep reachable. Warm hooks run dependency installs, builds, and Docker image pulls ahead of time, so each task claims a pre-warmed workspace. Workspaces sleep when idle and wake when you or a reviewer send the agent back.
Each workspace is a full development machine. It includes a Linux desktop with Chrome that the agent can drive to test its own work, and that you can watch or take over with your own mouse and keyboard, plus terminals, in-place file editing with code intelligence, and preview URLs for apps the agent starts.
Work can also start outside the app, from Slack, Linear, GitHub, GitLab, a schedule, a webhook, or the API. Teammates can open the same workspace, follow the live session, and comment on diffs, and analytics attribute agent time to people, agents, models, and credentials. Enterprise plans add SCIM, audit logs, static egress IPs, and dedicated or self-hosted deployment.
T3 Code keeps some advantages. It is free and open source, it can run agents on your own hardware next to your local services, it supports Grok Build and Antigravity, it has Windows and Android apps, and it works with Bitbucket, Azure DevOps, Forgejo, and Gitea as well as GitHub and GitLab. Replicas supports GitHub and GitLab, and it is a paid product with a 14-day free trial.
T3 Code on a VPS or cloud VM
Rent a Linux server, create a non-root user, and install T3 Code with curl -fsSL https://t3.codes/install.sh | sh. Install and sign in to each agent CLI on that server, for example claude auth login or codex login, and sign in to your Git host with gh auth login or glab auth login so T3 Code can open pull requests. The agent CLIs must be on the server's PATH.
t3 service install runs T3 Code as a systemd user service and enables lingering, so it starts at boot and keeps running after you log out. t3 update moves to a newer release, and because restarting the service interrupts running agent turns, it asks before restarting. Background services work on Linux and macOS but not Windows.
Every thread on the server shares the same user, credentials, and network. Choose New worktree for threads that run in parallel so they do not edit the same files. New threads default to the Full access permission mode, which runs commands and edits without asking for approval.
Connecting to it: T3 Connect, Tailscale, or SSH
T3 Connect is the simplest route. Run t3 connect on the server, approve the sign-in from a browser link and short code, and choose the environment from any T3 Code app signed in to the same account. It needs no port forwarding. Each account can link a limited number of environments, so deregister ones you no longer use.
For a private network, join the server and your devices to the same tailnet and start the server with t3 serve --tailscale-serve, or run t3 pair --tailscale on a running server. The pairing link uses the machine's tailnet HTTPS address, which the hosted web app at app.t3.codes needs.
In the desktop app, open Settings, then Connections, choose Add environment, and pick SSH. Enter a host such as user@example.com, and T3 Code starts or reuses a server there and opens the port forward for you. The host must be Linux or an Apple Silicon Mac.
Whichever route you use, treat pairing links and authorization codes as passwords, and revoke devices you no longer use from Settings, then Connections, on the host.
OpenRouter Spawn
OpenRouter Spawn lists T3 Code among the agents it can set up. Spawn provisions a VM on providers such as DigitalOcean, Hetzner, AWS Lightsail, Google Cloud, or Daytona, installs the agent, connects OpenRouter credentials, and opens an SSH session. Its page does not document T3 Code's remote access, so plan to set up T3 Connect or Tailscale yourself. The VM is still yours to pay for, secure, and shut down.
Side by side
T3 Code vs Replicas
Both are one place to run several coding agents on your own subscriptions. They differ mainly in where the agents run and who maintains that machine.
| Compared on | T3 Code | Replicas |
|---|---|---|
| Where agents run | A machine you own or rent, which must stay on and reachable | A managed Linux VM per task |
| Coding agents | Claude Code, Codex, Cursor, Grok Build, OpenCode, Antigravity, Pi | Claude Code, Codex, Cursor, OpenCode, Pi, Muse Code |
| Agent sign-in | Your subscriptions, signed in on the host machine | Your subscriptions or API keys, set for the organization or per person |
| Apps | Desktop for macOS, Windows, and Linux, web, iOS, Android | Web, desktop for macOS and Linux, iOS |
| Parallel tasks | Threads on the same machine, optionally in separate Git worktrees | Each task in its own VM |
| Where work starts | The T3 Code apps | The Replicas apps, Slack, Linear, GitHub, GitLab, schedules, webhooks, API |
| Environment | Whatever is installed on the host | Defined once by your team and pre-warmed before tasks start |
| Git hosts | GitHub, GitLab, Bitbucket, Azure DevOps, Forgejo, Gitea | GitHub and GitLab |
| Maintenance | You install, update, secure, and keep the host online | Managed by Replicas |
| Price | Free and open source, plus your server and agent subscriptions | Per-seat plan with a 14-day free trial, plus your agent subscriptions or API usage |
By situation
Which option fits your setup
The deciding question is whether you want to run the machine your agents work on.
- You want the T3 Code experience without keeping a machine on
- Replicas. Agents run in managed VMs, and you follow and steer them from the web, desktop, or iOS app.
- Your team shares agent work
- Replicas. Tasks start from Slack, Linear, GitHub, or GitLab, each runs in its own VM from a shared environment, and teammates review in the same workspace.
- You want to keep T3 Code and run it on a server
- A VPS with t3 service install, reached through T3 Connect from any device or through Tailscale on a private network.
- The work needs your own hardware or local services
- T3 Code on your own always-on computer with T3 Connect. On macOS the service stops when you log out, so keep the Mac logged in and awake.
- You only use the T3 Code desktop app
- Desktop-managed SSH to a Linux server or Apple Silicon Mac, with no tunnel or tailnet to set up.
Replicas fit
When Replicas is the right cloud alternative to T3 Code
Replicas fits when you like how T3 Code works but do not want agent work to depend on a machine you run. Teams typically choose it when several of the following are true.
- You want to pick Claude Code, Codex, Cursor, OpenCode, or Pi per task from one app and keep using your own subscriptions.
- You do not want to install, update, or secure a server, or keep a computer awake and reachable.
- You want each task isolated in its own VM rather than sharing one machine, its credentials, and its CPU.
- You want the agent to test its work in a real desktop and browser, and to take over that desktop yourself when needed.
- You want tasks to start from Linear issues, Slack threads, pull request comments, schedules, or webhooks.
- Teammates should be able to join the same workspace, follow the live session, and review together.
- You need audit logs, SCIM, and a record of who ran what, with which agent and model, at what cost.
Self-hosting
Checklist for running T3 Code on a cloud server
If you run T3 Code on your own server, these steps cover the common failure points: a server that stops on logout, over-broad permissions, and exposed access.
- Run T3 Code as a non-root user. Its documentation notes that running it as root creates a separate installation and T3 Connect identity.
- Install the background service with t3 service install, and check t3 service status to confirm lingering is enabled so the server survives logout and reboots.
- Install and sign in to each agent CLI and your Git host's CLI on the server, and check that they are on the PATH of a non-interactive login shell.
- Pick a default permission mode on purpose. New threads start in Full access, which runs commands and edits without approval, while Supervised and Auto ask before riskier actions.
- Use New worktree for parallel threads so agents do not overwrite each other's files.
- Reach the server through T3 Connect, Tailscale, or SSH instead of exposing its port publicly, and treat pairing links and codes as passwords.
- Keep deploy keys and cloud credentials off the server or scope them narrowly. Anything an agent can read, a prompt injection in a dependency or issue can try to exfiltrate.
- Run t3 update when no agent turns are in progress, since restarting the service interrupts them.
FAQ
T3 Code cloud questions
Getting started with Replicas
Run your coding agents in the cloud with Replicas
Replicas includes a 14-day free trial with no credit card required. Connect a GitHub or GitLab repository, define the environment once, connect Claude Code, Codex, Cursor, or OpenCode with your own subscriptions or keys, and start a task from the web, desktop, or iOS app, Slack, Linear, or a pull request comment. Each task runs in its own Linux VM and comes back as a pull request you review.