Moshi vs Happy

Of everything Moshi gets compared to, Happy is the closest. It targets the exact same itch — I want to check on the agent building my side project while I'm away from my desk — and it's very good at it. It's free, it's open source (MIT, 21k+ GitHub stars), it's end-to-end encrypted, and it ships push notifications and remote approvals out of the box. If you've been looking for a way to babysit Claude Code from your phone without paying anything, Happy is a genuinely great answer, and this page will not pretend otherwise.

But Happy and Moshi are built on two different bets, and the differences are real. Happy is agent-only and relay-based: you run a small CLI on your computer (happy instead of claude), it encrypts the agent session and relays it through Happy's server to a chat-style app on your phone. Moshi is a real terminal with a direct connection: it speaks SSH and Mosh straight to your own machine, the agent layer rides on top, and nothing routes through a third party.

Neither bet is strictly better. They optimize for different things, and the right call depends on what you value — price and openness, or a full terminal and a direct line to your box. Let's go through it honestly.

The rosters tell the story above. Happy covers Claude Code, Codex, and Gemini; Moshi covers those three plus OpenCode, Cursor, and a long tail — Kimi, Qwen, Grok, Pi, OMP. If your daily driver is Claude Code, Codex, or Gemini, both have you covered, and the roster only matters once you reach off the main path. The bigger difference is how each gets you there: a relayed chat session, or a direct terminal with the agent running inside it. This is the rare comparison where the competitor and Moshi share the same core mission — neither is trying to be a general-purpose SSH client first.

The short version

Read the table as two clusters. The terminal and direct-connection rows favour Moshi. The free and open-source rows favour Happy. Almost everything else — push, approvals, diffs, Android — both do well.

One session, desk to phone

This is the difference that's easy to miss on a feature table but changes how the tool feels day to day. Most phone agent clients own the session inside the app: Happy wraps the CLI — you run happy instead of claude, and that companion process holds the session and relays it; other clients bundle the agent or speak ACP. Either way the live session lives in their process, so continuity means handing it between their clients. Happy's desktop↔phone handoff is genuinely slick, but it's continuity within Happy.

Moshi rides the terminal's own continuity instead. The agent runs in a multiplexer on your host — tmux, Zellij, or the agent-aware Herdr — so it's just a normal attached session on your machine. Start claude in tmux at your desk, walk away, and reattach from Moshi on your phone: the same session, the same scrollback, the same running turn. Come back to the Mac, tmux attach, and you land exactly where the phone left off — nothing re-synced, no handoff, one session several clients can hold at once. For carrying a long agent run from desk to pocket and back, that seamless continuity is hard to beat.

Happy's real strengths

Let's start here, because they're the reason Happy is worth comparing to at all.

• It's free and open source (MIT). No subscription, no account, no credit card. You can read the code, fork it, and you're not exposed to a future rug-pull. For a tool that sits between you and your code, that's a serious, principled advantage.
• It's end-to-end encrypted. Your phone and computer share a key via the QR code you scan at pairing; the relay only ever moves encrypted blobs and stores a hash of your public key. Done well, and Happy does it well.
• You can self-host the relay. Point the CLI and app at your own server (HAPPY_SERVER_URL) and the hosted middleman disappears entirely. Few tools in this space let you do that.
• Setup is trivial. npm install -g happy, run happy, scan a QR code. No SSH keys, no host config, no firewall ports. For a lot of people that's the entire reason they picked it.
• It runs everywhere. Native iOS, native Android, and a real web app from one codebase. Moshi has no web app.
• It's mature and busy. 20k+ GitHub stars, dozens of contributors, near-weekly releases, and a steady stream of features — parallel sessions, Git Worktrees, desktop↔phone handoff, offline session history. For a young category, that's a lot of momentum behind a free tool.

If those five points are what you're optimizing for, you can stop reading — Happy is an excellent choice and you should use it. The rest of this page is for people weighing them against what a native terminal gives you.

Moshi is a terminal; Happy is not

This is the biggest architectural difference, and Happy is upfront about it: Happy is not a terminal. It's a purpose-built chat-style interface for the coding agents it supports. That focus is a feature — it's clean and uncluttered — but it means there are things you simply cannot do in Happy:

• Run an arbitrary command — tail -f a log, restart a service, run a one-off psql query, kick a build by hand.
• Drop into vim, htop, lazygit, or any other interactive TUI.
• SSH somewhere else, or hop to a second host.
• Do anything that isn't the agent.

In Moshi, the agent runs inside a real shell, built on Ghostty and GPU-rendered. When the agent finishes and you want to poke around — check the logs it generated, run the test it skipped, inspect a process, git log the branch it made — you're already in a terminal. With Happy, you'd reach for a separate SSH app. Whether that matters depends entirely on whether "drive the agent" is all you do on your phone, or just most of it.

