Grass vs SSH Apps: Which Should You Use to Access Coding Agents from Your Phone?

The Tailscale + SSH + tmux stack is the most-recommended DIY approach in r/ClaudeCode and r/ClaudeAI threads for accessing Claude Code from a phone. It works — seasoned developers with 73 upvotes attest to it. But "works" conceals a setup cost of roughly 20 minutes on Linux (longer on macOS, which requires PAM configuration edits that "can mess up things if not done correctly"), three recurring failure modes that no tutorial mentions, and a terminal UX that most developers describe as fighting the interface more than using it. This article compares the DIY stack — both tmux and its replacement Zellij — against purpose-built mobile agent interfaces so you can pick the right architecture for your workflow.

TL;DR

Use Tailscale + SSH + tmux if: you want maximum terminal control, already have Tailscale running, and are comfortable managing SSH sessions and tmux keybindings from a phone keyboard.

Use a purpose-built interface (Grass, Happy Coder) if: you want native mobile UX for agent approvals, diff review, and session reconnection — or if your laptop sleeping is a real constraint.

The fundamental split is architectural: SSH-based approaches are laptop-tethered. Cloud VM approaches are laptop-independent. No amount of tuning changes which category you're in.

Why Developers Reach for Tailscale + SSH + tmux

The DIY stack's appeal is real. Tailscale handles the VPN mesh, so there are no port-forwarding rules or dynamic DNS to maintain. SSH gives you a raw terminal with full Claude Code access. tmux (or Zellij) keeps the session alive when you disconnect. One Reddit thread puts it plainly: "A much better combination is tailscale + tmux + termius...start a session in mac...continue on the go...get back to mac and continue again...same session" — 73 upvotes in r/ClaudeAI.

Another voice from r/ClaudeCode: "I've tried what most of you suggested - tmux, termius and ssh via tailscale, and it's incredibly easy to set up. I would suggest this path to anyone."

This consensus formed in 2025, before purpose-built mobile agent interfaces were mature. The recommendation is still technically valid — but it's worth pricing in the full cost.

What the Setup Actually Costs

The most detailed DIY guide (esc.sh, Aug 2025, linked from r/ClaudeCode) documents 8 discrete steps. On Linux this takes roughly 20 minutes if everything goes smoothly. On macOS, one step requires editing PAM configuration files to enable SSH access — a step the guide flags as something that "can mess up things if not done properly." SSH access should also be restricted to the Tailscale network interface to avoid exposing it on the public internet.

Beyond the one-time setup, the ongoing maintenance tail includes:

• Tailscale account management across devices
• SSH key rotation when you add a new phone or machine
• tmux session lifecycle: starting sessions before you leave your desk, reattaching after drops
• macOS firewall and PAM reconfiguration after OS updates

Tutorials treat setup as one-time. The real cost compounds with each device change, OS update, and session failure.

The Three Failure Modes That Don't Make It Into Tutorials

1. SSH drops when your phone sleeps or switches from WiFi to cellular

SSH is a stateful TCP connection. When your phone sleeps or hops networks, the connection drops. The session survives in tmux, but you get a disconnected terminal. Mosh (Mobile Shell) can add connection resilience, but it's another layer to install, configure, and troubleshoot. From one community post: "SSH drops the moment your phone sleeps or hops from WiFi to cellular. Mosh can help with connection resilience, but it adds another layer to configure."

2. Idle SSH hangs that require manual reconnection

"Now problem is SSH with terminal is so bad after some idle it hangs" — this quote from a Reddit thread captures something the tutorials skip. Idle SSH connections frequently freeze rather than drop cleanly, requiring you to kill the terminal app, reopen it, and reattach to tmux. On a phone, this sequence is significantly more painful than on a desktop.

3. Terminal keyboard UX: Ctrl+B, tiny text, no touch-friendly navigation

"Existing SSH apps on Android are full terminal emulators, which means squinting at tiny text and fighting with touch input. I didn't need a full terminal — I needed a way to quickly navigate my tmux sessions and see what's going on." That's from the developer who built MuxPod after hitting these limits, writing in r/ClaudeAI.

tmux's Ctrl+B prefix key is awkward on a touch keyboard. Pane navigation requires key chords that phone keyboards handle inconsistently. Text is small. There is no native diff viewer, no permission approval modal, no haptic feedback.

