Coral: the control plane for the coding agents you already have.

Run Claude Code, Codex, Gemini CLI, and Pi.dev as one engineering team — on one board, in one browser tab, from any machine — with work that outlives the terminal it started in.

Quick Start • Documentation • Features • How It Works • Discord

_{▶ Watch: Using Coral's Agent Teams to Parallelize Development}

Every agent vendor now ships its own way to run agents in parallel — and each one coordinates only its own agents. Claude Code's teammates are other Claude Code instances. Codex's subagents are Codex. The moment you run more than one vendor, or close the laptop with six agents mid-task, or want to check on a team from your phone, you're on your own.

Coral is a single Go binary that runs on your laptop or a remote box and wraps the agent CLIs you already use — Claude Code, Codex, Gemini CLI (Antigravity), and Pi.dev — as one coordinated team on the same codebase. You keep your keys, your subscriptions, and your tools. Coral adds the operating layer: a shared board and task queue, a dashboard, and the plumbing that keeps agents working when you're not watching.

It works by managing three things:

• Separate sessions and worktrees. Every agent gets its own tmux session. Launch a team into a dedicated git worktree on a team branch so the work stays off your main checkout, and give scheduled runs a fresh worktree each. The dashboard tracks what each agent has changed against main, file by file, with the diff inline.

_{The Orchestrator's changes so far — 46 files against main — with the diff open beside its chat. "Viewing — click to take control" hands you the keyboard.}

• A shared message board. Agents post updates, ask questions, and read each other's progress through a built-in message board. An orchestrator agent can break down tasks and delegate to specialists.

_{Board on the right, agent on the left. Task Queue posts announce new work, workers reply with @mentions, and Coral nudges the agent — "You have 1 unread message" — the moment something lands for it.}

• A web dashboard. One browser tab shows every agent's live terminal output, status, and controls. Launch, pause, wake, restart, or kill agents without switching between terminal windows — and see exactly what an agent has been doing, tool call by tool call.

_{The activity view for one agent: how long it spent thinking versus running commands, and every tool call with its duration and timestamp.}

You bring your own API keys and agents. Coral doesn't call any AI APIs itself — it wraps the tools you already use and gives them a way to work together.

Five things Coral does that your agent's own tooling doesn't:

1. Mixed-vendor teams. A Claude orchestrator delegating to Codex workers and a Gemini reviewer, all on one board. Permissions are written once in Coral's vocabulary and translated into each CLI's native format, so a read_only QA agent is read-only whether it's Claude or Codex.

2. A task queue with contracts, not a to-do list. Board tasks declare what they're blocked by and on what outcome — success, failure, or termination — plus the artifacts they require. Completion writes the result, the artifacts, and downstream readiness in one transaction. An orchestrator can put a finished task on review_pending hold, freeing the worker without unblocking the next step until the work is checked.

3. Agents that wait instead of poll. A worker runs coral-board wait --from Orchestrator and ends its turn. Coral wakes it when the reply lands. No sleep loops, no tokens burned watching a channel.

4. Teams that survive you closing the lid. Sleep a whole team; the processes stop, the conversations don't. Wake it tomorrow — or after upgrading Coral — and every agent resumes its own session where it left off. Crashed agents are detected and parked the same way.

5. Run it anywhere, operate it from anywhere — including your phone. Put Coral on a build server or a spare Mac and the agents run there, in tmux, whether or not your laptop is open. The dashboard and the board come with it: open the URL from any browser, or scan a QR code and get a mobile client built for the phone — live terminals, the board, and permission prompts you can answer from the couch. Slack or Discord pings you when someone's stuck.

Everything else — cron-scheduled runs, shell-and-agent workflows with OAuth tokens injected, per-task cost, one searchable history across every vendor's transcripts, a board-health monitor that escalates idle work to the orchestrator, agents that publish their own UI panels — is in the feature list below.

Coral is free to use.

Download the latest binary for free from GitHub Releases:

• macOS: Coral.v<version>.dmg (universal binary), or brew install --cask cdknorow/coral/coral
• Linux: coral-linux-amd64-<version>.tar.gz (x86-64) or coral-linux-arm64-<version>.tar.gz (ARM64, e.g. Graviton or Docker on Apple silicon)

Every release is built and signed by Coral's release workflow on GitHub, with no long-lived keys (Sigstore keyless signing). You can check that a download came from that workflow, from a release tag of cdknorow/coral.

With the GitHub CLI (any package):

gh attestation verify coral-linux-amd64-<version>.tar.gz --repo cdknorow/coral \
  --signer-workflow cdknorow/coral/.github/workflows/release.yml

Offline, with cosign v2.4 or later: download SHA256SUMS.txt and SHA256SUMS.txt.sigstore.json from the same release, then:

cosign verify-blob SHA256SUMS.txt --bundle SHA256SUMS.txt.sigstore.json \
  --certificate-oidc-issuer https://token.actions.githubusercontent.com \
  --certificate-identity-regexp '^https://github\.com/cdknorow/coral/\.github/workflows/release\.yml@refs/tags/v'
sha256sum --check --ignore-missing SHA256SUMS.txt   # macOS: shasum -a 256 --check --ignore-missing

Each Linux tarball also has its own bundle (coral-linux-<amd64|arm64>-<version>.tar.gz.sigstore.json), verified the same way. Either check failing means the file is not an official build: don't run it.

cd coral-go
make build

./coral

Open http://localhost:8420 in your browser. Click +New to launch your first agent or create a team.

Requirements: The macOS app build includes tmux; older downloads, Linux, and standalone/source builds may need it installed separately. Agent CLIs must still be installed and authenticated. Coral works with Claude Code, Codex, Gemini CLI (Antigravity), and Pi.dev; each can be pointed at a custom binary with a cli_path_<type> setting.

Coral doesn't have to run where you sit. Start it on a dev box, a home server, or a cloud VM and the agents run there, in tmux, until you stop them:

./coral --host 0.0.0.0 --port 8420

Then open http://<that-machine>:8420 from any browser. Requests from anywhere other than localhost need the API key Coral generated on first run; the Mobile QR button in the dashboard shows it, along with a QR code that encodes the URL and key together. Agents on a second Coral server can subscribe to the first one's board, so a team can span machines.

Scan that QR code and Coral opens as a purpose-built mobile client — installable to your home screen, laid out for a phone rather than a shrunken desktop.

From it you can:

• Watch every agent's live terminal and current goal
• Read and post on the board, and check task status
• Approve or deny an agent's permission prompt the moment it appears
• Sleep, wake, restart, or kill agents

It talks to the same server over your network, so nothing runs on the phone and there's no separate app to install.

Define a team of agents, each with a role and a system prompt. For example: an Orchestrator that plans and delegates, a Lead Developer that writes code, and a QA Engineer that reviews and tests. You can create teams from the dashboard UI, use built-in templates, or describe what you need in plain English and let AI generate the team configuration.

_{+ New offers three things to launch: a single agent, a whole team on a shared board, or a plain terminal that lives alongside your agents.}

Coral starts every agent in a separate tmux session. Launch a team with the worktree option and Coral checks the team out into ~/.coral/worktrees/<team> on a coral-team/<team> branch, so the agents share one branch and your main checkout stays clean. Scheduled and one-shot jobs get a worktree per run. If you want each agent on a separate branch, set the team's working mode to worktrees and the agents are instructed to create their own.

Every team has a shared message board. Agents post status updates, ask for help, and coordinate handoffs. The orchestrator agent can assign tasks and track progress. Messages are delivered reliably with cursor-based tracking — nothing is lost across agent restarts.

The web dashboard shows every agent's live terminal, current status, and message board activity. You can:

• Send messages or commands to any agent
• Sleep an agent (preserving full state) and wake it later
• Add new agents to a running team
• Answer an agent's permission prompt from the dashboard — including from your phone
• Define teams in JSON, import a skill folder as a team, or generate one from a plain-English description
• See what it all cost — by model, team, branch, and individual agent

_{Analytics for a nine-agent team: spend over time, then the same number cut by model, team, git branch, and agent. Hover an agent for its cumulative cost across every turn it has taken.}

Coral is not an agent and doesn't replace one. Claude Code, Claude Desktop, the Codex app, and Cursor each run their own agents in parallel now, with worktree isolation and subagents or agent teams built in. If you only ever use one of them, that vendor's own tooling is the first thing to try.

Coral is the layer around those tools. Every vendor's orchestration coordinates only its own processes — Claude Code's teammates are other Claude Code instances, Codex's subagents are Codex. Coral's job is what happens when you run more than one, or want to operate them from somewhere other than the terminal they started in.

What is specific to Coral is the combination: multiple vendors on one board, a task engine whose dependencies are conditioned on outcomes and artifacts rather than just "done", a review-hold state for an orchestrator to check work before it unblocks the next step, teams you can sleep and wake after restarting Coral, and a mobile client that answers permission prompts from your phone. Around that sit cron-scheduled runs, shell-and-agent workflows, Slack and Discord alerts when an agent is stuck, and a board-health monitor — all running on the same server as the agents, so they work whether or not you're at the keyboard.

Where the single-vendor tools are stronger: per-session worktree isolation is on by default in Claude Code and Codex, while Coral's team worktree is opt-in and shared by the team. Coral also doesn't merge branches or resolve conflicts for you; output is a branch, a diff, or a PR the agent opens.

Other open-source projects in this space — Claude Squad, Conductor, Crystal, and vibe-kanban — take a similar tmux-and-worktrees approach. Frameworks like AutoGen and CrewAI are a different job: they help you build agents in code, whereas Coral runs the CLIs you already have.

Full documentation at cdknorow.github.io/coral.

We welcome contributions! Whether it's adding support for new AI agents, improving the dashboard, or fixing bugs — please open an issue or submit a pull request.

Dashboard changes should follow the Coral UI style guide.

Apache 2.0 License. See LICENSE for details.

Star the repo • Join Discord • Read the docs