Knot watches the folders you choose. Every save becomes a real git commit on your teammates' machines within seconds. No server, no account.
Two machines, two AI agents, one repo: they build it together over your LAN, hands-free, while you watch.
THE DESKTOP APP
A live dashboard, built-in chat, AI-agent activity across your machines, and on-device settings, running natively on Linux and macOS.





Dashboard, lifetime commits, devices, storage, bridge health
My Folders, per-project commit history & activity heatmap
Code graph, see how any codebase fits together
Activity, watch your AI agents coordinate across machines
Built-in chat, message your paired devices directly
Settings, themes, on-device AI, go-dark, auto-save timing
The folder and the peers are one-time setup. The save is the only piece in your day; a background helper and the encrypted Tor connection do the rest, invisibly.
01
Pick any folder on your machine. Tell Knot once. It now behaves like a git repository, because under the hood it is one. Existing `git` commands still work.
02
Anyone you want to collaborate with installs Knot. You give them a one-time pairing code; they accept it. From that moment, your two machines are paired.
03
Open the file. Write code. Hit save. Knot notices the change, waits a moment for you to finish, makes a real git commit, and sends it to every paired teammate. They see it within seconds.
Same wire-format efficiency as `git fetch` (real pack files). Same content-addressing guarantees (SHA-256 hash chain). What changes is who owns the bytes in transit, only you and your peers.
Everything below is built and verified end-to-end on real hardware across networks.
AI assistants on your paired machines build one project between them, no human in the loop, and you watch every step live. The thing a central host can't do.
Knot turns every save into a real git commit a moment after you stop typing.
Commits travel to every teammate over Tor, encrypted end-to-end, on home Wi-Fi or a mobile hotspot. No ports to open.
One code carries everything the other device needs. Paste it or scan the QR. Zero accounts, zero email.
Knot uses git's real object format, so `git log`, `git diff`, and `git branch` all still work underneath, nothing to relearn.
Every commit is signed by the person and the AI session behind it, and each agent is scoped to the paths it may touch. Out-of-scope changes never commit; export a tamper-evident record anyone can verify.
A companion mobile app streams every synced repo read-only over your LAN, and notifies you when a commit lands or an agent finishes a task. Keep an eye on the work without opening a laptop.
The cryptographic and transport primitives Knot ships are open and inspectable. Built in Rust, self-contained builds, no central server to run.
That is two machines. Here is the same loop across a whole team:
Same Tor primitives that route Whispr's messages. Same git object format that powers every git host on the internet. We didn't reinvent the cryptography; we removed the centralised server.
Knot's headline benefit for AI agents: one reads a repository's whole shape for a few thousand tokens, instead of paying several times that to list folders and open files to find its bearings. Every number below is reproducible on your own machine.
THE BENCHMARK · SAME REPO · SAME QUESTION · SAME AGENT
A 56-file Python codebase the agent had never read. The question, both times: “What is this project, what are its main components, and where would a new forecasting model go?” Both answers were correct against the source. Only the cost differed.
WITHOUT KNOT
≈ 5,185 tokens
5+ tool calls
base.py · registry.py · a modelWITH KNOT
≈ 1,504 tokens
1 tool call
knot_repo_map≥ 3.4× fewer tokens, on a small repo, with every assumption biased against Knot. The map is budget-capped (~2,000 tokens whether the repo has 56 files or 5,000), while ad-hoc exploration scales with the codebase, so the gap widens as projects grow.
VERIFY IT YOURSELF
Don't take our number. Generate your own. Run two fresh AI-agent sessions on the same repository: one with Knot's tools available, one without. Ask each the same orientation question, then compare the token cost the agent itself reports.
Metered by the agent's own billing, not by us.
Honest limits: the map doesn't replace reading code you're about to edit. It replaces the hunt for which code that is. Per-file symbol extraction currently covers Rust, Python, JavaScript/TypeScript, and Dart.
POWERED BY KNOT SCRIBE
The messages Knot writes come from Knot Scribe: our open, on-device model that reads the diff and writes the message, also released standalone on Hugging Face and Ollama.
The same install, three very different reasons to want it.
You want version history and cross-device sync, without a subscription for an unfinished side-project, and without uploading it to a company's servers.
"I just want my code to exist on hardware I own and not be lost."
One-time install per laptop. Teammate added in 30 seconds with a pairing code. No org to administer, no per-seat bill that grows with every hire.
"We don't want to stand up a hosted org just to share code with five people who already trust each other."
Your code never leaves your machines, end-to-end encrypted in transit. Every commit is signed by the developer and the AI session behind it, and agents are scoped to the paths they may touch.
"Legal won't let our code leave the network, but we still want our developers to use modern AI tools."
The v1 loop is shipping as a free download for Mac and Linux. Everything marked shipped or verified has working code; the last two cards are what comes next.
SHIPPED
Save → commit → sync end-to-end across machines and networks, over Tor, in seconds. Verified Mac ↔ Linux on home Wi-Fi and a mobile hotspot. Grab it from the download section below.
VERIFIED
An on-device model reads your diff and writes the commit message, so even the commit text is hands-free.
VERIFIED
The full AI-collaboration stack, verified: cross-machine agent builds you watch live, signed exportable provenance, and per-agent path scopes.
VERIFIED
Plain-language conflict resolution (keep mine / theirs / both, never raw git markers), a read-only mobile mirror over Wi-Fi, and a one-switch offline mode.
IN PROGRESS
Next up: a polished first-run wizard for non-developers, an Apple-notarized installer (no first-run warning), and a Windows build.
PLANNED
Single-file conflicts are handled today. Full three-way merge across diverged branches is still manual via `git`, which works, because it is a real git repo.
Plain-English answers. If something's still unclear, there's a contact link at the bottom of the page.
Three groups, roughly: (1) solo developers who want version history and cross-device sync without a subscription or uploading unfinished work to someone else's servers; (2) small teams who don't want a per-seat bill and an org to administer just to share code with people they already trust; (3) enterprises where compliance or contracts mean code legally can't leave the network.
Every connection uses Ed25519 mutual authentication: both sides cryptographically prove their identity before any byte of code crosses the wire. The wire itself is Tor (.onion hidden services), so the bytes are encrypted end-to-end and relays only ever see ciphertext. Pairing a new device requires explicit confirmation on both sides; trust never happens by accident. The same cryptographic primitives we use are the ones Signal, Tor, and OpenSSH ship: not new crypto, but well-audited crypto.
No. Code transfer is always peer-to-peer; your machines talk directly to your teammates' machines through Tor circuits. There is an optional small "coordinator" service that helps peers discover each other across the internet, but it never sees a single byte of your code, only "peer X says they host project Y." You can run it yourself on a $35 Raspberry Pi, or skip it entirely: peers reach each other over Tor by default, with no coordinator in the loop.
Yes. Knot uses git's real object format underneath, so a Knot-managed folder is also a real git repository. Every git command you already know, `git log`, `git diff`, `git branch`, `git checkout`, works on it. Knot is the layer above git that automates the save-commit-push ritual and removes the central server. It doesn't replace git; it makes git invisible when you don't need it.
Nothing transfers until they come back online, same as any peer-to-peer protocol. Your commit lives safely on your machine; once your collaborator's daemon connects, the queued commits sync automatically. Common workaround: a third peer that's always online (a home server, a $5/month tiny VPS) holds a copy and bridges the gap. It runs the same free Linux build, reachable over Tor with no ports to forward. It pairs like any other peer, so it's a better-connected teammate, not a central server.
The same thing that happens if you lose your SSH key today: you generate a new keypair and your collaborators issue you a new pairing code. There is no central account to "recover" because there is no central account. Your local repository is untouched. You can still read everything on your machine. You just have to re-establish trust with your peers, which takes about thirty seconds per peer.
Yes. Knot doesn't care what's in the folder: design assets, documents, datasets, screenplays, anything you want versioned and synced across machines. The one practical caveat is large binary files (videos, multi-gigabyte datasets): they'll work, but git's storage model is tuned for text, so very large binaries can bloat the history. Same caveat as git itself.
The free edition, for macOS and Linux. It's not yet notarized, so your system shows a one-time first-run warning. The steps to open it are below. Windows is coming.
Not yet notarized, so macOS blocks the first open. Clear it once, pick one:
xattr -dr com.apple.quarantine "/Applications/Knot.app"Prebuilt, self-contained, no toolchain, no openssl. Needs glibc 2.31+ (Ubuntu 20.04+, Debian 11+, Fedora 33+).
tar xzf knot-linux-x86_64.tar.gz && cd knot-linux-x86_64
mkdir -p ~/.local/bin && cp knotd knot knot-mcp knot-app ~/.local/bin/
knotd --tor & # background daemon
knot solo # in any folder: save → commit → sync The optional GUI (knot-app) uses standard desktop libs at runtime: libfontconfig1 libgl1 libxkbcommon0.
Your code never leaves your machines regardless of the signature.
Full release history: changelog. Questions, or a use case to talk through? Get in touch.