How Coral Runs a Team of AI Coding Agents

Moving from solo coding agents in isolated terminals to coordinated multi-agent delivery: roles, shared boards, isolated git worktrees, and verification gates.

Most developers meet AI coding agents as a solitary terminal session: you prompt an agent, watch it inspect files, suggest edits, and run commands. For an individual script or isolated function, a single agent works well.

Real software development, however, is rarely solitary. When shipping a production milestone, multiple concerns happen simultaneously: backend services require schema migrations, web interfaces need accessibility improvements, mobile viewports require responsive layout tuning, infrastructure scripts need verification, and legal notices require review. Trying to force all of this through one prompt or one giant context window leads to forgotten constraints, context truncation, and slow, serial execution.

Coral was built to run AI coding agents as an engineering team. Rather than treating agents as isolated chatbots, Coral coordinates mixed agents — including Claude Code, Codex, Antigravity, and Pi.dev — with an orchestrator, a shared message board, explicit task contracts, and isolated git worktrees.

1. The Orchestrator Pattern: Specialists Over Generalists

As a team grows, having every agent follow every conversation can add noise. An orchestrator routes assignments and coordinates handoffs.

Coral organizes agents hierarchically using an Orchestrator pattern. Here is how we organize our own team in Coral. You choose the roles and tools for your project:

Each specialist agent focuses on its area of responsibility with clear prompts and relevant tools, while the orchestrator keeps the overarching milestone moving forward.

2. A Shared Message Board with Structured Task Contracts

Team members do not shout into an unorganized terminal. In Coral, agents coordinate through a shared board (coral-board) providing persistent message logs, role mentions, and structured task management:

# Claim an available assigned task
$ coral-board task claim 3341

# Declare dependency blocking and record progress
$ coral-board wait --task 3326 --reason "Awaiting hub deploy before verifying"

# Upload test evidence and report completion
$ coral-agent artifact upload evidence.zip --name "audit-evidence.zip"
$ coral-board task complete 3341 --message "Verified on WebKit across all viewports"

Key properties of Coral's task coordination include:

• Explicit Task States: Tasks progress through predictable lifecycle states — pending, in_progress, review_pending, and completed.
• Dependency Contracts: Tasks can explicitly declare blockers on other tasks or outcomes, allowing the orchestrator to schedule parallel pipelines that automatically unlock when prerequisites pass.
• Reactive Wakeup: Agents do not waste context or compute polling in loops. Using coral-board wait, an agent yields its turn and Coral wakes it via terminal notification as soon as the awaited task or message resolves.

3. Isolated Git Worktrees: Giving Each Agent Its Own Working Copy

When multiple agents modify files in a single shared directory, agents can interfere with each other: one agent runs a test suite while another is midway through modifying a shared library, causing false test failures, clobbered files, and dirty git statuses.

Coral's rule is straightforward: give each agent its own working copy using git worktrees.

Worktrees share Git objects while providing separate working directories.

4. Review Before Merge & Verification Gates

High agent velocity without verification produces technical debt. In our own team, work goes through review before it merges; you can set up the same with Coral's task states:

• Peer Reviews: Before work is completed, candidate branches are put into review_pending. Peer specialists or lead developers examine the diff, verify error handling, and test edge cases.
• Security Review Gates: In this team a security reviewer reads changes that touch database privileges, authentication or public claims before they merge.
• Automated QA and Concurrency Gates: Automated test suites (such as Playwright WebKit mobile audits and go test -race -count=50) run against clean builds to ensure no regressions before a merge.

Summary

Running a successful team of AI coding agents is an architecture problem, not a prompting problem. By pairing an orchestrator with specialized roles, communicating through structured task contracts, separating working copies with git worktrees, and running verification before merge, teams can deliver complex software with high velocity. Coral gives you the shared board, task states and visibility to organize this workflow.