Chorus

The Agent Harness for AI-Human Collaboration

中文

Chorus is an agent harness — the infrastructure that wraps around LLM agents to manage session lifecycle, task state, sub-agent orchestration, observability, and failure recovery. It lets multiple AI Agents (with fine-grained, configurable permissions) and humans collaborate through the full workflow from requirements to delivery.

Inspired by the AI-DLC (AI-Driven Development Lifecycle) methodology. Core philosophy: Reversed Conversation — AI proposes, humans verify.

---

AI-DLC Workflow

Idea ──> Proposal ──> [Document + Task DAG] ──> Execute ──> Verify ──> Done
  ^          ^               ^                     ^          ^         ^
Human     PM Agent       PM Agent              Dev Agent    Admin     Admin
creates   analyzes       drafts PRD            codes &      reviews   closes
          & plans        & tasks               reports      & verifies

---

What's New

v0.7.0 — Fine-grained agent permissions: 5 resources × 3 actions grid replaces the PM/Developer/Admin three-way choice, with presets + a Custom option for free combination.

v0.6.7 — Chorus plugin for Codex CLI (one-command installer), workspace picker when one email belongs to multiple Companies, per-client connect guides.

v0.6.6 — npm one-click install (npx @chorus-aidlc/chorus), document export (MD/PDF/Word), proposal revoke, faster agent checkin with work status at a glance.

v0.6.2 — Embedded PGlite mode (zero-dependency deployment), structured logging with Pino, stateless MCP for horizontal scaling, default port changed to 8637.

v0.6.1 — /yolo skill: full-auto AI-DLC pipeline (Idea → Proposal → Execute → Verify) with Agent Team parallel execution.

v0.6.0 — IdeaTracker dashboard, independent review agents (proposal-reviewer + task-reviewer), real-time agent presence indicators, cross-column Kanban animation.

v0.5.1 — New user onboarding wizard, UI animation system, quick-dev skill (skip-proposal workflow).

v0.5.0 — Universal search (Cmd+K across 6 entity types), rich claim/assign response.

Full changelog: CHANGELOG.md

---

Quick Start

Run Chorus locally with two commands — no database, no Docker, no config files needed.

npm install -g @chorus-aidlc/chorus
chorus

That's it. Chorus starts with an embedded PostgreSQL (PGlite), runs migrations automatically, and opens at http://localhost:8637.

Note: PGlite is an embedded, single-process PostgreSQL — great for local single-user usage, but its connection handling has limits under concurrent load. If you plan to run multiple agents or users simultaneously, use an external PostgreSQL via DATABASE_URL=postgresql://... or the full Docker Compose stack.

Default login: admin@chorus.local / chorus

Options

# Custom port
chorus --port 3000

# Custom data directory (default: ~/.chorus-data)
chorus --data-dir /path/to/data

# Custom credentials
DEFAULT_USER=me@example.com DEFAULT_PASSWORD=secret chorus

# Use an external PostgreSQL instead of embedded PGlite
DATABASE_URL=postgresql://user:pass@host:5432/chorus chorus

Other deployment options

Method	Command
npm (simplest)	npm i -g @chorus-aidlc/chorus && chorus
Docker (standalone)	docker compose -f docker-compose.local.yml up
Docker (full stack)	docker compose up (PostgreSQL + Redis + Chorus)
AWS CDK	Deploy to AWS

---

Screenshots

Proposal — AI Agent Generates Plans in Real Time

Watch a PM Agent analyze requirements and generate a proposal with PRD and task DAG — with real-time presence indicators showing agent activity.

Pixel Workspace — Real-time Agent Status

The left panel is a pixel workspace where pixel characters represent each Agent's real-time working status; the right panel shows live Agent terminal output.

Kanban — Real-time Task Flow

The Kanban board updates automatically as Agents work, with task cards flowing between To Do → In Progress → To Verify in real time. Agent presence indicators highlight which resources are being worked on.

Kanban & Task DAG

Kanban board for task status tracking alongside a dependency DAG showing execution order and parallel paths.

