Claude Code
Protocol
stream-json
Spawns
$claude
Fable 5 · Opus 5 · Sonnet 5 · Haiku 4.5
Plan mode, approvals, 1M-context toggle and resume, all as first-class events.
Open source · Local first · Rust + Tauri
Ties every coding agent
into one thread.
An open source desktop command center that drives Claude Code, OpenAI Codex and Kimi Code natively. From your desk, or from your phone.
The part that matters
No API keys.
It spawns the claude, codex and kimi CLIs you already have installed. The subscriptions you already pay for are the auth.
- 3
- native protocols
- 0
- API keys
- 1
- thread
claude · stream-json · turn_completedcodex · thread/resume · session restoredkimi · acp · session/promptmesh · lenovo-dev → omen · thread.attachbrowser · agent cursor → #submitparley · reviewer B disputes step 4phone · approval_request · deep linkthread · 1,284 events replayed on reconnectclaude · stream-json · turn_completedcodex · thread/resume · session restoredkimi · acp · session/promptmesh · lenovo-dev → omen · thread.attachbrowser · agent cursor → #submitparley · reviewer B disputes step 4phone · approval_request · deep linkthread · 1,284 events replayed on reconnect
Three agents, one seat
It speaks each agent’s native wire protocol. Not a terminal wrapper.
No screen-scraped text, no Node server in the middle. Streaming, interruption, approvals, plan mode, images and session resume arrive as structured data, because that is how the agents actually talk.
OpenAI Codex
Protocol
app-server JSON-RPC
Spawns
$codex
Models discovered live via model/list
Threads resume through thread/resume, so restarts never cost you the conversation.
Kimi Code
Protocol
ACP
Spawns
$kimi
K3 · K3 256K · K2.7 Code
Full Agent Client Protocol support including session/resume.
Already installed and signed in? Then ThreadKnot is already authenticated.
See it running
The actual window, on an actual machine
Desktop
Capture pending
Phone
Capture pending
Shared browser
Capture pending
Parley
Capture pending
What it actually feels like
Three things no terminal tab
can do for you
01
Desk to pocket
Start a build at your desk. Keep steering it from the couch.
The same UI the desktop window renders is served to any browser on your LAN, so your phone is not a notification screen, it is the same command center. Events broadcast to every connected client, so desktop and phone never drift apart.
- Approve edits, switch models, interrupt a turn, all from the phone
- Push notifications deep-link to the exact thread that needs you
- Biometric lock and multi-server switching in the native companion
claude codeopus 5effort: highedits
you · from phone
ship the 3% card fee on the pay-invoice route
claude code
Reading src/app/pay/route.ts and the Stripe webhook handler. The fee needs to apply before the intent is created.
edit · route.ts
+ const fee = Math.round(amount * 0.03)
- const fee = 0
streaming to 2 clients
omen
invoice fee
approval needed: write route.ts
APPROVEPLAN
same thread
02
One real Chrome
The agent and you share a browser. Not a preview. Not a headless clone.
Each thread gets an isolated Chrome session that the agent drives from semantic accessibility snapshots with deterministic actions. You watch the same live window with the agent's cursor, its target outline and the action it is about to take, and you can grab the mouse mid-flow.
- Visible agent cursor, target outlines and a live action HUD
- Stable element refs, real keystrokes, iframes, uploads, dialogs
- Overlay protection: a cookie banner stops the click instead of eating it
← → ⟳https://dashboard.example.com/billing
ref e12 · buttonConfirm plan
actionclick("e12")human can take the mouse
03
Parley
Let the agents argue before you ship it.
Two or more agents work one thread as named participants: a builder plans or codes, reviewers attack the work, and you read the verdict. Different providers, or the same model twice for an honest second opinion.
- Turn-taking is a deterministic state machine, not a model burning tokens
- Mix providers: Opus builds, Codex reviews, K3 breaks the tie
- The whole argument is event-sourced, so you can replay how it landed
builder · opus 5reviewer A · codexreviewer B · k3
builder · opus 5
Plan: backfill in one transaction, then flip the read path. Four steps, reversible at every point.
reviewer A · codex
Step 4 flips reads before the backfill index exists. On a table this size that is a full scan under load.
reviewer B · k3
Agreed, and step 2 has no rollback. Concurrent index first, then flip.
verdict · 2 of 3
Revise before build. Reorder steps 2 and 4, add the concurrent index.
turn-taking: deterministic state machine
The ship's log
Eight things ThreadKnot is designed to do
Not a roadmap. This is the working set: what the app does the moment you open it.
Every major coding agent, no API keys
ThreadKnot spawns the claude, codex and kimi CLIs you already have installed and authenticated. Your existing subscriptions are the auth. No keys stored, no proxy in the middle, and out of the box nothing leaves your network.
Projects and threads
A project is just a folder. Each thread runs one agent in that folder with its own agent, model, reasoning effort and a 1M-context toggle on supported models.
You decide how far it can go
Per-thread access levels: Read-only asks for everything, Edits auto-accepts file changes, Full runs without prompts. Plan mode produces a read-only plan you approve with one click before it builds.
Never lose a conversation
Every thread is event-sourced. Normalized agent events append to an on-disk JSONL log and broadcast to every connected client, so threads replay on reconnect and provider sessions resume across app restarts.
One real browser, shared
Each thread gets an isolated Chrome session the agent and the human jointly control. The agent works from semantic accessibility snapshots with deterministic actions while you watch the same live Chrome, with a visible agent cursor, target outlines and an action HUD. Grab the mouse any time.
Many machines, one mesh
Workspaces group threads running on different computers under one sidebar. Every paired machine can see and control every other. No hub server and no accounts: out of the box peers find each other over your own LAN or tailnet, and pairing survives DHCP changes through machine identity plus mDNS discovery.
Parley: agents that review each other
Two or more agents, from different providers or the same model twice, work one thread as named participants. A builder plans or codes, reviewers argue the work, you see the verdict. Turn-taking is a deterministic state machine, not another model burning tokens to decide who speaks.
It follows you to your phone
Beyond the LAN web UI, a native Expo companion adds biometric lock, multi-server switching and push notifications that deep-link straight to the thread needing attention. Notifications filter per workspace, so two people sharing a server each hear only their own work.
Under the deck
A Rust core, a socket, and nothing in the middle
One axum server is the heart. Every client, desktop or phone or peer machine, talks to it over a token-gated WebSocket, and every agent event is appended to disk before it fans out.
Rigged for safety
Local-first is a security model, not just a preference
Three things decide what an agent can reach and who can reach it. All three are yours to set, and out of the box none of them route through anyone else.
Token-gated
Every client presents a token
The WebSocket refuses anything without it, and paired mobile devices get their own revocable credential stored only as a hash. Rotate the master token by deleting server.json; the server mints a new one on next start.
The leash is yours
You set how far an agent can go
Per-thread access levels: Read-only asks before everything, Edits auto-accepts file changes, Full runs without prompts. Plan mode produces a read-only plan you approve with one click before anything gets built.
LAN by default
Your network is the boundary
Out of the box nothing leaves your network: there is no port to forward, and devices connect over your own LAN or tailnet. That makes the blast radius of ThreadKnot exactly the network you already trust.
Free and open source
Nothing here phones home.
ThreadKnot is self-hosted by construction. There is nothing you have to sign up for, no plan to outgrow and no company that can change the terms on you later. If it runs on your machine today, it runs on your machine forever.
Released under the Apache 2.0 license.
Local first
Your code, your credentials and your agent transcripts never touch a third-party service. Threads live as JSONL on the machine that ran them.
No accounts
There is nothing to sign up for and no telemetry. Out of the box nothing leaves your network: the mesh is your machines talking to each other over your LAN or tailnet. The one optional exception: mobile push notifications relay through Expo's push service if you enable them.
Rust core, React UI
The core is Rust on Tauri 2 with an axum server. The interface is React with no state library and plain CSS, deliberately simple to work on.
Contributions welcome
The open surfaces are the agent drivers, the shared browser layer, the mobile companion and the mesh. Start with the protocol doc.
ThreadKnot’s agent integration began as a port of t3code’s, rebuilt on an all-Rust stack.
For builders
Three commands and you are on deck
You need Rust and Node on the machine, plus at least one of the agent CLIs installed and signed in. That is the whole prerequisite list.
$ git clone https://github.com/blibbers/threadknot.git$ cd threadknot
$ npm install
$ npm run tauri dev
Prerequisites
rust · node 20+ · one of claude / codex / kimi
Questions
The ones people actually ask
01Do I need an API key or a paid plan on top of what I have?
No. ThreadKnot drives the CLIs already installed on your machine and signed in with your own accounts. It never asks for or stores an API key, and there is no ThreadKnot service in the middle taking a cut.
02Where do my code and transcripts go?
Nowhere. Threads are appended to JSONL logs on the machine that ran them. There is no account system and no telemetry. Out of the box nothing leaves your network: the mesh is your own machines talking to each other over your LAN or tailnet.
03Is this a terminal wrapper?
No. Each driver speaks the agent's real wire protocol: stream-json for Claude Code, the app-server JSON-RPC interface for Codex, ACP for Kimi. That is what makes streaming, interruption, approvals, plan mode, images and session resume behave like data instead of scraped text.
04How does the phone actually work?
The Rust core serves the exact same UI the desktop window renders to any browser on your LAN, gated by a token. The Expo companion app wraps that with biometric lock, multi-server profiles and push notifications that deep-link to the thread that needs you. The companion app ships alongside the desktop builds.
05What does it run on?
Windows and macOS desktop builds, with a headless binary if you only want the LAN server. Linux runs today by building from source; packaged Linux builds are planned. The core is Rust on Tauri 2, the UI is React, and both are in the same open source repo.
06Can I contribute?
Yes. The most useful surfaces are the agent drivers, the shared browser layer, the mobile companion and the mesh. The wire contract lives in docs/PROTOCOL.md and is the single source of truth for anything that crosses the socket.
07What license is it under?
Apache 2.0. Free forever, use it anywhere, fork it, ship it. Optional paid services around the app fund development; the app itself never needs them.
08Is this against the AI providers' terms?
ThreadKnot never touches credentials or tokens. It launches the official claude, codex and kimi CLIs, each signed in through its own login flow, exactly as if you ran them in a terminal yourself.
09What can someone on my network do with the token?
Everything you can. The token is the only thing standing between a device on your LAN and full control of your threads, so guard it like an SSH key. Rotate it by deleting server.json, which makes the server mint a new one on next start and invalidates every paired client.
Two knots, one strand
Threads are the unit of agent work.
The knot is what ties them together.
Multiple agents, multiple machines, multiple devices. One place to command them, and it costs you nothing but the subscriptions you already have.