T3 Code 為 Claude Code、Codex 等編碼智能體提供免費開源控制面板

If you use AI coding agents every day, you have probably hit this wall: three terminals running Claude Code, one running Codex, all poking at the same repo, and no single place to see what each one is doing or what it changed.

T3 Code is an attempt to fix that. It comes from Theo Browne's team (the people behind the T3 Stack and T3 Chat), it is MIT licensed, and it costs nothing. In this post I will cover what it actually is, how to get it running, what you need to watch out for, and how it stacks up against the free and paid alternatives.

TL;DR

• T3 Code is not a coding agent and has no model of its own. It is a GUI and control layer that drives the agent CLIs you already have installed.
• It works with Claude Code, Codex, Cursor, Grok Build, OpenCode and Google Antigravity, using your existing subscriptions.
• You get a desktop app (macOS, Windows, Linux), a web app, and iOS/Android apps for checking on agents remotely.
• Each task is a thread that can run on its own Git branch or worktree, with an inline diff and a one-click PR flow.
• It is very early software (v0.0.x). New threads default to Full access, which means no approval prompts. Change that first.

What T3 Code actually is

The project describes itself as an "agent harness control surface". In plain terms:

 You (desktop / web / phone)
          |
          v
   T3 Code server  <-- owns processes, terminals, Git, project files
          |
   +------+-------+-----------+----------+
   |      |       |           |          |
 Claude  Codex  Cursor CLI  OpenCode   Grok / Antigravity
  Code    CLI

A server process on your machine owns everything that runs: the agent processes, terminals, Git operations and project files. The desktop, web and mobile apps are thin clients that connect to that server. The desktop app bundles its own server, so on a single machine you do not have to think about this split at all.

Because T3 Code drives the official CLIs, it signs in through each CLI's own login. It does not resell API keys or add its own usage quota. Whatever you pay Anthropic, OpenAI or Cursor today is what you keep paying. T3 Code itself is $0.

Why developers are paying attention

One window for many agents. Run Claude Code and Codex side by side, compare their approaches on the same problem, and switch models in the middle of a thread.

Branch per thread. Each thread can work on its own branch or Git worktree. A worktree is a second checkout of the same repo on a different branch, so two agents can edit files at the same time without stepping on each other.

Diff review and PRs in the same place. You see the diff as the agent works, then commit, push and open a pull request from the app. The PR gets a generated title and body.

Remote control. Leave the agents running on your workstation and check on them from your phone or laptop.

An MCP server. Other agents (Claude Code in a terminal, Codex, ChatGPT) can connect to T3 Code over MCP to read threads and start new ones. That makes a "coordinator agent" pattern possible without writing your own plumbing.

Getting started

Step 1: Install and log in to at least one agent CLI

T3 Code cannot do anything without an agent behind it. Set up at least one of these first:

# Claude Code
claude auth login

# Codex
codex login

# Cursor CLI
agent login

# OpenCode
opencode auth login

# Grok Build
grok login

Google Antigravity is the exception: you enable it inside T3 Code's settings and sign in with Google. No CLI needed.

Step 2: Install T3 Code

Pick whichever fits your workflow.

Try it once without installing anything permanent:

npx t3@latest

Install the CLI (server plus local web app):

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

# Windows (PowerShell)
irm https://t3.codes/install.ps1 | iex

Then:

t3                   # start the server and open the local web app
t3 service install   # keep it running in the background
t3 update            # move to a newer release
t3 --help            # full reference

Install the desktop app:

# macOS
brew install --cask t3-code

# Windows
winget install T3Tools.T3Code
# or
scoop install extras/t3code

# Debian / Ubuntu (download the .deb from GitHub Releases first)
sudo apt install ./T3-Code-*.deb

# Arch Linux
yay -S t3code-bin

Step 3: Change the default permission mode

Do this before your first real task. See the next section for why.

Step 4: Open a project and start a thread

Add your repo as a project, start a thread, choose the agent and whether it should run in a new worktree, and give it a task. When it finishes, review the diff and decide whether to open a PR or throw the branch away.

Permission modes: the setting that matters most

Every thread has a permission mode that decides how much the agent can do without asking you:

Two things to know:

1. Full access is the default for new threads. The agent can run any command and edit any file without asking. For a tool designed to run several agents at once, that is a risky default. Change it in Settings to Supervised or Auto.
2. Auto mode depends on the provider. Codex hands routine approvals to an AI reviewer and Claude uses its own auto permission mode. Providers without an equivalent, such as OpenCode, fall back to asking every time, like Supervised.

