A worker reviews a document alongside a small robot holding a CHAP section summary in an open-plan office

Collaborative Human-Agent Protocol

Including the
responsible human

CHAP is a protocol for auditable human-agent collaboration. It is open, and designed to work with MCP and A2A.

The complete technical introduction

Meet CHAP.

A technical introduction to structured, auditable collaboration between humans and AI agents.

01

What it is

A structured record of human-agent work

An agent drafts a decision and a person approves, edits or overrides it. That judgement is the most valuable signal in the system, and it usually gets lost in chat threads and tickets.

CHAP turns it into a structured, verifiable record.

Maya, a support specialist, reviews dozens of an agent's drafts every day. Unless her edits are captured, the agent keeps making the same mistakes.

What Maya does

We sincerely apologise for the extreme delay just wanted to follow up, your order is in transit and will arrive within the next three business days. We deeply regret any inconvenience caused. Let me know if you don't see it by then.

Her reason, in her words
Tone too apologetic for a routine tracking question
What CHAP records · wire shape (illustrative)
// a human override, captured as structured data
{
  "method": "decide.override",
  "params": {
    "task_id": "tsk_01HZ9YX7K3X8M2V4",
    "diff": [
      { "op": "replace", "path": "/body",  "value": "Thanks for following up…" }
    ],
    "intent_preserved": true,        // refined the result, didn't substitute it
    "rationale": "Over-apologetic for a routine tracking enquiry.",
    "tags": ["tone-softened"],
    "policy_refs": ["support-tone-v2"]
  },
  "evidence": { "prev_hash": "sha256:9f3c…", "sig": "ed25519:…" }
}

CHAP keeps Maya's edit with her one-line reason, so people and AI tools can reuse her judgement. Over time, the record shows how the organisation really decides.

The everyday actions it records

delegateacceptdeclinecompletereviewapproveoverrideabstainescalatehand offpauseresume
02

Why CHAP?

Because we're accountable for what is decided

CHAP adds the missing piece:

Agent proposes → Human decides → CHAP records → Team can prove, AI can learn
CHAP This layer · humans
Humans, agents and services collaborating in an auditable workspace
A2A Agents → agents
Agents delegating to other agents
MCP Agents → tools
Agents calling tools and data

CHAP works alongside both. Tool calls become citations, and A2A peers become participants.

The benefits of CHAP

Less risk, at lower cost.

One standard way to handle approvals, overrides and audit trails, so teams stop reinventing them.

One record across tools.

Approvals no longer sit across Slack, Jira and model logs. One query shows who did what, when and why.

No vendor lock-in.

CHAP is open, like MCP and HTTP, so your records stay usable if you change vendors.

CHAP supports the records these regimes ask for. It doesn't make a system compliant on its own. It produces the evidence that oversight, logging and incident review depend on.

EU AI Act · Art 14 & 12NIST AI RMFGMP Annex 11DORASOX-404SMCRHIPAA

CHAP can answer all of these.

Who delegated this work?
task.create
Which agent and which tools did the work?
citations · mcp_tool_invocation
Was it reviewed, overridden or abstained, and why?
review.request · decide.override · abstain.declare
What changed, and under which policy?
diff · policy_refs
Which mode was the agent in: shadow, trial or production?
modes
What was the abstention reason?
insufficient_evidence · policy_conflict · authority_boundary
Was there a handoff, deliberation or rollback?
handoff · deliberate · control
Can a third party verify the chain wasn't altered?
audit.verify_chain · SCITT receipts
All eight come from the evidence chain. With the security-signed and audit-scitt profiles, entries are signed at origin and witnessed outside the platform, so no one has to take the platform's word for it.

At every scale

Always the same building blocks

From a personal project to a regulated GMP estate, every scenario reuses the same primitives.

  1. A typed override with the difference and reason for it
  2. A clarifying question
  3. A context-preserving handoff
  4. A signed approval that becomes externally verifiable
Biopharma · GMP
A pressure drop on the fill-finish line

Deviation → investigation → QP release, signed with regulatory credentials and externally anchored.

Insurance · FCA Consumer Duty
The bereavement that changes everything

Vulnerability-based routing plus handler override with policy citations – evidence of meaningful review within SLA.

Wealth · SMCR / SOX
Five years on, the regulator asks

Replay an advisor's approval chain across years to prove control continuity and suitability.

