Kiteline

Your coding agents keep working while you're away from the keyboard.

Kiteline watches every Claude Code, Codex, OpenCode and DeepSeek Harness session on your computers and puts them on your iPhone, iPad and Apple Watch: you can see what each agent is doing, approve its requests, answer its questions and send it the next task.

English · 简体中文

Official website: tars.betac.cn. Official installers for Mac, Windows and Linux are available there and on GitHub Releases. The iPhone, iPad and Apple Watch app is on the App Store.

See it in action

No more coding blind. Send a task by voice; the agent reports back with screenshots.	Approve from anywhere. Lock screen, phone or watch; risky commands always ask twice.
Every computer, every agent. Mac, Windows, Linux and Remote-SSH in one list.	Start work on the go. Dispatch a task and check today's progress at a glance.

_{Click any clip to watch the full video.}

Highlights

Supported agents

The per-platform matrix is in PLUGINS.md. It is generated from the capabilities each plugin declares and updated with every release.

Why are some agents view-only? Kiteline never touches your AI credentials and never modifies an agent. It only acts through interfaces the agent itself offers: its local server or IPC, extension points such as hooks or an editor URI, or the terminal (tmux) it runs in. When an agent offers none of these, Kiteline can still show its sessions and full transcripts from disk, but it won't simulate input or patch the agent to take control. The app tells you why a session is view-only and how to enable more, for example by starting the CLI in tmux. Details are in the plugin guide.

Build a plugin. New agents are added as plugins: a manifest plus a small Python module running in the watcher. The plugin development guide covers the manifest, the interface and the rules, and tools/plugin_check.py lets you test a plugin on your own machine. Open a pull request: we review and test it, then sign it and publish it to the official plugin index, and every Kiteline user gets it without an app update.

Architecture

flowchart LR
    subgraph Devices["iPhone · iPad · Apple Watch"]
        APP["Kiteline app"]
    end
    subgraph Computer["Your computer · macOS / Windows / Linux"]
        HOST["Kiteline host<br/>Swift · Python"]
        WL["Watcher<br/>kiteline-watch.py"]
        UI["VS Code · terminal · tmux"]
    end
    subgraph Servers["Remote-SSH hosts"]
        WR["Watcher over SSH"]
    end
    AG[("Claude Code · Codex · OpenCode<br/>Qwen Code · DeepSeek Harness · …")]
    PUSH["Push gateway → APNs"]

    APP <-- "HTTPS + SSE · LAN · local CA" --> HOST
    APP <-. "P2P QUIC · relay fallback" .-> HOST
    HOST -- "JSON Lines · stdio" --> WL
    HOST -- "JSON Lines · SSH" --> WR
    WL --> AG
    WR --> AG
    HOST -- "Accessibility · editor URI · PTY" --> UI
    HOST -. "Web Push · RFC 8291 ciphertext" .-> PUSH -.-> APP

Under the hood

• Session discovery. A single-file Python watcher (watcher/kiteline-watch.py) with zero third-party dependencies runs on the local machine and on any Remote-SSH host over plain SSH. It follows Claude Code's session registry and JSONL transcripts, talks to Codex and OpenCode through their own local server protocols, and lets plugins cover other agents, for example through hooks an agent provides. Everything is normalized into one JSON Lines event stream.
• Input delivery. Claude Code has no writable stdin, so Kiteline delivers input through the front end:
  • VS Code sessions: Kiteline finds the right window through the Accessibility API, opens the extension's own vscode://anthropic.claude-code/open URI to select the session and prefill the prompt, checks the input box and then submits.
  • CLI sessions in tmux: the watcher drives them directly.
  • Other terminal sessions: Kiteline walks the process tree to the terminal app that hosts the session.
  • Codex and OpenCode: replies, approvals and answers go over their native protocols.
• Transport and pairing. The phone talks to the host over HTTPS on the local network. Each computer has its own root CA, and X.509 name constraints limit it to private address ranges. Live state is streamed as Server-Sent Events, and the computer is found automatically via Bonjour / mDNS. Pairing uses a 6-digit code, or a QR code that carries a one-time token and the CA fingerprint.
• End-to-end encrypted notifications. Payloads are encrypted on the computer with Web Push (RFC 8291 aes128gcm, VAPID per RFC 8292). They are decrypted only on the device, by a notification service extension. The push gateway only ever relays ciphertext to APNs.
• Remote access (closed-source component). Built with Rust and iroh: QUIC connections addressed by device public keys, NAT hole punching with relay fallback, and path migration between Wi-Fi and cellular without dropping the session. Only paired devices can connect.
• Signed plugins. Agents beyond the built-ins are distributed through an Ed25519-signed index. Each manifest declares capabilities (view, reply, approve, answer, interrupt, …) and the permissions it needs, and every client renders exactly what an agent supports.
• On-device speech. Hold-to-talk transcription runs locally with sherpa-onnx and the Fun-ASR-Nano model, so audio never leaves your own devices.
• World mode. A three.js scene shared by every platform and rendered from the same state stream.
• Flow Board. Also three.js, on the same host protocol. Cards are thin slabs with canvas textures; each line kind is one LineSegments buffer written as a ring, so the line count stays bounded. Base lines use normal blending so hundreds of them stay a faint grey, while only the lit lines (up to 320) and the particles (one shader-driven Points, up to 1,500) are additive. An automatic camera pans and zooms to the busiest card — straight on, in 2D — and lists the calls that just passed through it.

Tech stack

Screenshots

_{App Store screenshots shown in Chinese; the apps are fully localized in English.}

Open source and subscription

