Moshi vs Orca

Orca is one of the most impressive tools in the new wave of ADEs, agent development environments. It's built by Stably (a Y Combinator company), it's MIT-licensed, it's free, and it ships almost every day. Its pitch is clear: run Claude Code, Codex, OpenCode or any other CLI agent side by side, give each one its own git worktree, and track the whole fleet in one window. A companion app lets you check in from your phone.

Moshi comes at the same problem from underneath. It isn't an environment you move into. It's a user-experience layer on top of the terminal multiplexer your agents already run in, tmux or Herdr, reached over your own SSH or Mosh connection from an iPhone, an Android phone or the desktop. We wrote up the general argument in Moshi vs. ADEs: a layer, not a lock-in. This page is the specific version, against the ADE that does the most.

Neither approach is strictly better. Orca bets that one app should own the whole loop. Moshi bets that the loop should belong to open tools you already have, with a great interface on top that you're free to replace.

Both rosters are effectively "anything that runs in a terminal". Orca says so outright, and Moshi drives whatever you start inside tmux or Herdr. The difference is in the chat marks. They show which agents each tool can render as a native chat view rather than a raw terminal: 17 for Moshi, and four for Orca's transcript chat. For the rest, Orca shows the terminal plus hook-reported status. The agent list won't decide this one on its own. The architecture will.

The short version

Read the table as two clusters. The orchestration rows favour Orca: worktrees, the browser, GitHub and Linear are things it does in one window and Moshi deliberately doesn't. The ownership rows favour Moshi: who holds your agent, how your phone reaches it, and whether any of that depends on one app staying installed.

Orca's real strengths

Start here, because Orca earns the comparison.

• It's free and MIT-licensed. No subscription and no account to download it. The relay that pairs your phone is in the same repository, under the same license.
• Parallel worktrees are the core idea, and they're done well. Fan one prompt across several agents, each in an isolated git worktree, compare the results and merge the winner. If that's how you work, Orca is built around you.
• It's a real environment. WebGL terminals with splits, a VS Code-style editor with full source control, a Chromium window with a design mode that sends an element's HTML, CSS and a screenshot into the prompt, diff annotation, GitHub and Linear boards, and an orca CLI that agents can script.
• It remote-controls well. SSH worktrees run agents on a bigger box with port forwarding, and a Remote Orca Server lets one machine do the work while another shows the UI.
• The phone companion is capable. It lists worktrees across hosts and opens sessions as a chat transcript (with permission prompts and questions) or a real terminal, whose Live mode streams your keystrokes to the desktop PTY. You get a push when an agent finishes, and you can attach photos and files, review source control and PR diffs, stage and commit, and switch agent accounts with usage and reset countdowns.
• Its relay is end-to-end encrypted. The phone pins the desktop's key at pairing, and each session gets its own keys (Curve25519 plus XSalsa20-Poly1305, in the mobile app's source), so the relay only ever sees ciphertext. The public docs don't mention this, but the code is clear about it.
• It moves fast. v1.4.215 landed on September 27, 2026, and the repo has roughly 80k GitHub stars.

If that list is what you want, a single window that owns the whole fleet, Orca is an excellent choice. The rest of this page is for people weighing it against a thinner layer.

Size: 11 MB vs. 229 MB

We measured both macOS downloads on September 28, 2026.

That's roughly 20× on the download and about 25× once installed. The gap isn't sloppiness on Orca's side. An Electron app ships its own browser engine, and Orca also bundles an editor, a browser pane and a PTY daemon, because it's the environment. Moshi Desktop can stay small because it isn't: tmux or Herdr already holds the sessions, moshi-hook exposes them as small local web APIs, and the app is a thin client for those APIs. On Linux and Windows it's the same UI in your browser, with nothing to install.

Disk space isn't the real point. Size is a proxy for how much of your workflow the app owns.

Who holds your agent when the app quits?

This is the question that separates an ADE from a layer.

