Completion is not
acceptance.
When multiple agents work the same codebase, the coordination truth has to live somewhere they can’t lie about. CLAiR is that runtime — claims, leases, gates, merges, evidence — structured, authenticated, event-sourced, and accountable.
For engineering leaders, platform teams, and compliance officers running agentic delivery in regulated codebases.
See CLAiR coordinating real agents against a real repo. No deck.
Coordination truth shouldn’t live inside the agents.
Multiple agents on one repo is a distributed systems problem, not a prompt-engineering problem. CLAiR is the runtime that holds them honest — with the receipts.
Agents collide on the same code.
Two agents pick up overlapping work. One agent abandons a branch mid-flight. Another claims something it isn’t scoped to touch. With no live coordination authority, the codebase pays the cost — in races, lost work, and quiet conflicts.
Completion gets confused with acceptance.
An agent reports done. A reviewer skims. The change merges. Nobody can later show what gate was satisfied, what evidence was attached, or who authorized the release. “The agents finished” is not the same sentence as “we shipped something the auditors can sign off on.”
Claims, leases, gates — with evidence.
CLAiR brokers every claim, enforces every gate, projects every event into a queryable graph. Events are truth, denials are structured, mutations require authenticated principals. The agents stay focused on code; the runtime keeps the receipts.
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 — more than 40 endpoints covering ACOP, graph facade, events, branch leases, merge queue, conflicts, flows, compliance, and 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
Proven, not promised
CLAiR is real working software. Over 286 tests run green in CI across the Domain, Application, and Integration layers. The SQL projection is exercised on SQLite through the integration harness and runs the same code path on SQL Server and Azure SQL Edge.
Shipped today: Bo intake, the orchestration flow loader, branch leases, the merge queue, conflict-resolution-as-work-item, local Git-provider verification, the BogDB graph projection (write and read), and the compliance extension with pattern-based auto-attach.
Turn model output into accountable code work.
If you’re building agentic delivery into a regulated environment, CLAiR is the runtime layer that makes “we ran a constellation against this repo” something an auditor can read. 30 minutes is enough to see it working.