Moshi vs Kittylitter

Kittylitter — "the kitty app for your AI agents," repo name litter — is one of the more interesting new entrants in this space, and it deserves an honest look. It's free, open source (GPLv3), native on both iOS and Android, and built around a smart idea: bring your own coding agent to your phone instead of routing your work through someone else's cloud. It's Codex-first, it can run Codex directly on your phone with no server at all, and it reaches your machines three different ways — local-network auto-discovery, SSH, or a peer-to-peer tunnel that punches through NATs and firewalls.

Moshi shares Kittylitter's core instinct — your agent, your machines, no hosted middleman — and then makes a different set of bets. Moshi is Claude-Code-first, it's a real terminal rather than an agent-only chat view, and it leans hard into native iOS depth: Live Activity, Apple Watch, a diff viewer, image paste, and a Mosh connection tuned for phones. One is a young, free, Codex-centric agent client; the other is a paid, more mature, terminal-grounded agent cockpit. Here's the split.

The rosters above tell the story. Kittylitter is Codex-first — Codex is stable and the one it can run on-device — while Claude Code, OpenCode, and Pi are still beta, with Factory Droid in the mix (the one agent here Moshi doesn't drive). Moshi is built Claude-Code-first and normalizes the broader set, all stable: those four plus Gemini, Cursor, Kimi, Qwen, Grok, and OMP. So the split is real — if Codex is your daily driver, Kittylitter's first-class, on-device support is a genuine draw; if you run Claude Code, Gemini, or Cursor, Moshi's the one with stable, tuned support.

The short version

The story: Kittylitter wins on free, open source, Codex-first, and on-device execution. Moshi wins on being a real terminal, Claude-Code depth, Mosh, native iOS surfaces, and maturity. Both refuse to put a hosted relay between you and your code.

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: Kittylitter runs the agent through its own engine — on the phone itself, or started for you over SSH — and renders the conversation; other clients wrap the CLI or speak ACP. Either way the live session lives in their process, not in a terminal you can reach any other way.

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're 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 continuity is hard to beat.

Kittylitter's genuinely good ideas

It's worth being specific about what Kittylitter gets right, because some of it is novel.

• It runs Codex on-device. This is the standout. Kittylitter bundles upstream Codex and can run it on the phone itself — no remote machine, no SSH, nothing. If you want an agent that works entirely offline-from-a-server, that's something Moshi doesn't do (Moshi always drives an agent on a remote host).
• It's free and open source (GPLv3). No subscription; the only in-app purchases are optional tips. The full Rust/Swift/Kotlin source is on GitHub.
• No hosted relay. Every connection is to a machine you own — your LAN, your server over SSH, or a peer-to-peer link. Nothing routes through a Kittylitter cloud.
• Three connection modes, including clever P2P. Local-network auto-discovery (zero config), SSH (it even starts the agent on the server for you), and alleycat — a peer-to-peer daemon, built on Iroh's QUIC transport, that connects "through NATs and corporate firewalls" with no VPN or port forwarding, via QR-code pairing and a single multiplexed stream.
• Cross-platform from one Rust core. Native iOS and Android (and an Apple Watch target in the build), sharing a Rust engine via UniFFI.

If "free, open, Codex-first, and runs on my own hardware" is your checklist, Kittylitter is a strong, principled choice — and you should try it.

Moshi is a terminal; Kittylitter is an agent client

The core architectural difference mirrors the one between Moshi and other agent-first apps: Kittylitter renders an agent conversation — reasoning, code blocks, diffs, images — beautifully, but it isn't a full terminal. There's no PTY, no arbitrary shell, no tmux, no Mosh, no SSH session you can type into freely. You drive the agent; you don't drop into a shell beside it.

Moshi runs the agent inside a real terminal built on Ghostty and GPU-rendered with Metal. When the agent stops and you want to tail a log, re-run a test, restart a service, or hop to another host, you're already at a prompt. That terminal foundation is also what makes Mosh and the multiplexer picker possible — durable sessions that survive network changes and keep the agent running while your phone sleeps.

Claude-Code-first vs. Codex-first

This is a real fork in the road. Kittylitter's polished, stable path is Codex; its Claude Code support is explicitly beta. Moshi is built Claude-Code-first — the inbox, Live Activity, and approval flow are tuned around Claude Code's permission prompts and turn lifecycle, and Codex and the others ride the same rails. If your agent of choice is Codex, Kittylitter's depth there is a point in its favour; if it's Claude Code, Moshi's polish is in its favour. Be honest with yourself about which one you actually run all day.

One feed for every agent and host

Kittylitter is Codex-first and renders a clean agent conversation. Moshi's inbox is built to be the place you watch several agents from at once: every approval, question, and finished turn lands as a card, grouped by host and by project, so the same agent on your Mac and a Linux box stay separate. Moshi normalizes events from a long roster — Claude Code, Codex, OpenCode, Gemini, Cursor, and more — into one feed, with a finished turn floating up, a pending approval pinned to the top, and stale items archiving themselves after a few hours. Both apps can run agents in parallel; Moshi's bet is that a single triage feed beats flipping between threads once you've got more than one going.

A dashboard for your agents

Beyond the inbox, Moshi surfaces the state of each agent — the numbers that usually live buried in the TUI, or nowhere on a phone at all:

• Usage rings. Each account's rate-limit windows as rings: Claude Code's 5-hour and 7-day windows, Codex's rolling windows, OpenCode's provider limits. Check for headroom before a long turn — in the app or on a Watch complication.
• Context "stamina." A ring per active agent showing how much context window is left, flagged below ~15% so you can ask it to compact before it forgets what it was doing.
• Recent directories. Reconnect to a host and Moshi offers one-tap entries for the directories where Claude or Codex recently ran, read from their transcripts — back into the repo with no path to type.

Native iOS depth

Both apps can notify you and take voice input. Moshi's advantage is how deep it reaches into iOS around the agent loop:

• Live Activity & Dynamic Island. The active turn lives on your lock screen — watch a long run without opening the app.
• Apple Watch. Approve or deny from your wrist. (Kittylitter has a watch target in its build, but its scope isn't documented; Moshi's watch actions are a shipping feature.)
• Image and file paste. Pick a screenshot, photo, PDF, or log and Moshi SCPs it to your host, handing the agent a real file path — like Ctrl+V in Claude Code. Kittylitter renders images the agent produces; inbound paste-into-the-agent from your camera roll isn't a documented feature.
• Diff viewer, repo browser & browser preview. A phone-tuned side-by-side diff; a Browse tab that walks the repo file tree at any commit and opens files as syntax-highlighted source — so you can read the whole project, not just the diff Kittylitter renders; and a one-tap in-app preview of a detected localhost dev server over your session.

Themes and fonts: count vs. reach

Credit Kittylitter here — it ships 70-plus terminal themes out of the box (Catppuccin, Dracula, Nord, Gruvbox, Solarized, and more), comfortably more than Moshi's palette. If sheer theme count is what you're after, that's a point for Kittylitter.

Moshi takes personalization in a different direction. Its nine themes recolor the entire app — inbox cards, sheets, system bars, not just the terminal pane — and the light themes remap the 256-color ramp so htop, btop, and Neovim status lines stay readable instead of washing out. On top of that, Moshi lets you import your own .ttf font, download bundled ones like Iosevka and DejaVu Sans Mono, toggle individual OpenType features (ligatures, a slashed zero), and swap the app icon. It's fewer presets, more reach: theme the whole surface and bring your own font, rather than pick from a long list of terminal-only palettes.

Three ways in — and Moshi's own set

Kittylitter's connection story is genuinely clever, and worth taking seriously: zero-config LAN auto-discovery, SSH (it'll even start the agent on the server for you), and alleycat — a peer-to-peer daemon built on Iroh/QUIC that punches through NATs and corporate firewalls with a QR pairing and no VPN or port forwarding. For reaching a machine behind a hostile network with zero setup, that built-in P2P is a real advantage Moshi doesn't match natively.

