What is Cohorte?

Cohorte is a portable, stack-agnostic multi-agent development pipeline for your coding agent — Claude Code, Codex CLI, Cursor, Gemini CLI or OpenCode. You install a generic core once (globally, or bundled per repo), run /cohorte-init-pipeline inside a project, and the pipeline adapts itself to that project: its stack, its surfaces, its commands, its conventions, its guardrails.

From then on, features move through a disciplined loop — idea → spec → parallel build → review → fix → ship — where a lead (your main session) orchestrates stateless specialized agents, and every handoff between stages lives on disk, not in the conversation.

The doctrine is one set of source prompts; the installer renders them into whatever your agent reads and branches them on what it can actually enforce — see Runtimes for the matrix and what differs.

The three layers

Layer	Where it lives	What it is
Core	~/.claude/ or <project>/.claude/ on Claude Code; ~/.cohorte/<runtime>/ or <project>/.cohorte/<runtime>/ elsewhere	Stack-agnostic commands, agent templates, hooks, workflow scripts, shipped shell scripts. Rendered per runtime at install; refreshed by cohorte update; never contains project facts.
Profile	PIPELINE.md at the repo root	Everything project-specific, generated by /cohorte-init-pipeline: surfaces, commands, contract mechanism, gate patterns, design/RBAC/isolation flags, conventions. The single file every command, agent, and hook reads.
Generated artifacts	the runtime's agents dir, <project>/.claude/ or .cohorte/ (gate config, stamps, metrics), + specs/	Rendered surface agents, gate-config.json, permissions, isolation scripts, spec files. Deterministic functions of (current core template × profile data) — reconciled by /cohorte-update-pipeline, never hand-maintained.

This separation is what makes the pipeline portable: upgrading the core never touches your choices, and /cohorte-update-pipeline reconciles the generated files to a new core without re-running the interview.

The cast

• The lead — your main session. It runs the slash commands, authors the frozen contract, dispatches agents, merges their returns, and talks to you. It never implements surfaces itself.
• Surface implementers — one rendered agent per code surface (e.g. backend for apps/api, frontend for apps/web). Stateless, TDD-first, each owns exactly one tree and may touch nothing else. Rendered from a template with your conventions baked in at render time.
• review — a read-only reviewer (no Write, no Bash). Checks spec conformance, correctness, security, conventions, RBAC and mobile-first (when the profile enables them), TDD coverage. Emits a capped, machine-actionable report.
• release — the git/host ritual at /cohorte-ship: conventional commits, push, PR. Never edits source, never force-pushes.
• profile-reader — a tiny read-only agent that turns PIPELINE.md into JSON; phase 0 of every workflow script (workflow scripts have no filesystem access).

The doctrine

A few principles explain most of the design:

The frozen spec is the only source of truth. /cohorte-spec freezes specs/<id>.md — goal, scope, data model, the §5 contract, per-surface tasks, acceptance criteria. Agents are stateless and re-read it; nothing important is ever "remembered" in chat.

The contract is the only cross-surface channel. The lead authors <contract.path>/<id>.<ext> (Zod schemas, OpenAPI, protobuf… per the profile) before any implementer is dispatched. Implementers import it read-only; two surfaces never talk to each other directly. This is the invariant that makes parallel building safe.

One owner per tree. Every surface owns a disjoint path. Shared code (routing, global state, the design-system kit) gets its own single-owner surface. Nothing is ever edited by two agents.

Disk state, not chat state. Reports are staged to specs/reports/, findings land in the spec's ## Remediation checklist, metrics in pipeline-metrics.jsonl, the review verdict stamps a freshness digest in the spec front-matter. Consequence: /clear between stages is always safe — and strongly recommended, because the lead's history is re-sent at input price on every turn.

Guard-railed autonomy. A profile-driven PreToolUse hook inspects every Bash command (of every agent, subagents included) and hard-denies destructive ones, confirm-gates risky ones — branch-aware, so agents move fast on feature branches while the default branch stays protected — and enforces a preflight phase gate before review dispatches.

Token frugality is a feature. Deterministic preflight (no agents spawned on red code), quiet command variants, diffs computed once and staged, capped report schemas, conventions baked into agents at render time, byte-stable dispatch prompts for prompt-cache hits. See Token economy.

Two execution paths, same pipeline

Every phase can run conversationally (the slash commands — interactive, the default) and the heavyweight phases also ship as deterministic workflow scripts for the Claude Code Workflow runtime: review, audit, refactor. Same agents, same disk artifacts, same gate — a different orchestration engine. Workflows are opt-in and can't ask questions mid-run; their design moves every human decision to the edges. See Workflows.

What Cohorte is not

• Not a framework you code against — it's markdown, shell, and one Python hook dropped into the pipeline's own directories. Your app code never imports anything from Cohorte.
• Not tied to a stack. Node/pnpm monorepo, Python, Go, Rust — the profile captures your commands and conventions; the core never assumes.
• Not a replacement for judgment. Brainstorm, spec freeze, and ship confirmation are deliberately human. The pipeline automates everything between those three moments, not the moments themselves.