Nightcrew is a native macOS terminal for coding agents that work while you don't watch. Write the task in one sentence. A dispatcher hands it to Claude Code or Codex in its own git worktree, the work runs as a checked and reviewed autopilot run, and the inbox tells you what finished and what needs you.
per dispatcher turn. 29 s when it loaded every MCP server on the machine.
tokens in a fresh bot conversation. 744k with 2,019 tools attached.
an engine run may take, with one automatic continue after a timeout.
approval prompts during a background run, because it can only write inside its own worktree.
Most of an agent session is waiting: for a permission prompt, for a test run, for you to notice it stopped. Nightcrew moves that waiting off your screen.
An agent asks before each edit and command, so it stops whenever you look away.
Each task gets its own worktree and branch and runs in bypass mode there. Force-push and branch deletion are refused, and push follows your project rules.
An agent reports success without a spec, without tests at the right level, without a review.
Every file change becomes an autopilot run: a written spec, small slices, a check after each slice and reviewers before it reports. The card shows slices as they pass.
Front end, back end and docs each have their own agent, and you check tabs to see which one is stuck.
Every session of every project, grouped as Needs you, Failed, Running and Done. A notification arrives when a run finishes or blocks.
One sentence, a ticket link or a pasted error, in a new session on the repo.
The bot reads the code, sizes the task, picks an engine, model and account, and delegates.
Spec, slices, checks, reviewers and commits in a worktree of its own, with nobody watching.
Read the three-line report, look at the branch in Source Control, open the PR.
Sessions, the autopilot card, the inbox, Source Control, engines, bot profile, MCP servers and the new-task dialog.
How it worksHow the bot decides, how a run is isolated and checked, how push is guarded and how context is kept small.
Setup & connectInstall, the Setup checks, accounts, engines, MCP servers and registering a repo with harness.
Screenshots from a running build on example projects (a shop's web front end, its API and its docs). Nothing is mocked up. Click any picture to see it full size.
A session is a task on a project: its own branch and worktree, a conversation with the bot, and the engine runs it started. The sidebar lists sessions per project with their branch, lines changed, engine and state.
The latest report's Done, Left and Needs you lines stay pinned under the header, so the state of the task is readable without scrolling. Needs you is highlighted.
Replies longer than eight lines fold behind "show N more lines". Markdown tables render as tables, code as code, and the header shows the bot's context size against its limit.
Every delegation shows as a card: engine and model, why the bot picked them, the account it runs on, each tool step with lines added and removed, and the run's progress from harness.
Every session of every project in one list, ordered by who has to act. Unread items are bold. The Inbox button in the title bar counts only Needs you.
The Git tab shows the worktree's changes, the commits the run made on its branch (one per slice) against the base, and how far ahead it is. Stage, unstage or discard files, commit, review the changes side by side, or create the pull request (push plus gh pr create, after a confirmation card).
Files shows the worktree tree with changed folders marked. Activity shows the engine, lets you switch it mid-task (the bot writes a handoff note and the new engine continues in the same worktree), and lists subagents and events.
Give the bot a task, a base branch and an optional branch name. By default the session gets its own git worktree, so agents never touch each other's files. The worktree gets your .env files copied in and the project's setup script run.
Engines are agents spoken to over the Agent Client Protocol: Claude Code through claude-agent-acp, Codex through its ACP adapter, or any ACP agent you add. For each task the bot chooses the engine and model that fit its size, and runs it on the signed-in account with the most quota left.
Name and role, standing instructions, and a memory you add to. Execution settings say which model the bot itself uses, which engines it may hand work to, and when it must ask first.
git push, deploy, sending messages and deleting files.Pick a preset (GitHub, Sentry, Linear, Notion, GitLab, Playwright, Filesystem) or add any HTTP server or command, paste its token (Linear and Notion sign in through the browser instead), and choose the scope: this project only, or all projects. Tokens go to the macOS Keychain, never into the database or logs.
The same works from a session: /mcp opens the dialog, /mcp add <name> <url> and /mcp remove <name> do it in one line.
The mechanics behind a background run, in the order they happen. Every rule here is what the current build does.
The bot reads, sizes the task and delegates. It never edits files itself.
A bot runs on a Claude model you pick, in Claude Code print mode with read-only built-in tools (read, search, fetch) and only the MCP servers Nightcrew passes it. The engines below it can be any of the agents you installed. Its rules for each message:
/something is passed to the engine unchanged, so your own skills keep working.# what an engine receives for "Add CSV export to the orders page" /autopilot Add CSV export to the orders page: same filters as the table, at most 50,000 rows.
Each session works in <repo>/.worktrees/<branch> on its own branch from the base you chose. .env files are copied in and the project's setup script runs once. Two autopilot runs never share a worktree, so parallel agents cannot overwrite each other or your own checkout.
Autopilot is a harness skill. Harness is a folder of agent context shared by all your projects: skills, reviewer agents, hooks, standards per stack, and a record per run. A run goes through these stages, and the card follows them by reading the run record every 15 seconds:
Autopilot needs Claude Code through the ACP adapter and a repo registered in harness. Other engines and unregistered repos still run tasks, with normal approval cards.
A background run uses bypass permissions so it never waits for you. What it can do is still limited:
git push --force, -f, +ref, --mirror, --delete, :ref and --prune pushes, whatever the engine.When an engine ends, the bot reads its report and the run's outcome, writes Done, Left and Needs you, and sends a macOS notification: done with the slice count, or blocked with the reason. The inbox regroups every few seconds.
The header shows the bot's context, measured from the model's own usage, against a limit: 200k tokens, or 60% of a smaller model window. It turns amber at 70%. When the conversation reaches the limit, and has grown at least a quarter of the limit past its fresh size, the next turn starts a fresh conversation from a brief.
Session brief: - Task: Add CSV export to the orders page - Branch: feat/orders-csv (base main) - Done: CSV export on /orders, 3 slices - Needs you: review the branch and open the PR - Latest engine run: Claude Code · sonnet (done) · autopilot · 3/3 slices · done + the last 20 messages
An engine prompt may run for up to 12 hours. If it still times out, the main run continues once on its own. Engines can also consult an advisor model (Fable 5.2 by default, set in Settings → Advisor) when they have a concern, instead of stopping to ask you.
About ten minutes on a Mac that already has git. Steps one to four happen once per machine, step five once per repo.
Open the disk image and drag the app to Applications. Builds are signed ad hoc and not notarized yet, so open it the first time with right-click → Open. When macOS asks whether the app may use the Keychain, allow it: sign-ins and tokens are stored there.
The disk image already contains Node.js, a terminal editor, the notification helper and the harness kit, so a bare Mac needs only git and Python 3.11+ on top.
The first launch opens Settings → Setup. Every tool shows as found (with its path or version) or missing, with an Install or Sign in button that runs in a terminal you can watch. Re-check runs it again; when PATH changed, a Restart bar appears.
| Tool | Needed | What it is for |
|---|---|---|
| git | required | Worktrees and branches. Xcode's command-line tools are enough. |
| Claude Code CLI | required | The bot runs on it, and it is the default engine. |
| Claude sign-in | required | An account for the bot and engines. Sign in opens Accounts. |
| Node.js / npx | required | Runs the ACP adapters. Bundled in the app. |
| Claude ACP adapter | optional | @agentclientprotocol/claude-agent-acp, fetched by npx on first use. Needed for autopilot. |
| GitHub CLI (gh) | optional | Pull requests from Source Control. |
| Docker | optional | Projects whose checks start databases or services. |
| Python 3.11+ | optional | Only needed to install harness. macOS ships 3.9, which is too old. |
| harness | required | Install copies the bundled kit, links its skills, agents and hooks into ~/.claude and puts harness on PATH. |
Settings → Accounts lists Claude and Codex accounts. The default one is your normal Claude Code login; add more to spread work across quotas. Each account keeps its own config folder, and the bot runs a task on the account with the most quota left.
/accounts add codex for Codex.Claude Code (@agentclientprotocol/claude-agent-acp) and Codex (@zed-industries/codex-acp) are built in and start through npx. Any other agent that speaks the Agent Client Protocol is one block in the config file; it then appears in the bot profile's engine list, and the bot can pick it.
# ~/.config/w-terminal/config.toml [[engines]] name = "Claude Code (work)" command = "npx" args = ["-y", "@agentclientprotocol/claude-agent-acp"] models = ["sonnet", "opus", "haiku"]
Then choose, per bot, which engines it may use (Settings → Bots). The permission mode for a session cycles with shift+tab in the message box:
The mode is remembered per session, per project or for everything. When something needs approval, a card offers Approve, Always for this bot (saved as a rule) or Deny, and a macOS notification tells you it is waiting.
Settings → MCP servers: pick GitHub, Sentry, Linear, Notion, GitLab, Playwright or Filesystem, or a custom HTTP server or command. Paste its token (Linear and Notion sign in through the browser) and choose whether this project or all projects get it. The token goes to the Keychain; sessions get the server from their next turn.
Add a project folder with the + in the sidebar. If harness does not know it yet, you are asked once, with a key from the git remote (owner/name, or local/name without a remote) and layers guessed from the files it finds: Next.js, React, NestJS, .NET, Kotlin Spring, Postgres, Kubernetes. Register, or Not now. Setup lists every project and lets you register later.
Start a session on the repo (the + next to the project) and write the task. Then close the window or the laptop. A notification arrives when the run is done or blocked; the inbox has the rest.
you Add CSV export to the orders page. Same filters as the table, max 50k rows. bot Delegated to Claude Code · sonnet as a background autopilot run worktree feat/orders-csv · 0/3 slices · starting … 47 minutes later … Done: CSV export on /orders, 3 slices, checks green, walked in a browser Left: nothing Needs you: review the branch in Source Control and open the PR
# question there to ask the bot about the last command.
Download · Beta
This is a beta: it works for daily use, but expect rough edges and changes between builds. macOS 13 or later on Apple silicon. The disk image includes Node.js, an editor and the harness kit. Linux and Windows packages come next.
xattr -dr com.apple.quarantine /Applications/Nightcrew.app