Moshi vs T3 Code

T3 Code is one of the most talked-about entries in the new ADE (agent development environment) category, and for good reason. It comes from Theo and the T3 Tools team, it's MIT-licensed and completely free, and in a few months it has grown from a desktop app into a whole system: a desktop app, a hosted web app, iOS and Android apps, a CLI server, and T3 Connect for reaching your machines from anywhere. Its own tagline is "the open-source control plane for coding agents," and it's a fair description.

Moshi is built on a different bet. T3 Code is the environment: its server runs your agents, its clients are how you reach them. Moshi is a layer: your agents live in tmux or Herdr on your own machine, Moshi reaches them over your own SSH or Mosh connection, and it adds chat, diffs, previews, and approvals on top. We made the general case in Moshi vs. ADEs: A Layer, Not a Lock-In. This page is the head-to-head with T3 Code specifically.

Neither bet is strictly better. Let's go through it honestly.

T3 Code supports Claude Code, Codex, Cursor, Grok Build, OpenCode, and Google Antigravity, using the subscriptions you've already set up on the machine, and renders all six as chat. It drives each one through a structured protocol (Anthropic's SDK, Codex's app-server, OpenCode's SDK, and ACP for Cursor, Grok, and Antigravity). Moshi's hooks cover 19 agents: those six plus Pi, OMP, Kimi, Hermes, Copilot, Amp, Factory Droid, Qoder, Devin, OmO, jcode, Gemini, and Qwen. Its Chat View renders 17 of them, all but Gemini and Qwen. Because Moshi sits on a terminal, anything that runs in a shell works even when it isn't on the list. For most people, the rosters are a wash. The real difference is where the agent lives, and what the chat actually is.

The short version

Read the table as two clusters. The persistence, portability, and transport rows favour Moshi: your sessions are tmux or Herdr sessions, not T3 sessions, and nothing relays them. The open source, price, and PR workflow rows favour T3 Code. On the phone the two are closer than you might expect: both have a real terminal, push and approvals, Live Activities, usage limits, on-device voice, and attachments. Moshi adds Apple Watch.

Who holds your agent?

This is the question that decides everything else, so let's be precise about it.