Orca runs agents under its own background daemon, which owns the PTYs. It's a good design: Cmd-Q, an auto-update relaunch or an Orca crash won't kill Claude Code mid-task, and the next launch warm-reattaches. Orca's docs are candid about the limit, though. The daemon dies with the host, so a reboot, an OS update or a hard power-off ends every running agent, and only the layout and last scrollback come back. On SSH worktrees, the equivalent is a relay process Orca installs on the remote host, which leases the PTYs until you end them.

Either way, the sessions live in Orca's process, in Orca's format, and only an Orca client can attach to them. You can't tmux attach to an Orca agent from Ghostty, and another app can't pick it up.

With Moshi, the agent runs in a multiplexer that existed before Moshi and will outlive it:

• tmux, the fifteen-year standard, which any SSH client on any device can attach to.
• Herdr, an open-source (Apache-2.0) agent runtime built to keep agent terminals alive across machines. See the Herdr cheat sheet.
• Rex, the libghostty-based multiplexer Mitchell Hashimoto is building at Superlogical. It isn't public yet; once it ships, we plan to support it next to tmux and Herdr.

Start claude in tmux at your desk, pick it up from Moshi on your phone, then come back and tmux attach in your usual terminal. It's one session that several clients can hold at once, with nothing to sync or hand off.

Your phone: companion vs. client

Orca's mobile app is, in its own docs' words, "a remote control for the desktop you already have running". Phone and desktop each open an outbound WebSocket to Orca Relay, which Stably runs on its own infrastructure and which splices the two together. Credit where it's due: the traffic is end-to-end encrypted, so the relay sees only ciphertext. It's still their server in the path, though, and relay pairing needs an Orca sign-in; a LAN or Tailscale address is an optional fast path. Close the desktop app and a direct session drops until you reopen it. It's a sensible design for a companion, but it means the phone only works while Orca is running at home.

Moshi on your phone is a client in its own right. It speaks SSH and Mosh straight to your machine, the same connection a laptop would make, with no session relay in between. Mosh keeps the session alive through sleep and network changes. moshi-hook adds the agent layer on the host: the inbox, approvals, Live Activity and Apple Watch actions.

Chat View: who shipped it first

Both tools now turn a terminal agent into a chat you can read and reply to, so it's worth recording the timeline. Moshi's Chat View renders a live terminal agent session, running in tmux or Herdr, as a native chat, and hands back to the same terminal whenever you want it.

