The Control Plane That Refuses to Sell You Tokens

T3 Code doesn't have a model, doesn't resell subscriptions, and doesn't care which agent you use — it just wants to be the surface you run them all from, and it's MIT licensed so you can leave.
Every few months, the agentic coding ecosystem produces a new problem that nobody planned for. The current one: you have a Claude Code subscription, a ChatGPT plan that includes Codex, maybe a Cursor license, and three terminals open at once, each running a different agent against the same repository, none of them aware of the others. The agents are good. The situation around them is chaos.

T3 Code, the open-source project from Theo Browne’s team — the people behind the T3 Stack and T3 Chat — is a direct answer to that chaos. It calls itself “the open-source control plane for coding agents,” and the phrase is more precise than it sounds. T3 Code is not an agent. It has no model of its own. It is a server process that runs on your machine, owns the agent processes, terminals, Git operations, and project files, and presents all of it through desktop, web, and mobile clients. It drives the agent CLIs you already have installed and signed into: Claude Code, Codex, Cursor, OpenCode, Grok Build, Antigravity, Kiro, Pi, Muse Code, fx, and anything that speaks ACP. If it’s set up on your computer, T3 Code can control it.
That last design decision — drive what exists, sell nothing — is the whole thesis of the project, and it’s worth sitting with for a moment.
The boring part is the point
Most tools in this space have a business model that involves standing between you and a model provider. They resell tokens, add usage quotas, or bundle access into a subscription. T3 Code does none of this. Because it launches the official CLIs, it authenticates through each CLI’s own login. Whatever you pay Anthropic, OpenAI, or Cursor today is what you keep paying. T3 Code itself costs nothing and is MIT licensed.
This sounds like a detail. It isn’t. It means T3 Code’s incentive structure is aligned with exactly one thing: being a good piece of software. There’s no margin to protect, no token markup to defend, no reason to lock you into a particular provider. The README puts it bluntly: “If you don’t like something, fork it.” The marketing site is even less precious about it — the download button sits next to one labeled “Steal our code (legally).”
The architecture follows from this. A server on your machine owns everything; the desktop, web, and phone apps are thin clients that all show the same threads. The desktop app bundles its own server, so on a single machine the split is invisible. But because the split exists, the same threads are available from a phone over your local network, Tailscale, or the project’s own T3 Connect relay — which is where the project’s most talked-about feature lives.
The phone is the killer app
Start a thread at your desk, walk away, approve the next command from your phone. That’s the pitch, and judging by the testimonials on the site, it’s what actually lands. One user describes doing iOS development from his phone while two thousand miles away on holiday. Another marvels that it connects to a remote VM with no Tailscale setup. A third — an avowed AI skeptic, apparently grudgingly — concedes the thing is really good.
The demand for this was already visible before T3 Code existed. Browse the community forums and you find the same question asked over and over: how do I run Claude Code on my home machine from my phone? The answers people improvised — SSH tunnels through Tailscale, terminal emulators like Termius or Blink Shell — worked, in the way that duct tape works. Anthropic eventually built its own answer with Remote Control, which connects claude.ai and the Claude mobile apps to a local Claude Code session, keeping execution on your machine while the phone becomes a window into it.
But Anthropic’s version is, by design, Claude-only, subscription-gated, and wrapped in a thicket of enterprise policy toggles, feature-flag environment variables, and endpoint restrictions. T3 Code’s version is agent-agnostic: the same phone app approves a command from Codex that it approved from Claude an hour earlier. For people holding multiple subscriptions — and at this point, that’s a lot of working developers — that difference is the product.
Threads, worktrees, and the multi-agent workflow
The unit of work in T3 Code is a thread, and each thread can run in its own Git worktree — a second checkout of the same repository on a different branch. This is the unglamorous technical decision that makes the multi-agent story coherent rather than aspirational. Two agents editing the same working directory simultaneously is a recipe for corrupted state; two agents in separate worktrees are just two branches you can review independently. You watch the diff as the agent works, then commit, push, and open a pull request with a generated title and body from inside the app.
Beyond that, T3 Code exposes itself as an MCP server, which means outside agents — a Claude Code session in a terminal, Codex, even ChatGPT — can connect to it to read threads and start new ones. That enables a coordinator pattern where one agent delegates to others without anyone writing custom plumbing. It’s the kind of feature that sounds niche until you remember that the entire premise of the tool is that no single agent is sufficient anymore.
The performance claims deserve a mention, if only because they’re unusually specific for a project README: performance is treated as a feature, measured, and “a dropped frame is a bug.” One community voice put it more colorfully — T3 Code is proof that Electron apps don’t have to suck. Whether that’s true on your machine is an empirical question, but the fact that the team treats frame drops as defects rather than acceptable overhead says something about which audience they’re courting.
Where it sits in the field
The agentic coding landscape has spent the last two years producing agents at a ferocious rate — surveys of the space read like inventory lists, with Claude Code, OpenCode, Codex CLI, Droid, and a rotating cast of others each occupying a niche. What the landscape has largely failed to produce is a neutral layer above them. The incumbents each built their own harness, their own desktop app, their own remote story, all of it proprietary and all of it pointed at their own agent.
T3 Code’s own origin story acknowledges this: the team was inspired by the Codex desktop app, Conductor, Claude Desktop, and Cursor Glass, but found none of them met their bar for performance, remote readiness, and openness. T3 Code is what they built instead — a harness for harnesses, in the terminology the field has settled on. Google’s own documentation on agentic coding describes the software controlling the reasoning loop as the “agentic harness”; T3 Code is the layer that controls the harnesses.
The adoption signals are hard to ignore. The site claims over 500,000 developers tolerate it — the self-deprecating verb is theirs, and it’s a nice change from the usual growth-chart triumphalism. DHH has said Omarchy, his Arch-based Linux setup, will ship with a T3 Code installer. And the fork culture is already alive: one community post describes a user who loved T3 Code’s UI, found a different backend, and married the two — which is exactly what an MIT license is for.
The rough edges
None of this means the project is finished, and the sources are honest about that. It’s very early software — v0.0.x territory — and the most consequential rough edge is a default: new threads start in Full access mode, meaning no approval prompts for commands or file edits. For a tool whose flagship scenario is running multiple autonomous agents simultaneously against your repositories, defaulting to zero friction is a genuinely questionable choice. The community documentation says to change it first, before your first real task, and it’s right. Supervised mode, which asks before commands and file changes, exists and works — it just isn’t what you get out of the box.
The permission system itself is more granular than the default suggests: Supervised, Auto-accept edits, Auto, and Full access, each mapping to a different trust level. Auto mode, which lets routine actions run while risky ones still ask, depends on provider support and isn’t uniformly available. The project’s own contributing guidelines are another honest signal: review capacity is limited, small focused fixes are most likely to be merged, and features require an approved discussion first. That’s a team managing expectations, not a foundation pretending to be one.
It’s also worth being clear about what T3 Code is not. It is, in a sense, glue — sophisticated, fast, thoughtfully architected glue, but glue. Its value is entirely derivative of the agents underneath it. If Anthropic and OpenAI shipped equally good, equally open, cross-provider control surfaces tomorrow, T3 Code’s reason for being would shrink. The bet the project is making — implicitly — is that they won’t, because every provider’s incentive points toward its own walled garden. So far, that bet looks safe.
The open question
The deeper tension is sustainability. A free, MIT-licensed, no-token-markup control plane with a small team and limited review capacity is a wonderful gift and a fragile institution. The README addresses this with unusual directness: the team built it because they wanted the best possible development experience with agents, and they want users to have everything needed to fork and build their own tool if the project ever goes the wrong direction. That’s either admirable foresight or a quiet acknowledgment that open-source control planes have a history of burning out their maintainers. Possibly both.
What’s not in question is that the problem is real. Developers are running multiple agents across multiple subscriptions on multiple machines, and the official vendors are structurally incapable of solving for that, because solving for it means being neutral about whose agent wins. Neutrality is exactly what an open-source project with no token margin can offer. T3 Code got there first, got there fast, and — dropped frames treated as bugs and all — got there in a form you can take with you if it ever stops being what you need. In a landscape where every layer above the model is trying to own you, a control plane that explicitly doesn’t is the rarest kind of infrastructure.
Sources
- T3 Code | The open-source control plane for coding agents
- What is agentic coding? How it works and use cases
- local sessions from any device with Remote Control - Claude Code Docs
- Is the "agentic coding" working better than just follow along the AI and ...
- Running Claude Code from your phone — it actually works and ...
- T3 Code Review, but I Respect Your Time (November 2026)
- Best AI Coding Agents Summer 2025 - Medium
- How do you work on your Claude Code projects from your phone?
- I loved T3 Code's UI, then I found omp — so I forked T3 Code and married them
- Top 5 Agentic Coding CLI Tools
- Remotely operating Claude code from phone?
- T3 Code: A Free, Open-Source Control Panel for Claude Code, Codex and ...