crossweave gives each coding agent its own git worktree and shell, shows which one is working, asking or done, and trial-merges them in the background so you land (merge back) only what holds up. For developers who already run Claude Code, Codex or Gemini in more than one terminal.
Install (macOS and Linux)
curl -fsSL https://raw.githubusercontent.com/NMHx2005/crossweave/main/install.sh | shA scripted demo on a made-up project, recorded on the development build (v0.6.0): the sessions, commits and merges are real, the agent screens are scripted and the status marks are sent with cw notify.
Three steps, all of them in your own terminal and shell.
cw session new api
Each one gets its own worktree, branch and port block, and a shell in it.
claude
Type claude, codex or your own command in each shell. The rail shows who is working, asking or done.
cw converge status
Trial merges run in the background and show what merges clean and in what order. Then you land: cw land session api --yes.
Grouped by what you are doing. Each card is one sentence; its limits are one click away.
Each session is its own git worktree and branch, with a port block and a shell that is yours.
Each session gets its own branch, port block ($PORT), cache directory and optional database or Docker names. What runs in the shell — claude, codex, a dev server — is yours to type.
Leases are cooperative: a process that ignores them can still collide with another session.
Write a prompt once and send it to several sessions, with an exact preview.
Write a prompt once, optionally refine it with a program you name, and send it to one or several sessions with an exact preview. Enter is pressed only if you tick it.
Whether a session runs an agent is a guess; the draft is kept in memory only.
One click starts a session with its launcher, extra terminals and a browser on its port.
A preset starts a session with its launcher, extra terminals that each run a command, and a Browser pane on the session's port.
The commands live in your own settings file, and nothing waits for the server to be ready.
One list says which session is working, asking or done, inferred from the shell.
Every session on one list says whether it is working, waiting for you, done or failed — inferred from the shell itself, with nothing to configure.
Inferred from screen words, output and the process tree: reliable for Claude Code, Codex and Gemini, approximate for others. cw hooks install claude (or codex) makes them exact where the agent reports them.
The failing tail, error lines, console errors and the diff in one pane, ready to send.
A Debug pane gathers the failing test tail, the error lines, the browser panes' console errors and the diff, and drafts them for you to send. cw debug prints a similar bundle (the check output, the terminal's errors, a diffstat and the agent's latest words) to paste to an AI.
Error-line detection and secret scrubbing are heuristics, not guarantees.
Let an agent read or drive a browser pane: off by default, and it asks before it acts.
cw browser reads and drives a Browser pane behind a per-pane Off, Read or Control switch. It starts Off; control outside localhost, and running a script anywhere, asks you for each command.
Page text can carry hostile instructions and is marked untrusted; the switch is per pane and never remembered.
Background trial merges show what merges clean and in what order; cw land follows that evidence.
Background trial merges show which sessions merge without conflict and in what order, and cw land is gated on that evidence.
Evidence is valid only against the base commit it was trialled on, so after a land the others read unknown until they are re-trialled. It shows conflicts, not correctness, and --force can land on incomplete evidence.
Two sessions' changes side by side, shared files marked, each with its test verdict.
Two sessions' committed changes side by side, shared files marked, each side's test verdict and its own Land button.
Committed work only, and two sessions touching the same file is not the same as a conflict.
A hidden git commit around each recognised agent turn: see what it changed, take files back.
When a recognised agent starts and finishes a turn, crossweave records the worktree as a hidden git commit. See what a turn changed, or take the files back; a restore is a dry run first and saves a return point.
Needs a session with its own worktree and a recognised agent; turn boundaries are inferred and an automatic checkpoint can be skipped; ignored files are not included; the newest 50 are kept. Checkpoints are git objects in your repository, visible to git log --all and to git push --mirror, and they include non-ignored files such as secrets.
Click a diff line, write a note, and the notes are pasted into the session's shell.
Click a line in the Changes pane or a checkpoint, write a note, and the notes are pasted into the session's shell as one block. Nothing presses Enter for you.
Comments live in memory only, and a plain shell with no agent is refused.
Opt in: your trusted test command runs when an agent ends a turn, and a failure can alert you.
Opt in, and your trusted test command runs when an agent ends a turn that changed files. A failure can be sent to the shell with secrets redacted, and raises a desktop alert that never shows the output.
Off by default. Turn ends are inferred, so a run can be missed or repeated. It runs code the agent just wrote, outside any sandbox, for every project whose command you trusted; the alert comes from the open window, so only projects it has open raise it.
Secret, CI, migration and dependency files are badged, and Land asks before secrets and CI.
Files named like secrets, CI and hook configs, migrations and dependency manifests carry a badge in Changes, Checkpoints and Compare, and the Cockpit's Land button asks first for secret-like and automation files.
Judged by file name only: it can miss a key pasted into an ordinary file and flag a harmless one. cw land and Land all ready do not ask, and the question is skipped if the diff cannot be read.
A new session can start with a launcher — or just a shell.
Or your own wrapper (cx, a script, a dev server). crossweave does not choose or configure an agent: a launcher types the command you saved into the session's shell and runs it, and you can start with a plain shell instead.
| By hand (git worktree + tmux) | crossweave | |
|---|---|---|
| One branch and checkout per agent | You create and remove each worktree. | cw session new makes the worktree and branch; cw gc reclaims what ended. |
| Ports, caches, databases | Whatever you remember to set. | A port block, a cache directory and optional database or Docker names per session (cooperative, not enforced). |
| Who needs you | Flip through windows. | One rail: working, asking, done or failed. Status is inferred from terminal activity; accuracy varies by agent. |
| Which to merge first | Your judgement. | Trial merges show what merges clean and a recommended order. They show conflicts, not correctness. |
| A record of each agent turn | The reflog, if you committed. | A checkpoint per recognised turn you can inspect and restore (v0.6.0). |
crossweave adds a daemon and an app to the workflow above; if you only ever run two agents, plain worktrees are fine.
0.6.0 makes the loop with an AI agent safer and faster without choosing or configuring the agent for you: a checkpoint around every agent turn you can look at and…
0.5.0 gives the cockpit a Settings page in the manner of Cursor's and a Dashboard that shows what your projects and sessions cost in disk and memory — and proposes,…
0.4.0 is the release where the cockpit and the shell talk to each other, and where running several agents at once gets easier to supervise: a session can say it is done,…
A local-first tool that runs many sessions on one repository and lands them back. A session is a git worktree plus a shell in it, like a tmux window with its own branch. A background daemon (cwd) does the bookkeeping; cw, a terminal dashboard and the Cockpit app talk to it.
No. It has a lightweight file view and a diff, but it is not trying to replace your editor. Cmd+click opens files in the editor you choose.
Whatever you can run in a shell. There are launchers for Claude Code, Codex, Gemini CLI, OpenCode, Cursor Agent, Copilot CLI, Aider, Amp and Qwen Code, and you can add your own. Status marks are most reliable for Claude Code, Codex and Gemini.
No. You pick a launcher, or a plain shell, and you edit each launcher's command in Settings. Starting a session with a launcher types that saved command into the shell and runs it. crossweave does not pick, configure or supervise an agent.
crossweave itself sends nothing anywhere and has no telemetry: a local daemon behind one unix socket. Its only network uses are the installer's download, cw update, and an optional update check against GitHub. The Refine command is a program you name, and the agents you run and the pages you open have their own network behaviour.
The CLI, daemon and terminal dashboard run on macOS (Apple Silicon and Intel) and Linux (x64). The Cockpit app is macOS on Apple Silicon. Windows is not a target.
It is free and open source under the MIT licence.
Notarizing needs a paid Apple Developer account, which the author does not have yet. A browser download of the app will therefore trigger a macOS warning; the installer path and the manual steps on the Download page avoid or clear it.
Run cw update. cw also looks for a newer release in the background (the answer is cached for a day) and tells you when one exists; cw config update-check off turns that off.
Only if you turn it on (Settings → Checks, off by default) and only for a test command you trusted with cw config trust. It runs code your agent just wrote, outside any sandbox.
Quit the app, stop each project's daemon with cw daemon stop, remove sessions you no longer need, then delete the installed files. The exact steps, in order, are in the install docs.
The CLI and the daemon do everything; the Cockpit is the desktop view over them, on macOS with Apple Silicon. On Linux, or without the app, use cw and the terminal dashboard (cw tui).
It merges the session's committed work into the base branch in your main checkout, as a squash by default (merge and rebase are configurable). The checkout must be clean, a running session needs --force, and a conflict stops it. Afterwards the session's worktree and branch are removed, so anything uncommitted in that worktree is not kept.
An agent IDE is an editor with agents inside it. crossweave is the layer under your own tools: it gives each of them an isolated worktree and shell, shows their state and lands their work. It does not replace your editor or choose your agent.
A worktree shares the repository's object store, so it holds your working files, not another copy of the history. Dependencies installed per worktree (node_modules) are what grow. The Dashboard shows the disk each session holds (a lower bound while a measurement is still running), and cw gc reclaims ended sessions.
Your agents run as parallel warp threads. crossweave is the weft: the cross-thread that binds them so the fabric holds together.
Two worktrees, two shells, one rail. Follow the quickstart.