In T3 Code, agents run as children of the T3 server (t3 serve, or the server the desktop app starts for you). Projects, threads, and settings live in ~/.t3/userdata. You can install that server as a background service with t3 service install, so it keeps running with the desktop app closed. That's a real persistence layer, and it works. But it's T3's persistence layer. T3's own docs are candid about what that means: t3 update warns that restarting the service "interrupts running agent turns, terminals, and remote clients," and the background service is systemd on Linux and a login item on macOS (it stops when you log out; Windows isn't supported).

In Moshi, the agent runs in a multiplexer: tmux, Zellij, or the agent-native Herdr. Moshi never owns the process. Update Moshi, uninstall Moshi, or lose your phone, and the agent keeps working. When Rex, Mitchell Hashimoto's upcoming multiplexer, ships, we plan to support it next to tmux and Herdr, because it's built around the same long-lived, server-side sessions Moshi plugs into.

The practical consequence: a T3 thread can be reached from T3 clients (desktop, web, mobile), and nothing else. A Moshi session is a tmux or Herdr session, so it can be reached from Moshi, Ghostty on your Mac, Blink on an iPad, or plain ssh from a Linux box, all at the same time. That's the portability argument in one sentence: with T3 Code you pick T3's clients; with Moshi you pick any client, including none of ours.

T3 Code's real strengths

They deserve a proper list, because T3 Code is genuinely good.

• Free and MIT-licensed, top to bottom. The desktop app, the web app, the mobile apps, and T3 Connect are all free, with no in-app purchases. Their README puts it plainly: "Wait, what are you selling me?" "Nothing." If they ever go the wrong way, you can fork it.
• A polished desktop experience. Threads, model switching mid-thread, inline diff review before you push, and a one-button PR flow with auto-generated titles and bodies, plus draft, stacked, and amended PRs. Moshi doesn't do PR authoring at all; you'd use gh or the agent itself.
• Multi-machine by design. T3 Connect registers several machines under one account, and the web and desktop apps can even auto-balance new threads across them by available CPU and memory. That's a thoughtful feature Moshi doesn't have.
• Flexible remote access. T3 Connect for zero-config access, direct LAN or Tailscale pairing with a QR code, or desktop-managed SSH, where the app installs and starts a T3 server on a remote Linux box or Apple Silicon Mac and forwards the port for you.
• A real mobile app. The iOS and Android apps (Expo/React Native) can start agent runs, browse files, handle version control, review diffs, and open a terminal. They also have push for finished, failed, and blocked turns (approve or reject in the conversation), Live Activities on iOS and an ongoing activity on Android, a usage view with 5-hour and weekly windows plus a home-screen widget, photo and file attachments, and on-device voice on iOS 26+ using Apple's speech model. The full PR Code tab is desktop and web only; mobile gets a diff viewer.
• Momentum. 23k+ GitHub stars and nightly builds most days. It moves fast.

If those are the things you optimize for, T3 Code is an excellent choice. The rest of this page is for people weighing them against what a layer gives you.

Weight: 11 MB vs. 135 MB

We measured both macOS downloads on September 28, 2026:

T3 Code is roughly 12× larger to download and about 14× larger installed, and it's one of the lighter ADEs; Orca, Paseo, Claude's app, and the Codex app are all heavier. The gap isn't sloppiness. An Electron app ships its own Chromium and Node, and T3's desktop app also carries the server that runs your agents. Moshi Desktop is a Tauri app that uses the webview macOS already has, and it doesn't need a server of its own, because tmux or Herdr already holds the sessions and moshi-hook exposes them as small web APIs. On Linux and Windows, Moshi Desktop is the same UI served to your browser, with nothing to install.

Disk space is the least of it. Size is a proxy for how much of your workflow the app owns.

The phone: T3 Connect vs. your own SSH

Both apps get you to your agents from a phone. They take different roads.

T3 Code's default road is T3 Connect: sign in on the host (t3 connect), sign in on the phone, pick the environment. It's zero-config and works through NATs without port forwarding, and T3 keeps tunnels alive and renews credentials for you. It's also what delivers T3's push notifications, so without it you don't get pushed about finished turns or approvals.

It's worth knowing how it works. T3 Connect is a broker running as a Cloudflare Worker operated by Ping Labs, with Clerk for sign-in, and the traffic itself flows through Cloudflare Tunnels. That means it's encrypted in transit (TLS) but not end-to-end: Cloudflare terminates the tunnel, so the session isn't opaque to the infrastructure in the middle the way an end-to-end design would be. That's a common, reasonable architecture, not a scandal, but it's a different trust model from a direct connection. T3 Connect is free today, with a cap on linked devices, and Theo has said they may change course if the bill gets too large. If you'd rather avoid the relay entirely, T3 also offers direct LAN or Tailscale pairing, which is a genuinely good option.

Moshi's only road is your own connection: SSH or Mosh straight to your host, with the keys you already use. Terminal output, transcripts, diffs, and dev-server previews travel from your host to your phone and nowhere else. One honest caveat: push notifications, the inbox, and usage snapshots go through Moshi's server, because Apple and Google only deliver push from a server.

Mosh adds something a relay doesn't need to solve the same way: sleep your phone or switch from Wi-Fi to cellular, and the session simply catches up when you're back, without a persistent socket draining your battery.

What Moshi adds on the phone

On the phone, the two are closer than on the desk. Both have a terminal, diffs, push and approvals, Live Activities, a usage view, attachments, and on-device voice. Here's what Moshi does differently or in addition:

• Apple Watch approves or denies a permission prompt from your wrist. T3 Code has no Watch app.
• Push without a relay. moshi-hook sends events from your host, so approvals and completions reach you without routing the session through anyone's tunnel.
• Live Activity & Dynamic Island with approve and deny right on the lock screen.
• Usage rings for Claude Code's 5-hour and 7-day windows and Codex's rolling limits, plus per-agent context "stamina" and a Watch complication.
• Image and file paste copies a screenshot or PDF to your host over SCP and hands the agent a path.
• On-device voice on any supported iPhone, with a choice of Parakeet, Apple's SpeechAnalyzer, or local Whisper.
• A keyboard built for tmux, Herdr, and agent TUIs, with shortcut panels and gestures.

Two kinds of chat

Both apps give you a native chat for your agents, and it's easy to assume they're the same thing. They aren't.

In T3 Code, the chat is the session. T3 drives each agent through a structured protocol and renders what comes back as a thread. That's why the chat is so clean. It's also why there's no terminal underneath to fall back to. The thread lives in the T3 server, and the T3 clients are how you see it.

Moshi's Chat View is a lens over a live terminal. It shipped in June 2026 (moshi-hook v0.2.27 added transcript streaming on June 14, alongside iOS 3.6.0). It renders the agent's real transcript as native chat, while the agent keeps running in tmux or Herdr exactly as it would without Moshi. One tap takes you to the same session as a terminal, and you can still tmux attach to it from your laptop. Chat View is still experimental and part of Pro, with free uses to try it.

The trade is honest in both directions. T3's chat can do things a lens can't, like switching models mid-thread, because T3 owns the conversation. Moshi's chat can do something T3's can't: disappear. Turn it off, uninstall Moshi, and the session is still there, because it never belonged to the chat.

One feed, every agent and host

T3 Code organizes work as threads per project, with environments for each machine. Moshi's inbox collapses every agent on every host into one triage feed: a finished turn floats up, a pending approval pins to the top, and stale items archive themselves. On the desk, Moshi Desktop shows the same thing as a workspace rail across every machine, next to a chat view and a real terminal.

Review on the desk

T3 Code's desktop is strongest where code leaves your machine: inline review before you push, one-button PRs with generated titles and bodies, stacked and amended PRs. Moshi Desktop doesn't try to match that. Its git support is for looking, not committing: Diff and History tabs with a commit graph and ref chips, and the branch plus ahead/behind counts in the sidebar. There's no staging, committing, or PR creation. If the PR workflow is what you want from a desktop app, T3 wins it.

Where Moshi Desktop leans in is talking back to the agent about what it made:

• Comment on code (v0.4.1). Hover a line in a diff or a file, press + (or drag for a range), and write a note. It goes to the agent with your next message, anchored to that code.
• Design mode on web previews (v0.3.0). Dev-server previews open side by side with the terminal or chat, tunnelled over your SSH connection. Switch on annotation and comment directly on page elements with pinned, numbered notes. When the framework's dev tools expose it, each note carries the source file and line, so the agent knows exactly what to change.

T3 Code has inline diff review, but not these two feedback loops.

"But T3 Code is open source"

It is, and Moshi isn't. That's a real point in T3 Code's favour, and if open source is a hard requirement for you, you should pick T3 Code.

It's worth being precise about what open source buys you here, though. You can read and fork T3's code. But your running threads still live in the T3 server, in T3's format, reachable through T3's clients. Forking the code won't carry a single running agent to another tool.

Moshi flips that. The part you can't read is the UI. Everything that holds your work (tmux, Herdr, OpenSSH, Mosh) is open and isn't ours. If Moshi disappeared tomorrow, you'd lose an interface and nothing else, because your agents would still be running, one tmux attach away. We wrote more about why Moshi is closed in Moshi vs. ADEs.

Where T3 Code wins

Pick T3 Code when:

• Free and open source are non-negotiable. It's MIT and costs nothing, mobile and relay included.
• You want the PR workflow in the app: inline review, one-button PRs, stacked and amended PRs.
• You want zero-config remote access through T3 Connect, without setting up SSH keys or Tailscale.
• You run threads across several machines and like the idea of auto-balancing new work between them.
• You want a native Windows desktop app (Moshi Desktop is web-only on Windows and Linux).
• You're happy for one app to own the whole loop, and would rather not run a multiplexer at all.

Pricing

On price, T3 Code wins outright. You still pay Anthropic, OpenAI, and the rest for the agents themselves with either tool. Moshi Desktop is free for everyone; the phone app has a free tier, and its agent layer and Pro features are paid, with a one-time $199 option if you'd rather not subscribe.

The verdict

T3 Code is the best case for the all-in-one ADE: free, open, fast-moving, and genuinely thoughtful. Moshi is the case for the layer: your sessions stay in tmux or Herdr, and the app on top is replaceable, ours included. For the wider field, see Moshi vs. ADEs, and for other phone-first agent clients, Moshi vs Happy and Moshi vs Claude Code Remote Control.