Git coordinates code at rest · Datum coordinates agents in motion.

catches drift at the write, not at merge · CLI · Claude Code plugin · MCP · deterministic fence · async Opus arbiter · zero runtime deps

Install · How it works · Demo · Teams · Cloud · Docs · llms.txt

_{AI agents / LLMs: you are the reason this repo exists. Read /llms.txt, or connect the Datum MCP server to self-onboard into the coordination loop.}

---

Datum is a real-time coordination layer for teams whose engineers each run an AI coding agent (such as Claude Code) against the same repo. When one agent renames a database column, swaps a dependency, or changes an API shape, Datum catches the drift at the next write instead of at merge, by giving every agent in flight a live, versioned source of truth it cannot ignore.

▶ Watch the 60-second demo — or run the whole scenario locally with npm run demo.

The problem

Teams do spec-driven development right: a shared spec, a common CLAUDE.md, PRDs split per engineer. Then implementation starts and truth changes. One agent renames a column; the others keep building against a contract that no longer exists. The drift surfaces at merge, after the rework is already paid for. Specs are snapshots; agents in flight have no live source of truth.

How it works

A deterministic fast path, with the model on a slow path behind it.

Detect (fast, no model). A PostToolUse hook streams every edit to a shared bus. A path-and-parser watchlist flags contract-relevant changes (DB schema, API shape, dependency version, a recorded decision) and bumps a monotonic registry version in milliseconds.

Protect (fast, no model). This is the money shot. A PreToolUse fence runs a version check plus a set intersection on every tool call. A stale write that targets a changed contract is denied before it executes, naming the contract, the change, and the author:

- ⌖ DENY  Edit routes/users.ts  (PreToolUse fence)
- db.users.email was renamed to contact_email (migration 0042, asha, 40s ago).
- This edit selects .email and will break. Re-sync to v8 and use contact_email.
+ ✓ after re-sync to v8 the write targets contact_email — allowed.

The agent reads that reason and self-corrects on its next action. The deny lands ahead of any permission check, so it holds even under --dangerously-skip-permissions. It fails open and never bricks an agent if the bus is down.

Judge (slow, async, Opus 4.8). An arbiter off the critical path writes a per-recipient advisory tailored to each teammate's in-flight task and opens a pull request that patches the spec. It is model-agnostic, and the fence fires with the arbiter disabled — the model is never on the critical path.

Quickstart

Install the Claude Code plugin. One step wires the hooks, the MCP server, and the skills, and the agent configures everything else itself:

/plugin marketplace add suraj-phanindra/datum
/plugin install datum@datum

The plugin is zero-init: the datum-join hook self-seeds git-native identity (human, email, branch, and workspace from your git config) on the first session, and the /datum:setup skill starts the local bus in the background — no datumctl init, no babysitting a terminal. It bundles:

• The four hooks — datum-join (SessionStart), datum-claim (PostToolUse), datum-fence (PreToolUse), datum-guard (Stop).
• The MCP server, so agents read the registry and ledger and publish claims, syncs, and decisions.
• Six skills under /datum: — setup (configure + start Datum with zero manual steps), coordinate, claim, sync, resolve-fence, decide.

Kick the tires without installing anything into your own editor:

git clone https://github.com/suraj-phanindra/datum && cd datum
npm run demo             # the full three-agent scenario, headless, end to end

Prefer the CLI to the plugin? npx datumctl init wires the hooks + MCP, datum up starts the bus in the background, datum down stops it. datumctl is a self-contained npm package with zero runtime dependencies. Installed hooks need Node ≥ 18; the bus and the source/tests use node:sqlite and need Node ≥ 22.6.

Statusline badge (optional)

Keep your coordination state in the Claude Code status bar — add to .claude/settings.json:

"statusLine": { "type": "command", "command": "datum statusline" }

It prints ⌖ v<epoch> (plus ☁ in cloud mode and ✎N for the files you have claimed) from the local cache. No network, safe on every refresh, empty outside a Datum workspace.

Teams

The team is the repo. There is no login and no member list to maintain: membership is having the repo. Identity comes from your git config (user.name / user.email), and the workspace id derives from the git remote, so every clone of the same repo lands in the same team automatically.

datumctl serve --public          # one shared bus for the team (binds 0.0.0.0, prints a tunnel hint)
datumctl init                    # per engineer; the first init creates the committed datum.json
datumctl team                    # see the live fleet: workspace + bus + roster

The committed datum.json (repo root) shares the team's bus_url and workspace; the first init creates it, the rest read it. Full git-native model: docs/prd/teams.md.

Open core

The MIT-licensed core is the whole protocol: the CLI, the hooks, the MCP server, the single-team bus plus registry plus fence, the arbiter (bring your own Anthropic key), the git-native team layer, and the skills. The core is never crippled — a team can self-host all of it. Datum Cloud (premium, per-seat) adds the hosted multi-tenant bus, the team-management dashboard, a pooled arbiter (we pay the model cost), SSO, retention and audit, and analytics. It lives in a separate private repo and depends on the published datum-core, so the same core runs in both. See LICENSING.md and docs/ROADMAP.md.

Develop

npm test          # node --test over TypeScript, no build step
npm run build     # bundle via esbuild -> dist/
npm run demo      # headless coordination scenario
npm run web       # serve the read-only "tower" (observability only; it acts on nothing)

Requires Node ≥ 22.6 (native TypeScript type-stripping plus node:sqlite); use Node 24 for development and CI. The arbiter uses claude-opus-4-8 via ANTHROPIC_API_KEY when set, else the authenticated claude CLI.

Project layout

datum/
  cli/       datumctl entry + commands
  core/      datum-core: the coordination core as a package
  hooks/     datum-fence, datum-claim, datum-join, datum-guard
  plugin/    the Claude Code plugin (hooks + MCP + skills)
  server/    bus + registry + watchlist + arbiter + MCP server
  web/       the read-only "tower" dashboard
  demo/      headless scenario (npm run demo)
  test/      node --test suites
  docs/      ROADMAP.md + design + spec

Contributing · Security · License

Issues and PRs welcome — see CONTRIBUTING.md. Report vulnerabilities via SECURITY.md. Licensed MIT.