Idea & Requirements Elaboration

PM Agents clarify requirements through structured Q&A rounds before creating Proposals. The panel shows idea details alongside completed elaboration rounds with answers and category tags.

Proposal Review

Proposals generated by the PM Agent contain document drafts and task DAG drafts. Admins review and approve or reject on this panel.

Acceptance Criteria — Dual-Path Verification

Dev Agent self-checks and Admin reviews each acceptance criterion independently, with structured pass/fail evidence for every item.

Universal Search — Cmd+K Command Palette

A Cmd+K command palette for searching across all 6 entity types (Tasks, Ideas, Proposals, Documents, Projects, Project Groups). Supports scope filtering (Global / Group / Project), filter tabs per entity type, and keyboard navigation. Both the Web UI and AI agents (via chorus_search MCP tool) share the same search backend.

---

Features

• Session Lifecycle — Persistent sessions with heartbeats, auto-expiry, and failure recovery
• Task DAG — Dependency modeling, cycle detection, and interactive visualization
• Kanban — Real-time task flow with Worker badges and agent presence
• Multi-Agent Collaboration — Claude Code Agent Teams (Swarm Mode) for parallel execution
• Fine-Grained Agent Permissions — 5 resources × 3 actions grid with preset + custom combinations (details)
• Chorus Plugin — Lifecycle hooks automate session create/close, heartbeats, and context injection
• Requirements Elaboration — Structured Q&A rounds before proposal creation
• Proposal Approval Flow — PM drafts, Admin approves, drafts materialize into real entities
• Notifications — In-app + SSE push + Redis Pub/Sub with per-user preferences (design doc)
• @Mention — Tiptap autocomplete, permission-scoped search, mention notifications (design doc)
• Activity Stream — Full audit trail with session attribution
• Universal Search — Cmd+K across 6 entity types, 3 scope levels, snippet generation (design doc)

---

Architecture

