Kudzu MCP server
Commit Nov 13, 2026Provides version control infrastructure designed for AI agents with features like sparse cloning, history as an API, and lock-free landing.
Also known as garyships/kudzu
- Stars
- 2
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 13, 2026
- License
- MIT
What is Kudzu MCP?
Kudzu provides version control infrastructure designed for AI agents with features like sparse cloning, history as an API, and lock-free landing.
Summary generated from the project's README
About Kudzu MCP server
Managing version control for large-scale AI agent workflows is what Kudzu enables. Unlike standard Git, which requires full repository clones and manual pushes, this infrastructure is built specifically for agents that need to perform thousands of concurrent operations. It uses sparse cloning to fetch only the specific files or directories an agent needs, significantly reducing bandwidth and time compared to traditional methods.
Developers can connect Kudzu to MCP clients like Claude Code or Cursor using a local unix socket. The system provides 16 specialized tools, including kudzu_log, kudzu_blame, and kudzu_diff, which allow agents to inspect history and file changes directly via server APIs without needing a local checkout. For making changes, the server supports lock-free landing through a compare-and-swap mechanism, meaning agents can rebase and commit changes to main without waiting in merge queues or dealing with push conflicts.
This setup is ideal for teams running massive agentic workloads where traditional source control would fail due to clone storms or merge jams. It operates through a tiered architecture of servers, regional caches, and node daemons to scale reads and writes efficiently.
What you can do with it
- 1Inspect file history without checkoutsAsk an AI agent to identify who last modified a specific line of code and what other files were part of that change.
- 2Perform sparse repository cloningInstruct an agent to fetch only a specific subdirectory to save time and resources.
- 3Automate version bumps and landingsHave an agent update a version file and merge the change directly into the main branch.
- 4Handle high-concurrency mergesEnable multiple agents to commit changes simultaneously without being blocked by merge queues or locks.
Written from the project's README. Every use case is checked against a quote from it.
Configuration
KUDZU_REMOTE
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablegaryships/kudzu is public and reachablegithub.com/garyships/kudzu ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-13github.com/garyships/kudzu ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubKudzu
Git was built for humans. Kudzu is built for agents.
Version control infrastructure for the agent era. No full clones. History as an API. Lock-free landing for thousands of concurrent agents. MCP-native.
Website · Demo video · Design · For AI agents · 中文
⭐ Agents are about to outnumber the engineers who run them. If you think source control should be ready, star the repo.
Agents break git
Every engineer is about to run a hundred agents. They clone, commit and merge around the clock, all at once. Git was designed for one person on a laptop, and it breaks first:
| What breaks | What Kudzu does | |
|---|---|---|
| 🌪️ Clone storm | Every agent sandbox and CI job pulls the entire repo and all of its history. | Clients fetch only the objects they touch, through tiered caches. 50 identical cold requests become 1 upstream request. |
| 🚦 Merge jam | Thousands of agents race for main. Merge queues take a lock, pushes bounce, and everyone rebases and retries. |
The server rebases and lands with a compare-and-swap on the ref. No lock, no queue, no push. |
| 🔒 History trapped in clones | To ask "who changed this line?", an agent has to check out the repo first. | log, blame and diff are server APIs and 16 MCP tools. |
| 🪞 Mirror sprawl | Hundreds of mirrors, each a full copy, each needing repack and gc. | Immutable, content-addressed objects behind cache tiers. No packfiles, no maintenance. |
This isn't hypothetical. Anthropic's monorepo went from ~2,500 to 30,000+ merges a day in four months, and git couldn't keep up. They replaced it with an internal system, Scion, and published the design. Kudzu builds that architecture in the open, for everyone. The first version shipped the day after the post.
Try it in 60 seconds
curl -fsSL https://raw.githubusercontent.com/garyships/kudzu/main/install.sh | sh
cd any-git-repo && kudzu up # imports the history, runs server → cache → daemon
Then, in another terminal:
export KUDZU_REMOTE=unix:///tmp/kudzu.sock
kudzu log -n 5 --oneline # history without a checkout
kudzu blame README.md # computed on the server
kudzu clone --sparse src $KUDZU_REMOTE /tmp/wc # fetches only src/
With Go: go install github.com/garyships/kudzu/cmd/kudzu@latest. Windows builds are on the releases page.
🤖 Version control your agent can drive
Kudzu speaks MCP. One line connects Claude Code, and any other MCP client works the same way:
claude mcp add kudzu -e KUDZU_REMOTE=unix:///tmp/kudzu.sock -- kudzu mcp
Then just ask:
"Who last changed the retry logic in
services/api/handler.go, and what else did that changeset touch?" "What landed underservices/apitoday?" "Bump the version inVERSIONand land it on main." No checkout and no push: the server rebases and lands it.
| 11 read tools | 5 write tools |
|---|---|
kudzu_log kudzu_blame kudzu_diff kudzu_cat kudzu_ls kudzu_show kudzu_resolve kudzu_ancestry kudzu_refs kudzu_stats kudzu_wc_status |
kudzu_write (files in, landed changeset out) kudzu_land kudzu_rebase kudzu_wc_commit kudzu_wc_update |
--read-onlyhides the write tools.- Agents with a shell can use the Agent Skill instead.
- Every query and commit command takes
--json.
Setup for Cursor, Claude Desktop and other clients: docs/AI.md. There is also llms.txt for LLMs.
Kudzu vs git
| git | Kudzu | |
|---|---|---|
| Clone | full history to every client | only the trees and blobs you ask for, sparse by default |
| History, blame, diff | computed from your local clone | server API, no checkout needed |
| Commit | commit locally, then push | the server creates the changeset; nothing to push |
| Landing | merge queue, global lock | lock-free: server-side rebase plus compare-and-swap on the ref |
| Scaling reads | mirrors that each hold the whole repo | tiers of caches for immutable objects |
| Maintenance | repack and gc on every replica | none: no packfiles |
| Offline | ✅ fully | ❌ needs the server, by design |
| Storage | delta-compressed packs (smaller) | one object per blob, no deltas (larger) |
How it works
flowchart TB
S["kudzu server<br/>changeset log · refs · derived data<br/>history · blame · diff · rebase · land"]
CA["kudzu cache · region A<br/>in memory, coalesces misses"]
CB["kudzu cache · region B"]
D1["kudzu daemon · node 1<br/>on disk, shared by every job"]
D2["kudzu daemon · node 2"]
D3["kudzu daemon · node 3"]
S --- CA & CB
CA --- D1 & D2
CB --- D3
D1 --- A1(["agent"]) & A2(["agent"])
D2 --- A3(["CI job"])
D3 --- A4(["agent"])
Every tier answers the same object RPCs, so clients never need to know the topology. Objects are content-addressed and immutable, so any tier can serve any request.
Clone = ask for what you want, never say what you have.
sequenceDiagram
participant A as agent
participant D as node daemon
participant C as regional cache
participant S as server
A->>S: resolve main (proxied through the tiers)
S-->>A: changeset + root tree id
A->>D: want [root tree]
D-->>A: hit
A->>D: want [services/, docs/] (subtrees outside the sparse cone are never requested)
D->>C: miss: want [docs/]
C-->>D: hit, served from memory
D-->>A: trees
A->>D: want [blobs…] in batches, streamed and resumable
Landing never takes a lock.
sequenceDiagram
participant A1 as agent 1
participant S as server
participant A2 as agent 2
A1->>S: commit --land main
A2->>S: commit --land main
S->>S: CAS main m0 → c1 ✓
S->>S: CAS main m0 → c2 ✗ lost the race
S->>S: rebase c2 onto c1 = c2′, CAS c1 → c2′ ✓
S-->>A1: landed c1
S-->>A2: landed c2′ (rebased on the server)
Changesets record only what changed. Root trees, per-path history, a commit-graph skip list and blame are derived data that one recursive engine computes, eagerly or lazily. See docs/DESIGN.md for the details.
Run the tiers separately
kudzu up runs all three tiers in one process. In production each tier runs on its own: one server, a cache per region, a daemon per machine.
# import an existing git repo (re-run any time: only new commits are ingested,
# and main only fast-forwards, so work landed in Kudzu is never rewound)
kudzu import --store ./data --git /path/to/repo --as main
# ...and keep a git mirror of what lands in Kudzu (also incremental)
kudzu export --store ./data --git /path/to/mirror.git --ref main
kudzu server --store ./data --listen 127.0.0.1:7070 &
# or several stateless servers sharing Postgres and an S3-compatible bucket:
# kudzu server --meta postgres://... --objects s3://bucket/kudzu --listen ...
kudzu cache --upstream 127.0.0.1:7070 --listen 127.0.0.1:7071 &
kudzu daemon --upstream 127.0.0.1:7071 --listen unix:///tmp/kudzu.sock &
export KUDZU_REMOTE=unix:///tmp/kudzu.sock
# sparse clone, edit, land
kudzu clone --sparse services/api $KUDZU_REMOTE wc && cd wc
echo "// hi" >> services/api/handler.go
kudzu commit -m "api: say hi" --land main
# or skip the checkout entirely
kudzu write -r main -m "bump version" --land main VERSION=@./VERSION
A unix socket only lets its owner connect (mode 0600), because whoever can connect can land changes and move refs. To share a daemon between users, put its socket in a directory that is not world-writable, nor inside one, and pass --socket-mode 0660 (or 0666). Clients refuse a socket that another user owns in a world-writable directory such as /tmp, or in a directory of theirs inside one, since any user could have created it first.
Over TCP, anyone who can reach the port can read the repository and land, so give a server on TCP an access policy (--auth, see DESIGN.md §10). Every tier also refuses cross-origin writes from web pages, and a tier on a loopback address answers only to localhost or an IP address, so a web page you visit cannot reach it.
scripts/demo.sh /path/to/git/repo runs the whole flow end to end and prints each tier's cache statistics.
Numbers
These come from importing the last 529 commits (3,613 files) of a real repo, with every tier on one machine. They are illustrative, not a benchmark.
| time | |
|---|---|
| import 529 git commits, with all derived data | ~5 s |
sparse clone of src/ (1,838 files), cold daemon |
0.30 s |
| full clone, warm daemon | 0.46 s |
| full clone on a second machine, warm regional cache | 0.49 s |
git clone --no-local of the same repo |
2.07 s |
| 50 simultaneous cold requests for the same objects | 1 upstream request |
The trade-off: with no packfiles or deltas, server storage was 79 MB, against 26 MB for git's packfile.
Status
Kudzu is a working prototype with a test suite: go test -race ./.... Imports are checked against git ls-tree and git blame --first-parent, and exports round-trip back to git. Also built: per-directory access control (kudzu server --auth), several stateless servers on Postgres and S3-compatible storage (--meta, --objects), garbage collection (kudzu gc --store) and lazily fetched FUSE checkouts that you can edit and commit from (kudzu mount --writable, built with -tags fuse). v0.2.0 also fixes what a security review of every tier found; the changelog has each release's notes. Not built yet:
- Spanner or CockroachDB metadata stores (Postgres works today)
Contributions are welcome: open an issue or a pull request, and see AGENTS.md for a map of the code.
License
MIT. Independent open-source project. Architecture based on Anthropic's public write-up of Scion, Redesigning source control at Anthropic.
Kudzu MCP questions
How does Kudzu handle large-scale agent activity compared to Git?
Unlike Git, which requires full clones and can suffer from merge jams, Kudzu uses tiered caches for sparse fetching and a lock-free compare-and-swap mechanism for landing changes.
Can I use Kudzu with Claude Code or other MCP clients?
Yes, Kudzu is MCP-native and can be connected to Claude Code or any other MCP client with a single line of configuration.
Does Kudzu require a full repository checkout to view history?
No, history, blame, and diff are provided as server APIs, allowing agents to query information without checking out the entire repository.
What are the storage trade-offs when using Kudzu instead of Git?
Kudzu uses one object per blob without deltas, which results in larger storage requirements compared to Git's delta-compressed packfiles.