Coordination authority for
multi-agent code work
CLAiR — Code Lease, Arbitration, and Intelligence Router — owns the live coordination truth that should not live inside the agents themselves. Claims, leases, gates, branches, merges, compliance evidence: structured, authenticated, event-sourced, and accountable.
Completion is not acceptance.
An agent may complete a work item. CLAiR still requires the configured acceptance, verification, review, or compliance gates before any downstream work is released. That one distinction is the difference between "the agents finished" and "we shipped something the auditors can sign off on."
Around that spine, CLAiR adds three more design rules: events are truth (all state derives from a JSONL event log; read models are rebuilt views), denials are structured (every refusal returns a machine-readable error code, category, related entity IDs, and suggested next action), and mutation requires authorization (no claim, lease, complete, accept, merge, or release fires without an authenticated principal scoped to the operation).
What CLAiR owns
- Claims and leases with TTLs, renewals, voluntary release, and expiry.
- Arbitration across competing agents, stale-work cleanup, retry and reassignment policy.
- Blackboard coordination with scope-aware visibility rules.
- Orchestration flows — stages, gates, release conditions, acceptance state.
- Source-control authority — branch leases, merge queues, conflict-as-work-item.
- Compliance gate hooks — requirements, evidence, exceptions, matrix.
- Agent identity — authentication, scoped authorization, structured error responses for every denial.
- Bo intake — structured handoff envelopes from the planning provider become CLAiR operations.
- Graph projection — durable state writes into BogDB so upstream orchestrators like ASE can query history.
What CLAiR is not
CLAiR's scope is narrow on purpose. It is not a general-purpose workflow engine, not a code editor, not a build system, not a CI pipeline, not a version control system, not a model host. If a capability doesn't directly serve coordinating multi-agent code work with repo-aware, branch-aware, artifact-aware semantics, it doesn't belong in CLAiR.
That focus is what makes it composable. Temporal can still run your business workflows. Your CI/CD can still ship your builds. Your agents can still use whatever model host they prefer. CLAiR holds the line on coordination, and everything else stays free to evolve.
CLAiR implements ACOP — the Agentic Code Orchestration Protocol
ACOP is the runtime contract for multi-agent code work: register or observe an agent, ingest a work item, claim it with a lease, renew or release, attach artifacts and evidence, write blackboard entries, query actionable work, load orchestration flows, gate downstream releases, coordinate branches and merges, and return structured denials for every refused operation.
Bo produces the structured code-work evidence. BogDB stores the durable graph projection. MCP is a tool surface; A2A is message transport. CLAiR is the runtime that holds them honest — the ACOP service that turns "we asked the agents to do the work" into "we have evidence the work was done, approved, and merged according to the gates we configured."
Where CLAiR fits in the Beyond Ordinary stack
ASE is the human-facing control plane. It defines work, configures constellations, supervises runs, and reports out. ASE doesn't arbitrate live claims — it asks CLAiR.
Bo produces the deterministic code intelligence and planning artifacts. When Bo wants to hand work into the system, it sends a handoff envelope to CLAiR's /bo/intake endpoint, which normalizes it into ACOP operations.
BogDB is the durable graph projection. CLAiR's JSONL event log is the source of truth; BogDB is the queryable read model that lets ASE answer "what happened on this codebase, who approved it, and what evidence proves it."
Each boundary is a contract. Replace any of them and the rest still works.
Engineered, not sketched
- .NET 10 minimal API — 38 endpoints covering ACOP, graph facade, events, branch leases, merge queue, conflicts, flows, compliance, Bo intake
- JSONL event store as the system of record — events are truth, read models are derived
- Optional EF Core read-model on SQL Server / Azure SQL Edge for queryable indexes
- BogDB graph projection — node/edge upserts on every appended event
- Keycloak OIDC authentication (with a static-token mode for local dev)
- Sliding-window rate limits, structured error envelope, scoped principals
- Blazor Server dashboard with read-only views over agents, work items, claims, blackboard, events, policies, and reports
Built and tested in the open
CLAiR is real working software. 286 tests cross Domain, Application, and Integration layers, all green in CI. The EF Core projection is exercised on SQLite via the integration harness; the SQL Server path runs the same code.
Phases 1–3 are complete, plus branch leases, merge queue, conflict resolution, the Bo-intake normalizer, the orchestration flow loader, the BogDB projection (write and read), and the compliance extension. Diffsets, pattern-based compliance auto-attach, and Git-provider integration are on the roadmap.
For a phase-by-phase honest status, ask us for the current-state matrix — or watch the project come together one slice spec at a time.
Live coordination, with the receipts
If you're building agentic delivery into a regulated environment, CLAiR is the runtime layer that turns model output into accountable code work. It's the component underneath ASE that makes "we ran a constellation against this repo" something an auditor can read.