Cohort

An autonomous AI software-engineering organization for Claude Code and OpenCode.

Give it one objective in plain English. It plans the work, builds the org to do it, and gates every merge behind independent review.

18 MCP tools · 375 tests · 15/15 spec capabilities · a real $0 end-to-end run · adversarial multi-agent review

Cohort is an autonomous, multi-agent orchestration layer for software engineering: give it one objective and it generates a bespoke engineering org for the task at hand (domains, specialists, reviewers), runs parallel OpenCode workers in isolated git worktrees, puts their work through code review by dedicated read-only reviewer agents, integrates whatever passes review, and replans whatever does not. Claude Code is the CEO, planner and reviewer throughout; it never writes implementation code itself. Deterministic mechanics, worktree management, budget guardrails, verification and merge order, live behind an 18-tool stdio MCP surface, not in the model's judgment.

Quickstart

Prerequisites: Claude Code CLI, the OpenCode CLI, and Node.js >= 22.

npm i -g @bhavya-dhoot/cohort
cohort login    # verifies Claude Code + OpenCode + provider auth, never stores secrets
cohort init     # scaffolds .cohort/ config 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"

cohort run walks the full loop below: plan, generate org, spawn parallel specialists, review, integrate. You approve the plan before any worker spawns, and you approve the integration diff before it merges.

Related MCP server: Universal Infinite Loop MCP Server

How it works

1. Analyze the objective into a brief.

2. Plan a task DAG, contracts and file-ownership partitions, plus an org chart sized to the objective. Human gate: plan approval.

3. Generate org, on-demand .opencode/agent/*.md specialists for the roles the plan needs.

4. Batch spawn DAG-ready, file-ownership-disjoint tasks as isolated OpenCode workers, each in its own git worktree.

5. Verify every worker independently, by running real build/test/lint commands against its worktree diff, never by trusting its self-report.

6. Review the verified diffs with dedicated read-only reviewer agents, whose verdicts (pass, revise, block) gate what merges.

7. Integrate passing work onto the run's integration branch in DAG order, then run a full regression suite.

8. Replan whatever was blocked, scoped to only the affected subtree and capped at a few iterations before mandatory human escalation, then repeat from batch spawn until the DAG is done.

Proof it works

A real end-to-end run, not a hermetic test: Claude drove the actual MCP tools against a fresh throwaway project, generating a live org (CEO, engineering manager, three domain leads, three specialists, reviewers, integration) on the auto-selected free OpenCode model, at $0.00. Three parallel OpenCode workers built in isolated worktrees; three live Claude reviewer subagents then caught a real bug, an inconsistent module system (ESM export in a CommonJS project) in two of the three modules, and blocked them instead of merging. The correct module shipped, the other two were replanned. Full writeup: docs/DEMO-RUN.md.

One of three modules shipped; two were correctly blocked by review and queued for replan. That is the review gate working as designed, not a partial failure. The same run also surfaced and fixed 2 real Windows worktree bugs (a transient handle-lock on removal, and a stale worktree registration) that the hermetic test suite had not exercised.

Capabilities

All 15 capabilities in the build spec, delivered:

Architecture

16 core modules behind the MCP surface: worktree management, verification, review, memory, budget, model routing and more. Full design, principles, worker lifecycle, execution pipeline, state model and the complete tool surface: docs/ARCHITECTURE.md.

Extensibility

Five shipped YAML files under config/ (orchestrator, models, agents, memory, providers), each overridable per project in .cohort/config/. Custom check suites, memory sections, reviewers, worker backends and providers each resolve to plain YAML config, a markdown agent file, or a TypeScript interface satisfied at construction, with no edits to packages/core/src. See docs/EXTENDING.md.

Safety

Workers run on free models by default, under hard budget ceilings. Verification never trusts a worker's self-report; it runs real commands against the worktree diff. Reviewers are read-only. No secrets are stored; authentication goes through each provider's own login flow.

License

MIT

Repository · npm · Site