The mode is set per thread, so changing it in one thread does not affect others.

Remote access in practice

The machine running T3 Code does the work. Your phone or laptop is just a remote. That means the host has to stay awake and reachable.

You have three main ways to connect:

LAN or Tailscale (traffic stays on your network):

t3 serve --host <your-lan-or-tailnet-ip>
t3 pair            # prints a QR code and a one-time pairing link

For HTTPS over Tailscale:

t3 serve --tailscale-serve

T3 Connect (no router or VPN setup):

t3 connect

This needs a T3 account and routes the connection through T3's relay. Convenient, but be aware of that trade-off if your company has rules about where code-related traffic goes.

SSH from the desktop app: add an SSH host in Settings, and T3 Code starts a server there and forwards the port for you. Projects, credentials and agent work stay on the remote machine. The remote host must be Linux or an Apple Silicon Mac.

Treat pairing links and codes like passwords. Keep them out of screenshots, logs and bug reports.

Letting other agents drive T3 Code (MCP)

Every T3 Code environment exposes an MCP endpoint at https://<environment-address>/mcp. For example, to connect Claude Code running in a terminal:

claude mcp add --transport http t3 https://<environment-address>/mcp
claude mcp login t3

For Codex:

codex mcp add t3 --url https://<environment-address>/mcp
codex mcp login t3

A new agent gets Read only access by default. You can raise it to Supervised or higher so it can start, message and stop threads. The address must be HTTPS (or localhost on the same machine), and sign-ins expire after 30 days.

What to know before you adopt it

It is early. The README says to expect bugs, and stable releases are still on v0.0.x with nightly builds shipping several times a day. Stick to the stable channel for real work.

Contributions are mostly closed. The team says small fixes may be considered, but big features will not be accepted for now. Feature ideas go to GitHub Discussions. If you need something specific, the MIT license lets you fork.

Docs live in the repo. There is no docs site yet. Everything is under docs/, and it is genuinely useful.

Your existing agent config still applies. Because T3 Code runs the real CLIs, things like your CLAUDE.md, AGENTS.md, hooks and MCP servers configured for each CLI should keep working.

The PR flow assumes a Git and GitHub-style workflow. If your work is not branch-and-PR shaped, you will get less out of it.

Costs still exist, just not here. Running four agents in parallel burns through your Claude or ChatGPT plan limits four times faster.

How T3 Code compares to other tools

There are two broad groups to compare against: orchestrators (tools like T3 Code that sit on top of agents) and AI editors and first-party agent apps (tools that come with their own model access).

Orchestrators and agent managers

Quick notes on each:

• Conductor is the closest competitor and the most polished Mac experience. It uses Git worktrees per workspace, like T3 Code. Its free plan covers local workspaces; reviews list Pro at around $50/month for cloud workspaces that keep running when your laptop is closed. If you are not on a Mac, it is not an option.
• Claude Squad is a lightweight Go binary built on tmux and worktrees. It is great if you live in the terminal and do not want a GUI at all. No phone app.
• Vibe Kanban frames agent work as kanban tickets, which suits people who like to plan a backlog first. Its original company, bloop, shut down in 2026 and the project continues as a community-maintained open-source tool, which is worth weighing for long-term support.

AI editors and first-party agent apps

The key difference: Cursor, Codex and Claude Code are where the model access and billing live. T3 Code does not replace them. It sits on top and lets you run several of them from one place.

Which one should you pick?

• You use more than one agent and want a GUI on any OS: T3 Code.
• You are on a Mac, want the most polished experience, and are fine with closed source: Conductor.
• You prefer staying entirely in the terminal: Claude Squad.
• You want to plan agent work as tickets on a board: Vibe Kanban.
• You only use one agent and are happy with it: Its own app or CLI is probably enough. Claude Code and Codex both support parallel work on their own.
• You want an editor with AI built in, not an agent manager: Cursor.

Wrapping up

T3 Code is not trying to be another AI model or another editor. It is a free, open control layer for the agents you already pay for, with worktrees, diffs, PRs and a phone app in one place. It is rough around the edges and changing fast, so treat it as early-adopter software and lock down the permission defaults. But if you already juggle several coding agents, it is one of the more interesting open-source projects to try right now.

Links:

• GitHub: pingdotgg/t3code

Pricing and feature details were checked in early November 2026. These tools change quickly, so verify on each project's site before making a decision.