Each on its own ticket, worktree and branch. One sidebar tells you which is running, which is stuck on a decision, and which has left your hands — ticket to merge request, in the tmux you already have.
No runtime needed — installs a self-contained binary.
Five agents means five terminals to check, and you are the thing all five are waiting on. jmux gives them one rail to report on instead. Every frame below came out of a running jmux — the actual cells, the actual colours, the actual text. Scroll, and the window works.
Every session you have running, always on screen — branch, merge request, CI, and what the agent in it is doing right now.
No hunting through tabs to find out who is working. And when a twenty-session day gets loud, Ctrl-a f narrows the rail to Needs you or Active.
The flag and the timer say who is waiting on a decision, and how long they have been stuck. Everything else keeps running.
That state comes from hooks, not screen-scraping. Claude Code, Codex and pi report their own run state through installed emitters, so WAITING is a fact rather than a guess at what a buffer looks like.
Define the workflow you actually think in — To do, In progress, Waiting, Done — and sit each stage on however many tracker statuses it takes.
Ctrl-a G and the whole fleet re-files itself under your ladder. Press again and it groups by agent state instead, in urgency order: Needs you, Running, Active, Done, Idle. Work you've handed off sinks into one collapsed Parked band at the bottom.
The dim ○ rows are issues with no session yet. Grouped by stage they sit under the stage that claims them; anywhere else they collect in one Up next band.
Your queue and your fleet stop being two different screens.
Land on one and jmux shows the ticket beside the exact pre-flight: session name, the worktree it will cut, base branch, tool, agent. Nothing is provisioned yet.
Press Enter and all of it happens — worktree created, session opened, your agent launched with the issue already in its context. No stashing, no branch switching, no pasting a ticket into a prompt.
The row you were reading becomes the row above it.
Your tracker has 25 statuses, named for someone else's process. You think in five. So define your own stages — Urgent, To do, In Progress, Waiting, Done — and sit each one on as many tracker statuses as it takes. In Code Review and Awaiting QA Sign-off are both just Waiting. jmux runs your terminal off your ladder, not theirs.
Ctrl-a W — your stages, then every status your tracker offers. Two settings each: which stage it belongs to, and whether its work has left your hands.
In review, in QA, blocked on a teammate — that session drops into one Parked (n) row. Nothing is killed.
The issue moves, someone comments, the MR is touched, a pipeline goes red. It returns flagged, with nobody watching for it.
Each stage lists the work still waiting, right under the sessions already on it. Click a row and it becomes real — worktree, session, agent.
Ctrl-a u takes the top of your first non-empty stage and does the whole ticket-to-worktree-to-agent dance.
Ctrl-a a opens an issue from wherever you are. Ctrl-S files it and starts work on it.
Move an issue along when work starts, an MR opens, or it merges — with ^a Z to undo. Off until you say so.
Every other tool's answer to a growing fleet is a bigger grid. This one gets quieter as work leaves your hands — and loud again the moment it comes back. Nothing starts and nothing moves in your tracker until you say so: the fleet reports, you decide.
The sidebar tells you who needs you. This is where you watch all of them at once. Pin the Claude or Codex pane from every session into one live grid — then type into any tile and you are steering that agent for real.
Linear for issues. GitHub, GitLab or self-hosted GitLab for merge requests — the one integration a desktop app can't reach into your network to offer. Sessions link themselves to their branch's PR and issue, and pipeline status lands in the sidebar as a glyph.
Press n on any issue in the panel to start it. Or skip the picking: Ctrl-a u pulls the top item off your first non-empty stage and does the whole thing without asking.
An agent writing code you can't see is an agent you can't trust. Ctrl-a g opens a tabbed side panel — Diff, Issues, MRs, Review — with the Diff tab driven by hunk: syntax highlighting, word-level diffs, split and full-screen.
Split mode to watch the code land as it lands. Ctrl-a z for full-screen when it's time to actually read it. Then flip to the MRs tab and finish the job without opening a browser — a approve · r undraft · s status · o open.
Someone attached a screenshot to the bug. Everywhere else that's a URL you have to leave the terminal to follow. Here it's the picture — in the pane, under the sentence describing it, in the comment thread where the argument happened.
Real image data, drawn with the kitty graphics protocol in Ghostty, kitty, WezTerm and Konsole. Nothing to turn on: jmux asks your terminal whether it can draw and believes the answer. Where it can't, images stay the links they always were — and clicking a rendered one still opens it.
This works because jmux is the outermost program on your terminal. tmux runs inside a pty jmux owns, so the pixels never have to survive a multiplexer.
Ctrl-a b splits the pane and puts Chromium in it. Not a text-mode renderer, not a screenshot — a live page you can click, scroll, fill in and open DevTools on, without leaving the terminal.
Ctrl-a p → Open dev server works out what the session is actually listening on and opens it. It reads listening sockets, not your scrollback, so the server that printed its URL four hundred lines ago is still found — and a URL sitting in a log line is never mistaken for one.
Every pane is its own browser, with its own tabs and history. Your agents can drive them too — snapshot, click, fill, eval — so the thing writing the code can check its own work.
The browser is terminal-browser by Zenbu Labs (MIT). jmux doesn't ship it and doesn't reimplement it: you install it, and jmux relays its graphics, sizes its pane and hands it to your agents. Needs a terminal that can draw — and, for now, Apple Silicon macOS.
No other multiplexer and no agent IDE shows you this. jmux reads Claude Code's own OpenTelemetry stream and puts two numbers on a session's row: how much of its context window is gone, and how long its prompt cache stays warm.
Both change how you work a fleet. The first tells you which session is about to start forgetting things, so you can hand it off before it does. The second tells you which one to send the next message to now — writing into a warm cache costs up to 90% less on input tokens, and a five-agent day is a lot of input tokens.
Nothing to set up. If Claude Code is running, the numbers are there.
“I've used tmux for 5 years — jmux makes me 5× more efficient.”
“The attention flags, clean sidebar, and quick session switching have genuinely made my workflow much smoother and less chaotic.”
Every tool here gives you somewhere to run an agent. The question is how much of the rest — the ticket, the branch, the review, the handoff — it is willing to take on.
| jmux | Agent IDEs | Agent muxes | Raw tmux | |
|---|---|---|---|---|
| Panes, splits & sessions that survive a detach | ✓ | Embedded terminals | ✓ | ✓ |
| Agent run state at a glance | Hooks + telemetry | ✓ | Screen heuristics | ✗ |
| Worktree isolation & diff review in place | ✓ | ✓ | ✗ | ✗ |
| Issues & PRs, incl. self-hosted GitLab | ✓ | Partial | ✗ | ✗ |
| Your workflow: stages, parking, ticket → merged | ✓ | ✗ | ✗ | ✗ |
| Context window & cache-warm economics | ✓ | ✗ | ✗ | ✗ |
| Keeps your terminal config, plugins & bindings | ✓ | ✗ | Brings its own | ✓ |
| Reversible — your sessions outlive it | ✓ | ✗ | ✗ | ✓ |
← swipe the table to compare →
Agent IDEs — Orca, Cursor, Windsurf, Conductor — ship their own terminal, editor and runtime in a desktop app.
Agent muxes — herdr and friends — are agent-aware multiplexers that replace tmux rather than build on it.
And Claude Code's own Agent Teams? That's an input, not a column. Agent Teams splits one task, in one repo, with one vendor's agent. jmux runs your whole queue across repos, agents, worktrees and branches — an Agent Teams run is one session inside it.
The other agent multiplexers are replacements — a new server, a new config, a new keymap, and your plugins left behind. jmux isn't one. It drives the tmux you already have, so your config, prefix key, plugins, theme and bindings all carry over. It enforces only the handful of settings it needs to draw its own chrome.
Which is what makes the work genuinely durable. Sessions detach and reattach over SSH, from a second machine, from a phone. They survive the terminal closing — and they survive jmux itself being killed, because the agents were never running inside jmux to begin with. Quit for good and your sessions are exactly where you left them, reachable with jmux gone entirely.
The chrome follows suit: every glyph and surface is drawn from your terminal's own palette, so jmux looks native in light or dark without a line of config. Tune the rest from the settings screen (Ctrl-a I) — running / waiting / complete colors, code host, issue tracker, panel widths.
Other control surfaces stop at panes and processes. This one understands tickets, branches and run state — so an agent can pick up TRA-933, cut its own worktree and session, do the work, and raise a flag when it needs a human. Every answer is JSON. Context resolves itself from $TMUX, so it works headless.
Every session at a glance — project group, git branch, agent state, pipeline status, linked issue or PR, live context tokens. A workspace map where your status bar used to be.
Ctrl-a b — real Chromium in a pane, beside the agent building the page. Ctrl-a p → Open dev server finds what the session is serving and opens it. Your agents can drive it too.
Ctrl-Shift-↑/↓ — no prefix, no menu, no mode. Or click the sidebar.
When an agent finishes or gets stuck, its session raises an orange ! in the sidebar — straight off a Claude Code Stop hook.
Ctrl-a p — fuzzy-search sessions, windows, pane actions, settings, and issue commands.
Ctrl-a I — state colors, adapters, per-repo defaults. The chrome already matches your terminal's palette.
jmux --demo runs everything on mock data. No credentials, no tracker, nothing to configure.
Hook-driven run state, live context & cache from telemetry, plus a jmux-control skill.
Installed by jmux --install-agent-hooks. State is reported, not guessed.
PR detection, CI glyphs, approve & mark-ready from the panel. Enterprise supported.
Is Ctrl-a b — Chromium beside your agent, drivable by it. By Zenbu Labs, MIT.
Any terminal agent works in a pane, with opt-in screen detection for run state. vim, emacs, lazygit, your own scripts — it's a real terminal underneath.
Free and open source. tmux 3.2+ is the only requirement — and jmux offers to install that for you.
No runtime needed — installs a self-contained binary.
macOS and Linuxbrew. The only channel that installs tmux for you, since brew can declare it a dependency.
brew install jarredkenny/tap/jmux
Runs jmux from source under your own Bun 1.3.8+. The way in on Alpine and other musl systems, where the binary cannot run.
bun install -g @jx0/jmux
Signed tarballs with checksums for macOS and Linux, on arm64 and x86-64 — including a baseline build for older CPUs.
Browse the release →macOS and Linux (glibc). On Windows, run it inside WSL. Not ready to point it at your repos? jmux --demo runs the whole thing on mock data — no credentials, no tracker, nothing to configure.