Is Zellij a Real Improvement Over tmux?

Zellij is emerging as the preferred tmux replacement for mobile Claude Code access. Multiple community threads recommend it as "much more user friendly than tmux" with native session attach and a less arcane keybinding model. From r/ClaudeAI: "Or try zellij! Much more user friendly than tmux, but still supports tmux bindings."

What Zellij actually fixes: The key bindings are more discoverable. Session attach works without the tmux a -t ceremony. The UI is friendlier for developers who don't live in tmux daily.

What Zellij does not fix: It uses the identical Tailscale + SSH transport. All three failure modes above are unchanged — dropped connections on phone sleep, idle hangs, and small-screen keyboard friction. Switching from tmux to Zellij solves a layer-7 ergonomics problem while leaving the layer-4 transport problems intact.

One additional failure mode that appears in neither tmux nor Zellij documentation: shared terminal sessions force your desktop and phone to show the same viewport. If you want to monitor agent progress on your phone while your desktop shows a different context, you need extra window configuration that most developers don't set up.

How Claude Code Remote Control Compares

Claude Code Remote Control (launched February 2026, Max-only at $100–200/month) was positioned as the official answer to mobile agent access. In practice, it has documented reliability failures:

• Drops connection randomly with no warning
• Creates a new URL on every reconnect, which kicks mobile users to a different session view
• Cannot start sessions from mobile — only continue ones kicked off from the desktop
• Single-session limitation

From a Reddit thread on r/ClaudeCode: "Drops connection randomly with no warning. Creates a new URL on every reconnect (kicks mobile to a different session view). Sometimes shows 'active' in terminal but session doesn't appear in the app. Yesterday it held for hours. Today it can't survive 10 minutes. Same machine, fresh session."

Remote Control is laptop-tethered by design and adds the constraints of a Max subscription on top. Multiple GitHub issues have been filed against these behaviors (issues 29219, 28571, 29855, 30691).

Options Side-by-Side

What the DIY Stack Gives You That Purpose-Built Tools Don't

This comparison should be honest. The DIY stack has real advantages:

Full terminal access. If you need to run arbitrary commands, check logs, or use tools that aren't wired into a purpose-built UI, SSH gives you everything.

No third-party agent infrastructure. Your agent traffic flows from your phone to your machine via Tailscale's relay. Nothing touches an intermediary server. For developers sensitive about what leaves their network, this matters.

Flexibility. You can run any agent, any tool, any workflow. The terminal doesn't constrain what you can do.

Zero recurring cost. Tailscale's free tier covers personal use. SSH and tmux are free. If you already have Tailscale for other reasons, the marginal cost of adding Claude Code access is zero.

The honest framing: "For most developers this is the fallback, not the first choice — SSH into your server via Termius or similar, run Claude Code in a tmux session. Maximum control, maximum friction on a phone keyboard."

What Purpose-Built Interfaces Give You That SSH Cannot

Some things the DIY stack fundamentally cannot replicate without significant custom tooling:

Native permission forwarding. When Claude Code needs to run a bash command or write a file, a purpose-built app surfaces that as a native modal with approve/deny buttons and haptic feedback. Over SSH, you watch the terminal pause and type your response. For a deeper look at this pattern, see How to Build Human-in-the-Loop Approval Gates for AI Coding Agents.

Diff review with syntax highlighting. After an agent session, reviewing what changed via git diff in a terminal on a 6-inch screen is painful. A purpose-built diff viewer renders file-by-file diffs with color coding and file status badges.

Session management without terminal commands. Browsing past sessions, resuming a prior conversation, or switching between repos doesn't require tmux window management.

Laptop independence. This is the architectural divide. Grass runs agents on an always-on cloud VM powered by Daytona — the agent keeps running when your laptop sleeps, closes, or is off entirely. No SSH-based approach can replicate this because the agent process lives on your laptop. As one Grass maker put it on Product Hunt: "The VM doesn't care if your phone is in your pocket or charging on your nightstand. Your agent keeps shipping."

For a broader comparison of all mobile agent interfaces, see The Best Apps to Control Coding Agents from Mobile (2026).

The Micro-Ecosystem That Spawned Because the DIY Stack's UX Is Painful

The fact that multiple tools have been built specifically to work around DIY stack friction is itself evidence of the problem:

