Codync turns the coding agents on your computer — Claude Code, Codex, Cursor, Pi, OpenCode, Grok Build, Gemini, Copilot and ~40 more — into persistent bots you delegate to from your iPhone, Mac, Windows PC, Linux desktop or any terminal, the way you'd message a colleague. Pick who, say what, put the phone away. You get a notification when a bot finishes or needs your approval.

Why bots? On a phone, "find the right working session, then pick an environment" is too slow. With bots you already know who to hand the intent to: open the chat, type, done.

Why Codync

• Free and open source. No subscription, no paid tier, MIT licensed. It runs on your computer with the agents and accounts you already have.
• Bring any coding agent. Claude Code, Codex, Cursor, Gemini, Copilot, OpenCode, Pi, Grok Build and ~40 more — everything in the ACP registry. Installed agents are found automatically, the rest are fetched on first use, and every bot picks its own. Mix them freely: a Claude bot can ask a Codex bot for a review.
• Many bots, one team. Run as many bots as you like side by side, each with its own agent, project folder and approvals, all working at once. Put several in a group chat and they answer in turn, like a team channel; @name picks who replies. Start a thread on any message to branch off without cluttering the main chat.
• Built in Rust. codync-host is one small, fast Rust binary for macOS, Windows and Linux (static on Linux, runs on any distro) that drives every agent, keeps the transcripts and serves every client.
• One app per kind of device. Native SwiftUI on the iPhone, one desktop app for Mac, Windows and Linux (Electron), and a terminal UI for SSH.
• A Grok Bot, Muse and Dots alternative. Persistent named bots, group chats, reply threads, bots asking each other for help, approval cards, per-bot memory, remote screen, voice calls and "needs you / done" notifications — the same features, without being tied to one model or one subscription.
• Reach your computer from anywhere, free. The hosted Cloudflare relay is included at no cost: no Tailscale, no VPN, no port forwarding. Traffic is end-to-end encrypted between your phone and your computer, so the relay only forwards ciphertext. Same Wi-Fi or Tailscale? The phone connects directly instead.
• Every computer, one app. Sign in and your iPhone lists every computer on your account (Mac, Windows PC, Linux desktop, server or cloud VM); tap Connect, confirm a 6-digit code on that computer, and its bots show up next to the others. A new bot can live on any of them, and the Mac app reaches your SSH machines too. Each computer approves each device itself, so an account alone never unlocks a computer.
• Remote screen. See and control your computer from the iPhone over WebRTC (hardware H.264), and let bots use the screen themselves through the built-in computer tool.
• Voice calls. Talk to a bot hands-free from the iPhone and hear its replies read aloud.
• Private push. Notification text is sealed to your phone's key, so the push relay never sees what your bots said.

Platforms

The host (codync-host, Rust) runs on macOS, Windows and Linux; every client talks to it, so all your bots and chats are the same everywhere.

Looking for the former native Mac app (SwiftUI + AppKit)? Version 2.7.0 moved Mac and Linux to one Electron desktop app. The native implementation is preserved in Git history; see the changelog and source lookup commands and the archived AppKit chat implementation notes.

How it works

Remote Apple client ⇄ encrypted channel (direct or Cloudflare cloud/) ⇄ codync-host ⇄ ACP agent
Local / SSH client  ⇄ loopback HTTP + SSE                             ⇄ codync-host
Host notifications → APNs worker (relay/) → iPhone

• Bots have a name, a character avatar, standing instructions, an agent backend, a project folder and a permission policy. Each bot has a persistent main chat and optional reply threads; the agent sessions underneath are an implementation detail (resumed with session/load, restarted with New session).
• Group chats hold several bots and you. Each message starts a short room turn: the bots you @-mention (or everyone) reply one at a time, each in its own session, and can react to each other, up to 3 rounds. See group chats and threads.
• Bots can ask each other for help. Tell one “ask Reviewer to check these changes.” The built-in team MCP server lets it discover your other visible bots and wait for a reply. Requests appear in both chats; each recipient keeps its own agent, folder and approvals. Native subagents stay under the coding agent's control. See bot collaboration.
• The chat only shows what matters: your messages, each turn's final reply, approval cards and notices. Every tool call, diff, plan and thought is one tap away in Full conversation. While a bot works, its row shows what it's doing right now.
• Agents are detected automatically: the host hydrates PATH from your login shell (plus Homebrew, ~/.local/bin, nvm, bun, volta, asdf, mise, pnpm…), finds every harness you have installed, and prefers its native ACP mode. Anything else in the official ACP registry can be picked too — Codync fetches it on first use (npx, uvx or a checksummed binary).
• codync-host (Rust, macOS, Windows and Linux) runs on your computer. It speaks the Agent Client Protocol to each agent, keeps transcripts in SQLite, and serves the phone. Every change carries a global rev, so the phone reconnects with since: rev and never misses anything.
• Usage limits come from your local installs, with no extra login: Claude via claude -p /usage (a local command, no model call) plus Claude Code's status line, Codex via ~/.codex/sessions. The phone, widgets and menu bar only see percentages.
• Push goes through a tiny relay that holds the APNs key. The phone trades its device token for an encrypted ticket; the host only ever holds tickets.

UI patterns (roster, character avatars, approval cards, trace sheet, "needs you / done" notifications) follow Grok Bot.

Install

One line (macOS or Linux):

curl -fsSL https://raw.githubusercontent.com/leepokai/Codync/main/packaging/install.sh | sh

On a Mac it installs the app (the host ships inside it); on Linux the host, plus the desktop app when a display is present. Add sh -s -- --host-only for servers and headless Macs. Re-run it to upgrade.