Moshi gets onto your machines a few ways of its own. It discovers SSH servers on your LAN over Bonjour, provisions a saved connection from a QR "easy pair" flow the host generates, and connects over SSH or Mosh — with Mosh roaming across network changes in a way a plain SSH or P2P link doesn't. For NAT traversal it leans on Tailscale: a tailnet host is just a normal target, and everything — terminal, the agent's push, the diff viewer — rides your mesh. The honest split: Kittylitter has slicker built-in P2P; Moshi has Mosh resilience plus a clean Tailscale story. Both refuse to put a hosted relay in the middle.

Voice, on-device and free

Both apps take voice, and Kittylitter's is realtime and free — a genuine plus. Moshi's voice runs on-device by default — your pick of NVIDIA's Parakeet, Apple's SpeechAnalyzer (iOS 26+), or a local Whisper (large-v3-turbo and smaller) — so a dictated prompt never leaves the phone, and it has two modes: a chat composer to edit a long prompt (and attach a screenshot) before sending, and a command mode that types straight into the shell. Neither is strictly better; Kittylitter leans into live conversation, Moshi into private, editable dictation that doubles as a way to fire raw commands.

Maturity and momentum

Honesty cuts both ways here. Kittylitter is new — the repo opened in February 2026 and the release line is still in the 0.x range — and moving fast, with a couple-thousand GitHub stars, a small but enthusiastic contributor circle, and beta-tier support for everything that isn't Codex. The alleycat P2P daemon is newer still and untagged, and the Android build is itself labeled beta. That pace is exciting, but it also means rougher edges and a shorter track record. Moshi is a more established, shipping product — 4.8★ across 750+ App Store ratings — with a settled feature set across the agent loop and a native Apple Watch app, not a watch target still in flight. If you like being early and don't mind in-progress features, Kittylitter's velocity is a plus; if you want something that's been load-bearing for a while, Moshi is the safer bet.

Where Kittylitter wins

Pick Kittylitter when:

• Free and open source are non-negotiable. GPLv3, no subscription, tips only.
• Codex is your daily driver and you want the most direct Codex experience.
• You want an agent that runs on the phone itself — Kittylitter's on-device Codex is genuinely novel and Moshi has no equivalent.
• You want built-in peer-to-peer connectivity through firewalls without setting up Tailscale or port forwarding.
• You're happy on the bleeding edge of a fast-moving young project.

Pricing

Kittylitter is free — the only in-app purchases are optional tips (roughly $9.99 to $99.99), and even its voice is included at no charge. Moshi has a free tier with paid Pro features and a one-time license. If cost is the deciding factor, Kittylitter wins it outright; Moshi's pitch is the terminal, the Claude-Code depth, the native surfaces, the usage and context dashboard, and a settled product worth paying for.

The verdict

Kittylitter and Moshi agree on the important thing — your agent runs on your hardware, not a vendor's cloud — and then optimize for different users. Kittylitter is the free, open, Codex-first option that even runs on-device. Moshi is the paid, terminal-grounded, Claude-Code-first cockpit with the deeper iOS integration. If you're comparing the whole field, see Moshi vs Happy for the other open-source agent client, Moshi vs Secure ShellFish for the file-and-SSH client that grew agent features, and the iOS terminal roundup for the general-purpose terminals. The short version: if Codex on-device and free, open P2P are what you want, Kittylitter is a smart, principled pick; if you want a real terminal, Claude-Code depth, and a dashboard for everything your agents are doing, that's Moshi.