Claude Code, from your phone. A native remote for Claude Code, Codex, Hermes and any ACP agent, Oh My Pi and opencode running on your own machines: a universal iPhone and iPad app with the turn on your Lock Screen, and open-source desktop clients for Linux and the Mac. Point-to-point over your own Tailscale tailnet: no relay, no sign-in, no SSH session or tmux to keep alive. The transport's security is Tailscale's WireGuard, not something Tailscode implements. Screenshots, the full feature tour and pricing live at midgarcorp.cc/tailscode.
iPhone, iPad & Mac — App Store · Linux — AUR · Linux — tarball · midgarcorp.cc/tailscode · GPL-3.0
Free is the whole core with one server; Pro is a one-time $14.99 purchase for unlimited servers, concurrent Live Activities and the delegate board.
-
On the machine where you code, install a server. For Claude Code, one command, no Swift or git needed; it ends with a QR code:
curl -fsSL https://raw.githubusercontent.com/guitaripod/claude-bridge/master/install.sh | bash(
brew install guitaripod/tap/claude-bridgeworks too. For opencode or Oh My Pi see Requirements.) -
Install Tailscale on that machine and on your phone or computer, signed in to the same account.
-
Open Tailscode and scan the QR code, open the link, or pick the machine it discovers. It checks each step and tells you what is left; "Try the demo" shows every screen with no server at all.
- Hermes and any ACP agent — Hermes, Gemini CLI, Codex, goose, Kimi, Qwen Code, Copilot and the rest of the ACP registry run through the claude-bridge already on your machine: it finds them, proves each with a real session, gives one with no model a brain from the model server the machine already runs (llama-swap, ollama, LM Studio, vLLM) in one tap, keeps keys on the machine, and puts them in the model pill beside Claude.
- The machine keeps the clock — ask later or every morning (
weekdays 7:30,every 2 hours); the bridge asks with every app closed, keeps one conversation that remembers, stays quiet when nothing changed, and says what it missed while the machine was off. - Every turn, live — thinking, tool calls, subagents in place, diffs in the code's own colours, pictures the agent looked at. Prose is written out at an even pace, never re-wrapping under you.
- A long chat keeps its history — the server opens a chapter where the topic moved and writes one sentence on what each closed chapter came to; a heading sits above the message a chapter began at, a panel lists them all to jump from, and a chat from before chapters is split once the first time it is opened.
- Speak instead of typing — dictation in every composer on iPhone, iPad, Mac and Linux (Apple platforms need iOS 26 or macOS 26): tap the mic to go hands-free or hold to talk, slide to cancel or onto Send, and the engine runs on your own device, so nothing you say leaves it.
- Steer without leaving the chat — allow once / always / deny cards, the agent's questions as a real form, follow-ups queued on the server while it works, stop server-side.
- Every machine, one list — sessions across all your servers grouped by machine with live status, search inside transcripts, a tailnet radar, and an agents board (Now, Peek, Hour) that becomes a wall on a monitor left on; restart one server or all of them from their cards.
- Models and money — one chooser over every provider, a party of six models one tap away, carry a conversation to another model, per-prompt effort, session spend, the month's analytics across machines, per-provider quotas.
- Compaction is a seam you can read;
/designopens a mock-up board; slash commands complete from the server's own catalog; the repo is read (branch, drift, diffs), never operated. - Delegate — hand a packet down a ladder of cheaper models on the server (from the board or straight from a chat with
/delegate) and get a verified patch back, held for you to read and apply. - Image and video — describe a clip or paint from a reference on a tailnet machine running ComfyUI (Linux and iPhone paint; the Mac renders video only).
- iPhone — Lock Screen and Dynamic Island Live Activities pushed by claude-bridge, a turn that ends while the app is closed still says so (the phone holds a wait on the server over the tailnet, no relay), each device choosing what it hears (finished work once it settles, every turn, failures only or never, with a minimum length and muted chats), quota widgets and Control Center tiles, a home board, quick ask from the icon, haptics with meaning, on-device prompt enhance.
- iPad — a sidebar of places, servers and pinned chats beside the chat list and the conversation, folding into the phone's single stack whenever the window narrows and back without closing anything; drag a chat out for a window of its own.
- Desktops — tiling splits with vim-grade verbs, a terminal, file tree, browser and video panes, a global chord that summons quick ask from any program, vim in the composer. Quick ask runs your own actions (templates with
{clipboard},{link},{session},{screen},{file},{latest:~/Downloads}tokens, each on its own machine and model, kept inquick-actions.json), knows a copied link by its site, grabs a region of the screen, sends files on the same machine by path, and asks the whole party at once side by side. - Eight themes with two faces each, one typography ramp, ten languages, Liquid Glass where the platform draws it.
- iPhone and iPad iOS 18+ (Liquid Glass and prompt enhance need iOS 26). macOS 26+. Linux GTK 4.12+ and libadwaita 1.4+ (Ubuntu 24.04, Debian 13, Fedora 40, Arch; not Ubuntu 22.04 or Debian 12); VTE, mpv, WebKitGTK and libpulse add the terminal, video and browser panes and the voice call's audio.
- Tailscale on this device and on the machine the agent runs on.
- A machine on that tailnet running one of:
-
opencode serve(port 4096), opencode 1.18 or 2 — the app asks the server which API it speaks. One command sets it up as a service, gives it the password opencode 2 insists on, and keeps its model list current:curl -fsSL https://raw.githubusercontent.com/guitaripod/Tailscode/master/scripts/opencode-serve-install.sh | bash -
claude-bridge in front of Claude Code (port 4098) — also what makes Live Activity pushes possible. From 1.17 it also hosts Hermes and any ACP agent, and keeps schedules.
-
omp-bridge in front of Oh My Pi (port 4099).
-
- Optional: ComfyUI (port 8188) on the tailnet for image and video generation.
iPhone and Mac — App Store; one purchase covers both. The Mac can also be built ad-hoc, unsandboxed: scripts/install-macapp.sh replaces /Applications/Tailscode.app.
Arch — tailscode builds the latest release tag; tailscode-git tracks master.
paru -S tailscodeOther Linux — the release tarball: one static-stdlib x86_64 binary plus desktop entry, icons, man page and completions, built in CI on ubuntu-24.04 (needs nothing newer than GLIBC_2.39).
tar xf tailscode-*-linux-x86_64.tar.gz -C ~/.local --strip-components=2The app watches the release feed and lights an update mark in its own chrome, then hands you the command for the way it was installed. A Flatpak manifest lives in packaging/flatpak/ but is not on Flathub. On a Steam Deck use Desktop Mode with a keyboard; install Tailscale with the deck script first.
First run is a checklist the app verifies: Tailscale on this device, your machine (scan its QR code, open its link, or pick one it found on the tailnet), connected. Nothing to type.
iOS — xcodegen generate, then the Tailscode scheme in Xcode with your own DEVELOPMENT_TEAM. --demo (or "Try the demo" on first run) populates scripted servers with no tailnet; DEBUG builds auto-connect from TAILSCODE_HOST / TAILSCODE_PASSWORD.
macOS — scripts/install-macapp.sh. Design contract in TailscodeMac/AGENTS.md.
Linux — Swift 6.4, then:
sudo pacman -S --needed gtk4 libadwaita glib2 gdk-pixbuf2 libepoxy vte4 mpv webkitgtk-6.0 libpulse curl # Arch
sudo apt install libgtk-4-dev libadwaita-1-dev libgdk-pixbuf-2.0-dev libepoxy-dev \
libvte-2.91-gtk4-dev libmpv-dev libwebkitgtk-6.0-dev libpulse-dev # Debian, Ubuntu
TAILSCODE_KIT_REMOTE=1 scripts/package-linux.sh build # static-stdlib binary
TAILSCODE_KIT_REMOTE=1 scripts/package-linux.sh tarball # release artifact
tailscode --selftest # headless end-to-end checkThe manifests use CodingAgentKit from a sibling checkout when there is one and from its published tag otherwise. scripts/parity.sh --check is the gate; scripts/release.sh and scripts/release-mac.sh archive App Store builds through a stable-macOS build VM; scripts/asc-*.py drive App Store Connect.
TailscodeCore/ Shared, toolkit-free: parity registry, themes + typography, cascade
streaming, activity + presence, spend + analytics + trophies, git,
model fleet + quotas, splits + pane targets, slash + shortcuts,
quick ask + summon, image + video generation, design board, update
ledger, stores, demo world, and the tests for all of it
Tailscode/ iPhone and iPad UIKit client — connection, chat, home board, usage,
settings, Live Activity + widgets, push
TailscodeMac/ AppKit client — tiling, Liquid Glass, Metal presence orb, SelfTest
TailscodeLinux/ GTK4 client — a SwiftPM package (C shims for adw, vte, mpv, WebKit, PulseAudio)
TailscodeWidget/ ActivityKit widget, quota widgets, controls
TailscodeMacWidget/ Mac quota widget
TailscodeNSE/ Notification service extension (push-driven widget reloads)
packaging/ Flatpak manifest, Arch PKGBUILDs, desktop entry, icons, metainfo
scripts/ Parity gate, packaging, dev loops, release, App Store Connect
Programmatic UIKit and AppKit, GTK4 through C shims, Swift 6 strict concurrency, no SwiftUI outside the widgets. All networking, streaming and state live in CodingAgentKit; the clients render ConversationState and forward intent.
TailscodeCore/Sources/TailscodeCore/Parity.swift declares AppCapability — one case per user-facing capability, each with a toolkit-free spec — and every client answers every case in its own Parity.swift with an exhaustive switch and no default. Adding a capability is a compile error in all three clients until each says what it does about it: .implemented(anchor), .partial, .gap(reason), .notApplicable(reason), or on the Mac .varies(direct:appStore:), because the ad-hoc build and the sandboxed App Store build are allowed different answers.
scripts/parity.sh prints the matrix and checks every claimed anchor in that client's own tree (reading #if TAILSCODE_MAS as the compiler does); it runs as a Stop hook and under both desktops' --selftest.
Exhaustiveness forces disclosure, not implementation — .gap("later") compiles. What it guarantees is that nothing can exist on one platform while the others say nothing.
| Repo | What |
|---|---|
| CodingAgentKit | The engine: Swift 6 package, Linux + Apple, one client over opencode 1.x/2.x, claude-bridge and omp-bridge, SSE streaming, MessageReducer, mockable backends, a CLI |
| claude-bridge | Exposes Claude Code (claude -p stream-json) as HTTP sessions with SSE, subagents, compaction, spend, analytics, git and APNs pushes |
| claude-bridge agents | Hermes, Gemini CLI, Codex and any ACP agent on the same port, and schedules the machine asks itself |
| omp-bridge | The same wire protocol over Oh My Pi, schedules included |
| voice-bridge | The voice gateway: Nemotron VoiceChat on your own NVIDIA GPU, used as an ear that transcribes live and dispatches to the agent |
| delegate | The daemon that runs packets down a ladder of cheaper models |