Cohort

One objective in. Cohort builds the org, runs specialists in parallel, reviews their work, and ships what passes.

See the live run

18 MCP tools 375 tests 15/15 capabilities $0 runs MIT

How it works

The loop that runs every objective, from a plain-language ask to merged, reviewed code.

Analyze & plan

Turn the objective into a task graph and a concrete execution plan.

Generate org

Build a domain-specific chart of leads and specialists for this objective, not a template pulled off a shelf.

Spawn workers

Each specialist runs as an isolated OpenCode worker in its own git worktree, owning a disjoint set of files.

Review

Dedicated read-only reviewers, assigned by the org chart, gate every diff before it can merge.

Integrate

Passing work merges to the integration branch with a clean regression suite.

Replan

Blocked or failed work is recorded and folded into the next batch instead of forcing a merge past a real defect.

Replan folds blocked work back into step 01 for the next batch.

Capabilities

Fifteen capabilities, built and proven end to end. Six that show up first.

Dynamic org generation

Every run gets its own chart: CEO, engineering manager, domain leads, and specialists, sized to the objective. Nothing hardcoded, nothing reused between runs.

Parallel isolated workers

Each specialist runs in its own git worktree, owning disjoint files so batches execute concurrently, conflict-free.

Dedicated reviewers

Read-only reviewer agents, assigned by the org chart, gate every diff. Blocking is a real verdict, not a rubber stamp.

Replan loop

Blocked or failed work is recorded and folded back into the next batch instead of forcing a merge past a real defect.

Observability

One report per run: execution timeline, task DAG, per-model cost, and a failure breakdown, generated from on-disk artifacts.

Extensible without touching core

Custom check suites, memory sections, specialists, and worker backends plug in through config or a markdown agent file. No core edits, no eval of user code.

A real run, at $0

Not a hermetic test. Claude as orchestrator, real MCP tools, real OpenCode workers, against a fresh throwaway project.

CEO Engineering manager 3 domain leads 3 specialists Reviewers Integration

The orchestrator turned one objective into a real org: a CEO, an engineering manager, three domain leads, three specialists, reviewers, and an integration step.

Three OpenCode workers ran in parallel, each isolated in its own git worktree, each owning exactly one file. Three live reviewer agents then read the real diffs, and caught a genuine bug: two of the three modules came back as ESM in a CommonJS project, unloadable under require(). The reviewers blocked both and passed the one clean module.

feat-configarchitectureblock

feat-validatesecuritypass

feat-healthtestingrevise

The gate held. The two blocked modules were replanned instead of force-merged, and run_report rendered the observability report below straight from the run's on-disk artifacts.

Read the full run

3 / 1 / 0 / 2Tasks: total / done / failed / pending

3 / 0 / 0Workers: total / merged / failed

6 / 2Reviews: total / blocking

8m 57sDuration

$0.0000Committed cost

18 tools375 tests, 15/15 capabilities

Quickstart

Install, authenticate once, scaffold a project, and hand it an objective.

$npm i -g @bhavya-dhoot/cohort

$cohort login

$verifies Claude, OpenCode, and provider auth. never stores secrets.

$cohort init

$scaffolds .cohort/ and registers the Claude Code plugin.

$cohort run "Build a small Node utility library: a config loader, an input validator, and a health-check handler."