That terminal foundation is also what makes the session durable. The agent runs inside a multiplexer — Moshi has pickers and shortcut panels for tmux, Zellij, and the agent-aware Herdr — so it keeps working while your phone sleeps, and you reattach to the exact pane it's blocked on. Happy gets durability a different way: its CLI holds the session and the relay stores the history, so a phone that lost signal catches up when it returns. Both survive a dropped connection; one does it with a real multiplexer you can also drive by hand, the other with a companion process and a relay.

One feed, every agent and host

Happy's chat model is one conversation per session, which is clean. The flip side is that "what are all my agents doing right now" means flipping between threads. Moshi's inbox collapses everything into one feed, grouped by host and by project — the same agent on your Mac and a Linux box stay separate, and Moshi normalizes events from a long roster (Claude Code, Codex, OpenCode, Gemini, Cursor, and more) into the same rows. A finished turn floats up, a pending approval pins to the top, and stale items archive themselves after a few hours so the list stays "now," not "history." Both apps run multiple agents at once; Moshi's bet is that a triage feed beats a stack of chats once you're juggling more than one.

Review beyond the diff

Both apps show you the diff — Happy renders Codex patches as full inline diffs, and that's genuinely good. Moshi's review surface goes one step further: the same diff app has a Browse tab that walks the entire repo file tree at the working tree or any past commit, opening any file as syntax-highlighted source (TypeScript/JavaScript, Go, Swift, JSON, YAML, Markdown, shell, and more). So when the agent references a file it didn't touch, or you want to read the function it just called, you're not boxed in by the patch — you can browse the whole project, all over the host gateway tunneled through your own SSH session. See the diff viewer.

Direct connection vs. a relay

The other architectural fork is how your session reaches your phone.

Happy runs a CLI on your computer that wraps the agent, encrypts its output, and ships it through Happy's relay (hosted at their server by default, or your own if you self-host). The relay also stores your encrypted history so a phone that lost signal can catch up. It's encrypted end-to-end, so the operator can't read it — but by default there is a third party in the path, and your session needs that happy process running on your machine the whole time.

Moshi connects the other way around. It speaks SSH and Mosh directly to your machine — the same connection you'd make from a laptop. There's no relay storing your session, encrypted or otherwise; the data path is your phone to your host. The agent's approval and turn events ride a small host daemon (moshi-hook) that pushes through Apple's notification service, but the terminal session itself is a direct line. If "my code and my session never touch someone else's server" is a hard requirement, that's the difference.

Mosh also buys Moshi resilience that a relay doesn't need to solve the same way: switch networks or sleep your phone, and Mosh catches the session up when you return — no persistent socket draining your battery in the background.

The direct-line idea runs deeper than the terminal, too. Moshi's diff viewer and browser preview ride a gateway that moshi-hook serves locally on your host and tunnels through your existing SSH session — so the diff contents and your dev-server traffic stay phone-to-host and never pass through Moshi's infrastructure. The one thing that does cross Moshi's servers is the push notification: when an agent needs you, moshi-hook sends an alert through Apple's notification service so your phone can wake. That's a much smaller surface than relaying the whole encrypted session — though it's worth being fair that Happy's relay is end-to-end encrypted and self-hostable, which is its own strong answer to the same privacy question.

Image paste, straight into the prompt

On a desktop you screenshot a bug and drag it into Claude Code. Moshi makes that one tap on a phone: pick a photo, screenshot, PDF, or log, and Moshi copies it to your host over SCP into ~/.moshi/uploads/, then hands the agent a local path — exactly like pressing Ctrl+V in Claude Code or Codex. See Image and file paste. It works for arbitrary files too — PDFs, logs, configs — and the transfer is SCP to your own machine. This is one place Moshi's terminal foundation pays off directly: there's a real file path on a real host to hand the agent.

A keyboard for the moment you drop to the shell

Because Happy is a chat interface, there's no on-screen terminal keyboard to speak of — you type into a prompt box, and the moment you want to do something on the machine you switch apps. In Moshi the shell is right there, and so is a keyboard toolbar built for it: a D-pad whose corners you can set to Interrupt (clear the line, cancel a runaway turn) or a dedicated Backspace for the agent TUIs that eat the normal one; a shortcut builder that binds any sequence — a tmux prefix chord, Ctrl+R, Esc :wq, a prompt fragment you send constantly — to a slot or a gesture; and per-agent shortcut sets for Claude Code, Codex, Cursor, and OpenCode. It's the difference between an app that talks to the agent and an app you can also run the box from.

Native iOS depth

Both apps push you when an agent needs input or finishes, and both let you approve remotely — that's the core loop, and Happy nails it. Where Moshi goes deeper is in the native iOS surfaces around that loop:

• Live Activity & Dynamic Island. The active turn lives on your lock screen and in the Dynamic Island — glance at a long run without opening anything.
• Apple Watch. Approve or deny from your wrist.
• On-device voice. Dictate prompts with a model that runs entirely on your phone — your pick of NVIDIA's Parakeet, Apple's SpeechAnalyzer (iOS 26+), or a local Whisper (large-v3-turbo and smaller) — included, with a chat mode to edit a long prompt and a command mode that types into the shell. Happy's voice is genuinely nicer in one respect — it's realtime conversational (you talk back and forth with the agent) — but it's hosted on ElevenLabs: free for about an hour, then a subscription. And as of early 2026 you can't point it at your own ElevenLabs account; the agent IDs are wired to Happy's, so there's no bring-your-own-key escape hatch. Moshi's trade is the opposite: no live back-and-forth, but recognition that's free and never leaves the device.

Happy answers some of this in its own way — a diff sidebar with full inline patches, markdown tables, multiple parallel sessions, Git Worktrees, instant desktop↔phone handoff with a single keypress, and offline access to past sessions even when the desktop terminal is off. It's a genuinely polished app with a big, active community behind it. The honest summary is that Happy covers the agent-conversation surface very well, and Moshi covers the whole-device surface — terminal, diffs, browser preview, watch, Live Activity, usage — because it's a native terminal first.

A dashboard for your agents

Push and approvals are the loop both apps nail. The layer above it — the state of every agent you're running — is where Moshi reaches for things Happy's chat-style app doesn't surface:

• Usage rings. Moshi reads each account's rate-limit windows off the host and draws them as rings: Claude Code's 5-hour and 7-day windows, Codex's rolling windows, OpenCode's provider limits. You can see whether you have headroom before kicking off another long turn — in the app or on a Watch complication.
• Context "stamina." A ring per active agent showing how much of its context window is left, flagged below ~15% so you can ask it to compact before it loses the thread.
• Recent directories. Reconnect to a host and Moshi offers one-tap entries for the directories where Claude or Codex recently ran, read from the agents' transcripts — straight back into the repo, no path to type.

Phone-native, terminal-first

Both apps are native and both notify you, so this is about the surfaces unique to running a terminal on a phone. Moshi treats each session as a card in an app-switcher with a live preview thumbnail; minimize one to the home view and it restores with the buffer intact. Face ID gates your saved keys and, optionally, resuming the app — and while that check is pending the live previews stay blurred, so your terminal isn't on screen for a shoulder-surfer. Pick one of nine themes and the whole UI recolors, not just the terminal pane, with light modes tuned so htop and Neovim status lines stay legible. None of this is a knock on Happy; it's the cost of being a chat client rather than a terminal — there's no terminal buffer to preview, theme, or protect in the first place.

Where Happy wins

To keep this balanced, here's the clear list. Pick Happy when:

• Free and open source are non-negotiable. This is the headline. Moshi has a free tier but is a paid, closed product; Happy is free top to bottom and MIT-licensed.
• You want zero SSH setup. QR-pair and go. No keys, no host config, no ports.
• You want a self-hostable relay so even the encrypted middleman is yours.
• You want a web app alongside mobile. Moshi is iOS and Android only.
• You want realtime, conversational voice. Happy's hosted ElevenLabs voice lets you talk back and forth with the agent hands-free; Moshi's on-device dictation is one-way (you speak, it types).
• You want a big, fast-moving open-source community. 20k+ GitHub stars, weekly releases, and features like Git Worktrees, parallel sessions, and offline access to past sessions when the desktop is off.
• The agent is genuinely all you do on your phone, and a chat-style view is exactly enough.

Pricing

The blunt truth: Happy is free and Moshi is not. Moshi has a free tier, but the agent layer and Pro features are paid. What Moshi offers in return is a native terminal, a direct connection, and a one-time license option.

A couple of honest notes:

• Happy's core is genuinely $0 — app, CLI, and self-hosted relay. You still pay Anthropic or OpenAI for the agent itself, but that's not Happy's charge. Its only paid feature is hosted, realtime voice (ElevenLabs): free for about an hour, then the "Plus Plus" subscription shown on iOS around $19.99/month. There's currently no bring-your-own-ElevenLabs-key option, so if you want voice past the free hour, that's the price.
• Moshi charges for the agent layer and uniquely lets you buy it once for $249 instead of subscribing.

If price is the deciding factor, Happy wins it outright. Moshi's pitch is that the terminal, the direct connection, and the native depth are worth paying for — and at 4.8★ across 750+ App Store ratings, buyers tend to agree.

The verdict

These two are the friendliest rivalry in this whole space — they're chasing the same workflow from opposite directions. If you want the cheapest, most open path to driving an agent from your phone, Happy is excellent and you should try it. If you want that same loop wrapped in a real native terminal with a direct line to your own machine, that's Moshi. If you're weighing the other open-source agent clients, Moshi vs Kittylitter covers the Codex-first, on-device option, and Moshi vs Secure ShellFish covers the file-and-SSH client that grew agent features. For the wider field, the iOS terminal roundup and Moshi vs Termius cover the general-purpose SSH clients too.