Skip to content
cmux alternative · macOS

A cmux alternative that runs Claude Code and Codex on whole projects.

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.

Jump to the row-by-row table

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

Is there a cmux alternative that also runs my dev services?

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.

Three agents, one prompt
lpm start api
lpm worktree api --count 3 --run claude --prompt "fix the flaky auth test"
lpm status --json

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.

lpm

The project

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

Run 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.

One prompt, three agents

Where a tab stops being enough

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.

Worktree

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.

Standalone copy

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.

See it

One prompt, three project copies

Duplicate fans the project out and starts an agent in each copy, all from one prompt.

How it compares

cmux and lpm, row by row

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.

  • Start, stop and restart a project's services
    lpm
    one click, or lpm service web restart
    cmux
    not documented — you run the commands in a tab
  • Bring up only the services one task needs
    lpm
    a named profile per subset
    cmux
    not documented
  • Ports checked before the stack starts
    lpm
    ask, free, or fail per service
    cmux
    listening ports shown on the tab
  • Saved commands for migrate, seed and lint
    lpm
    a project button, or lpm run
    cmux
    actions and custom commands in cmux.json
  • Config that lives in the repo
    lpm
    .lpm.yml you commit — services and profiles travel with the branch
    cmux
    user-level cmux.json, plus .cmux/cmux.json per repo
  • Drafts the config from your repo
    lpm
    your installed agent CLI reads package.json, Gemfile, compose files and Makefile
    cmux
    you write it
  • Isolated checkout per agent
    lpm
    linked Git worktree or standalone copy
    cmux
    not documented
  • Fan one prompt out to N agents
    lpm
    1–50 copies, the prompt queued on each
    cmux
    no fan-out documented — one prompt per workspace
  • Reports agent status back to the app
    lpm
    Claude Code and Codex, via hooks lpm installs
    cmux
    agent hooks, cmux notify, notification panel
  • Agent CLIs it launches for you
    lpm
    Claude Code, Codex, Gemini CLI, OpenCode
    cmux
    the same four, plus Aider, Cline, Goose, Amp and anything you type in a tab
  • Review the diff before you keep it
    lpm
    side-by-side diff pane
    cmux
    branch and PR status on the tab; no diff view documented
  • Scriptable from outside the app
    lpm
    the lpm CLI, with --json on nearly every verb
    cmux
    cmux CLI + Unix socket
  • Drive a browser from a script
    lpm
    browser tabs, not scriptable
    cmux
    snapshot, click, type, evaluate JS
  • Terminal-emulator quality
    lpm
    a terminal built for services and agents
    cmux
    libghostty rendering, vertical tabs, splits
  • Work on a remote machine
    lpm
    SSH projects with port forwarding, or a paired Linux host driven from your Mac
    cmux
    cmux ssh user@remote
  • License, and what a paid tier buys
    lpm
    MIT, nothing to buy
    cmux
    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.

Migration

What carries over from cmux, and what does not

Not much to convert — the two files describe different things. cmux.json configures your terminal; .lpm.yml describes your stack.

~/.config/cmux/cmux.json
// app-wide: shortcuts, sidebar, notifications,
// actions, custom commands, workspace layouts
// (.cmux/cmux.json adds per-repo actions)
<repo>/.lpm.yml
services:
  api:
    cmd: npm run dev
    port: 3000
  worker:
    cmd: npm run worker

profiles:
  light: [api]
  • cmux list-workspaceslpm list --json
  • cmux notifylpm set-status

    A badge on the tab, a chime, a macOS banner when you are away from the window, and a push to your phone.

  • socket control~/.lpm/lpm.sock

    One shell-quoted command per line.

  • a tab per agenta project copy per agent (lpm worktree / lpm duplicate)
  • a cmux action or custom commandan action in .lpm.yml — a button, or lpm run

    Declared 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.

Which one to pick

Terminal-first, or project-first

Both are macOS-native and open source. The split is which half of the agent workflow you want the tool to own.

Pick lpm

You want one switcher that owns starting, stopping, duplicating, and switching whole projects.

  • You want the whole project to come up with the agent: services, profiles, a port check at start, and a diff pane before you keep anything.
  • You keep several repos in play at once and want one window that already knows each one's services and which agents are busy in it.
  • You would rather the agent CLI already on your machine wrote the first draft of the service list, and you pruned what it got wrong.
  • You want the services in a file the branch carries, so a teammate on that branch gets the same stack.
  • You fan one prompt out to several copies of the repo, each agent on its own checkout.
Pick cmux

You want a native macOS terminal with agent ergonomics baked in.

  • You want the terminal itself to be programmable: vertical tabs, splits, a browser pane your scripts can click through, and cmux.json behind all of it.
  • You want libghostty rendering, and your Ghostty theme and font to carry over.
  • Your work is one repo at a time, and project juggling isn't your bottleneck.
See it in action

Projects, terminals, agents, a built-in browser — one click each

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.

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 iPhone
FAQ

Questions about cmux and lpm

  • What is cmux?
    A native macOS terminal from Manaflow built around AI coding agents: vertical tabs showing branch and PR status, split panes, a notification panel, a scriptable browser pane, and a CLI plus Unix socket to control all of it. It renders through libghostty and reads your Ghostty config for themes and fonts.
  • Is cmux free and open source?
    Yes. cmux ships under GPL-3.0-or-later; its repository adds that commercial terms may be available where the GPL will not do, and that a paid Founder's Edition buys early access to features still in progress. lpm is MIT and has nothing to buy. Cost is not the reason to choose between them.
  • Can I run several Claude Code or Codex agents at once?
    In cmux each agent gets its own tab, so two agents in the same folder still edit the same files. lpm splits the repo first — up to 50 copies at a time, each one a linked worktree on a branch of its own or a full folder copy that keeps its Git history — and queues the same prompt in every copy, with working, needs you, done or a problem on the agent tab that owns it. What the copies still share is ports and databases.
  • Can lpm and cmux run side by side?
    Yes, and it is a reasonable setup. cmux configures your terminal; lpm describes your projects. Neither reads the other's config.
  • How do I move a cmux setup to lpm?
    There is nothing to convert: cmux.json describes your terminal, not your stack. Add the folder in lpm, then hit Generate with AI in its config editor — the Claude Code or Codex you already have reads the repo, compose file included, and drafts the services for you to prune. A command you kept as a cmux action becomes an lpm action: one click, or lpm run.
  • Does lpm need tmux?
    No — and cmux does not need it either. lpm never puts your services inside tmux and does not require it on the machine: the services keep running when you quit lpm, reopening the app picks them up again, and there is no .tmux.conf anywhere in that.

Run your projects, your way.

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.