• MuxPod (Android) — a mobile-first tmux client via SSH, built because the builder needed "a way to quickly navigate tmux sessions without squinting at tiny text"
• PocketMux — WebRTC P2P connection that eliminates the DDNS/VPN/SSH stack entirely
• claude-mux — a bash wrapper adding RC compatibility and slash command workarounds
• Tactic Remote — an npx companion for Claude Code, Codex, and Amp

Each addresses a specific pain point in the DIY stack. Their existence reflects the gap between "works" and "is a good mobile UX."

When to Use Each Approach

Use Tailscale + SSH + tmux when:

• You want full terminal control and are comfortable with the UX tradeoffs
• You already have Tailscale set up for other reasons
• You only need mobile access occasionally, not as a primary workflow
• Your laptop reliably stays on while agents run

Switch to Zellij when:

• You're already using tmux and find the keybindings painful on mobile
• Session attach friction is slowing you down
• You don't need to solve the underlying connection failure modes

Use Claude Code Remote Control when:

• You're on Claude Max already and want a zero-setup option
• You accept the reliability issues and single-session limit

Use Grass when:

• You want native mobile UX for approvals, diffs, and session management
• Laptop independence matters — you want agents to keep running overnight
• You run multiple agents (Claude Code, Codex, OpenCode) and want one interface
• You're starting from scratch and don't already have a Tailscale + SSH setup

FAQ

Is Tailscale + SSH + tmux the best way to access Claude Code from a phone?

It's the most-recommended DIY approach in r/ClaudeCode and r/ClaudeAI threads, and it works reliably for developers comfortable with terminal UX on a phone keyboard. Whether it's "best" depends on what you're optimizing for. Full terminal access and maximum control: yes. Native mobile UX with permission modals, diff review, and laptop independence: purpose-built tools are better suited.

What is the main difference between tmux and Zellij for Claude Code mobile access?

Both tmux and Zellij keep your Claude Code session alive after disconnecting. Zellij has more discoverable keybindings and a friendlier interface for developers who aren't tmux power users. But both use the same Tailscale + SSH transport, so both share the same failure modes: sessions drop when your phone sleeps, idle connections hang, and mobile keyboard UX is constrained by the terminal paradigm.

Does the Tailscale + SSH + tmux stack work on macOS?

Yes, but macOS requires an additional PAM configuration step that Linux doesn't. The most detailed community guide flags this as a step that "can mess up things if not done properly" and recommends restricting SSH access to the Tailscale network interface. Plan for 30+ minutes on macOS versus ~20 minutes on Linux.

Can I start a new Claude Code session from my phone using SSH?

Not without using a terminal to manually run the tmux and Claude Code commands. You can reattach to an existing session you started on your desktop, but launching a fresh session requires typing commands on a phone keyboard. Purpose-built interfaces let you pick a repo, pick an agent, and start a new session entirely from the phone UI.

What does Grass do differently from the Tailscale + SSH + tmux approach?

Grass runs agents on an always-on cloud VM (powered by Daytona) rather than your laptop. Your laptop can sleep or be off entirely — the agent keeps running. The mobile app surfaces permission requests as native modals, shows git diffs with syntax highlighting, and lets you start new sessions from your phone. Grass uses BYOK — your API key never touches Grass infrastructure.

Verdict

The Tailscale + SSH + tmux stack is a legitimate approach that earns its community recommendations. It's free, gives you full terminal access, and keeps your API key entirely on your own infrastructure. If you already have Tailscale for other purposes and are comfortable with terminal UX on a phone keyboard, it's a reasonable choice.

The costs are real too: ~20 minutes of setup (more on macOS), three recurring failure modes that tutorials skip, and a mobile UX that's fundamentally constrained by what a raw terminal can offer on a 6-inch screen. Switching from tmux to Zellij improves keybinding ergonomics but doesn't change the underlying transport or failure modes.

Purpose-built mobile agent interfaces exist precisely because the terminal paradigm doesn't map well to phone-native interaction patterns. Native permission modals, diff viewers, and session management without tmux commands are things SSH cannot provide without significant custom tooling — which is exactly why the DIY micro-ecosystem (MuxPod, PocketMux, claude-mux) exists.

Pick the architecture that matches your actual constraints, not just the one that has the most upvotes in last year's Reddit threads.