kn0t another
AI tool.

Coordination for the agents you already use.

Run Claude Code, Codex, Gemini, Copilot and OpenCode in parallel. kn0t shows what each supported session has claimed, holds overlapping work before it lands, and sends the agreement back to the agents. You step in only when they cannot agree.

claude code · codex · gemini cli · copilot cli · opencode
your code never passes through kn0t · solo runs fully local
the map · livecore · 4 threads · --:--:-- utc
▲ tangle · caught before the push
thr-041 × thr-044 · core/api · auth/session.ts
session.ts:41 · later edit held · first claim stays active
⟂ contract t-118 · negotiating
claude-code: interface lands first, +compat shim
codex: accepted. rebasing onto t-118
● untangled
t-118 agreed · edit order recorded
shared contract recorded · held thread can retry
◐ loose end → sam
session TTL: 15m or 60m? one click.
─ thread  ·  ◯ tangle  ·  ⟂ contractschematic · demo data
01See the work.

Every supported session on one live Map, with its person, tool, repository and claimed files.

02Catch the overlap.

When a second session touches claimed code, kn0t holds that change on your machine.

03Agree the change.

The agents agree an order in-session. A person decides only when they cannot.

01 / the problem

Parallel agents do not share context.

a.

Parallel sessions save time.

One developer can run several coding sessions at once, across tasks, repositories and worktrees.

1 developer · several sessions · parallel work
b.

Each session sees only its own work.

Your Claude changes an interface while your Codex builds against the old version. Both changes can look correct in isolation, even when they cannot work together.

radius: auth · sessions · middleware · billing
c.

The conflict appears later.

The first warning is often a failed test, a review comment or a merge conflict, after both sessions have moved on.

CONFLICT (content): auth/session.ts · found at merge

The same problem exists across terminals, worktrees and teammates.
kn0t checks each supported change against work already in progress.

02 / how it works

Watch, Hold, Settle.

threads, live · core + web
thr-041 · mara + claude-code
core/api · auth/session.ts · rotate session tokens
live
thr-044 · jun + codex
core/api · middleware · rate limits, reads sessions
live
thr-038 · priya + gemini
web/checkout · copy + empty states
clear
thr-045 · tomás + copilot
core/billing · invoice retries
clear

01Watch

kn0t shows active sessions, repositories and claimed files on one live Map.

▲ tangle · caught before the push
thr-041 × thr-044
both touched core/api · auth/session.ts
thr-041 · claude-codeclaim active
thr-044 · codexwrite held
caught: codex requested session.ts:41 while claude-code held an active claim. the later edit was held.

02Hold

When a later change overlaps an active claim, kn0t holds it and names the other thread. The first thread keeps working.

⟂ contract t-118 · agent-to-agent
claude-code (thr-041): landing interface change first. exporting compat shim.
codex (thr-044): accepted. rebasing onto t-118.
◐ loose end → sam (human)
session TTL after rotation. judgement call.

03Settle

The agents agree an order, then the held change retries with that agreement in context. If they cannot agree, kn0t asks a person. Supervised sessions can also resume an idle exchange without gaining access to write or command tools.

03 / accounts and rules

Keep agents in the right place.

kn0t keeps agent accounts separate, applies your repository rules and makes supported session history searchable. It does not choose the work or write code.

identities

Keep each agent account separate.

Work Claude, personal Claude and a client's Codex can share one laptop without sharing credentials or repository access. Adopt an existing account or create an isolated vendor home, then launch it with claude-perso that opens the agent signed into the right account. Sign-in stays with the vendor.

identities · this machine
claude code · v1.8
● claude·work▶
● claude·perso▶
codex · v0.42
● codex·default▶
❯ claude-perso  → you're claude·perso
bindings

Set which accounts may use each repo.

Set each account to ✓ allow, ? ask or ✗ deny for a repo. When a denied account tries to change it, kn0t holds the change and tells the agent which identity is allowed.

● edit held · side-project/api.ts
side-project is bound to claude·perso.
This session is claude·work (deny here).
Relaunch under an allowed identity
(kn0t → Identities → ▶), or ask the
human to change the binding.
→ kn0t returns that reason to the agent.
guardrails

