Hand off the issue.
Review the PR.
MergeMill runs several coding agents in parallel, each in its own git worktree, and takes every feature from plan to merged pull request. You approve what runs, cap what it spends and decide what merges.
Uses your existing Claude Code login · Apple Silicon and Windows x64
FEATURE · ENG-412
Move session tokens to httpOnly cookies
- ✓ Plan
- ✓ Spec
- ● Build
- Review
- PR
- Merge
- $0.42
Vega · slice 1/3
Waiting for approval: npm test
- $0.31
Orion · slice 2/3
Editing src/session/cookies.ts
- $0.00
Lyra · slice 3/3
Blocked by slice 1, starts when it merges
APPROVAL · VEGA wants to run
$ npm test -- session
Parallel
Every agent on its own branch and worktree
6 steps
Plan to merged PR, each step configurable
Capped spend
Live cost per task, budget per feature
4 ways in
Desktop, phone, terminal and a home server
Why MergeMill
One agent at a time is slow. Five in one checkout is chaos.
Coding agents are good enough to do real work, but running them well means juggling terminals, branches, approvals and bills. MergeMill does the juggling, so your attention goes on the decisions.
Run more at once, safely
Each agent gets its own git worktree and branch. They never edit the same files, and your own checkout is never touched.
Stay in control without hovering
Edits in the worktree go through on their own. Shell commands and web access wait for your yes. Questions arrive as cards, and you hear from MergeMill only when it needs you.
Ship finished work, not drafts
A feature doesn't stop at “code written”. It's reviewed, opened as a PR, watched through CI and review comments, and merged when you say so.
How it works
From issue to merged PR, with you at the checkpoints.
Start a feature from a sentence or a Linear issue. A different agent takes each step, and you approve the moments that matter.
Plan
An agent interviews you about the feature until the plan is right, then writes it down.
You: approve the plan or ask for changes
Spec
The plan becomes a spec, carved into small slices that can each ship alone, with what blocks what.
You: approve the spec and slices together
Build
Every unblocked slice gets its own agent and worktree, is built test-first, and is merged into the feature branch.
You: answer approvals and questions
Review
A fresh agent reviews the whole branch, fixes problems and flags what a human must look at.
You: read the flagged areas
PR
The pull request is opened with a proper description and the flagged areas as inline comments.
You: review it like any PR
Merge
An agent watches CI and review comments and fixes what comes up, until the PR is green.
You: squash-merge when ready
Every step's prompt, skills, model and pre-approved tools are yours to change. Add steps such as Test, which starts the dev servers for you to try the feature, or Publish, which posts the plan and spec to Linear, or write your own.
Features
Everything you'd otherwise build yourself.
Know what it costs, as it runs
Cost, tokens and cache hits per task. Today's spend and burn rate. Your subscription's 5-hour and weekly limits. Set a dollar cap per task or per feature, and raise it if you want the work to carry on.
Linear in, Linear out
Pick an issue and hand it over. The plan and spec land on the issue, slices become sub-issues, and the status moves itself: In Progress, In Review, Done.
One feature, many repos
Group an API and the web app that calls it into a Project. A feature gets a worktree per repo on one branch, its own dev servers wired to each other, and each repo's own review and PR rules.
Your choice of model
Claude agents run on the Agent SDK with your Claude Code login. Cursor and Codex agents run alongside them, and every step can use a different model.
Review that knows what to flag
The Review step fixes what it can and flags the areas a human must check, such as auth, payments, migrations and public APIs, as inline comments on the PR. Commit messages are written from the real diff.
Picks up where it left off
Agents, history and spend survive a restart, and messaging an agent resumes its session. Notifications and a dock badge tell you when something needs you, and the app keeps itself up to date.
Anywhere
Close the laptop. The work keeps going.
One engine, four ways to reach it. Approve a command from your phone, check in over SSH, or hand a feature to a server at home.
macOS · Windows
Desktop app
Everything in one window: features, agents, review, workflows and spend history.
iOS · Android
Phone app
Finds your desktop on the same Wi-Fi. Approve requests, answer questions and start features from the sofa.
macOS · Linux
Terminal
A full-screen terminal UI and scriptable subcommands on the same saved state. Works over SSH.
Docker
Home server
Run the engine headless on a NAS and hand features to it. Bring them back when you're at your desk.
Compared
Versus a few terminal tabs.
| Agents in terminal tabs | MergeMill | |
|---|---|---|
| Running several at once | Agents share a checkout and trip over each other | A worktree and branch per agent, merged back cleanly |
| Knowing what needs you | Flip through tabs to find the one that's waiting | Approvals and questions in one place, with notifications |
| Cost | Find out when the bill arrives | Live per task, with caps per task and per feature |
| Getting to a PR | You plan, review, open and babysit it | Plan, spec, build, review, PR and merge as steps |
| Your issue tracker | Copy and paste the issue, update it by hand | Linear issues in, statuses and documents updated for you |
| When you walk away | Work stops when the laptop sleeps | Approve from your phone, or hand off to a server |
Start your first feature in five minutes.
MergeMill was built for personal use with a Claude subscription. If you build on it for other people, use API key authentication instead.
Install and open MergeMill
Signed and notarized on macOS. It keeps itself up to date from then on.
Be signed in to Claude Code
MergeMill uses that login. Add the GitHub CLI for pull requests and a Linear key if you use Linear.
Pick a repo and start a feature
Describe it in a sentence or choose a Linear issue. Approve the plan, and the work begins.