Medtech
A device-complaint triage

Abstention on authority boundary escalates to a qualified human – recorded, with the reason typed.

Manufacturing
An operator agent in production

Mode-gated promotion: the agent earns production only on evidence from the chain.

Creative · dispute
'We never approved that'

A non-repudiable signed approval tied to a content version by hash settles it.

See all scenarios in the repo →

If accountability sits with you, let's talk about the evidence layer.
Talk to us
03

How it works

This is CHAP in action

Step through a real session. Every action becomes an entry in the audit log, and the overrides, grouped by tag, become the learning signal.

Workspace
wsp_support_triage
Live
M
Maya
human · reviewer
T
Triage Bot
agent · drafter
C
Coordinator
service · workspace
0 / 6
Click Start to walk through a real CHAP flow, envelope by envelope.

A real audit trail

One session, end to end.

One claim, from delegation to sign-off, adapted from Appendix A of the paper. Every entry is hash-linked and can be replayed years later.

wsp_claims_review · evidence chain 12 entries · hash-linked · signed at origin
000
task.create
A claim is delegated to the agent. human:handler → agent:claims-bot
001
task.update
The agent starts work, and the task moves to in progress. agent:claims-bot
002
whisper.ask
A quick, deadline-bound question to a human: the tap on the shoulder.
003
whisper.answer
The human answers in seconds; the answer is recorded.
004
task.complete
The agent delivers a draft, with MCP tool calls recorded as citations (server, call id, input + output hashes).
005
review.request
The draft is sent for human review. agent:claims-bot → human:handler
006
decide.override
The handler overrides, with diff, rationale, tags and policy references captured together. This is the most important entry in the log.
007
deliberate.open
A point too big for one approver goes to a weighted group decision.
008
deliberate.vote
Each vote is yea, nay or abstain, with the voter's comment.
009
deliberate.close
Outcome computed against the decision rule. A veto, if any, stays in the log with its reasoning.
010
task.create
A follow-up credit task is delegated as a result of the decision.
011
task.complete
The follow-up is delivered and finalised.
With the chain on, each entry carries a hash of the one before it, so rewriting any line breaks every hash after it. audit.read replays the history and audit.verify_chain checks it.

The audit log becomes a tuning dataset.

Every override carries a typed diff and a reason, so normal work records that a person stepped in, and why.

A high refining-override rate

means the agent reached the right decision the wrong way, for example through weak retrieval or a poor template.

A high substituting-override rate

means it reached the wrong decision, for example because of an ambiguous policy or missing context.

Each calls for a different fix. Slice overrides by model, task, policy, reviewer and tag without scraping a single final document, or let chap-analytics export evaluation cases and flag drift.

04

For builders

Get started in five minutes.

Run the reference server locally, then send JSON-RPC envelopes with curl. No SDK, identity provider or signing setup needed for the first walkthrough.

git clone https://github.com/BrightbeamAI/chap
cd chap/reference/core && npm install && npm run start:demo
# CHAP Core → http://localhost:8080/chap  ·  then send envelopes with curl
examples/00-five-minute-start.md
# with the reference server running – envelope 1: Alice joins as a reviewer
curl -s -X POST http://localhost:8080/chap \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": "1",
    "method": "participant.join",
    "params": {
      "workspace":    "wsp_demo",
      "from":         "human:alice@example.org",
      "to":           "service:coordinator@example.org",
      "ts":           "2026-05-17T09:00:00Z",
      "type":         "human",
      "display_name": "Alice",
      "role":         "reviewer"
    }
  }' | jq

# then: join the bot → describe → create → progress → complete → audit.read

The anatomy.

Workspace

The shared, policy-bound room.

Participants

Humans, agents, services – typed addresses.

Tasks

The units of work they hold.

Artefacts

Drafts, decisions, overrides, citations.

Evidence log

Append-only. Hash-linked with the chain on, signed with security-signed.

The seven methods in the core.

workspace.describeWhat is this room? Who's in it? Which profiles are advertised?
participant.joinAdd a human, agent or service to the workspace.
participant.leaveRemove a participant.
task.createDelegate work to an assignee with structured input.
task.updateReport progress; transition state.
task.completeDeliver output and finalise the task.
audit.readQuery the workspace's history with filters and ranges.

That's enough to run a Core workspace. Everything else is an optional profile layered on top.

