Run Ten Agents in Parallel and Your Git Repo Breaks First

The pitch for coding agents has been consistent all year: they run unattended, so you should run several at once. Five, ten, more. One on the auth refactor, one on the flaky test, one on the migration that nobody wants to touch.
The tooling mostly holds up. Then you try it, and the thing that breaks turns out to be your working directory.
Two agents in one checkout will overwrite each other's files within a minute. The fix has been in git since 2015: worktrees, which give each branch its own directory while sharing one object database. Git can do this. Git's interface for doing this is bad enough that most people never use it.
Worktrunk is a Rust CLI that fixes the interface. It has 11,900 stars, about 2,200 of them from the past week, and it is MIT or Apache-2.0 depending on which you prefer.
The three-typing problem
Creating a worktree in git requires typing the branch name three times:
``` git worktree add -b feat ../repo.feat cd ../repo.feat ```
Two of those three are redundant. They exist because the command wants a path and a branch, and the path is almost always derivable from the branch. That sounds like a small annoyance. It is the reason worktrees stayed a technique for people with strong opinions rather than a default.
Worktrunk addresses worktrees by branch name and computes the path from a configurable template. Any command that accepts a branch also accepts the path of the worktree holding it. So the awkward three-line dance becomes:
``` wt switch -c -x claude feat ```
Create a branch, create its worktree, and start Claude in it, from wherever you are. The `-x` flag runs a command after switching. Anything you append after a separator is passed through to that command, which is how you hand the agent its first instruction:
``` wt switch -x claude -c feature-auth ```
Three of those in one shell and you have three agents on three branches, isolated, with no coordination between them.
Install
Homebrew on macOS or Linux: `brew install worktrunk && wt config shell install`. Cargo, pacman, conda-forge and pixi all work. On Windows it is `winget install max-sixty.worktrunk` followed by `git-wt config shell install`.
The Windows note is worth repeating because it will bite someone: `wt` already points at Windows Terminal, so Winget installs the tool as `git-wt` to avoid the collision. You can also disable the Windows Terminal alias in app execution aliases and use `wt` directly.
The `config shell install` step is not optional. It installs the shell hook that lets a command change your current directory, which is the entire mechanism behind `wt switch`. Skip it and every command appears to do nothing.
The commands that matter
Four of them cover most of the workflow.
`wt switch ` moves you. `wt list` shows every worktree with status markers: `@` for where you are, `+` for staged changes, `↑1` for one commit ahead of main, `⇡` for unpushed commits. That output alone is better than `git worktree list`, which gives you paths and nothing else.
`wt remove` cleans up, deleting the worktree and the branch together, which is two commands in git and one place to get it wrong.
`wt merge main` is the interesting one. It squashes the current branch, rebases onto main, fast-forwards, and removes the worktree, in one step. If you have ever resolved the same conflict three times across three parallel branches, you know why this exists. Parallelism multiplies the merge problem, and the merge problem was already the least pleasant part of the job.
There is also `wt switch pr:123`, which jumps straight to the branch behind a pull request. Small feature, disproportionate quality-of-life.
Storage is the part nobody warns you about
Ten worktrees means ten copies of `node_modules` and ten copies of `target/`. On a laptop that is hundreds of gigabytes, and the first `cargo build` in each one takes four minutes.
Worktrunk handles this with copy-on-write build caches. On file systems that support it, APFS on macOS, btrfs and XFS with reflinks on Linux, the worktrees share the build directory and only diverge when a file changes. The first build pays. The next nine borrow.
This is the kind of feature that reveals what the author actually uses the tool for. Nobody adds shared build caches to a worktree manager as a marketing move. They add it after the fourth time their disk filled up.
The related detail is `hash_port`, a template filter that gives each worktree a unique port. Ten worktrees, ten dev servers, no port collisions, no manual bookkeeping. Combine it with a post-start hook that installs dependencies and boots the server, and a new worktree is fully operational the moment the agent starts.
Hooks are the sharp edge
Hooks run shell commands automatically at defined moments: after a worktree starts, before a merge, after a merge. Post-start hooks are how you get environment setup for free.
They are also arbitrary code execution triggered by a git operation. A repository can ship a config that runs something on `wt switch`, and if you clone it and switch into a branch, you ran it. That is the same class of risk as `npm install` running a postinstall script, and it deserves the same treatment: read the config before you trust the repo.
The tool's own answer to this is that hooks are declared in configuration you control. Whether that is enough depends on your threat model, and for anyone who clones unfamiliar repositories it is worth a thought.
What it does not fix
Worktrees share one `.git` directory, which means they share branch references, stash, and configuration. Two agents cannot check out the same branch. A `git rebase` in one worktree changes history that another worktree is sitting on. Reflog entries interleave in ways that make forensic work harder.
Worktrunk makes the common case pleasant and does not change the underlying model. If your agents need genuinely independent repositories, you want separate clones, and you lose the shared object store that makes worktrees cheap in the first place.
There is also a coordination problem the tool does not touch. Ten agents on ten branches will produce ten pull requests that touch the same three files, and no amount of worktree management makes those merge cleanly. The teams getting value from parallelism seem to be the ones assigning disjoint areas, not the ones running the most agents.
Why this kind of tool is winning attention
Agent frameworks get the announcements. The utilities that make agents usable get the stars.
That pattern has repeated all year: memory layers, permission modes, sandboxes, worktree managers. Each one exists because the model got good enough to do the work and the surrounding environment was never designed for a worker that does not get tired, does not ask questions, and will happily run for forty minutes in the wrong directory.
Worktrunk is a small, focused answer to one of those gaps. Its 11,900 stars count developers who tried to run three agents at once and discovered that the hard part was the file system.
Related articles
Chinese text in video always turns to mush. Dreamina handed the typesetting to code
Dreamina launched Motion Studio on November 10. It no longer generates frames; the model writes code that lays out text, shapes and pacing. Chinese titles stop blurring, but whether the content is right is still on you.
A community spreadsheet of taps that turns off the ads inside Chinese Android builds
A no-root tool that switches off the ads Chinese phone makers ship inside the system UI. Its method is a hand-written tap script per phone model, maintained by volunteers every time a ROM moves. It works, and the maintenance is the point.
GPT Image 2.6 held the token price and raised the bill
GPT Image 2.6 kept every token rate from 2.5 and still costs more per image, because more of the work now happens in output tokens. Eleven days into the ramp, the pricing structure says more than the leaderboard does.
Someone rebuilt IDM from the outside and wrote down what they did not touch
A Rust reimplementation of Internet Download Manager claims 5x the speed and 86 languages. The more interesting document is the paragraph explaining how it was built without copying anything.