Ninebrains

Run Claude Code and OpenAI Codex agents in parallel, each in its own git worktree,
with a central Brain that hands out the work and gates that prove it before it counts as done.

Free, open-source, local-first desktop app for macOS, Windows and Linux.

Website · Quickstart · Documentation · Compare · Security · FAQ

---

Run four agents without losing the thread

One coding agent in one terminal is easy to follow. Four at once is not: they share a checkout, step on each other's files, and nobody checks their claims before you read them.

Ninebrains gives every agent a lane of its own, then puts something in charge of the work and something else in charge of the truth.

	What it does
Lanes	Each agent gets its own git worktree and branch, terminal, editor and browser. Four to a tab, unlimited tabs. They cannot touch each other's files.
The Brain	Holds the plan as a graph of jobs with dependencies, plus a mailbox, and hands ready jobs to whichever lane is idle. Its status is one click away from Settings, and visible across every open project at once from Arena.
Gates	When a lane says it is done, a second, independent run has to prove it: tests, screenshots, a read-only reviewer, citation checks. No agent grades its own work.

The name comes from the octopus: one central brain, plus a small brain in each of its eight arms.

Ninebrains is a fork of Emdash by General Action, so you also get its worktrees, terminals, Monaco editor, diffs, pull requests, issue integrations, MCP servers, skills and automations.

Status: early but shipping often. The latest release is out for macOS, Windows and Linux; builds are not yet code-signed.

Features

In this build:

• Lanes grid. 2×2 lanes per tab, unlimited tabs, status lights driven by the agents' own hooks, sleep (hide a lane; its agent keeps running), maximize, and a per-lane browser.
• The Brain. A drawer in the Lanes view runs a Claude Code session as the Brain, which turns a brief into a job graph and dispatches ready jobs to idle lanes. Settings → General explains what it does and lets you pause dispatch; Arena shows its status and every open job across every project you have open, with a jump straight to a blocked job's plan.
• Verification gates. Tests, a three-width screenshot check, a read-only reviewer and citation checks. A failed gate sends feedback back to the lane and retries, up to three attempts, then blocks and tells you.
• Rigor settings. Two 0-10 sliders in Settings → Gates decide which gates every job gets, with a per-project override.
• Planner. A canvas where jobs are nodes and dependencies are edges. Run plan compiles it into Brain jobs, idempotently, and refuses cycles. The Brain can draft a plan from a brief; accept all of it or just the nodes you select, and the rest stays dashed until you decide.
• Packs. Per-project bundles of lane roles, skills, MCP servers and gates, for coding, SEO and research. Every pack is off until you turn it on.
• Lane roles and modes. Start a lane from a pack role, and switch a lane between attended and unattended from its header.
• Unattended runs. claude -p and experimental codex exec runs, with per-run budgets, a sandbox, a minimal environment and a STOP switch that ends every run in under 5 seconds.
• Nothing phones home. Telemetry is off, with no endpoint built in. No hosted account. Auto-update checks GitHub Releases in packaged builds (once at 30 s, then hourly, release metadata only) and never downloads or installs anything without your Download and Restart now choices; every candidate must verify against Ninebrains' own Ed25519 update key, baked into the app.

Planned: a per-lane account picker and usage meter, per-lane port leases, an overnight queue with a morning digest, a video pack, and signed builds (Apple Developer ID + notarization, Windows Authenticode) so Gatekeeper and SmartScreen stop warning.

A closer look

The Brain Type a brief into the Brain's terminal. It creates jobs, links their dependencies, and the app dispatches ready jobs to idle lanes.	Verification gates Every attempt keeps its evidence: test output, screenshots at three widths, and the reviewer's verdict.
Planner Draw the plan as jobs and dependency edges, then compile it into Brain jobs with Run plan.	Lane roles Start a lane from a pack role. Its prompt, agent and model preferences fill in automatically.
Arena Every open job across every project you have, with the Brain's dispatcher status and a jump to a blocked job's plan.	Settings → General What the Brain does, its live status, and a switch to pause dispatch, without opening the drawer.

Install

One line

Installs Ninebrains, or updates an existing install. The script picks the file for your OS and CPU, downloads it from GitHub Releases, and checks it against the release's SHA256SUMS before installing anything. With the GitHub CLI signed in it also verifies the build attestation, and installs nothing if that fails.

# macOS and Linux
curl --proto '=https' --tlsv1.2 -fsSL https://ninebrains.dev/install | sh

# Windows (PowerShell)
irm https://ninebrains.dev/install.ps1 | iex

