Editorial Listing

T3 Code

T3 Tools · T3 Code: Open-Source App for Running Claude Code, Codex, Cursor, and Other Coding Agents from Desktop, Web, and Phone

Open T3 Code

T3 Code is a free, MIT-licensed control surface for coding agents. It runs Claude Code, Codex, Cursor, Grok Build, OpenCode, Antigravity, Kiro, Pi, Muse Code, and fx on your own machine through the subscriptions you already have, and gives you one chat interface for them on desktop, web, iOS, and Android. It suits developers who use several coding agents and want to start, review, and ship their work without living in a terminal, including from a phone.

PricingFree
Setupmedium
Runs onDesktop · Web · Self-hosted
Open sourceYes
DocsYes
CategoryCoding
Agent OrchestrationAgent HarnessParallel AgentsGit WorktreesOpen SourceClaude CodeCodexModel-AgnosticMobile AppPull RequestsSelf-HostedDesktop App

Best for

Developers who already pay for one or more coding agents (Claude Code, Codex, Cursor, Grok Build, OpenCode) and want a single GUI to run them in parallel, ship pull requests, and keep working from a phone or another computer

Not ideal for

Anyone looking for a coding agent with its own model, teams that need managed cloud execution or an organization-wide admin console, and anyone who needs stable, pre-tested releases

Who it's for

Individual developers and small teams who run several CLI coding agents on their own machines and want to manage them from desktop, browser, and phone

