cmux
The terminal
Vertical tabs with branch and PR status, split panes, a browser pane a script can snapshot and click, cmux ssh for a remote workspace, and a socket API over all of it.
cmux gives Claude Code and Codex a scriptable Mac terminal. lpm adds the project around them: services, per-tab agent status, and 1–50 parallel copies.
cmux owns the terminal. lpm owns the project the agents run inside.
Facts checked against cmux's documentation, its configuration reference and the cmux repository. Every cmux row traces to those three; lpm's own rows were read back out of the app's source that day. Tell us what has drifted.
The short answer
cmux and lpm both give Claude Code and Codex a native window on the Mac, and they draw the line in different places. cmux is the terminal: vertical tabs showing branch and PR status, split panes, a browser pane that scripts can click through, and a Unix socket that can create workspaces and read the screen. lpm is the project: it starts and stops the services the agent needs, checks the declared ports first, and splits the repo before the agents start — a linked worktree branched off where the code stands now, or a straight copy of the folder that keeps its own Git history — so nothing one agent writes lands on top of another's work.
Both are free to use and macOS-only, and their configs describe different things, so running both is a normal setup rather than a compromise.
lpm start api
lpm worktree api --count 3 --run claude --prompt "fix the flaky auth test"
lpm status --jsoncmux
Vertical tabs with branch and PR status, split panes, a browser pane a script can snapshot and click, cmux ssh for a remote workspace, and a socket API over all of it.
lpm
Start the stack, check the ports, fan one prompt out to 50 copies, and read working, needs you, done or a problem off each agent's own tab.
Both
They configure different things and neither reads the other's config. Many people keep cmux as the terminal and let lpm own which project is up.
Three agent tabs in one folder are three agents editing the same files.
Duplicate turns the count into projects instead. Pick worktrees or standalone copies, set how many — up to 50 — choose the action or command each one runs, and type the prompt once. Every copy inherits the project's services and actions, and the sidebar shows what each agent is doing.
A real linked worktree per agent, on its own branch. Git carries tracked files only, so neither your .env nor your installed dependencies arrive — flip on Install dependencies when the copy needs them.
The project as it sits on disk right now, with its own Git repository, so two agents can attempt the same branch.
None of this isolates a port or a database. What lpm does is check every declared port as the copy comes up, and name whatever is already sitting on one — a warning at the door, not a partition. See the isolation models compared.
Duplicate fans the project out and starts an agent in each copy, all from one prompt.
Sixteen rows. Three go to cmux — the browser it can script, the emulator underneath it, and the longer list of agent CLIs it will launch for you.
| Capability | lpm | cmux |
|---|---|---|
| Start, stop and restart a project's services | one click, or lpm service web restart | not documented — you run the commands in a tab |
| Bring up only the services one task needs | a named profile per subset | not documented |
| Ports checked before the stack starts | ask, free, or fail per service | listening ports shown on the tab |
| Saved commands for migrate, seed and lint | a project button, or lpm run | actions and custom commands in cmux.json |
| Config that lives in the repo | .lpm.yml you commit — services and profiles travel with the branch | user-level cmux.json, plus .cmux/cmux.json per repo |
| Drafts the config from your repo | your installed agent CLI reads package.json, Gemfile, compose files and Makefile | you write it |
| Isolated checkout per agent | linked Git worktree or standalone copy | not documented |
| Fan one prompt out to N agents | 1–50 copies, the prompt queued on each | no fan-out documented — one prompt per workspace |
| Reports agent status back to the app | Claude Code and Codex, via hooks lpm installs | agent hooks, cmux notify, notification panel |
| Agent CLIs it launches for you | Claude Code, Codex, Gemini CLI, OpenCode | the same four, plus Aider, Cline, Goose, Amp and anything you type in a tab |
| Review the diff before you keep it | side-by-side diff pane | branch and PR status on the tab; no diff view documented |
| Scriptable from outside the app | the lpm CLI, with --json on nearly every verb | cmux CLI + Unix socket |
| Drive a browser from a script | browser tabs, not scriptable | snapshot, click, type, evaluate JS |
| Terminal-emulator quality | a terminal built for services and agents | libghostty rendering, vertical tabs, splits |
| Work on a remote machine | SSH projects with port forwarding, or a paired Linux host driven from your Mac | cmux ssh user@remote |
| License, and what a paid tier buys | MIT, nothing to buy | GPL-3.0-or-later, commercial terms on request, a paid Founder's Edition for early access |
Two of lpm's rows have a page behind them: what the lpm CLI hands an agent and what the diff pane shows before you keep a change.
Not much to convert — the two files describe different things. cmux.json configures your terminal; .lpm.yml describes your stack.
// app-wide: shortcuts, sidebar, notifications,
// actions, custom commands, workspace layouts
// (.cmux/cmux.json adds per-repo actions)services:
api:
cmd: npm run dev
port: 3000
worker:
cmd: npm run worker
profiles:
light: [api]lpm list --jsonlpm set-statusA badge on the tab, a chime, a macOS banner when you are away from the window, and a push to your phone.
~/.lpm/lpm.sockOne shell-quoted command per line.
lpm worktree / lpm duplicate).lpm.yml — a button, or lpm runDeclared once per project, so every copy of that project has it too.
Anything in the right-hand column that changes state — lpm start, lpm worktree, lpm service web restart, lpm run — is routed through lpm itself, so leave the app open when a script calls one. lpm list and lpm logs read the running services themselves, so they answer whether lpm is open or closed. The exception among the readers is lpm status, which prints what your agents are doing: the app is where those states are kept.
Keeping both is normal: cmux stays your terminal, lpm decides which project is up.
Both are macOS-native and open source. The split is which half of the agent workflow you want the tool to own.
A one-minute tour of lpm starting projects and handing one to Claude Code — lpm is a macOS app, so the clickable demo runs on desktop.Click anything — it runs live in your browser.
lpm is a macOS app with a multi-pane terminal workspace. Open this page on your computer to try the interactive demo.
Get lpm for MacOr check your Macs from your iPhoneClick a step to run it in the window.
Done poking around? Get lpm for Mac and point it at your own projects.
Agent terminals side by side, and what each one hands a running agent.
One agent per branch, and the ignored files a fresh checkout never brings along.
Hand Claude Code and Codex a CLI that starts services, reads logs, and fans out copies.
Read what an agent wrote file by file, beside the services it was working against.
The same split, weighed against the emulator you may already keep open all day.
lpm is free under MIT and macOS-only. Add a repo, draft its services with the agent CLI you already have, and keep cmux open beside it.