Check files, content and commands.

Check paths, proposed content and Bash commands. Use built-in secret and risky-command checks or your own patterns, scoped by repository and schedule.

guardrails · mara
✗ deny   content · secret/key sets
? ask    command · unexpected push
✗ deny   path · **/.env*
⏻ active while away · quiet 22:00–08:00
the record

Search past sessions.

Search supported local transcripts and coordination events by repository, tool, account or time. The index stays on your machine.

the record · local index
⌕ what changed before checkout broke?
repo web · vendor any · identity any
41 matches · local index
▸ codex · web/checkout/copy.ts · 14:02
▸ claude·perso · checkout/empty.tsx · 13:58
the index stays on this machine.
04 / solo and team

Start with your sessions. Add your team.

solo · first 7 days free

Keep your agents and accounts straight.

Run supported coding tools across work and personal accounts. kn0t keeps those accounts out of the wrong repositories and checks their changes against your rules.

+
Every account, kept apart.
If work Claude wanders into a personal repo, the change is held and the agent is told why. You can create an isolated vendor home from the identity panel.
+
Rules across supported tools.
Path, content, and command checks. Built-in secret detectors, custom patterns, schedules, and one rule set across supported tools.
+
Supported sessions, searchable.
Search supported transcripts by repo, vendor, and account from the local index.
+
Your own agents, one map.
See supported sessions together and hold a later edit when it crosses an active claim.
+
Launched through kn0t, supervised.
Start agents through kn0t and each session is known from launch to exit: identity set at start, claims released the moment a window closes, and an idle negotiation nudged instead of forgotten.
your machine · mara3 agents · 3 accounts
● claude·work · core/apilive
● claude·perso · side-projectlive
● codex·default · web/checkoutlive
✗ held · claude·work → side-project (deny)
⌕ 312 sessions indexed · local
05 / across tools

One view across every supported tool.

A team can use Claude Code, Codex, Gemini CLI, Copilot CLI and OpenCode in the same repositories. kn0t gives their separate sessions one shared claim map.

It sits beside those tools. It does not host your repositories or replace an agent.

dev a · agents
claude code
core/api
auth/session.ts
dev b · agents
codex
core/api
middleware
kn0t sits in the gap between them
no vendor's tooling reaches here

Your agents can use different tools. They still share one Map.

claude codecodexgeminicopilotopencode+ your humans
06 / assurance

Exactly what leaves your machine.

working solo

Work content stays local.

The personal Map, edit decisions, transcript record, and search index run on your laptop. Account and billing requests are separate from that work content.

uploaded work content: none
on a team

Coordination signals only.

Your machine shares who is working, in which repo, and which file paths are claimed, so your teammates' agents can steer around yours. Contract proposals and decisions are shared too. Team coordination does not include file contents, diffs, prompts, or transcripts.

mara · core/api · auth/session.ts · claimed
either way

Code content stays local.

Not your files, not your diffs, not your prompts, not your transcripts. The record and its index live in one file on your disk. If it would show what you wrote, it does not go up.

code ✗ · diffs ✗ · prompts ✗ · transcripts ✗

If the shared service goes down, the app on your machine keeps coordinating and enforcing its current rules.
If the kn0t app itself is unavailable, kn0t steps aside within a fixed time limit and the change goes through.

deterministic · no LLM call decides a tanglehuman authority · agents and people author contractsnarrow sharing · coordination signals, not work content
08 / plans

Plans for one developer or a team.

compare plans →
free
£0
included after the trial · no card needed
2 live threadsoverlapping changes held5 guardrails3 days of local session historyone machineauto answers between agents need Solo
solo
–
one dev, supported tools and accounts
live Map for your agents and accountsoverlapping changes heldwork and personal accounts kept separaterules across supported agentssearchable local session historyidle agents can answer coordination messages
team
–
agents that talk to each other · one shared map
coordination across the teamone shared Map across machinesoverlapping changes helda person asked only when needed
enterprise
let's talk
for larger organisations
talk to us
everything in Teamcurrent: team policy, posture and audit controlsplanned: organisation-wide Map and stakeholder accessplanned: SSO, SAML and SCIM

Keep parallel work from colliding.