Show HN: Heddle- ATC for Your Subagents Heddle, a new open-source tool formerly known as loom-vcs, launches as version control for AI coding agents, preventing file collisions by using intent leases and isolated worktrees. The tool reports conflicts before tokens are spent, unlike git which discovers them after the fact, and targets fleets of agents working on a single repository. Heddle is serverless and git-native, offering leaderless, warn-only leases and an always-green mainline. Version control for many hands moving at once. Git is the filesystem; Heddle is air traffic control. A heddle is the part of a loom that keeps threads separated so they never tangle. That's the product. Formerly known as loom-vcs; renamed to avoid collision with several unrelated Loom projects. Without Heddle. You point two Claude Code sessions at your repo. Agent A spends 40 minutes and ~200k tokens rewriting src/auth/ around a new session model. Agent B, told to "clean up the login flow", touches the same files with the opposite assumption. Neither knows the other exists — git has nowhere to put that knowledge. B finishes last, so B's edits win; A's work is silently gone from the tree. The test suite goes red at commit time, and you spend the evening and another few hundred thousand tokens having a third session diagnose a breakage that is really two AIs' half-rewrites interleaved. The most expensive thing agents do is semantically reconcile two overlapping rewrites after the fact — and this workflow makes it routine. With Heddle. A leases src/auth/ with the goal "move auth to the new session model". When B's session asks Heddle what's being worked on — one MCP call — it sees that lease, goal attached, and self-partitions: it either takes the suggested disjoint scope or waits. The collision is reported at the start , when handling it costs one tool call, not at the end , after both budgets are spent. If both proceed anyway, each works in its own worktree, nothing is overwritten, and the second landing is told exactly which files moved and rebases once — the expensive reconciliation becomes rare instead of fast. That is the entire bet: git reports collisions after the tokens are spent; Heddle reports them before. You run several coding agents on one repo. They overwrite each other's files, land red on top of red, and die mid-task leaving dirty worktrees nobody owns. You can't see who is doing what, so every collision is discovered at the end — at merge or in CI — when the only fix is expensive re-work. Git has no concept of intent : a branch name is a string, so agents can't ask "who is already working on this?" and route around each other. Isolation — every task gets its own git worktree; two threads physically cannot clobber each other's edits. Coordination — before editing, a thread declares an intent lease machine-readable goal + file globs ; overlaps warn at declaration time, which lets agents self-partition work over MCP with no human traffic cop. Leases warn, they never block — an agent is never stopped; the only gate is at landing. Integration — the mainline fabric advances only through a green verify run plus a human/consent gate, with an honest file-level merge: a file changed in both the fabric and the thread refuses to land "fabric moved under you — rebase" instead of overwriting either side. Never-red main means no fleet-wide token burn diagnosing a stranger's breakage. Recovery — a dead agent's thread becomes an orphan : goal, acceptance criteria, and a seconds-old checkpoint attached, claimable by anyone. That is schedulable work, not a mystery dangling branch. An honest concession: two careful humans working slowly don't need this. The value scales with writer count and edit frequency — it exists for fleets of agents and humans who work like them . Heddle is not alone in this space. Several projects have converged on worktree isolation + gated merging — that convergence is evidence the problem is real. What Heddle claims as its own is narrower and specific: leaderless, warn-only intent leases no dispatcher, no locks , an always-green fabric advanced only by compare-and-swap over bare git remotes no server , decentralized orphan adoption , and stitch-level history — a serverless, git-native protocol and one binary, not a platform. See Adjacent projects adjacent-projects for the neighbors and what each does that Heddle doesn't. N agents racing the SAME task. Heddle coordinates different tasks on one repo. For redundant attempts at one task, use a judge/tournament harness — then lease the winner's landing. Replacing git. Heddle sits on top; git stays your history, remotes, and review tooling. The optional bridge projects each landed weave into local git history — one commit per weave by default, checkpoint-level if you ask see bridge mode below — and never pushes. Humans doing normal PRs. Slow, coordinated-out-of-band work is what git+GitHub already does well. The disaster being prevented, on your own machine. One repo, two terminals "agents" A and B : cargo install --path . one binary: heddle cd your-repo heddle init --verify "cargo check" or any command that exits 0 on green Keep the verify fast. It runs on every heddle propose , and every agent waits for it before its work can land — a 49-second suite is 49 seconds of every agent's time, every attempt. Point it at a quick subset a few seconds: cargo check , pytest -q -m "not slow" , npm run test:fast and let the full suite run in CI. heddle init times the command once and tells you if it is slow it skips that when stdout isn't a terminal, or with HEDDLE SKIP VERIFY TIMING=1 . A: heddle lease "greet in french" 'greeting.txt' WORK IN: ~/.heddle/