T3 Code review: the open-source agent control plane, tested

What T3 Code actually is

T3 Code calls itself an agent harness control surface, which is a precise description once you unpack it. It is not a model, not an agent, and not a subscription. It is a window in front of the agent CLIs already installed on your machine, and a wire protocol that lets a phone or a browser drive that same machine.

The project is built by T3 Tools Inc, the company behind t3.gg and T3 Chat, and it went public in February 2026. The repository is github.com/pingdotgg/t3code, licensed MIT, with roughly 19,500 stars and about 2,670 commits on main when this guide was checked on 19 August 2026. That growth curve is the fastest anything in the agent-workbench category has managed.

Installing it

There are four supported routes. The npx route is the quickest way to see it, and it needs a recent Node: the README pins ^22.16 || ^23.11 || >=24.10.

# quick start, any platform with Node
npx t3@latest

# macOS
brew install --cask t3-code

# Windows
winget install T3Tools.T3Code

# Arch Linux
yay -S t3code-bin          # stable
yay -S t3code-nightly-bin  # nightly

The Linux story deserves a footnote. There is a packaged Linux desktop, but the packaged route is Arch-first through the AUR. On Debian, Fedora, or anything else, the practical path is the Node quick start rather than a distro package. That is still more than Conductor offers, which is macOS only, but it is not the same as a first-class deb.

The features that matter

A worktree per thread

Each thread can be bound to its own git worktree: a separate working directory on its own branch. Two agents can then edit the same repository at once without fighting over files or clobbering each other’s test runs. This is the single feature that turns "several agents" from a slogan into something you can actually operate, and it is why git worktrees are worth understanding even if you never touch the command directly.

One-click pull requests

From a thread you can commit, push, and open a PR with a generated title and body. Draft PRs, stacked PRs, and amending an existing PR are all supported. Release v0.0.32 included a fix to "follow branch drift in dedicated worktrees so PRs link to their thread", which is the kind of detail that only shows up once real people are using the feature on real branches.

Model switching mid-thread

You can change model inside a running conversation rather than starting over. In practice this is a cost lever: plan on the expensive model, execute the mechanical part on the cheap one.

Remote control

This is where T3 Code goes further than most of the category. There are three ways to reach a running instance from another device: expose the desktop app’s backend from Settings then Connections, run the headless server from the CLI, or have the desktop app launch T3 Code on another machine over SSH.

# pair a phone or browser with a running instance
npx t3 pair
npx t3 pair --tailscale

# headless server, bound to a Tailnet address
npx t3 serve --host "$(tailscale ip -4)"

# or let Tailscale Serve terminate TLS for you
npx t3 serve --tailscale-serve
npx t3 serve --tailscale-serve --tailscale-serve-port 8443

What it costs, and what the free part hides

T3 Code costs nothing and there is no announced paid tier. Your bill is entirely whatever Codex, Claude Code, Cursor, Grok, or OpenCode already charges you, unchanged, because T3 Code never sits in the token path.

The catch is not a hidden fee, it is a hidden number. Because it never proxies your tokens, T3 Code cannot tell you what a thread cost or how much of this week’s limit you have burned. If you run four agents in parallel across three repositories, the answer to "what did today cost" lives in three or four separate vendor dashboards and nowhere in the tool that ran the work.

The honest limits

None of this is a knock on the project. It is four months past its first public commit and it says so loudly. But a review that only lists features is an advertisement, so here is the other column.

• It is v0.0.34. The README opens with "We are very very early in this project. Expect bugs." Nightly builds ship several times a day; on 19 August 2026 there were three tagged inside a few hours.
• No spend or quota instrumentation. Covered above, and it is structural rather than a missing feature.
• Provider setup is on you. Five CLIs, five installs, five logins, five sets of auth failure modes. The nightly that added npx t3 triage, which hands a broken install to your own coding agent, exists because this is the most common support burden.
• Exposure risk is real. Remote access is a genuine strength, and it is also a remote-code-execution surface pointed at your source tree. Treat the pairing token as a credential.
• The hosted relay involves an account. Remote pairing beyond the loopback path authenticates through Clerk OAuth. The CLI uses a public client with PKCE and stores no client secret, which is the right design, but "fully local, no accounts" is not an accurate description of the remote flow.
• Linux packaging is Arch-first. Everyone else runs it through Node.

Who it is for

The decision is unusually clean, because T3 Code is strong in a specific direction rather than broadly.

If you are choosing between the two vendor-neutral workbenches specifically, the split is source ownership against a packaged operating loop. T3 Code hands you the code. Continuum hands you the review gates, the cross-device session, and the ledger, already assembled. Both let you keep the agent subscriptions you already have, so this can be a per-project decision rather than a vendor bet.

Either way, the category itself is the thing worth understanding: see what an agentic development environment is for why the unit of work moved from the file to the agent run.

Questions people ask

Keep reading

Continue through Agentic coding with Vibe coding tools: the honest list, sorted by what they actually do.