T3 Code: what it is, how to use it, and why we run our coding agents through it

We build a lot of software with AI coding agents, usually several at once: one fixing a bug, one drafting a feature in a separate branch, one researching a library. Running those in a row of terminal tabs gets messy fast. T3 Code is the app we now use to keep them organised, and this post explains what it is, how to set it up and where its limits are.

T3 Code is very early software and changes weekly. Commands below come from the project’s README and docs at the time of writing; check the GitHub repository before you rely on a detail.

What T3 Code is (and isn’t)

T3 Code is an open-source app from the team behind the T3 stack. The README calls it an agent harness control surface. The important word is control: T3 Code doesn’t contain its own model or its own agent. It drives the coding-agent command-line tools already installed on your machine:

• Claude Code and Codex (on by default),
• Cursor, OpenCode, Pi, Grok Build and others, with more being added.

Because it uses those CLIs, it also uses your existing subscriptions. You don’t pay T3 Code for model access, and you can switch between agents per task without changing tools.

It runs as a desktop app (macOS, Windows, Linux), a web app, and iOS and Android apps. In every case the real work happens on the machine running the T3 Code server; the apps are windows onto it.

Why it is good

One place for every agent. Claude Code for one task, Codex for another, a local model through OpenCode for a third, all in one sidebar with the same diff view and the same approval flow.

Threads with their own worktrees. Each task is a durable thread tied to a provider, model and workspace. A thread can run in your current checkout or in a new Git worktree with its own directory and branch. Two agents working on two features at the same time no longer trample each other’s files.

Diffs and checkpoints you can trust. You can review changes per turn, for the whole branch, or for the working tree, and leave review comments on lines that go straight back to the agent. Each turn is checkpointed, so “revert to this message” restores the files and the conversation together. (Checkpoints are not backups; keep committing.)

Source control built in. Commit, push, open a pull request with a generated title and description, and read review comments and CI checks without leaving the app. It warns you before committing straight to the default branch.

It runs on a server, and you can drive it from your phone. This is the feature we use most. More on it below.

Open source. MIT-licensed, so you can read exactly what it does with your code and credentials.

How to set it up

1. Install at least one agent

T3 Code needs an authenticated agent CLI on the machine. For example:

# Claude Code
claude auth login

# Codex
codex login

# OpenCode
opencode auth login

Install each CLI first using its own official instructions.

2. Install T3 Code

The quickest route is the command-line installer, which gives you the t3 command:

# macOS / Linux
curl -fsSL https://t3.codes/install.sh | sh

# then start the server and open the local web app
t3

To try it without installing, npx t3@latest works too. There are also desktop builds: brew install --cask t3-code on macOS, winget install T3Tools.T3Code on Windows, and a .deb and AUR packages on Linux.

3. Add a project and start a thread

Open the app, add a repository as a project, and start a thread. Pick the agent and model, choose whether it runs in the current checkout or a new worktree, and describe the task. You can also set a project default in a t3.json file, including a setup script that runs whenever a new worktree is created (installing dependencies, copying an .env.example).

4. Choose a permission mode deliberately

T3 Code separates interaction mode (default or plan) from permission mode: Supervised, Auto-accept edits, Auto, and Full access. Check what your version defaults to. Our rule:

• Plan first for anything larger than a few files.
• Supervised for unfamiliar or valuable code.
• More autonomy only inside a worktree, on a throwaway branch.

Approval requests appear in the thread, and you can answer them from any connected device, including your phone.

Running T3 Code on a server

This is where T3 Code goes from “nice UI” to “different way of working”. Every T3 Code server is an environment that owns its files, projects, threads, credentials, Git operations and terminals. Your laptop and phone are just clients. So you can put the server on an always-on machine (a home server, a cloud VM, a beefy workstation) and:

• start a task from your laptop, close the lid, and check on it from your phone;
• keep long agent runs going without keeping your laptop awake;
• give agents a machine with more CPU and memory than your laptop;
• keep client code and credentials on one controlled machine.

The basic setup on a Linux server, as a normal (non-root) user:

curl -fsSL https://t3.codes/install.sh | sh

# install your agent CLIs and log in to them on this machine, then:
t3 service install   # run T3 Code as a background service
t3 up                # choose how your devices reach it

t3 up offers three ways in:

• T3 Connect, a managed tunnel: no router or firewall changes; sign in with the same account on your other devices.
• LAN or Tailscale: t3 up --lan accepts direct connections from your local network and tailnet. Here the pairing code is the only protection, so keep it to private networks.
• SSH from the desktop app: add the server under Settings → Environments, and the app installs and runs the server over SSH for you.

t3 pair creates a one-time pairing link for a new device. You can restrict what a token can do with --scope flags. Without them, tokens get full permissions.

A few things the docs are explicit about, and we agree with:

• Treat pairing links and codes like passwords. Keep them out of screenshots, chat and bug reports.
• Don’t run T3 Code as root. It creates a separate installation, and some features (like the built-in browser) won’t run properly.
• If the service stops when your SSH session ends, enable lingering: sudo loginctl enable-linger "$(id -un)".
• Revoke sessions and pairing links you no longer use.

The honest limits

• It is early. The README says it plainly: “Expect bugs.” Updates arrive often, and the server and apps need to be updated together.
• It doesn’t make agents smarter. Provider features differ, and T3 Code doesn’t paper over that. A weak agent in a nice UI is still a weak agent.
• Worktrees don’t isolate everything. Two worktrees can still fight over the same port or local database. Use the setup script to give each one its own.
• Contributions are mostly closed for now, so you can’t easily shape the roadmap.

How we use it

We run T3 Code on an always-on machine, with Claude Code and Codex installed, and open threads per task in their own worktrees. We plan first, review diffs in the app, and open pull requests from it. It is how parts of this website were built, including this blog.

If you want the bigger picture of where T3 Code fits among Claude Code, Codex, OpenCode, Hermes and OpenClaw, read AI agent harnesses compared. For why agents belong on a server at all, see Why run an AI agent on a server.