T3 Code Unifies Every Coding Agent Under One Control Panel
Since I started using T3 Code, the satisfaction is comparable to GTA-6
Having used Coding Agents for so long, many of you have probably run into this problem: during daily development or office work, you use many Coding Agents, and different agents have different models. Although you can use an open-source gateway to connect many models to one agent, you'll still face compatibility issues between different Agent Harnesses and models.
Let me show you the agents I use daily... 
I often want to switch to ZCode but end up switching to OpenCode instead... tough.
In short: using a model with its own official Harness is the best, at least you won't encounter weird problems.
Since using the official Harness with its own model is the most stable, it's inevitable to have a dozen or so clients and CLIs on your desktop, and switching windows, importing projects separately, and finding old conversations are all fractured.
So a question arises: is there a way to preserve the execution capabilities of each vendor's original Harness, but use a unified entry point on the outermost layer to manage them all?
That's what I want to talk about today: T3 Code.
What is T3?
T3 Code is an open-source project initiated by Ping Labs (Theo Browne's team), released under the MIT license. The official description is: Agent Harness Control Surface (Unified Control Panel for Multiple Coding Agents).
T3 Code is an open-source project initiated by Ping Labs (Theo Browne's team), released under the MIT license. The official positioning is restrained and precise: Agent Harness Control Surface (Unified Control Panel for Multiple Coding Agents).
Its biggest difference from common model relay clients is:
- BYOS, doesn't resell tokens - T3 Code itself doesn't sell model quotas, nor does it replace underlying inference logic. Instead, it directly takes over the official CLIs and Agents already installed and logged in on your machine. The accounts and configurations you subscribed to elsewhere can be used directly. The underlying layer still runs the original Harness, minimizing the mysterious bugs that come from modified adaptations.
- Native compatibility with ACP protocol and ACP Registry - Besides the built-in adapted first-tier agents, T3 Code fully supports ACP (Agent Client Protocol) and the official ACP Registry ecosystem. Any tool that supports the ACP standard protocol (such as Qoder CLI, Kimi Code, DeepSeek Harness, goose, Junie, etc.) or a custom local ACP command can be connected into the same panel for scheduling.
- Cross-device sync + remote mobile control - T3 Code provides macOS / Windows / Linux desktop clients, a Web client, and native iOS / Android mobile apps. The backend runs as a local service, and you can remote into your home or office computer's agents via LAN, Tailscale, or the built-in T3 Connect secure tunnel. Monitor progress, approve permissions, and send commands anytime, anywhere.
- Git Worktree isolation and task orchestration - Automatically creates an independent Git Worktree and branch for each task thread. Multiple agents can modify the same project simultaneously without overwriting each other's files. The right panel integrates Diff comparison, commit, push, and PR workflows. It also supports delegating subtasks across agents (Delegate) to different models in a single main thread.
If you want to try it quickly, install it via command line or package manager:
# Install desktop app on macOS
brew install --cask t3-code
# Or run it temporarily with npx
npx t3@latest
Or just tell AI to install it for you.
Hands-on Test
After installation, the onboarding interface is very intuitive. It can directly scan local Agent environments and enable them with one click: 
This area can connect different agents. If an agent isn't on the homepage, you can find it in Browse.
If you don't know which Agents are installed locally, you can let the Agent configure it for you.
For example, I configured everything that could be configured.

T3 supports importing projects and their threads from other Coding Agents.
One thing I like about T3 is that it doesn't require opening Finder to import projects. It directly searches your project paths.

Just select the project path and open it with one click, very convenient.
After selecting a project, we can see all Coding Agents and their corresponding models in the model list.
T3 also supports remote mobile connection, which directly kills the Happy open-source project.
After I choose a project, this is my Agent + model list.

I feel this is the Coding Agent I want. It has a high degree of freedom. I can let different Agents choose different models to do the work.
Currently it's my first choice. You can connect a small decision model or use other methods to let the LLM do task type judgment.
Gemini has released many new models recently. Using a reverse proxy to connect to Gemini has always been risky for account bans, so I often had to use the less convenient Antigravity client. With T3 Code, I can use Gemini stably because Google has turned its own Antigravity into a standard ACP Server and listed it on the public ACP Registry.
According to Google's official clarification, as long as you use standard protocol to call the unmodified official antigravity-acp runtime through a client like T3 Code, and use native personal OAuth login (oauth-personal) for single-user interactive development, it is an officially permitted compliant method. The only small limitation is that when using a personal subscription through a third-party ACP client, the model range is usually limited to the Gemini models included in the subscription.
This is indeed strong.
For example, I asked T3 to review the current code using Qoder. 
When I first saw it could summon Qoder to work, I thought it was using Computer Use to click on the Qoder desktop app. But after checking the underlying implementation and combining the logs above, I realized it's not like that: T3 Code doesn't use GUI desktop automation to operate the Qoder client. Instead, the main agent uses T3's built-in orchestration layer (internal /mcp delegation interface) to spin up an independent sub-thread, and then calls the locally installed Qoder CLI in the background via the ACP protocol to execute tasks.
After the sub-thread finishes, the result is returned to the main thread. Compared to Computer Use, this method of launching CLI sub-processes based on standard protocols is much lighter and more stable.
T3's right panel toggle (Toggle right panel) is well done. I can inspect code and view changes. Although these are basic features, T3's usability is quite good.
Overall operations match my basic expectations, and this is much better than Codex.
Above I mainly verified the basic pipeline: multi-agent integration + project import + model switching + basic conversation and code review.
T3 Code also has some core advanced features. Next are the parts really worth testing.
Cross-Agent Orchestration and Parallel Worktree Delivery
I just used GPT-6.2 Sol to set up a bug in this task. I had Kimi and Qwen each fix a bug, then used DeepSeek-V4.1 Flash for testing, and finally had GPT-6.2 Sol do code review and merge.
This task ran two subagents, one is kimi, one is Qwen. You can click into the subagents to see the execution of different tasks.
Then DeepSeek independently verified the four task fixes.

Finally, the test conclusion.
The whole process was very smooth.
Complete Git Change Flow and PR Collaboration Loop
I also ran a full test on this part. From the same origin/main, I started two parallel Worktree sub-threads (Test A and Test B), each only modifying README.md, and ran the entire chain from code changes to PR linkage.
Architecture
After seeing these test results, let's look back at T3 Code's architecture design. It's clear why it can be compatible with so many Agents, and why things like mobile remote control, Worktree isolation, and cross-agent orchestration are so smooth.
(I didn't test the mobile remote feature, but I think everyone understands that by now.)
Overall, T3 Code is structurally very clean:
- Frontend control surface (
apps/web+apps/desktop+ mobile) - The web client is built on React + Vite, responsible for presenting thread lists, diff review, and approval interactions. The Electron desktop app is just a native window shell around the same frontend, hosting the local backend service. iOS / Android mobile clients, LAN browsers, Tailscale, and T3 Connect tunnels all connect to the same backend. - Local core engine (
apps/server) - The real control hub isapps/serverrunning on Bun. It communicates with the frontend via WebSocket + lightweight JSON-RPC protocol, constrained by the interface contracts inpackages/contracts. Inside the server,OrchestratorV2handles multi-turn execution and event streams, andThreadManagementServicemanages persistent threads, queues, reconnection recovery, interruption control, and local project/Worktree environment boundaries. - App-owned internal
/mcpservice and cross-agent delegation - T3 Code exposes an internal/mcpendpoint to the agents running on top of it, wrapping subtask delegation, thread read/write, scheduled tasks, and preview controls as standard tools. So even if the main thread runs Codex, it can use internal MCP to spin up a Kimi, Qwen, DeepSeek, or Qoder CLI sub-thread to work together. - Original Harness and ACP dual-track execution + Worktree isolation - The bottom layer never rewrites or modifies model inference logic. On one side, it directly connects to official CLIs already logged in locally (Claude Code, Codex, Antigravity, etc.). On the other side, it connects third-party tools in the ACP Registry ecosystem through the standard ACP protocol. With dynamically allocated Git Worktrees, concurrent code changes are isolated into independent branch environments.
Final Thoughts
After testing it thoroughly, I find T3 Code very easy to use. It doesn't force a big model aggregation wrapper client. Instead, it works at the control level. T3 Code is essentially a reporting hub. It doesn't do Harness adaptation or model tuning. It simply makes coordinating multiple agents and providing a unified entry point easy and clean.
I think that's enough.
Maybe simplicity and usability are the key.
If you're like me, often having several Coding Agents open on your desktop and finding switching between them annoying, then T3 Code is definitely the open-source solution most worth trying right now.
Top 1 from juejin.cn, machine-translated. The original thread is authoritative.
The pain point of switching back and forth is spot on; having each Agent with its own client is indeed fragmented. What impressed me most is the positioning of not selling tokens and only being the control layer; BYOS is quite restrained. The feature of remotely checking progress on your phone also looks pretty practical.