crossben/orchestra-code

<p align="center" <img src="assets/logo.svg" alt="Orchestra" width="440" </p

<p align="center"<strongThe operating system for AI coding agents.</strong One supervised interface, many coding agents.</p

<p align="center" <a href="https://github.com/crossben/orchestra-code/actions/workflows/ci.yml"<img src="https://github.com/crossben/orchestra-code/actions/workflows/ci.yml/badge.svg" alt="CI"</a <a href="LICENSE"<img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License: MIT"</a <a href="go.mod"<img src="https://img.shields.io/badge/Go-1.22+-00ADD8.svg" alt="Go 1.22+"</a </p

Orchestra dispatches coding-agent CLIs (Claude Code, OpenCode, Mimo, …) through one supervised interface. You just chat: it answers plain questions, routes coding tasks to the best agent, validates every result (build → lint → test), lets the agent fix its own failures, and keeps nothing without your y. It can decompose a big request into steps — running independent ones in parallel, each isolated in its own git worktree (or folder copy outside a repo) — remembers every run, and can benchmark agents against each other.

# install (Linux/macOS) — prebuilt binary
curl -fsSL https://raw.githubusercontent.com/crossben/orchestra-code/main/install.sh | sh

# …or with Go (any platform)
go install github.com/crossben/orchestra-code/cmd/orchestra@latest

# …or build from source
git clone https://github.com/crossben/orchestra-code && cd orchestra-code
go build -o bin/orchestra ./cmd/orchestra

Windows: download the .zip from Releases, or use go install. If orchestra isn't found after install, add the bin dir to your PATH (the installer prints the exact line).

cd /your/project           # any git repo, clean working tree
orchestra                  # interactive chat shell (AI-routed)
orchestra dashboard        # full-screen TUI (agents / history / benchmarks / chat)
orchestra run "add a /health endpoint" --test "go test ./..."

Requirements: Go 1.22+, git, and at least one agent CLI on your PATH (claude, opencode, mimo, …). Add your own agent in one config block — see docs/EXTENDING.md. Roadmap and design notes in plan.md; contributions welcome — CONTRIBUTING.md.

Two ways to use it — same engine underneath:

Interactive shell (the primary UX)

orchestra            # drops you into a chat session

orchestra (auto) › what does this repo's config loader do?
  … routing
  <answered inline — no agent dispatched>

orchestra (auto) › add a /health endpoint
  ↳ implement → agent "opencode" (code change)
  … agent runs, tests run, diff shown …
  accept these changes? [y/N] y
  ✓ changes accepted and committed

orchestra (auto) › @claude write tests for it   # force one task to a specific agent
orchestra (auto) › /route off                   # fall back to a fixed active agent

The **AI router** is on by default: plain questions are answered inline, coding tasks auto-route to the
best agent (with a printed reason). The agent is chosen by: the AI's own suggestion → the agent with the
best track record in this directory (accepted runs + benchmark wins, once there are ≥3 outcomes; e.g.
`claude: 8/10 accepted in this dir`) → `router.routes` → `default_agent`. Overrides: `@<name> <task>` forces an agent; `/route off` switches to
a fixed active agent (`/agent <name>`). Shell commands: `/agents`, `/route [on|off]`, `/agent`, `/help`, `/exit`.
Each accepted turn is committed, so the tree stays clean and every turn's diff shows only its own changes.

### One-shot (scriptable, for CI/workflows)

orchestra run "add a /health endpoint" --agent claude --test "go test ./..."

### Plans & sequential workflows

Decompose a large request into ordered steps, then execute them one at a time — you approve the plan
first, then review each step's diff:

orchestra plan "build user authentication" # just show the decomposition orchestra do "build user authentication" # plan → approve → run each step, commit as you go

`do` commits each accepted step and **halts at the first rejected step** (prior steps stay committed).

**Parallel** (`--parallel`): the planner marks which steps are independent; Orchestra runs each ready
step concurrently in its own **git worktree** (or, in a folder that isn't a git repository, its own
**temporary copy of the folder**), then you review + merge each result before the next dependency wave
unlocks:

orchestra do --parallel --jobs 4 "build the API, the CLI, and the docs"