The argument

Worktrees isolate.
They don't coordinate.

A worktree per agent is the reflex answer to parallel coding agents, and for fully independent tasks it works. But isolation has two costs that grow with every agent you add.

The bill. Every worktree is another environment: another install, another build cache, another dev server to keep alive. The whole point of a shared checkout is paying for the environment once.

The blindfold. Isolated agents can't see each other's in-flight work, so the collision between their changes isn't prevented, it's deferred to merge time, where it's biggest, has the least context attached, and you're the one holding it. Agents that could have adapted to each other mid-task instead each build against a world that no longer exists.

The two aren't mutually exclusive: worktrees for independent, long-running work, Quilt for agents in the same code at once. Git stays the source of truth either way; every Quilt commit is an ordinary Git commit and history is never rewritten.

What coordination looks like

On a shared checkout with Quilt, contention becomes a conversation instead of a silent loss. A denied claim names the holder, their stated intent, and when their lease lapses, so the blocked agent can adapt, queue, or escalate:

$ QUILT_ACTOR=builder-flows quilt claim deals.js flows.js --intent "wire flows to deals"
  ✗ denied  deals.js (held by builder-friction)
      builder-friction is: friction pass: rename + archive flags
      their claim lapses 22:12:05Z unless renewed
  ✓ claimed flows.js

The blocked agent builds its granted files, re-claims after the holder's commit auto-releases, and layers its change on top of the landed one. Two clean commits, both changes in the file, nothing lost.

Quilt also warns at claim time when a symbol you claimed depends on a function another actor is changing, and if one actor overwrites another's uncommitted lines anyway, both versions are preserved and the collision is surfaced:

⚠ collision  claude-ui overwrote codex's edits in auth.ts. both saved, run:
$ quilt restore auth.ts

Nearby tools, and the difference

Pieces of this exist elsewhere, and some of them are good. Worktree managers (Cursor's parallel agents, Conductor) isolate agents in separate checkouts and meet at merge time. Attribution tools (Git AI, agentdiff) record which agent wrote what, some with cryptographic signing. Coordination servers (MCP Agent Mail and similar) hand out advisory file leases so agents don't collide.

Quilt is the composite, built around one mechanism none of them have: commit --mine takes a dirty shared tree and produces clean, correctly attributed Git commits per agent, even where two agents touched the same file. Attribution feeds the claims, claims feed the commit construction, and the whole loop runs on one checkout with one dev server. Use a lease server without attribution and you still can't untangle the tree at commit time. Use attribution without claims and you learn who collided only after they did.

Small tool, sharp edges stated

• All state lives in a local .quilt/ sidecar. Delete it any time; your repo is untouched.
• Quilt never calls an LLM, never spawns agents, never rewrites Git history.
• Claude Code is first-class (hooks + MCP). Codex is capture-only today; Cursor and Aider via MCP tools.
• POSIX only for now: macOS and Linux, no Windows/CRLF.
• Enforcement is scoped: writes through your agent's edit tools (Claude Code hooks, the MCP tools) are blocked at claim boundaries before any bytes change. Anything else (raw shell, other processes) is advisory coordination, not a sandbox.
• Bash and codegen edits aren't auto-captured: claim first, and they bind to you. Uncaptured edits are surfaced, never miscredited.