┌──────────────────────────────────────────────────────────────────┐
│                 Chorus — Agent Harness (:8637)                    │
│                                                                  │
│  ┌── Harness Capabilities ───────────────────────────────────┐   │
│  │  Session Lifecycle │ Task State Machine │ Context Inject   │   │
│  │  Sub-Agent Orchestration │ Observability │ Failure Recovery│   │
│  └───────────────────────────────────────────────────────────┘   │
│                                                                  │
│  ┌── Chorus Plugin (lifecycle hooks) ────────────────────────┐   │
│  │  SubagentStart/Stop │ Heartbeat │ Skill & Context Inject  │   │
│  └───────────────────────────────────────────────────────────┘   │
│                                                                  │
│  ┌── API Layer ──────────────────────────────────────────────┐   │
│  │  /api/mcp  — MCP Streaming (50+ tools, permission-gated)  │   │
│  │  /api/*    — REST API (Web UI + SSE push)                 │   │
│  └───────────────────────────────────────────────────────────┘   │
│                                                                  │
│  ┌── Service Layer ──────────────────────────────────────────┐   │
│  │  AI-DLC Workflow │ UUID-first │ Multi-tenant              │   │
│  └───────────────────────────────────────────────────────────┘   │
│                                                                  │
│  ┌── Web UI (React 19 + Tailwind + shadcn/ui) ──────────────┐   │
│  │  Kanban │ Task DAG │ Proposals │ Activity │ Sessions      │   │
│  └───────────────────────────────────────────────────────────┘   │
└──────────────────────────────────────────────────────────────────┘
     ↑              ↑              ↑              ↑
  Agent w/      Agent w/       Agent w/         Human
  PM perms   Developer perms  Admin perms     (Browser)
   (LLM)         (LLM)          (LLM)
                     │
          ┌──────────▼──────────┐   ┌─────────────────────┐
          │  PostgreSQL + Prisma │   │  Redis (optional)   │
          └─────────────────────┘   │  Pub/Sub for SSE    │
                                    └─────────────────────┘

Packages

Package	Description
packages/openclaw-plugin	OpenClaw Plugin — Connects OpenClaw to Chorus via persistent SSE + MCP bridge.
packages/chorus-cdk	AWS CDK — Infrastructure-as-code for deploying Chorus to AWS.

Tech Stack

Component	Technology
Framework	Next.js 15 (App Router, Turbopack)
Language	TypeScript 5 (strict mode)
Frontend	React 19, Tailwind CSS 4, shadcn/ui (Radix UI)
ORM	Prisma 7
Database	PostgreSQL 16
Cache/Pub-Sub	Redis 7 (ioredis) — optional
Agent Integration	MCP SDK 1.26 (HTTP Streamable Transport)
Auth	OIDC + PKCE / API Key / SuperAdmin
i18n	next-intl (en, zh)
Deployment	Docker Hub / Docker Compose / AWS CDK

---

Getting Started

Quick Start with Docker (Recommended)

No build tools or external databases required. The image bundles PGlite (embedded PostgreSQL):

git clone https://github.com/Chorus-AIDLC/chorus.git
cd chorus

DEFAULT_USER=admin@example.com DEFAULT_PASSWORD=changeme \
  docker compose -f docker-compose.local.yml up -d

Open http://localhost:8637 and log in with the credentials above.

Data is persisted in a Docker volume. The embedded mode is single-instance only (no Redis).

Production Deployment (PostgreSQL + Redis)

For production with multiple replicas:

DEFAULT_USER=admin@example.com DEFAULT_PASSWORD=changeme \
  docker compose up -d

See Docker Documentation for all environment variables and configuration options.

---

Local Development

Prerequisites: Node.js 22+, pnpm 9+, Docker (for PostgreSQL/Redis)

cp .env.example .env
pnpm docker:db
pnpm install
pnpm db:migrate:dev
pnpm dev
# Open http://localhost:8637

Local Development (no Docker)

Prerequisites: Node.js 22+, pnpm 9+

cp .env.example .env
pnpm install
pnpm dev:local        # Dev server on http://localhost:8637

PGlite runs embedded PostgreSQL on port 5433. Data stored in .pglite/ — delete to reset.

Deploy to AWS

./install.sh

The interactive installer provisions VPC, Aurora Serverless v2, ElastiCache Serverless, ECS Fargate, and ALB with HTTPS. Configuration saved to default_deploy.sh for re-deploys.

Connect AI Agents

The fastest path is the in-app setup wizard: open the Web UI, go to Settings → Setup Guide → Open setup guide, and follow the step-by-step instructions for your client (Claude Code, Codex, OpenCode, OpenClaw, or other agents). The wizard creates the API key for you, shows the exact commands, and walks through verifying the connection.

If you'd rather read the full docs:

Client	Guide
Claude Code	CONNECT_CLAUDE_CODE.md
Codex CLI	CONNECT_CODEX.md
OpenCode †	CONNECT_OPENCODE.md
Other MCP agents (Cursor, Continue, custom, …)	CONNECT_OTHER_AGENTS.md

† OpenCode support is provided by the community-maintained opencode-chorus plugin (npm: opencode-chorus), authored by @etnperlong. Thanks!

Create API Keys in the Web UI under Settings → Agents → Create API Key. Keys start with cho_ and are shown only once.

---

Skill Documentation

Method	Location	Use Case
Plugin-embedded	public/chorus-plugin/skills/chorus/	Claude Code + Plugin, automated Sessions
Standalone	public/skill/ (served at /skill/)	Any Agent, manual Session management

---

Documentation

Document	Description
PRD	Product Requirements Document
Architecture	Technical Architecture Document
MCP Tools	MCP Tools Reference
Chorus Plugin	Plugin Design & Hook Documentation
Search	Global Search Technical Design
AI-DLC Gap Analysis	AI-DLC Methodology Gap Analysis
AIG Implementation Plan	Agent transparency roadmap
Presence Design	Real-time agent presence system
Docker	Docker image usage & deployment
Logging	Structured logging architecture
CLAUDE.md	Development Guide

---

License

AGPL-3.0 — see LICENSE.txt