Add the profiles you need

A small core and optional profiles.

Add a profile only when you need it. A workspace advertises its profiles through workspace.describe and serves only their methods.

The profile explorer shows which calls change when you add one. Immutability is optional too, and blockchain is never required.

Start here core + 1
coreMandatory
Workspaces, participants, tasks, append-only audit log. Seven Core methods.
reviewHighest value
Request, approve, reject, override, abstain, escalate. The profile you just saw in the demo.
Workflow 5 profiles
modes
Shadow → trial → production. Roll out new agent versions safely.
Safe agent rollout
routing
Cost, criticality and confidence signals carried, not interpreted.
Match review depth to risk
deliberation
Quorum, weighted votes, vetoes. Group decisions that keep the dissent.
Multi-approver sign-offs
whisper
Deadline-bound interrupt questions with a default if it lapses.
The tap on the shoulder
handoff
Propose, accept or decline a transfer of work, with context preserved.
Shift changes · time-zone handovers
Identity & trust 4 profiles
identity-oidc
OIDC binding – reuse your existing identity layer; the private key never leaves the device.
Enterprise SSO
identity-vc
W3C Verifiable Credentials – a qualification asserted cryptographically in the workspace.
Regulated professions
security-signed
Ed25519 + JCS canonicalisation. Per-message non-repudiation.
Signed at origin
audit-scitt
IETF SCITT transparency log (RFC 9943). An outside witness for every entry.
Regulatory audit
Operations 1 profile
control
Pause, resume, snapshot and roll back agent work. The operational control plane.
Incident response

It works with what is already there.

MCP tool calls become citations, A2A peers become participants, and Python bridges bring human decisions from LangGraph, Pydantic AI, LlamaIndex, AG2 and Google ADK onto the same log.

JSON-RPC 2.0envelopes
OIDC / W3C VCidentity
IETF SCITTtransparency log
in-totoattestations
MCPtool calls as citations
A2Apeers as participants

One query, one chain, three protocols.

Ready-to-adapt how-to guides ship in the repo: CHAP + MCP · CHAP + A2A · CHAP + OIDC.

05

Research

Why CHAP is open

Why open, and why from us

TCP/IP, HTTP, OAuth and MCP show that open standards become the base for many platforms. The layer where people and agents work together will be standardised one way or another, and it is better done in the open.

Built against capture

At least three Steering Committee seats will go to people outside the largest contributor, so no one, including us, can steer CHAP alone. Until the committee forms, every decision is published with its reasons.

Grounded in running code

A CHAP Enhancement Proposal cannot be accepted until a working implementation passes the conformance tests, and a change that works in only one vendor's stack is not accepted.

Status and the road to 1.0.

CHAP is a public draft. Two coordinators, in TypeScript and Python, are checked against each other and published on npm and PyPI. The message format can still change before 1.0, and the public roadmap sets out the milestones.

Runs today
Today

A working draft

Two coordinators checked against each other, refused attempts on the record, MCP and A2A servers, agent-framework bridges and chap-analytics.

Next
Next milestones

Settle the surface

One message format with a version on every request, a decided audit chain, a maturity level for every part, and rules for who may join a workspace and act in it.

Planned
For 1.0

Tested from outside

An implementation from outside Brightbeam passes the test kit, an external security review reports, and maintainers come from at least two organisations.

The roadmap has no dates. Each milestone finishes when its checks pass. ROADMAP · CHANGELOG · SPECIFICATION

Build it in the open

The most useful contribution now is a second, independent implementation.

CHAP is licensed CC-BY 4.0 for the specification and Apache 2.0 for the code, implementable royalty-free in any language.

Small changes → a pull request

Typos, examples, test vectors, integrations go straight to a PR.

Bigger changes → a CEP

New methods, transports or breaking changes go through a CHAP Enhancement Proposal, with a public comment period and the decision and its reasons on record.

'The Human–Agent Symphony will not emerge simply because models improve. It will emerge when the collaboration layer between humans and agents becomes explicit, observable, portable and shared. CHAP is a proposal for that layer.'

CHAP paper · §15
Start on GitHub Read a CEP Build an implementation
06

FAQ

Questions we're asked.

For leaders
For builders

The third protocol

One clear record of how people and agents work together.

Better models alone will not produce it. It needs an open standard, and CHAP is our proposal for one.

Start on GitHub Read the paper