# CHAP Coordinator [Health: Active]

**Category:** 💻 Developer Tools  
**Repository:** https://github.com/BrightbeamAI/chap  
**GitHub Stars:** 104  
**Views:** 1  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/chap-coordinator

## Description
Auditable records of human decisions over AI agent work. Approvals, edits, overrides, escalations.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `uvx` (confidence: high):

```json
"mcpServers": {
  "chap-coordinator": {
    "command": "uvx",
    "args": ["chap-analytics"]
  }
}
```

## Documentation

## What CHAP Coordinator MCP server does

CHAP Coordinator MCP server provides a structured record for work shared by AI agents and human participants. It treats an agent’s output as an artefact, then records the human response as an approval, edit, override, rejection, handoff, or escalation where applicable. The resulting history is intended to show what was produced, who acted on it, and why.

Work is grouped into named workspaces. A workspace can contain protocol profiles such as `core/1.0` and `review/1.0`, along with human and agent participants. Tasks identify the work being performed, while review requests connect an artefact to the person or participant expected to assess it.

Overrides can preserve the original intent while recording a structured diff, rationale, and controlled tags. This makes reviewer changes usable as supervision or analysis data rather than leaving them only in chat messages or ticket comments.

## How it works

The coordinator follows a sequence that can begin with workspace creation and participant registration. An agent then creates a task, completes it with an output, and submits that output for review. A human can record a decision against the task, including a JSON-style change description and an explanation.

CHAP Coordinator MCP server links the resulting envelopes with content hashes and `prev_hash` references. An audit read can replay the connected history as one chain, which helps reconstruct a decision after ordinary logs expire, systems change, or the original conversation is difficult to find. The README also describes optional profiles for Ed25519 signing, OIDC-bound identity, and external transparency-log anchoring, but does not provide their configuration details here.

The protocol is designed to sit alongside MCP and A2A: MCP handles tool access, A2A handles communication between agents, and CHAP records shared work involving people.

## Setup and configuration

The repository provides packages for both TypeScript and Python. In TypeScript, instantiate `Coordinator` with a `SqliteStore` pointing to a database path such as `./chap.db`. The Python example uses the same coordinator concept and SQLite persistence, dispatching JSON-RPC requests through the coordinator.

A typical setup creates a workspace, registers a human participant and an agent participant, and selects the profiles needed by that workspace. The examples identify participants with values such as `human:me@local` and `agent:cursor#v1`. The supplied material does not specify environment variables, MCP client configuration blocks, network settings, or authentication settings.

## Tools and capabilities

CHAP Coordinator MCP server exposes coordinator operations corresponding to the documented API methods:

- `workspace.create` creates a workspace and assigns profiles.
- `participant.join` adds a human or agent participant.
- `task.create` starts a unit of work and returns a task identifier.
- `task.complete` attaches an agent’s output to a task.
- `review.request` sends an artefact to a reviewer.
- `decide.override` records a structured human change, rationale, and tags.
- `audit.read` retrieves the linked audit history.

The examples show the same workflow through TypeScript methods and Python JSON-RPC dispatch. The project describes conformance vectors as passing and publishes both PyPI and npm packages, but the provided material does not define a complete MCP tool schema.

## Limitations and notes

The supplied documentation does not state which MCP transport the coordinator uses, list a full set of MCP tool names, or describe a hosted deployment. It also does not document retention, concurrency, access-control, or database migration behavior. Treat the SQLite examples as embedded persistence guidance rather than evidence of production-database support.

The code is licensed under Apache 2.0, while the protocol specification is marked CC BY 4.0. These are separate licensing terms, so check the repository license when distributing implementations or derived protocol documentation.

_Full upstream README: https://allmcps.com/mcp/chap-coordinator/readme_