subgentic/coral

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

Reach your Coral servers from any browser, your phone included. Invite-only beta.

Run Claude Code, Codex, Antigravity 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.

Download the latest release
macOS (.dmg) • Windows installer (.msi) • Windows portable (.zip) • Linux x86-64 • Linux ARM64
_{or with Homebrew: brew install --cask cdknorow/coral/coral}

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

_{The dashboard with a team of agents at work: the agent list, one agent's chat, and the team's message board. (Sample data.)}

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 terminal 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.

_{An agent's changes so far — here four files against the previous commit — with the diff open beside its chat. (Sample data.)}

• 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 an agent the moment something lands for it. (Sample data.)}

• 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 on each kind of work, and every tool call with its duration and timestamp. (Sample data.)}

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, whether or not your laptop is open. (Agents stop if Coral quits there; choose tmux in Settings to keep them running.) 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 open source (Apache-2.0).

Download the latest release from GitHub Releases. These links always point to the newest version:

• macOS: Coral.dmg (universal binary), or brew install --cask cdknorow/coral/coral
• Linux: coral-linux-amd64.tar.gz (x86-64) or coral-linux-arm64.tar.gz (ARM64, e.g. Graviton or Docker on Apple silicon)
• Windows: Coral-x64.msi (installer) or Coral-x64-portable.zip. These are currently not code-signed, so Windows SmartScreen warns that the publisher is unknown. Verify the file with the attestation check below before you run it.

