Maya, a senior support agent, will review dozens of agent message drafts this afternoon – thousands by year-end. Most she approves; a few she edits before sending. Without capturing her changes – and implementing a learning loop – the agent will make the same mistake next time.

// a human override, captured as structured data
{
  "method": "decide.override",
  "params": {
    "task": "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:…" }
}

Now, Maya edits the draft and types a one-line reason as she saves. The change is saved, along with her reason as the rationale. Which means any person, or AI tool, can apply her judgement – in the next five minutes or decades later.

CHAP records the everyday actions of everyday work. And builds intelligence capital across the organisation.

The common actions it manages include:

Underwriters own every decision. A Qualified Person signs-off a batch. An operator owns the line. So when you are using AI, human oversight needs to happen. And afterwards, it must be provable that it happened.

CHAP adds the missing piece:

CHAP composes with both – tool calls are recorded as citations; A2A peers appear as participants.

The benefits of CHAP

CHAP pays off at the project, programme, site and organisation level.

Whether you're using CHAP for a personal project – or implementing it across a global, regulated estate in a GMP environment, CHAP helps you get started with 12 worked scenarios directly available in the repo. Despite a wide range of use cases, each 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

Here are six of the 12 scenarios:

See all scenarios in the repo →

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

# 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:[email protected]",
      "to":           "service:[email protected]",
      "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.

The seven methods in the core.

The anatomy is driven end-to-end by just seven calls.

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

Everything beyond the deliberately small core is an optional, versioned profile. Only add when you need it – advertised at runtime through workspace.describe.

Immutability is itself an optional profile – blockchain is only one way to implement it, never part of the core.

It works with what is already there.

CHAP defers to good standards everywhere else. MCP tool calls are recorded as citations, not re-implemented. A2A peers appear as bridge participants.

One query, one chain, three protocols.

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

A task assigned and accepted, worked with a cited tool call, reviewed, overridden with a rationale, put to a weighted group decision, and signed off – every entry hash-linked and replayable years later. The paper's Appendix A trace.

The audit log becomes the point.

Because every override carries a typed diff – and a reason – the audit log becomes a tuning dataset as a side effect of normal work. It tells the systems not just that a human stepped in, but why.

These tune to different fixes. Abstention rates tell you where the human/agent boundary should sit. You can slice overrides by model version, task kind, policy, reviewer role and tag – without scraping a single final document.

Why open – and why from us

Open standards gain most traction

TCP/IP, HTTP, OAuth, OIDC and now MCP – the pattern is consistent. Open, shared standards become the basis of many platforms. And given that the collaboration between humans and agents will have to be standardised – one way or another – we believe better in the open, with as many implementers contributing as possible.

Status, and the road to 1.0.

CHAP is v0.2 – a public draft. The wire format and schemas are stable for review; the Core runs; the review profile and a routing-aware playground are runnable; conformance scaffolding is in the repo. Wire-format changes in 0.x remain possible – we're inviting feedback before committing to 1.0.

The method catalogue holds 39 method handlers – seven for the Core path, nine for Minimal conformance. Hierarchical workspaces are an explicit candidate for v0.3. Security note: Ed25519 lacks post-quantum resistance – hybrid post-quantum signatures are named as future work. CHANGELOG · SPECIFICATION

Build it in the open

The most useful thing you can build right now is your second implementation.

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

FAQ

Questions we are asked.