Git coordinates code at rest. Datum coordinates agents in motion.
A live, versioned source of truth for your team's contracts. When one agent renames a column or swaps a dependency, the others are stopped at their next write, before they build against a contract that no longer exists.
asha: "phone signups make email the wrong name." users.email → contact_email, migration 0042.
the problem
You find out at merge. After the rework is paid for.
Every engineer on your team runs their own coding agent against the same feature. You start aligned: a shared spec, a common CLAUDE.md, a PRD split per person. Then one agent renames a column or swaps a dependency, and the others keep building against a contract that no longer exists. Specs are snapshots. Agents in flight have no live source of truth, so the drift surfaces at merge, after the tokens are already spent.
how it works
Three pieces. One protocol.
A live, versioned record of your schemas, API shapes, dependency versions, and decisions. Every change is stamped with who made it, when, and why, so the truth is always one place, not scattered across branches.
One command installs Claude Code hooks on every machine. Each tool call is checked against the current contract before it runs, and a stale write is stopped with the reason inline. A CLAUDE.md can be ignored. A fence cannot.
Detection and fencing are instant and deterministic. The model runs off the critical path to decide which change breaks whom, write each teammate a fix for their exact task, and open a pull request that updates the spec.
the cockpit
It happens where you already work.
Asha migrates the schema on her branch. Ben's agent, mid-edit on another branch, never gets to write the broken query.
No human in the loop. The agent reads the reason and corrects itself before the next write.
the latency answer
The model adds judgment, not latency.
Correctness comes from a deterministic fast path. The model layers judgment on top, off the critical path, so coordination never makes an agent wait.
A path-and-parser check on every edit flags contract changes and bumps a version. No model call.
A local version check on each tool call. The network is touched only when a fresh change lands.
The arbiter runs in a queue. The bar is beating your next relevant write, not the wall clock.
If the bus goes down, the hook fails open and the agent keeps working. No agent is ever bricked.
install
One command in Claude Code. Or the CLI, if you prefer.
The plugin wires the four hooks, the MCP server, and five skills into every session, so each agent claims its scope, syncs before a risky write, and reads a fence denial in its own voice.
Run these two slash commands in Claude Code. Zero init: the join hook seeds your git-native identity on the first session.
Wire the hooks and MCP without the plugin, then run the coordination bus your sessions point at.
try it: npm run demo runs the full scenario end to end. Three agents build one feature, one renames users.email, and a teammate's stale write gets fenced and self-corrects. Then watch it in the read-only live tower, or read the docs on GitHub.
pricing
The core is free forever. Cloud adds the parts a team cannot self-host.
The whole protocol is MIT and self-hostable: the CLI, the hooks, the MCP server, the bus plus registry plus fence, the arbiter (bring your own Anthropic key), the git-native team layer, and the Claude Code skills. Datum Cloud is the hosted convenience on top.
- CLI, hooks, MCP server, and the five skills
- Single-team bus, registry, and the fence
- The Opus 4.8 arbiter, bring your own key
- Git-native team layer and read-only tower
- Hosted multi-tenant bus, no VM or tunnel
- Team-management dashboard and workspaces
- Pooled arbiter, SSO, retention and audit
- Analytics: drift trends and fence stats
Built on the published datum-core package, so the same coordination core runs self-hosted and in Cloud. See the full pricing →