Each release also keeps its versioned file names (Coral.v<version>.dmg, coral-linux-<arch>-<version>.tar.gz, Coral-<version>-x64.msi, Coral-<version>-x64-portable.zip): the same files.

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 subgentic/coral. Releases up to v1.4.141 were built before the repository moved, in cdknorow/coral: for one of them use --owner cdknorow and cdknorow/coral/.github/workflows/release.yml in the commands below (GitHub keeps a release's attestation with the owner that built it, so --repo finds nothing for them).

With the GitHub CLI (any package):

gh attestation verify coral-linux-amd64.tar.gz --owner subgentic \
  --signer-workflow subgentic/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 --new-bundle-format \
  --certificate-oidc-issuer https://token.actions.githubusercontent.com \
  --certificate-identity-regexp '^https://github\.com/subgentic/coral/\.github/workflows/release\.yml@refs/tags/v'
sha256sum --check --ignore-missing SHA256SUMS.txt   # macOS: shasum -a 256 --check --ignore-missing

The checksum command must print <your file>: OK for the file you downloaded; if it prints nothing, nothing was checked.

On Windows, check the MSI or the portable ZIP you downloaded the same way (PowerShell, with the GitHub CLI); it must report the attestation as verified for release.yml on a tag of subgentic/coral:

gh attestation verify Coral-x64.msi --owner subgentic `
  --signer-workflow subgentic/coral/.github/workflows/release.yml

This proves the file came from Coral's release workflow. It is not Windows code signing: the MSI and the programs in it carry no Authenticode signature yet. The SHA256SUMS.txt check above covers the Windows files too.

Each Linux tarball also has its own bundle (coral-linux-<amd64|arm64>.tar.gz.sigstore.json, and the same for the versioned name), verified the same way. The bundles are in Sigstore's current bundle format: cosign 2.x reads them only with --new-bundle-format (without it, it fails with "bundle does not contain cert for verification"); cosign 3 reads them either way. Either check failing means the file is not an official build: don't run it.

First install and sign in to at least one agent CLI: Claude Code, Codex, Antigravity (agy), or Pi. Coral runs these tools; it does not install or authenticate them.

• macOS: Open the DMG, drag Coral.app to Applications, then open Coral. The app includes tmux. For terminal commands, run /Applications/Coral.app/Contents/MacOS/install-cli.sh and add ~/.local/bin to your PATH.

• Windows: Run the MSI, then open Coral from the Start menu. For the portable ZIP, extract it, open PowerShell in that folder, and run .\coral.exe --no-browser.

• Linux: Download the archive for your architecture, then extract and start it (ARM64: replace amd64 with arm64):

  mkdir -p "$HOME/.local/share/coral"
  tar -xzf coral-linux-amd64.tar.gz -C "$HOME/.local/share/coral"
  export PATH="$HOME/.local/share/coral:$PATH"
  coral --no-browser

  Add that PATH line to your shell's startup file for later terminals. Agents run in Coral's built-in terminal and stop when you quit Coral. To keep them running after Coral quits, install tmux and choose it in Settings > Terminal, or start with --backend tmux.

On first launch, review the Terms of Service and accept them if you agree. For a terminal launch, keep the terminal open while Coral runs. Open the local address printed at startup. If the browser shows Create a password, enter and confirm a password, then choose Create password and open Coral. The app can open a signed-in browser directly; you can also run coral open from a terminal on the server.

In the dashboard, choose Launch agent, enter an existing project folder on the computer running Coral (or use Browse), and choose Launch. To choose an agent CLI, open More options > Agent first. In the agent's Terminal, answer any folder-trust or sign-in prompt, then send a task from Chat with Enter. Use Launch team on Home to start several agents together.

See Getting started for the full installation and first-agent walkthrough.

Install Git, Make, Go 1.26.10 or later, and a C compiler (on macOS, Xcode Command Line Tools), then:

git clone https://github.com/subgentic/coral.git
cd coral/coral-go
make build
./bin/coral --backend pty --no-browser

The build puts the tools in bin/. For the commands below, add that directory to your PATH or use ./bin/coral in place of coral.

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 their own terminal sessions until you stop them:

coral --remote --host 0.0.0.0 --port 8420

Then open http://<that-machine>:8420 from any browser. Sign in with your Coral password, or use the Mobile QR button in the dashboard to open a signed-in link on another device. See Remote access for setup. Agents on a second Coral server can subscribe to the first one's board, so a team can span machines.

Coral uses its built-in terminal by default, so agents stop when Coral stops; to keep them running across restarts, start Coral with --backend tmux (tmux installed).

Run Coral in an interactive terminal for the first start so you can accept the Terms of Service and answer the remote-access question. With Docker, allocate a TTY (docker run -it) and publish port 8420 (-p 8420:8420). Inside the container or your SSH session, run:

coral --host 0.0.0.0 --port 8420 --no-browser   # asks about remote access

Answer y to enable remote access. Without a TTY, Coral skips that question; use --remote to enable remote access explicitly. Open http://<server>:8420 in your browser. If Create a password asks for a setup code, run coral setup-code on the server, or docker exec -it <container> coral setup-code inside the running container, and enter the code in that form. Run it as the same user and with the same --home DIR if you set one; for a different port, add --url http://localhost:<port>.

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.

_{The same dashboard on a phone: the agent list, and one agent's chat. (Sample data.)}

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.

Coral Hub (app.coralhub.dev, invite-only beta) lets you reach your Coral servers from any browser without opening a port. A fresh install never connects, or asks you to, on its own: connect a server from the home screen or Settings › Coral Hub, or run coral cloud connect on it. Coral offers it at first launch (the dashboard's Connect screen and a prompt in the terminal) only when you pass a hub URL (--cloud-url https://app.coralhub.dev or CORAL_CLOUD_URL) or start it with --cloud-connect prompt (CORAL_CLOUD_CONNECT=prompt); --cloud-connect off turns that off. See Coral Hub.

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 four things to launch: a single agent, a whole team on a shared board, a plain terminal that lives alongside your agents, or a folder pinned to your Agents list.}

Coral starts every agent in a separate terminal 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: token and cost totals, spend over time, then the same cost cut by provider and model, and further down by thinking level, team, git branch, and agent. (Sample data.)}

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 subgentic.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