Read the script first if you like: open the same URL in a browser. What the checksum check does and does not prove is in Verify a download.

Download

Get the latest build from GitHub Releases:

OS	File
macOS, Apple Silicon	Ninebrains-<version>-mac-arm64.dmg
macOS, Intel	Ninebrains-<version>-mac-x64.dmg
Windows	Ninebrains-<version>-win-x64.exe
Linux	Ninebrains-<version>-linux-x86_64.AppImage or …-linux-amd64.deb

Builds are not code-signed yet. macOS Gatekeeper and Windows SmartScreen will warn you, and that is the layer the one-line installer and the in-app updater work around, not through. Updates installed from inside the app are signed with Ninebrains' own Ed25519 update key; check every manual download against the release's SHA256SUMS file and build attestation before you open it:

shasum -a 256 -c SHA256SUMS --ignore-missing
gh attestation verify Ninebrains-<version>-mac-arm64.dmg --repo Advance-Labs/ninebrains

docs/RELEASING.md covers Windows and Linux, and how to open an unsigned app.

Updating

Ninebrains updates itself: a packaged install checks GitHub Releases for a newer version (once 30 s after startup, then hourly) and shows a Download button at the bottom-right when one is out. Nothing downloads until you click it, each candidate is accepted only after its SHA256SUMS.json verifies against an Ed25519 key baked into the app, and the new build installs on the launch that follows your Restart now choice (in place on macOS/Linux; the new installer at quit on Windows). Your projects, settings and history stay where they are.

The one-line installer above is still there for manual installs, if you prefer it:

