❯ Native macOS · built on jujutsu
Run a fleet of Claude Code agents side by side: each isolated in its own jj workspace, drawn in a real GPU-native terminal, and able to message its peers directly — so they coordinate without you relaying between them.
For macOS 26 · Apple silicon · a jj repo
Why jujutsu
Spinning up parallel agents is the easy part — every tool does it. The friction shows up when you reorganize the work while the agents keep running, and that's a version-control problem. On git, your in-flight edits aren't even commits, so restructuring mid-flight risks stranding them. jj makes restructuring safe even while the agents are mid-edit.
| Git worktrees what every other parallel-agent tool builds on | jj workspaces how Revcode runs every session |
|---|---|
| Git worktrees Your work-in-progress isn't a commit — it lives in a working tree, off to the side of history. | jj workspaces Your working copy is always a commit; jj snapshots it continuously. No staging, no stashing, no in-between state. |
| Git worktrees Branch a new agent and it starts from your last commit — uncommitted work stays behind unless you stash it first. | jj workspaces Branch from exactly where you are. In-flight edits are already in the change, so they travel into the new session. |
| Git worktrees Reorganize the chain while agents run and their uncommitted edits can strand — you stop them, stash, rebase, and hope. | jj workspaces Reorganize anytime. Each session's work is already a commit, so a 2-second sync loop realigns every workspace as they keep running. |
| Git worktrees Amend or rebase a shared commit and its hash changes — branches, worktrees, and a session's “parent” all go stale. | jj workspaces Change IDs stay stable across amend, rebase, and squash, so a session's parent never drifts and integration is one command. |
Additive, not a migration. jj git init --colocate
turns your repo into a jj + git repo in place — your
.git, your remote, your git push, and your
teammates' git all stay exactly as they are. They never need to know
Revcode runs on jj.
What you get
Each session runs in its own jujutsu workspace, isolated on disk. And because jj snapshots the working copy continuously, your in-flight edits are always already part of the change — so a new session branches from exactly where you are, uncommitted work and all. No stash, no clean-checkout surprise, no half-finished rebase to recover from.
⌘N → new workspace + session from your current change
Revcode owns the rendering surface with libghostty — the engine inside Ghostty — drawing every pane on a Metal-accelerated thread. No tmux copy-mode, no webview in the way. You get native scrollback, native ⌘C / ⌘V, and full terminal fidelity across all of your sessions at once.
libghostty · GPU / Metal · zero tmux
Every session is a full, top-level Claude Code process in its own pane — and they're peers. A session can list the others, spawn a new one that branches from its change, and send a message that arrives in real time. Revcode routes it, so you're not the courier between your agents.
Anthropic's Agent Teams coordinates subagents inside one launch. Revcode coordinates independent, top-level sessions — each in its own workspace and pane you can switch to.
create_session · list_sessions · message_peer
A persistent sidebar shows every session's status — running, idle, or waiting on a permission prompt — so you can see at a glance which one needs you. Switch between them without detaching. Parked sessions stay alive across quits and restarts, because the jj workspace on disk is the source of truth, not an app database.
⌥↑↓ switch · ⌘N new session · survives restart
Everyday workflows
These aren't buttons. They fall out of running Claude Code on jj, with Revcode keeping every workspace in sync while the agents work. Each one is painful or impossible on git-worktree tools.
Mid-feature, your agent hits an unrelated bug.
create_session jj rebase -r @ -d <fix> Two independently landable commits — no working-tree juggling.
You want an alternative approach without losing your place.
jj squash / jj abandon The speculative branch starts from exactly where you were — in-flight edits and all.
Three sessions in flight; you want to reorder the commit chain.
message_peer No stopping agents, no stale worktrees to recover.
Spin up a speculative refactor Friday; come back Monday.
Persistence is the jj workspace itself, not a database that can drift.
Who it's for
Whether jj is already your daily driver, a word you've half-heard, or beside the point — Revcode meets you where you are.
Full, top-level Claude Code sessions in a native macOS GUI, each in its own jj workspace, coordinating over peer MCP. Nothing else runs this stack — and it's built around the way you already work, not bolted onto git.
Run the same parallel agents — minus the stash-dance and the stale-worktree cleanup. You stay in git and never have to think about the jj underneath; the payoff is reorganizing work mid-flight without it falling apart.
Spin up a single session, then fan out when a task naturally divides. Revcode keeps the whole fleet glanceable and in sync — and because every change is a commit you can undo, nothing lands in a half-finished state you can't back out of.
Where it's headed
Right now a manager session coordinates its executors by hand — you wire up jj and peer MCP yourself. The plan is to make that one coordinated step, with a live progress view over the whole fleet. These are the next commits on the graph, not shipped yet.
A manager spawns N executors, pulls their work in, and re-rebases the rest in one coordinated step — instead of composing jj and peer MCP by hand.
Branch a session that inherits the parent's conversation summary, not just its files — so the new agent starts where the last one left off.
An integrated graph that knows which commits are live in a running session, and warns before you reorganize one out from under it.
Revcode is in active development — we build Revcode with Revcode, every day. Leave your email and we'll tell you the moment the macOS build is ready, plus the occasional update. Nothing else.
macOS 26 · Apple silicon · a jj repo · coming soon