Kiteline was built to free developers from waiting on their agents. It began as an internal tool our team relies on every day and has been refined through real development work. We are now opening it up so that more developers can benefit.

There are many remote-control tools available. Every Kiteline feature comes from a real development need: managing multiple agents, picking up to-dos, group chats between sessions, code editing, in-session terminals, world mode and more. Together they cover the full workflow of coding remotely with agents, with the aim of being comprehensive and practical.

Build it yourself. All the source code is public in this repository. If you have the time and enjoy building things, you're welcome to build, modify and extend it under the terms of the AGPL-3.0. Suggestions are always welcome through Issues.

Use the official build. If you'd rather not spend time and tokens building and maintaining it yourself, download the official build from the website:

• When your phone and computer are on the same Wi-Fi, every feature is free.
• To use Kiteline from any network, subscribe to Kiteline Pro in the iPhone app. It costs about as much as a cup of bubble tea a month and pays for server renewal and maintenance.

Repository layout

.
├── Sources/                Mac host (Swift, SwiftUI)
├── Resources/              Mac resources, world mode (three.js), code editor (CodeMirror)
├── KitelineKit/            SwiftUI components shared by the Mac and iPhone apps
├── watcher/
│   └── kiteline-watch.py   Session watcher, runs locally or over SSH (stdlib only)
├── desktop/
│   ├── kiteline/           Windows and Linux host (Python)
│   ├── client/             Windows and Linux native window (C#, Avalonia)
│   └── packaging/          PyInstaller and tarball packaging
├── plugins/                Agent plugins distributed separately from the app
├── PLUGINS.md              Supported agents per platform (generated)
├── tools/plugin_check.py   Test a plugin on your own machine
├── tests/                  Integration tests for the HTTP API and the watcher
├── build.sh · install.sh   Mac build and install
└── docs/                   Plugin development guide, agent integration notes, world mode

Not included: the remote access component, the iPhone, iPad and Apple Watch app shells (pairing, settings, widgets, Xcode project) and the servers (relay, push gateway, statistics). A build from this repository works on your local network. For remote access, use the official build; see Open source and subscription.

Build from source

Mac

Requirements:

• macOS 14 or later.
• Xcode, or just the Command Line Tools (xcode-select --install).
• Python 3, which the session watcher runs on.

git clone https://github.com/hon6/kiteline.git
cd kiteline
./install.sh                 # build, install to /Applications/Kiteline.app and launch
./install.sh my-server       # also watch sessions on Remote-SSH hosts (passwordless ssh)
./build.sh                   # build only → dist/Kiteline.app

A build from source replaces an installed official Kiteline and keeps its data and pairings. To make that possible, a few runtime identifiers keep the project's early names:

• the data folder ~/Library/Application Support/TARS;
• the executable name;
• the watcher installed as ~/.ccpulse/ccpulse-watch.py on each machine.

The app is signed with a self-signed identity created on the first build, so macOS permissions carry over between rebuilds.

Optional offline speech recognition: copy libsherpa-onnx-c-api.dylib and libonnxruntime.dylib from the sherpa-onnx-core 1.13.8 macOS arm64 wheel into vendor/sherpa-onnx/lib/. Without them, Kiteline falls back to the system speech recognizer.

Windows and Linux

Requirements: Python 3.10 or later.

cd desktop
python3 -m venv .venv && . .venv/bin/activate      # Windows: .venv\Scripts\activate
pip install -r requirements.txt
python -m kiteline               # opens the console in your browser, adds a tray icon
python -m kiteline --headless    # servers without a desktop: prints the pairing code

Packages:

• Linux tarball: bash desktop/packaging/build-linux.sh.
• Windows zip: desktop\packaging\build-windows.ps1.
• Native window (.NET 10): run bash desktop/client/publish.sh linux-x64 win-x64 first, then package with KITELINE_WITH_CLIENT=1.

Pair your phone

1. Install Kiteline from the App Store.
2. Open Phone Access on the computer: the menu bar icon on Mac, the tray or the console on Windows and Linux.
3. Scan the QR code. No account is needed.

Privacy and security

• No AI credentials. Kiteline never signs in to Claude or any other AI service, never reads or forwards API keys or session tokens, never calls a model API and never modifies the agents themselves.
• Your devices only. Conversations and code travel only between your computer and your phone, end-to-end encrypted.
• Usage statistics. Every 15 minutes the computer sends a summary to the Kiteline server: device types and versions, which agents and models are used, token counts and the display name you set, with all IDs hashed. It never includes conversations, code, file names, paths or session titles. Turn it off in Settings → Send usage statistics (Sources/UsageStats.swift, desktop/kiteline/stats.py).
• Read-aloud. If you choose Microsoft voices for reading replies aloud (optional, via edge-tts), the text being read is sent to Microsoft to be synthesized.

Contributing

Issues, discussions and pull requests are welcome, especially plugins for new agents (see the plugin development guide). Before opening a pull request, please read CONTRIBUTING.md.

License

Copyright © 2026 hon6. Licensed under the GNU Affero General Public License v3.0. If you distribute a modified version, or run one as a network service for others, you must make your source code available under the same license. For other licensing arrangements, contact [email protected].

"Kiteline" and the paper-kite logo identify the official app; please don't use them for modified versions. Agent names and logos (from LobeHub Icons, MIT) belong to their respective owners and are used only to show which tool a session comes from. Kiteline is not affiliated with or endorsed by Anthropic, OpenAI, Anysphere or any other agent vendor. Third-party licenses are listed in Resources/ThirdPartyNotices.json.