Server data from the Official MCP Registry
Track which AI agent wrote which lines in a shared Git checkout; each commits only its own lines.
Track which AI agent wrote which lines in a shared Git checkout; each commits only its own lines.
Valid MCP server (3 strong, 3 medium validity signals). No known CVEs in dependencies. Package registry verified. Imported from the Official MCP Registry.
7 files analyzed · 1 issue found
Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.
This plugin requests these system permissions. Most are normal for its category.
Add this to your MCP configuration file:
{
"mcpServers": {
"io-github-wkoverfield-quilt": {
"args": [
"-y",
"@quilt-dev/cli"
],
"command": "npx"
}
}
}From the project's GitHub README.
Quilt is a command-line tool that tracks which agent wrote which lines in a shared Git checkout, so multiple AI coding agents can work in one repo at once and each commits only its own changes.
It captures every edit at the tool boundary, keeps a per-line record of who wrote
what, and reconstructs each agent's own changes at commit time. Git stays the
source of truth. Quilt never calls an LLM or spawns agents, and its state lives in
a .quilt/ sidecar you can delete without touching your repo.

npm install -g @quilt-dev/cli
quilt setup # wire Quilt into your repo (Claude Code, Cursor, or plain git)
You can run about three coding agents on one repo before they start clobbering each other. Two edit the same file and one silently overwrites the other. Their commits tangle into one blob you can't attribute. The usual advice is "run fewer," or "give each agent its own worktree."
Quilt lifts that ceiling. The agents share one checkout, and Quilt keeps attribution clean, prevents collisions, and gives each agent its own clean commit. And it holds as you add agents. Here are seven fanning out on one repo, run head to head:

That is ./examples/fleet.sh. It uses the quilt system, and you can also run it yourself.
commit --mine commits only your lines, even when
they share a hunk with another actor's.utils.js#formatPrice, not the whole file, so
agents editing different functions never contend. Ten languages via tree-sitter;
whole-file claims for the rest.Every commit Quilt produces is an ordinary Git commit. It trusts Git and never
rewrites it, and all state lives locally under .quilt/. No account, no daemon.
quilt setup # wire Quilt into the repo (MCP server, hooks, coordination)
quilt doctor # confirm it's wired and capture is flowing
Give each agent process its own id, so Quilt can tell them apart:
QUILT_ACTOR=auth-agent claude # this agent's edits are attributed to auth-agent
Then each agent commits only its own lines:
quilt status # who owns what
quilt preview --mine # exact patch that would be committed
quilt commit --mine -m "fix auth redirect"
quilt fleet shows the whole picture: every actor, their claims, and anything
that needs a human. See docs/reference.md for the full
command list.
A worktree per agent is the usual answer, and for fully independent tasks it works. But isolation moves the problem to the end, and its costs grow with the number of agents.
| Run fewer agents | Worktree per agent | Quilt | |
|---|---|---|---|
| Parallelism | capped low | high | high |
| Setup per agent | none | full install/build/env × N | none (one checkout) |
| See each other's in-flight work | n/a | no | yes |
| Collisions | avoided by hand | surface at merge | prevented, or surfaced live |
| Clean per-agent commits | n/a | after a merge | yes |
Worktrees isolate; they don't coordinate. When agents work the same code at the same time, you usually want them to see each other and account for each other as they go. That is what Quilt does. The two aren't mutually exclusive: worktrees for independent, long-running work, Quilt for agents in the same code at once.
quilt setup wires the capture hooks and a shared MCP server. On Claude Code the
hooks let agents use the built-in Edit and Write tools normally while Quilt
records each change's author and blocks a write into code another agent holds,
with no protocol for the agent to follow. Each agent just carries its own id in
QUILT_ACTOR. For other runtimes, the same capture and prevention is available as
MCP tools.
See docs/orchestrators.md for Codex, Cursor, Aider, and the difference between process-per-agent and many-agents-in-one-process setups.
.quilt/ state layout.Contributions are welcome. See CONTRIBUTING.md.
MIT
Be the first to review this server!
by Modelcontextprotocol · Developer Tools
Web content fetching and conversion for efficient LLM usage
by Modelcontextprotocol · Developer Tools
Read, search, and manipulate Git repositories programmatically
by Toleno · Developer Tools
Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.