Most coding agents live in exactly one place: whatever terminal you happened to start them in. T3 Code, built by Theo Browne's team at Ping.gg, calls itself an "agent harness control surface" — it doesn't run its own agent, it controls the ones already installed on your machine (Claude Code, Codex, Cursor, Grok Build, OpenCode) from a desktop app, a web app, or a genuinely capable mobile app, so a long-running agent task isn't tied to keeping one terminal window open.
That's a real problem once you use background coding agents seriously. A task that runs for twenty minutes needs a decision halfway through, and you're away from the desk. Two agents are running in two terminals and you've lost track of which is doing what. A worktree on a remote machine is finishing a refactor, and checking on it means opening an SSH session. Each agent CLI is good on its own; the friction is in supervising several of them.
This explainer covers what T3 Code is and isn't, why its mobile app matters, how it handles remote and multi-environment work, why the team built it, how to set it up with each supported agent CLI, what the release history says about its maturity, and who should try it now versus wait.
It's a Control Layer, Not Another Agent
The project's own framing in the README is unusually direct about what it isn't: not a new agent, not a hosted service, not something being sold. It authenticates against the CLI tools you already have installed and already pay for — if Claude Code, Codex, Cursor, Grok Build, or OpenCode is set up and authenticated on your machine, T3 Code can control it. That's a meaningfully different starting point than a platform trying to get you onto its own agent or its own subscription; the entire value proposition is the control surface itself; the agents underneath stay exactly what you already chose.
Why the Mobile App Is the Actual Differentiator
Most agent-orchestration tools are desktop-only, which quietly assumes you're at your machine whenever an agent needs a decision. T3 Code ships real iOS and Android apps specifically to break that assumption — you can check on running agents, review what they've done, and send follow-up instructions from your phone. Recent release notes show real investment in that side specifically: a cross-platform mobile usage dashboard, a unified sheet for model and thread settings, work-log parsing that catches provider-specific error patterns, and ongoing polish on how threads and drafts behave on mobile. For anyone kicking off a long agent task and stepping away from the desk, that's the actual gap most competing tools leave open.
Built for Remote and Multi-Environment Work
Beyond the mobile story, the recent changelog shows a system being built for running agents somewhere other than your local machine: worktree selection per project, dev database seeding for worktrees, remote non-Git project support, and a usage page that reads provider transcripts across environments rather than assuming everything runs on one box. Combined with support for five different underlying agent CLIs, the design goal reads clearly: be the layer that works the same way whether an agent is running locally, in a worktree, or on a remote host — a genuinely useful property once a team has more than one machine or environment in the loop.
Why It Exists, In the Team's Own Words
The README answers the obvious skepticism directly, under a section literally titled "Wait, what are you selling me?": nothing. The team says it built T3 Code because it wanted the best possible development experience with agents, and names its actual reference points — the Codex desktop app, Conductor, Claude Desktop, and Cursor Glass — as things that inspired the project but didn't clear its bar. The stated goal is software that's performant, remote-ready, and truly open, with an explicit fallback plan: if the project ever goes the wrong direction, the team wants users to have everything they need to fork it and build the editor they actually want. That's a more concrete standard to hold a project to than typical open-source mission language, and it's worth checking the project against over time rather than taking at face value once.
Benefits of T3 Code
The project's narrow focus translates into a handful of concrete benefits for people already using coding agents heavily.
One place to supervise every agent
Instead of remembering which terminal holds which agent, you see Claude Code, Codex, Cursor, Grok Build, and OpenCode sessions in a single interface. That reduces the overhead of running several agents at once and makes it less likely that a stalled task goes unnoticed for an hour while you assume it's still working. Pinned and reorderable threads help keep the most important sessions at the top of the list.
Agent tasks stop being tied to your desk
The mobile apps let you check progress, read what an agent has done, and answer its questions from a phone. A twenty-minute task that needs a decision halfway through no longer waits for you to get back to your machine, which makes long-running agent work far more practical in a normal day. It also means you can start tasks before leaving the desk with less worry about them stalling.
No new subscription or vendor lock-in
T3 Code is MIT-licensed and authenticates against the CLIs you already pay for. Trying it adds no new bill, and you keep using whichever agents you prefer. If the project changes direction, the licence means you can fork it rather than migrating away. The team names that fallback explicitly as part of its reasoning for building in the open.
Consistent workflow across environments
Per-project worktree selection, remote project support, and a usage view across environments mean the same interface works whether an agent runs locally, in a worktree, or on a remote host. Teams with a dedicated dev box or home server get a consistent way to reach agents there. That consistency matters more as agent work spreads across machines.
Easier comparison between providers
Running different agents side by side in one interface makes it practical to compare how each handles similar tasks. That helps developers decide which agent suits which kind of work, without switching tools and habits each time. It also reduces the cost of trying a new provider when one is released.
T3 Code Use Cases
These are the workflows where a control surface for multiple agents adds the most, based on what the project supports today.
Long refactors with mid-task check-ins
You start a large refactor before a meeting or a commute. Partway through, the agent needs a decision about an API change. With T3 Code, the question reaches your phone, you answer it, and the agent continues. The outcome is that long tasks keep moving instead of sitting idle until you return to your desk. Reviewing the agent's work log on the phone also lets you catch a wrong turn early, before it compounds.
Running several agents in parallel worktrees
Developers increasingly split work into parallel tasks, each in its own worktree with its own agent. T3 Code's per-project worktree selection and thread list keep those sessions organised, so you can see which task is finished, which is blocked, and which needs review without hunting through terminals. Dev database seeding for worktrees makes each parallel task easier to test in isolation.
Agents on a remote dev machine or home server
Some developers run agents on a more powerful remote box or a server that stays on overnight. With T3 Code running as a background service on Linux and remote access configured, you connect from a laptop or phone to check progress, rather than opening an SSH session for each agent. The project's documentation covers both the service setup and remote access from a phone.
Mixing providers by task
A developer might prefer one agent for large codebase changes and another for quick fixes or exploration. Controlling both from the same app makes that mix practical. The usage page, which reads provider transcripts across environments, also helps track how much each agent is being used. That visibility is useful for anyone paying for several agent subscriptions at once.
Lightweight evaluation of agent tooling
Teams deciding how to structure agentic development can use T3 Code as a low-cost way to experiment with multi-agent supervision. Because it installs with a single npx command and uses existing subscriptions, the trial costs little beyond setup time. If the workflow doesn't fit, there's nothing to cancel or migrate away from.
Common T3 Code Mistakes
Most problems people hit with an early-stage control layer come from expecting more of it than it claims to offer.
Expecting better code from T3 Code itself
T3 Code doesn't run a model. The quality of the code depends entirely on the agent underneath. Developers who switch expecting better results are judging the wrong layer; what changes is supervision, not output quality. If an agent's output is weak, the fix is choosing or prompting the agent differently.
Depending on it for critical sessions
The project says plainly that it's very early and to expect bugs, and recent releases fixed issues like background subagents being silently killed. Routing every critical agent session through it, with no fallback, ignores that warning. Keep a direct terminal path to important sessions until the project matures.
Skipping CLI setup and version checks
Nothing works until at least one agent CLI is installed and logged in, and npx requires a supported Node.js version. Many "it doesn't work" moments come from missing authentication or an older Node release rather than T3 Code itself. Check npx t3@latest --help and each CLI's login status first when something fails.
Opening remote access casually
Agents can edit files and run commands. Exposing a control surface for them to other devices without reading the remote-access and permission guides creates an unnecessary security risk, especially on shared or public networks. Treat it like remote shell access, because in practice that's what it enables.
Planning to steer the roadmap through pull requests
Larger outside contributions aren't being accepted yet. Teams that adopt it assuming they can add missing features themselves may be disappointed; detailed bug reports are the realistic way to influence it for now. Forking remains an option, but it means maintaining your own copy of a fast-moving codebase.
Getting Started and Provider Setup
T3 Code doesn't run models itself, so before anything works you need at least one underlying agent CLI installed and authenticated: Codex CLI with codex login, Claude Code with claude auth login, Cursor CLI with agent login, Grok Build CLI with grok login, or OpenCode with opencode auth login. Once one of those is set up, the lowest-friction way to try T3 Code is npx t3@latest, which requires Node.js 22.16+, 23.11+, or 24.10+ and launches both the backend and a local web app in your terminal with no separate install step — npx t3@latest --help gives the full CLI reference. The desktop app installs from GitHub Releases or through a platform package manager: winget install T3Tools.T3Code on Windows, brew install --cask t3-code on macOS, or yay -S t3code-bin on Arch Linux via the AUR.
Documentation goes deeper than a typical early-stage README: there are dedicated guides for permission modes, keyboard shortcuts, customizing a project's icon, remote access from a phone or another machine, keeping the app and server in sync as both update, source-control integrations, running multiple accounts for Codex and Claude specifically, and running T3 Code as a background service on Linux. For a project that says outright it's "very very early," that's a meaningfully more complete documentation set than the maturity warning would suggest.
The Release Cadence Shows a Real, Wide Feature Surface
Beyond the correctness fixes already mentioned, recent releases show the product growing on nearly every surface at once: sidebar v2 became the default sidebar, pinned threads can be drag-reordered, a cross-platform mobile usage dashboard shipped, project settings got overhauled into a real settings page with breadcrumbs, worktree selection became per-project, and the desktop app's Browser panel now remembers recently used sites. Mobile-specific fixes are similarly granular — detecting PowerShell cmdlet errors inside work-log rows, stopping Android message bubbles with code blocks from overlapping, fixing long-press-to-navigate behavior on thread rows. That density of small, specific fixes across desktop, web, and mobile in a short window is a reasonable proxy for how much of the app is actually in active daily use by the team building it, not just scaffolded and left alone.
T3 Code vs Juggling Terminal Sessions
The simplest way to judge whether T3 Code is worth trying is to compare it with what most developers do today: run each agent CLI in its own terminal.
| Concern | Agent CLIs in separate terminals | Through T3 Code |
|---|---|---|
| Where you supervise agents | Whichever terminal each agent was started in | One desktop, web, or mobile interface |
| Checking in while away from the desk | Requires remote terminal access | Native iOS and Android apps |
| Mixing providers | Separate tools, separate habits | Claude Code, Codex, Cursor, Grok Build, and OpenCode in one place |
| Worktrees and remote hosts | Managed by hand per session | Per-project worktree selection and remote project support |
| Cost | Your existing CLI subscriptions | The same subscriptions; T3 Code itself is free and MIT-licensed |
| Maturity | Each CLI's own release track | Self-described as very early, with frequent correctness fixes |
If you only ever run one agent, in one place, while sitting at your machine, the left column is fine. The case for T3 Code grows with every extra agent, environment, and hour you spend away from the keyboard while something is running. For a broader view of tools in this category, see our overview of AI agent orchestration platforms.
What "Very Early" Actually Means Here
The project is candid about its maturity, and it's worth taking that at face value rather than reading past it. The README states outright: "We are very very early in this project. Expect bugs," and contributions beyond small fixes aren't currently being accepted — this is being built by the core team's own priorities, not shaped by outside PRs yet. The release history backs that up in a good way, though: recent fixes cover real correctness issues like a server-side reaper that was silently killing live background subagents, a greedy agent process that could take down the whole server, and Codex resume handshakes that were completing turns that never actually ran. That's the kind of bug class you only find by running the thing hard in production, which is a reasonable signal of real usage even at an early stage.
T3 Code Best Practices
If you decide to try it, a few habits make the evaluation more useful and keep an early-stage tool from becoming a single point of failure.
- If you're already running multiple coding agent CLIs, T3 Code's value is entirely in not having to juggle separate terminal sessions and remembering which one is doing what — worth trying specifically if that's already your actual pain point.
- The mobile app is worth evaluating on its own merits for anyone running long agent tasks that benefit from a check-in-and-steer workflow rather than active babysitting.
- "Very early" should be taken seriously before depending on this for anything critical — the project says so itself, and the volume of correctness fixes in recent releases (agents being silently killed, turns completing that never ran) confirms it's still finding real bugs at a meaningful rate.
- Contributions aren't really open yet, so evaluate this as a fast-moving, team-driven product to adopt and report bugs against, not a project to plan on shaping through PRs in the near term.
- Start on a non-critical project. Point T3 Code at a side project or a disposable worktree first, so any early-stage bugs cost you nothing while you learn how it handles threads, permissions, and resumes.
- Keep the underlying CLIs usable on their own. Make sure you can still reach each agent directly in a terminal, so if the control surface misbehaves you can fall back without losing a session's work.
- Read the permission-mode and remote-access guides before exposing anything. Remote control of agents that can edit code and run commands deserves the same care as any remote shell, so set it up deliberately rather than with defaults you haven't read.
- Track releases and re-test after upgrades. With fixes landing frequently, check the changelog when you update and rerun a quick smoke test on your usual workflow before trusting it with longer tasks.
Practical Takeaway
T3 Code is a focused bet on a specific, underserved layer: not a better agent, but a better way to control the agents you already use, from wherever you actually are — desktop, browser, or phone. For teams already running multiple coding agents day to day, it's worth trying specifically as a control-and-monitoring layer, with the expectation that it's genuinely early software from a team candid about that fact.
Teams evaluating multi-agent control and remote-agent workflows — alongside tools like Orca or Paperclip — can get hands-on architecture help from Woyce Technologies.
FAQ
What is T3 Code?
T3 Code is an open-source "agent harness control surface" from Theo Browne's team at Ping.gg — a desktop, web, and mobile app that lets you control coding agent CLIs you already have installed (Claude Code, Codex, Cursor, Grok Build, OpenCode) from one place. It doesn't replace those tools or add its own model. Instead it gives you a single interface to start, monitor, and steer them, including from your phone, which matters most when agent tasks run long enough that you step away from the desk while they work.
Is T3 Code its own AI agent?
No — it doesn't run its own agent or model. It controls and monitors CLI agents already installed and authenticated on your machine, using the subscriptions you already have for those tools. That means the quality of the code you get back depends on the underlying agent you pick, not on T3 Code. What T3 Code changes is how you supervise that agent: where you can see its progress, how you respond to it, and how easily you can switch between several.
Is T3 Code free to use?
Yes, it's MIT-licensed and open source, installable via npx t3@latest to try without installing, or as a desktop app via winget, Homebrew, or the AUR. There's no paid tier or hosted service attached to it. Your only costs are the agent CLIs it controls, which you pay for separately through their own subscriptions, so trying it adds no new bill beyond the time it takes to set up.
Does T3 Code have a mobile app?
Yes — real iOS and Android apps let you monitor running agents, review their work, and send follow-up instructions remotely, which is a more developed feature than most competing agent-orchestration tools offer. Recent releases added a cross-platform mobile usage dashboard, a unified sheet for model and thread settings, and fixes specific to how threads and code blocks render on mobile. The project also documents how to set up remote access from a phone to the machine running the agents.
Is T3 Code stable enough for production use?
The project describes itself as "very very early" and explicitly warns to expect bugs. Recent release notes show active fixes for real correctness issues, which is normal for early-stage software but worth weighing before depending on it for anything critical. Fixes have included background subagents being silently killed and resumed turns completing without actually running. A sensible approach is to use it for supervision and convenience while keeping the underlying agent CLIs as your fallback if something misbehaves.
Can I contribute to T3 Code?
The project states it's mostly not accepting contributions yet — small fixes may be considered, but larger features are being driven by the core team rather than the community at this stage. The most useful contribution right now is probably detailed bug reports, given how quickly the team is shipping correctness fixes. Because it's MIT-licensed, you're also free to fork it, which the team explicitly describes as a fallback if the project ever heads in the wrong direction.
How do I try T3 Code without installing anything permanent?
Run npx t3@latest in a terminal (Node.js 22.16+, 23.11+, or 24.10+ required). It launches T3 Code's backend and a local web app on your machine without a separate install step. You'll still need at least one supported agent CLI installed and logged in first, such as Claude Code or Codex, because T3 Code controls those tools rather than running models itself. Run it with the help flag to see every available option.
Do I need a paid subscription to use T3 Code?
T3 Code itself is free and open source. It authenticates against agent CLIs you already have installed and paid for separately — Claude Code, Codex, Cursor, Grok Build, or OpenCode — so your cost is whatever those tools already charge, not an additional T3 Code fee. In practice, that means you need at least one paid or otherwise authenticated agent CLI for T3 Code to be useful. If you already pay for more than one, T3 Code lets you use them side by side without changing how each is billed.
Can T3 Code run as a background service?
Yes, on Linux specifically — the project documents running it as a background service, alongside separate guides for remote access from a phone or another machine. Running it as a service is useful when the agents live on a home server or a dedicated development box: the server keeps running, and you connect from the desktop, web, or mobile app whenever you want to check progress or send instructions.
What CLI tools do T3 Code contributors need beyond Node.js?
Contributors need Vite+'s global vp command-line tool (installed via a shell script from vite.plus) and then run vp i to install dependencies — a build-tooling layer separate from the agent CLIs T3 Code itself controls. This only matters if you're building T3 Code from source. Regular users can ignore it and use the npx command or a desktop package instead. As noted above, the team is mostly not accepting outside contributions yet, so most readers won't need this setup.
Conclusion
Coding agents have become good enough to run long, unsupervised tasks, and that exposes a new problem: supervising them. Each agent CLI lives in its own terminal, on one machine, and assumes you're sitting in front of it. T3 Code takes a narrow, sensible position on that problem. It doesn't compete with Claude Code, Codex, Cursor, Grok Build, or OpenCode. It gives you one free, open-source control surface for all of them across desktop, web, and mobile, with support for worktrees and remote hosts.
The caveats come straight from the project itself. It's very early, it's mostly not accepting outside contributions, and recent releases have fixed serious correctness bugs. That's encouraging evidence of heavy real-world use, but it's also a reason not to make it the only way you can reach a critical agent session.
If you already juggle multiple agent CLIs or regularly leave long tasks running, try it with npx t3@latest on a non-critical project and see whether the mobile check-in workflow changes how you work. For teams designing a broader agentic development workflow, our AI agent development team can help with the architecture.