Mac — download codync-macos.dmg and drag it to Applications, or:

brew install --cask leepokai/codync/codync

All three install the same signed, notarized app.

Open Codync: it sets up the host on first launch. Open Codync opens the full window; Pair iPhone… shows the QR code.

Windows — download codync-windows-x64.exe and run it. It installs for your user and starts the host at sign-in. The installer isn't code-signed yet, so SmartScreen asks you to confirm it once (More info → Run anyway). Not on Windows yet: remote screen, on-device speech and the Claude Code status line hook. Details: desktop app.

iPhone — get Codync on the App Store (iOS 18+, free), then scan the QR code from Pair iPhone… on the Mac, the Windows or Linux app, or codync-host pair.

Why the iPhone app can be a version behind: every iPhone release goes through Apple's App Review first, which usually takes a day or more, so the App Store version can trail the Mac, Windows, Linux and host releases. Your computer accounts for that: an update that needs a newer iPhone app waits until that version is in the App Store, then installs, and the iPhone app shows a reminder when a newer version is available.

Linux — the host, plus the desktop app:

curl -fsSL https://raw.githubusercontent.com/leepokai/Codync/main/packaging/install.sh | sh
# or: brew install leepokai/codync/codync-host
codync-host install   # systemd --user service
codync-host pair      # QR code in the terminal, or Settings in the app

The script also installs the desktop app (codync, an AppImage, with its .desktop file) when you're in a graphical session. By hand: codync-linux-<arch>.AppImage, .deb or .tar.gz from Releases.

Building the desktop app yourself: cd apps/desktop && npm ci && npm run dev.

Linux server / cloud VM — the host runs headless on any distro (static binary, x86_64 + arm64). Setup, remote access and limitations: docs/guides/linux-servers.md.

Remote access works out of the box through the free Cloudflare relay, end-to-end encrypted; the phone switches to a direct connection on the same network or over Tailscale. Details: remote relay.

Agents — install and sign in to whichever you use; Codync finds them. Claude Code, Codex and Pi run through their ACP adapters (fetched by npx, so Node.js is needed for those).

codync-host install also routes Claude Code's status line through codync-host statusline so live limits reach the host; an existing status line keeps working (it's wrapped, and restored on uninstall).

codync-host

Data lives in ~/.codync. The local bearer token authorizes loopback helpers and SSH-forwarded callers. Remote devices use individual keys and grants over the encrypted channel; revoke a lost device through device management rather than rotating the loopback token. Host methods and caller permissions live in host/src/api/.

FAQ

Is Codync free? Yes. $0 with every feature included, MIT licensed. You pay only your agent's provider, through the plan or key you already have.

Can I use my Claude or ChatGPT plan? Yes. Codync runs the agents already signed in on your computer: Claude Code with your Claude plan, Codex with your ChatGPT plan, and so on. It never calls a provider's API with your login.

Is there a Claude Code or Codex app for iPhone? Codync is one, free: Claude Code or Codex keeps running on your Mac or Linux machine, and you chat with it, approve its edits and get notified from the iPhone. Guides: Claude Code on iPhone · Codex on iPhone.

Which agents can it run? Claude Code, Codex, Cursor, Gemini, Copilot, OpenCode and about 40 more through the ACP registry. Each bot picks its own.

How is it different from Grok Bot, Muse or Dots? The same bot-based way of working (named bots, group chats, threads, approvals, memory), but open source, free, running on your own computer and with any coding agent. Side-by-side pages: codync.dev/compare.

Where does my data go? Bots, chats and memory stay on your computer. The phone reaches it directly on the same network, or through an end-to-end encrypted relay that can't read your messages.

Do I need an account? No. Pair your phone by scanning a QR code. Signing in with Apple or Google is optional.

Which computers can run it? A Mac, a Windows PC, or a Linux desktop or headless server. The iPhone app and the terminal UI over SSH talk to the same host.

Repository

Build, install, restart and full checks: development guide.

The Xcode project is generated: xcodegen generate --spec apps/project.yml.

cd host && cargo test            # host
cd apps/desktop && npm test      # desktop app (also: npm run typecheck)
# iPhone package: xcodebuild test -scheme CodyncKit-Package (apps/ios/Kit, iOS Simulator)
cd cloud && npm test            # cloud API / channel relay
cd relay && npm test             # relay tickets

Changelog

2.7.0 — one desktop app for Mac and Linux

The SwiftUI Mac app and the GTK 4 Linux app are replaced by a single desktop app in apps/desktop/ (Electron). It looks and works like the Mac app it replaces: the same roster, chat, inspector, marketplace, settings, menu bar, pairing, SSH computers, voice calls and remote screen helper. Why: the native chat had become too slow to scroll and stream long transcripts, and keeping two desktop apps in step took more than one person can maintain. The iPhone app stays native SwiftUI; its shared package moved into apps/ios/Kit/. Details: desktop app.

Native Mac source (SwiftUI + AppKit). The last native revision is 1055636, the parent of migration commit 41135ac. It includes apps/macos/ and the Mac code paths in kit/. The chat used MacChatList, an AppKit NSScrollView hosting SwiftUI message rows; see the archived implementation notes.

git show 1055636:apps/macos/Views/ChatWindow.swift
git worktree add ../codync-swiftui 1055636  # a checkout of the whole native-era repo

For release-by-release changes, see GitHub Releases.

Versioning

Clients and the host each name the oldest version of the other they still work with (minApp in the host's hello, minHost in each client), so an app can meet an older or newer host. Details: compatibility.

License

MIT