KNOT · PEER-TO-PEER VERSION CONTROL

Your code.
Your machines.
No middleman.

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

Everything in one window.

A live dashboard, built-in chat, AI-agent activity across your machines, and on-device settings, running natively on Linux and macOS.

01 HOW IT WORKS

Three pieces. You only see one.

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

The folder

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

The peers

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

The save

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.

02 FEATURES

What it does

Everything below is built and verified end-to-end on real hardware across networks.

🤝

AI agents build together

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.

💾

Saves are commits

Knot turns every save into a real git commit a moment after you stop typing.

📡

Reaches peers across networks

Commits travel to every teammate over Tor, encrypted end-to-end, on home Wi-Fi or a mobile hotspot. No ports to open.

🪪

Pairing codes, not accounts

One code carries everything the other device needs. Paste it or scan the QR. Zero accounts, zero email.

🪢

Real git underneath

Knot uses git's real object format, so `git log`, `git diff`, and `git branch` all still work underneath, nothing to relearn.

🧾

Provable, governed AI

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.

📱

Follow it from your phone

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.

03 ARCHITECTURE

Receipts, not claims.

The cryptographic and transport primitives Knot ships are open and inspectable. Built in Rust, self-contained builds, no central server to run.

Knot architecture diagram A developer hits save on their machine. The Knot daemon notices the change, makes a real git commit, and pushes that commit as an encrypted git pack directly over Tor to every paired teammate. The teammate's daemon verifies the signature, imports the pack, and the new commit shows up in their local git log within seconds. No GitHub, no central server, no cloud account, no manual push. YOUR LAPTOP Hit save in editor Daemon sees the change Real git commit (signed) DEVICE BOUNDARY Encrypted git pack PEER-TO-PEER · NO MIDDLEMAN TOR · .onion ED25519 MUTUAL AUTH Both sides prove identity ON THE WIRE Encrypted bytes only Relays carry, never read TEAMMATE'S LAPTOP Encrypted git pack DEVICE BOUNDARY Verify + import pack New commit on disk Shows in `git log` NOT IN THE PICTURE No GitHub · No central server · No cloud account · No `git add` · No `git push`
A save in your editor becomes a real git commit on your machine, encrypts as a git pack, travels over Tor directly to every paired teammate, and shows up in their local git log within seconds. No GitHub, no central server, no cloud account, no manual push.

That is two machines. Here is the same loop across a whole team:

Knot peer-to-peer mesh Six devices arranged in a ring: your Mac, your desktop, two teammates on Mac and Linux, a phone running a read-only mirror, and an optional always-on peer such as a home server, a Raspberry Pi, or a cheap VPS. Encrypted lines connect every device directly to the others. There is nothing in the middle: no central server, no hub, no cloud. Each machine talks straight to every other, so the same flow keeps working as the team grows. PEER-TO-PEER MESH · MANY MACHINES, NO MIDDLE NO CENTRAL SERVER NO HUB · NO CLOUD Your Mac EDITING Teammate LINUX Phone MIRROR · READ-ONLY Server / Pi ALWAYS-ON · OPTIONAL Teammate MAC Your desktop BACKUP Every line is Ed25519-authenticated, encrypted end to end. Relays carry bytes, never read them.
No server in the middle: every machine talks directly to every other. Add laptops, a phone, or an optional always-on peer (a home server, a Raspberry Pi, a cheap VPS) and they all sync the same repo.
knot-architecture.txt
Identity Ed25519 keypair · generated on-device · stored at OS-permission 0600
Pairing Mutual `knot1:<base64>` blob exchange · explicit confirm on both sides
Wire auth Ed25519 challenge–response · per-connection nonces · no replay
Transport Tor · onion-v3 hidden services · no clearnet bytes
Object format Real git pack files · libgit2 · `git` CLI works on a Knot folder
Push Bundle over Tor · fast-forward only · non-FF lands in refs/knot-incoming/
Capabilities Ed25519-signed grants · offline-verifiable · instant revocation
Coordinator Optional · sees encrypted bytes only · cannot tamper with the hash chain
Server None

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.

04 PROOF

Measured, not claimed.

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

  • list the files · read the README
  • open base.py · registry.py · a model
  • …and that's granting perfect first-try file picks

WITH KNOT

≈ 1,504 tokens

1 tool call

  • one call to knot_repo_map
  • files ranked by importance, each with its symbols
  • complete, correct answer

≥ 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.

Knot AI

POWERED BY KNOT SCRIBE

Every commit message is written on-device.

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.

Explore Knot AI
05 WHO IT'S FOR

Three audiences, one tool.

The same install, three very different reasons to want it.

SOLO

Personal projects

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."

STARTUP

Small distributed team

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."

ENTERPRISE

Centralised office

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."

06 STATUS & ROADMAP

Where we are.

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

Free download, Mac + Linux, live now

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.

shipped

VERIFIED

Knot AI writes your commit messages

An on-device model reads your diff and writes the commit message, so even the commit text is hands-free.

working

VERIFIED

AI collaboration you can prove

The full AI-collaboration stack, verified: cross-machine agent builds you watch live, signed exportable provenance, and per-agent path scopes.

working

VERIFIED

Built for non-developers

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.

working

IN PROGRESS

First-run wizard, notarized installer, Windows

Next up: a polished first-run wizard for non-developers, an Apple-notarized installer (no first-run warning), and a Windows build.

soon

PLANNED

Merge of divergent histories

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.

planned
07 FAQ

The questions everyone asks.

Plain-English answers. If something's still unclear, there's a contact link at the bottom of the page.

+ Who should use Knot?

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.

+ Is Knot safe?

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.

+ Does Knot use a server?

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.

+ Do I still get to use `git`?

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.

+ What if my collaborator is offline when I save?

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.

+ What happens if I lose my keypair?

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.

+ Can I use Knot for things that aren't code?

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.

08 GET IT

Download Knot

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.

Versionv0.1.0
macOSIntel, and Apple Silicon via Rosetta · .dmg
Linuxx86_64 · .tar.gz (glibc 2.31+)
SHA-256 mac8d9f07ae9e9c8c29cd433f2477c6501e71de27d368e008c6b9c0b2a7db99a873
SHA-256 linuxd328613d2b5a1f12591d34d4c39f8dbc562ba95eb1b6930eb347c793869e188f
First run · macOS

Not yet notarized, so macOS blocks the first open. Clear it once, pick one:

  • Most reliable (any macOS): open Terminal and run
    xattr -dr com.apple.quarantine "/Applications/Knot.app"
  • Or open Knot once (it's blocked), then System Settings → Privacy & Security → “Open Anyway”.
  • Older macOS (pre-Sequoia): right-click Knot → Open → Open.
First run · Linux

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.