Capabilities

  • Drives Claude Code, Codex, Cursor (through the official Cursor SDK), Grok Build, OpenCode, Google Antigravity, Kiro (Early Access), Pi, Muse Code, and fx using their existing logins, plus other agents from the ACP Registry
  • One chat interface on an Electron desktop app (macOS, Windows, Linux), the hosted web app, and iOS and Android apps, all connected to a server on the machine that runs the agents
  • Threads in the project checkout or in their own git worktrees, with configurable branch naming and automatic worktree cleanup
  • Sends one prompt to several models at once, each in a separate thread and worktree
  • delegate_task lets an agent start child agents on any provider or model and wait for their results, and the T3 Code MCP lets agents create, launch, message, search, and interrupt threads
  • Forks any thread, using the provider's native fork where available, and switches providers or accounts mid-thread with a summary of recent messages
  • One-click commit, push, and pull request with generated commit messages, titles, and descriptions
  • Pull Requests page to review, comment, request reviewers, merge, and merge or rebase GitHub stacks, for GitHub, GitLab, Forgejo, Gitea, Bitbucket, and Azure DevOps
  • Agents can watch a pull request and wake when checks fail, required checks pass, someone reviews, or the branch conflicts
  • Remote access through the T3 Connect relay, LAN or Tailscale HTTPS pairing, or desktop-managed SSH, with load balancing of new threads across machines
  • Mobile push notifications and iOS Live Activities or Android ongoing cards when an agent finishes, fails, or needs approval
  • Usage page with estimated API-equivalent cost and pooled subscription limits across multiple Codex, Claude, Cursor, Grok, and OpenCode accounts
  • Four permission modes per thread: Supervised, Auto-accept edits, Auto (provider's automatic review), and Full access
  • Device panel that streams an iOS Simulator or Android Emulator next to a thread, which agents can also control
  • Recurring and one-time scheduled tasks, a server-side message queue that survives restarts, and auto-resume of threads that hit a provider usage limit once it resets
  • Managed policies let administrators set defaults and locks per machine, cap permission modes, restrict providers and clients, and turn off telemetry, including through Windows Group Policy

Limitations

  • Provides no model or agent of its own: at least one provider (such as Claude Code, Codex, or Cursor) must be installed and authenticated on the host machine, and usage limits and costs come from those subscriptions
  • Pre-1.0 and fast-moving: v0.1.9 was the stable release on November 11, 2026, with several nightly builds a day; the v0.1.0 upgrade copied threads one way and required updating every connected server, desktop app, and phone app
  • Agents run on a machine you control, which must stay on and reachable for phone or web access; there is no hosted execution
  • The background service runs per user; on macOS and Windows it stops when you log out, so the machine must stay signed in and awake for unattended remote access (Linux keeps running after logout)
  • T3 Connect is free for up to three machines per account; more machines require a paid T3 Chat plan (10 with Pro, 100 with Premier), or you can use LAN or Tailscale connections instead
  • Mobile push notifications require signing in to T3 Connect; direct LAN or Tailscale connections do not deliver them
  • New threads default to Full access, which allows commands and edits without approval, until you change the default
  • Sends product usage events (via T3 Code's endpoint to PostHog) and T3 Connect relay traces (to Axiom) by default, with no prompts, responses, or file contents; T3CODE_TELEMETRY_ENABLED=false turns off both on the server, while browser and mobile clients send their own diagnostics
  • Feature parity varies by provider: Auto mode uses automatic review only on Codex, Claude, Cursor, Grok, and fx, other providers such as OpenCode and Antigravity fall back to asking, and Kiro and Muse Code offer only Supervised and Full access

Use cases

  • Starting a Claude Code or Codex task on a home workstation from a phone and approving its commands when a notification arrives
  • Sending the same prompt to several models in separate worktrees and comparing the results before opening a PR
  • Switching a stuck thread from one provider to another without restarting the conversation
  • Committing, pushing, and opening a pull request with a generated description, then letting the agent watch CI and reviews
  • Tracking remaining Claude and Codex subscription limits across several accounts and machines in one view
  • Running agents on a remote Linux server over SSH while driving them from a laptop's desktop app

Our take

T3 Code is best understood as a better front end for agents you already use, not a new agent. Its strongest arguments are the remote-first design, where a phone can supervise agents running on a workstation or server, the ability to move a thread between Claude, Codex, Cursor, and others as limits or quality shift, and a pull request workflow that covers six Git hosts. Since v0.1.0, the better way to combine harnesses is delegate_task, which hands a subtask to another provider's agent, because mid-thread switches carry only a summary of recent messages. The costs are stability and defaults: it is still pre-1.0 at v0.1.x, with nightly builds several times a day and stable releases roughly weekly, new threads start in Full access, and telemetry is on until you turn it off. Developers comfortable with that can get a lot from it; managed policies now let an administrator lock settings on each machine, but teams that need central governance or predictable releases should look elsewhere.

Who should use it

Developers who already use Claude Code, Codex, Cursor, Grok Build, or OpenCode and want a GUI for running several threads in parallel, people who want to start and approve agent work from a phone, and anyone juggling multiple agent subscriptions who wants one view of their usage limits.

Who should skip it

People without an existing coding agent subscription, teams that need managed cloud execution, central policies, or audit controls, and anyone who prefers to stay in the agents' own terminal interfaces.

Strengths

  • Free and MIT-licensed, with no T3 Tools subscription fee
  • Uses the agent subscriptions you already pay for and lets you switch providers mid-thread
  • Strong remote and mobile story: relay, LAN, Tailscale, or SSH, plus push notifications
  • Built-in pull request workflow across six Git hosts
  • Pooled view of subscription usage limits across accounts and machines

Weaknesses

  • Pre-1.0 and changing quickly, with several nightly builds a day
  • Host machine must stay on and reachable for remote use
  • New threads default to Full access permissions
  • Usage telemetry is on by default
  • No hosted execution; governance is limited to machine-level managed policies

T3 Code pricing

Open source

Free

  • MIT license
  • Desktop apps for macOS, Windows, and Linux, plus a CLI server
  • Hosted web app and iOS and Android apps
  • Optional T3 Connect relay with a T3 account, free for up to 3 machines

Note: T3 Tools' Terms of Service say T3 Code is currently offered without a subscription fee and that any future paid feature will show its price before purchase. You pay separately for the coding agent subscriptions or API keys you connect. T3 Connect is free "for now" for up to three machines per account; linking a paid T3 Chat account raises the limit to 10 machines with Pro or 100 with Premier, and phones and browsers do not count toward it. Checked against the T3 Code FAQ and Terms of Service on November 16, 2026.

Where T3 Code excels

Supervising agents away from the desk

With T3 Connect and the mobile app, an agent running on a home or office machine can notify you when it needs approval or finishes, and you can reply, approve, or start new threads from a phone.

Comparing models on the same task

Shift-clicking several models sends one prompt to each in its own worktree, so you can compare diffs from different providers before choosing one to turn into a pull request.

Working around subscription limits

The Usage page pools limits across accounts, limited threads can auto-resume at reset, and a thread can move to another provider or account with its recent context.

T3 Code vs. competitors

T3 Code vs. Orca

Orca is a desktop agent development environment that runs any CLI agent in its own terminal, with an editor, per-worktree browser, SSH worktrees, a mobile companion app, and Linear and Jira integration. T3 Code drives its built-in providers and ACP Registry agents through their protocols and SDKs in its own chat interface, runs as a server that can stay headless and serve desktop, browser, and mobile clients, and adds mid-thread provider switching, pooled usage limits, and pull request review across six Git hosts. Pick Orca to keep agents' native terminals and an editor around them; pick T3 Code for a chat GUI you can reach from any device.

T3 Code vs. JetBrains Air

JetBrains Air also runs several vendors' agents side by side, in JetBrains IDEs and a desktop app, and adds cloud tasks, policies, credit limits, and analytics for organizations. T3 Code is free and open source, runs agents only on machines you control, and limits administration to per-machine managed policies rather than organization-wide analytics and credit controls.

Frequently asked questions

What is T3 Code?

T3 Code is an open-source control surface for coding agents from T3 Tools. A server on your machine runs the agents you have installed, such as Claude Code, Codex, Cursor, Grok Build, OpenCode, Antigravity, or Pi, and you work with them through a chat interface in the desktop app, the web app, or the iOS and Android apps.

Is T3 Code free and open source?

Yes. The source is on GitHub at pingdotgg/t3code under the MIT license, and the Terms of Service say T3 Code is currently offered without a T3 Tools subscription fee. You still pay for the coding agent subscriptions or API keys you connect. The T3 Connect relay is free for up to three machines per account; linking a paid T3 Chat plan raises that to 10 (Pro) or 100 (Premier), and LAN or Tailscale connections have no such cap.

Which coding agents does T3 Code support?

Its docs list Codex, Claude Code, Cursor, Grok Build, Kiro, OpenCode, Google Antigravity, Pi, Muse Code, and fx, and it can add other agents from the official ACP Registry. Each provider must be installed and signed in on the machine running the T3 Code server. One agent can delegate work to another with delegate_task, which T3 Code recommends over switching providers mid-thread.

Can I use T3 Code from my phone?

Yes. The iOS and Android apps connect to a T3 Code server on another machine through T3 Connect or a LAN or Tailscale pairing link. That machine must stay running. Push notifications for finished work and approvals require T3 Connect.

Does T3 Code send my code to T3 Tools?

Agents run on your machine and talk to the providers you choose. T3 Code's server sends product usage events (provider, model, permission mode, turn result, token totals, and hashed account identifiers) through T3 Code's own endpoint to PostHog, and T3 Connect relay traces to Axiom, but not prompts, responses, or file contents. T3CODE_TELEMETRY_ENABLED=false on the server turns both off; the mobile app's crash reports have their own toggle. Optional hosted features such as T3 Connect relay traffic through T3 Tools' service.

T3 Code vs Orca: what is the difference?

Both are free, MIT-licensed apps for running several coding agents in parallel in git worktrees, and both have phone apps and SSH remotes. Orca is a desktop environment that keeps each agent in its own terminal next to an editor and a per-worktree browser. T3 Code replaces the terminal with its own chat interface, runs as a server that can stay headless and serve desktop, browser, and mobile clients, and adds mid-thread provider switching, pooled usage limits, and pull request review across six Git hosts.

Integrations & fit

Claude CodeCodexCursorGrok BuildOpenCodeGoogle AntigravityPiACP RegistryGitHubGitLabForgejoGiteaBitbucketAzure DevOpsTailscaleOpenRouterWSLKiroMuse Codefx1Password
Good fit forSolo / individual, Startup / small team
Pricing modelFree· No cost to start
See pricing on T3 Code →

Alternatives to consider

About T3 Code

T3 Code, from T3 Tools Inc., does not ship a model or an agent. It is a server that runs on the machine where your code lives and drives the agent harnesses already installed and signed in there, plus clients that connect to that server: an Electron desktop app for macOS, Windows, and Linux, a hosted web app at app.t3.codes, and iOS and Android apps. Each task is a thread, which can work in the project checkout or in its own git worktree; Shift-clicking models sends the same prompt to several models, each in its own thread and worktree. Since v0.1.0 (October 2026), an agent can hand work to child agents on any provider with a delegate_task tool, for example Claude planning and Codex implementing, and a T3 Code MCP server lets agents create, message, and fork threads. You can also switch providers mid-thread, but the handoff is lossy: the new agent gets a selection of recent messages, not the previous agent's reasoning or tool results, so T3 Code recommends delegation instead. Around the chat sit tools for shipping: one-click commit, push, and pull request with generated titles and descriptions; a Pull Requests page for reviewing, merging, and handling GitHub stacks across GitHub, GitLab, Forgejo, Gitea, Bitbucket, and Azure DevOps; and a watch_pull_request tool that wakes the agent when checks fail or reviewers comment. A Usage page shows token use and estimated API-equivalent cost and pools subscription limits across Codex, Claude, Cursor, Grok, and OpenCode accounts. Remote work is central to the design: the T3 Connect relay or LAN and Tailscale pairing let a phone or browser drive agents on the host machine, desktop-managed SSH lets the desktop app run agents on a remote Linux or Apple Silicon host, with push notifications and Live Activities when an agent finishes or needs approval. The tradeoffs: it is pre-1.0 software (v0.1.x) with several nightly builds a day, the host machine has to stay on and reachable, T3 Connect is free for up to three machines per account, the default permission mode for new threads is Full access, usage telemetry is on by default, and model costs and limits come from your own agent subscriptions.

Updates from T3 Code

New FeatureT3 Connect agent sign-in and Claude session approvals

T3 Code v0.1.9 lets you approve agent sign-ins through T3 Connect instead of copying a pairing code, allow an MCP app for a whole Claude session, revert merged GitLab merge requests, and use OpenCode's native goals.

New FeatureKiro, managed policies, and one-time schedules

T3 Code v0.1.7 added Kiro as an Early Access provider, managed policies that administrators can deploy centrally (including through Windows Group Policy), one-time scheduled tasks, child-agent approvals from the parent thread, and shareable thread links.

LaunchOrchestrator V2: delegate_task, thread forks, and the T3 Code MCP

T3 Code v0.1.0, the first stable release of Orchestrator V2, added delegate_task for child agents on any provider, thread forks, a T3 Code MCP server for agents, Muse Code and OpenCode 2 support, a server-side queue that survives restarts, and scheduled tasks. Threads are copied one way on first start, and every connected server and app must be updated.

New FeatureThreads without a project and one-click provider updates

T3 Code v0.0.45 lets you start a thread without a project, create a new Git project from just a name, update provider CLIs on every connected machine with one click, and fold busy threads into a beta Working section until they need you.

New FeatureMulti-model threads, ChatGPT sign-in for Codex, and more usage limits

T3 Code v0.0.43 added starting one prompt with several models in separate worktrees, connecting ChatGPT accounts for Codex with managed authentication, subscription limits for OpenCode Go, Cursor, and Grok, and automatic storage cleanup.

New FeatureGitHub stacks, Forgejo and Gitea, and Android notifications

T3 Code v0.0.42 added navigating, merging, and rebasing GitHub stacks, linking several pull requests to a thread, Forgejo and Gitea support, rewinding conversations while keeping file changes, iOS Simulator and Android Emulator support, and Android agent notifications.

Are you the founder? Claim this listing →