• Linux .deb installs: update with curl ... | sh -s -- --deb (runs sudo apt install). The plain line installs the AppImage into ~/.local/bin instead.
• Running app: macOS prompts you to quit it; Windows stops unless you pass -Force; the Linux AppImage is swapped in place, so restart it afterwards.
• Windows always installs for the current user. An all-users install makes the script stop with a message, unless you pass -Force.
• Options go after sh -s -- (for example --require-attestation), or on Windows use & ([scriptblock]::Create((irm https://ninebrains.dev/install.ps1))) -RequireAttestation, because irm ... | iex takes no arguments. All options: Verify a download → Installer options.

Canary builds update from canary releases only (Ninebrains-Canary-* prereleases), and an update never downgrades you: after a bad release, install the next good one.

Build from source

You need Git and any recent pnpm. The repo pins pnpm 10.28.2 and Node 24.14.0, and pnpm fetches both itself.

git clone https://github.com/Advance-Labs/ninebrains.git
cd ninebrains
pnpm install
pnpm run dev

To build the app instead of running the dev server, run pnpm --dir apps/emdash-desktop build. docs/FORK.md lists the tested toolchain and baseline.

You also need claude (Claude Code) and/or codex installed and logged in. Ninebrains starts them; it never logs in for you.

Quickstart

1. Add a project. In the sidebar, use the add button next to Projects and pick a local git repository.
2. Open Lanes. Press ⌘K (Ctrl+K on Windows and Linux) and run Open Lanes.
3. Add lanes. Click an empty slot, choose the project and an agent. Each lane gets its own worktree on a lanes/<id> branch. Add up to four per tab; use + for another tab.
4. Set up gates. At the default rigor, jobs need a test command. In Settings → Gates → Tests, pick the project, type its test command (for example pnpm test) and click Save test command.
5. Give the Brain a brief. Click Brain in the Lanes title bar, then Start Brain, and type the brief into its terminal. The Brain breaks it into jobs and hands them to idle lanes.
6. Watch the gates. When a lane finishes a job, its light turns to verifying while the gates run. A failed gate sends the lane back to work with the feedback; a passed job lands in the lane's Done list.

The getting-started guide covers each step in detail.

Concepts

Term	Meaning
Lane	One agent (Claude Code or Codex) in its own worktree, with a terminal, editor and browser
Brain	The coordinator: a graph of jobs, a mailbox, and the dispatcher that pairs ready jobs with idle lanes
Job	One unit of work for one lane. A job is ready when every job it depends on is done
Gate	An independent check that must pass before a job counts as done: tests, screenshot, reviewer, security review, fact-check
Pack	A per-project bundle of lane roles, skills, MCP servers and default gates
Arena	Every provisioned task across every open project, in one place, including the Brain's dispatcher status and open jobs

How it compares

These are layers, not rivals. Ninebrains runs Claude Code, and it is Emdash underneath.

	Claude Code on its own	Emdash	Ninebrains
The agent itself	Yes	Launches it	Launches it, unchanged
Other agent CLIs	—	Codex, OpenCode, Amp and others	Lanes: Claude Code and Codex. Other agents still work in Emdash tasks
Several agents on screen at once	One terminal each	Split panes within one task	2×2 grid of lanes across worktrees, unlimited tabs
Shared plan with dependencies	—	—	Brain job graph and planner canvas
Independent check before "done"	—	—	Verification gates, three attempts, then blocked
Domain bundles	Your own skills and MCP config	Skills and MCP catalog	Packs: coding, SEO, research
Scheduled or unattended work	claude -p in your own scripts	Cron automations	Budgeted runs with a STOP switch
Telemetry	Anthropic's own settings apply	PostHog analytics	Off, no endpoint
Remote machines over SSH	—	Yes	Inherited for tasks; lanes are local-only

Security and privacy

• Your logins stay yours. Ninebrains launches your own logged-in claude and codex CLIs. It never reads, copies or stores their credentials, and never runs a login for you.
• Telemetry is off, and no telemetry endpoint is built in.
• Lanes are contained. Each launch gets its own token for the Brain, which listens on 127.0.0.1 only and rejects web pages. Reviewers run in a disposable, read-only checkout, and unattended runs get a sandbox, a minimal environment and never a permission-bypass flag.
• The SEO pack sends data to Advance Labs when you enable it, off by default. With its default address, lanes send your Google access token and search data to Advance Labs' hosted AEO Toolkit endpoint; self-host it and point the pack at AEO_MCP_BASE_URL and nothing goes to Advance Labs. See Packs.

Read the security overview and the full threat model. Report vulnerabilities to security@advancelabs.dev, as described in docs/SECURITY.md.

FAQ

Is Ninebrains a replacement for Claude Code?

No. It launches your own claude and codex CLIs and leaves them alone. Ninebrains is the room they work in: separate worktrees, a shared plan, and an independent check before work counts.

Do I need an API key?

No. Ninebrains starts the CLIs you are already logged in to, so your subscription login works as it does in your terminal. You can point a lane at your own API key or a model server instead, in Settings → Models, and keys are stored in your OS keychain.

Does it cost extra?

Ninebrains is free and open source. Usage is whatever your provider plan or key charges. The SEO pack's hosted endpoint is free to use today; that may change if AEO Toolkit billing is switched on, and you can self-host it.

How many agents can I run at once?

Four lanes per tab, and as many tabs as you want. The real ceiling is your machine and your provider's rate limits, not the app.

How is this different from running git worktrees in tmux myself?

Worktrees and panes are the easy half, and Ninebrains does that for you. The other half is a plan that knows which job depends on which, a mailbox so lanes can talk, and a gate that makes a second agent prove the work before you read it.

Can agents review each other's work?

That is the point of gates. The reviewer gate runs a fresh agent with read-only tools in a disposable checkout of the result, and it can be a different provider from the one that wrote the code. A failed gate sends feedback back to the lane, up to three attempts, then blocks the job.

What data leaves my machine?

Your agents talk to Anthropic or OpenAI exactly as they would in your terminal. The app calls GitHub for its GitHub integration and skills catalog. Pages you open in a lane browser, and URLs the fact-check gate verifies, are fetched from the web. Packs you enable talk to their servers: the SEO pack to Advance Labs' endpoint (unless you self-host it), and the coding pack's GitHub server to GitHub. There is no telemetry.

Does it work on Windows and Linux?

Builds come from the same CI matrix for macOS, Windows and Linux. Ninebrains is developed and tested on macOS first. On Windows and Linux, the tests gate has no OS sandbox (it relies on a scrubbed environment, timeouts and process kills), and Windows paths are not yet tested.

Can I use more than one Claude account?

Yes, with one config directory per account. See Accounts.

Documentation

The user guide lives in docs/guide/ and is published at ninebrains.dev/docs.

Contributing

See CONTRIBUTING.md and architecture. Please read the Code of Conduct.

Credits and licence

Ninebrains is a fork of Emdash by General Action, Inc., used under the Apache License 2.0. Emdash supplies the worktrees, terminals, editor, browser, MCP, skills, automations and packaging that Ninebrains builds on. Ninebrains is not affiliated with or endorsed by General Action. Every change to an inherited file is listed in docs/UPSTREAM-PATCHES.md.

The SEO pack uses Advance Labs' AEO Toolkit (Apache-2.0).

Apache-2.0. See LICENSE.md and NOTICE. Copyright 2026 Advance Labs Inc. Portions copyright General Action, Inc.