• June 11, 2026: the first Moshi Chat View code.
• June 14, 2026: moshi-hook v0.2.27 ships transcript streaming on Homebrew. Moshi iOS 3.6.0 follows in mid-June with "Chat View mode that turns your live TUI into a native chat interface".
• June 28–29, 2026: Orca merges its desktop "Native chat" (PR #6641) and releases it in v1.4.105, experimental and off by default.
• July 16–17, 2026: Orca merges its cross-surface chat (PR #5824) and announces the mobile Chat UI beta on TestFlight and as an APK.

So Moshi shipped chat over a live terminal session about two weeks before Orca's desktop version and about a month before its mobile one. Orca's implementation has come a long way since, and chat UIs for agents in general predate both.

The coverage differs more than the dates do. Orca integrates agents through managed hooks: it installs hooks into each agent's config (16 hook installers, plus plugins for OpenCode and Pi) to report status and approvals. Its chat is much narrower:

• Structured chat covers Claude and Codex only, through the Claude Agent SDK and the codex app-server. It runs locally only (SSH, WSL and remote hosts fall back to the terminal) and is off by default.
• Transcript-backed chat covers claude, openclaude, codex, grok and omp.
• Everything else, including Antigravity, Gemini, Cursor, Kimi, OpenCode and Pi, gets the terminal plus hook status. Mobile chat also lags the desktop (issue #22754).

Moshi's Chat View covers 17 agents today: Claude Code, Codex, OpenCode, Pi, OMP, OmO, Kimi, Grok, Hermes, Cursor, Antigravity, Copilot, Amp, Factory Droid, Qoder, Devin and jcode. Its hooks cover 19, adding Gemini and Qwen. And because it reads the session inside tmux or Herdr, it works the same on a local machine or a remote host over SSH. To be clear about the trade-offs: Chat View is still experimental and a Pro feature, with a few free trial uses.

Review, preview, paste

Both tools cover the loop after an agent finishes. Orca does it inside its own window: annotate diffs and send comments back, preview in its Chromium pane, drag files into the prompt, and stage and commit in full source control.

Moshi does it on top of your own host, from the phone or the desktop.

• Git. Moshi Desktop has Diff and History tabs with a commit graph and ref chips, and the sidebar shows each branch's ahead/behind status. It's for viewing: staging and committing stay in your terminal or the agent. On the phone, the diff viewer's Browse tab walks the whole repository at the working tree or any past commit.
• Comment on code. Hover a line in a diff or file on Moshi Desktop, press + (or drag to cover a range), and your note goes to the agent with your next message.
• Previews with an annotation mode. Browser preview tunnels detected dev-server ports over your SSH connection, and can open side by side with the terminal or chat. Its design mode lets you comment directly on page elements. Comments stay pinned with numbered markers as the page moves, and they include the source file and line when the framework's dev tools expose it (React/TanStack, Vue/Nuxt, Astro, Solid, or code-inspector-plugin).
• Paste. Image and file paste copies a screenshot, PDF or log to your host over SCP and hands the agent a path, just like Ctrl+V in Claude Code.

Native iOS depth

Orca's companion covers status, replies, a live terminal and source control well. Its dictation, though, is transcribed by the speech model configured on the paired desktop, not on the phone, and there's no Live Activity or Apple Watch support. Moshi goes further into the phone itself:

• Live Activity and Dynamic Island. The active turn sits on your lock screen.
• Apple Watch. Approve or deny from your wrist.
• On-device voice. Parakeet, Apple's SpeechAnalyzer or a local Whisper, running entirely on the phone, whether or not a desktop is awake.
• A keyboard built for the shell, with tmux and Herdr panels, a D-pad, and per-agent shortcut sets.

Open source, and the freedom to leave

Orca is open source and Moshi isn't, so it's fair to ask which one leaves you freer. The honest answer is a little counterintuitive.

Open source lets you read Orca's code, audit its end-to-end encryption and fork it. That's a real advantage. But your running agents still live in Orca's daemon and speak Orca's protocol, and forking the repository won't move a single running session to another tool.

Moshi's closed part is only the interface. Everything that holds your work is open and not ours: tmux, Herdr, OpenSSH and Mosh. Uninstall Moshi and every agent keeps running, one tmux attach away from any terminal you like. We cover why Moshi isn't open source, and why that still leaves you freer, in Moshi vs. ADEs.

Where Orca wins

Pick Orca when:

• Free and open source are non-negotiable. It's free top to bottom and MIT-licensed, including the end-to-end-encrypted relay.
• Parallel worktrees are how you work. Fanning one prompt out to five agents and merging the winner is Orca's home turf.
• You want one window for everything: editor, full source control, browser, GitHub and Linear, diffs and agents.
• You don't want to learn tmux, and you're happy for the app to manage sessions for you.
• You'd like a remote server without SSH setup, using Orca's paired-server flow over Tailscale.

Pricing

On price alone, Orca wins: everything is free, and you pay only for your agent subscriptions. Moshi Desktop is free for everyone, and the phone app's agent layer and Pro features are paid, with the option to buy once instead of subscribing.

The verdict

Orca is the best argument for the all-in-one ADE: generous, open and ambitious. Moshi is the argument for keeping the foundation yours and swapping the interface whenever something better comes along. For the wider field, including T3 Code, Paseo and the first-party Codex and Claude apps, read Moshi vs. ADEs.