Datafew Locus · Code Admission Control Plane

Trust at the speed of autonomous code

Software engineering is entering the autonomous era. Datafew Locus is the admission layer that lets organizations scale coding agents into production—with cryptographic proof on every merge.

$datafew admit -- pnpm test
refuse  approval_required · src/auth/session.ts::rotateKey fix:    revert protected block or obtain owner approval exit 1  (tests skipped — scope gate failed first)
admit

All policy gates passed; signed receipt bound to the exact diff.

refuse

A gate failed or approval is needed, with a concrete fix for the agent.

unverified

Nothing failed, but required test, coverage, or custom evidence is missing.

The shift

When machines write the majority of code,
review stops being a conversation. It becomes a protocol.

Engineering teams face a defining mandate: capture the velocity of autonomous coding agents while preserving the discipline of mission-critical systems. Datafew Locus separates code generation from code admission—turning policy, syntax, and test evidence into a permanent, independently verifiable record.

Architecture

Keep the code. Sign the proof.

Customer environment Repository, agent & test execution stay here Coding Agent & Thin CLI Preflight over MCP · package changed files Local / CI Test Runner Run tests · collect JUnit, LCOV & custom reports Offline CI Merge Gate Verify Ed25519 signature & git changeDigest diff + reports signed receipt Datafew Locus Request memory only · zero code stored Scope & Syntax Gates Function-level scope · execution-free parse Evidence Judge & CI Reuse Judge JUnit / LCOV · reuse verified CI hashes Ed25519 Receipt Signer Sign verdict, provenance & sequential index

Fast failure before tests

Scope violations and syntax regressions are refused immediately, before CI spends time running tests.

Honest provenance

Every receipt separates what Locus directly checked from what customer CI ran and reported.

Customer CI stays final

Agent hooks give early feedback; required CI checks verify the receipt offline before merge.

Integration

A complete control plane across every agent and CI.

A standalone plugin or MCP server runs inside the agent's own session. Datafew Locus coordinates three independent layers—in-session guidance, server-side deterministic judgement, and offline CI enforcement—so policy holds from first edit to final merge.

01 · REMOTE MCP & SKILL

Pre-edit guidance inside the agent

Agents query policy, preflight target blocks, and inspect refusal reasons over /mcp. Source code stays outside model context.

02 · THIN CLI & HOOKS

Deterministic packaging in the loop

Stop hooks invoke the public datafew CLI to submit changed files and local reports, returning structured fix guidance immediately.

03 · REQUIRED CI GATE

Independent merge enforcement

CI runs under its own principal, obtains an authoritative receipt, and verifies the Ed25519 signature and git changeDigest offline before merge.

Supported agents & CI recipes

Claude Code Stop hook · MCP · CLI
Codex CLI · MCP · AGENTS.md
Cursor Hook · MCP · Rules
Devin CLI · MCP · Setup
Antigravity Stop hook · MCP · Skill
Grok CLI · MCP · Snippet
GitHub Actions Required check · Verify
GitLab CI Pipeline gate · Verify

Guarantees

Engineered for systems that cannot fail.

0 bytes Source code stored

File bodies live only in request memory. Storage holds paths, block IDs, hashes, and counts.

0 calls Model inference

Pure deterministic decision core. Identical inputs and policy always return the identical verdict.

Ed25519 Offline verifiable

Signed sequential numbering exposes any deleted record; verify independently with public keys.

Neutral Any agent or CI

REST, remote MCP, and a public thin CLI across model vendors and Git platforms.

Positioning

Where execution ends, admission begins.

Agent harnesses drive execution. Datafew Locus is the independent governance layer that verifies policy and anchors every merge in cryptographic proof.

Dimension Agent Harnesses AI Code Reviewers CI & Linters Datafew Locus
Primary role Orchestrate tools & sandboxes Comment on pull requests Run builds & static rules Enforce admission & sign receipts
Determinism Model & prompt dependent Probabilistic (LLM) Deterministic scripts Pure deterministic, 0 LLM calls
Granularity Shell, tool & file permissions Whole-diff text feedback File & pattern alerts Function & code-block policy
Audit proof Local session transcripts PR comment threads Vendor-bound CI logs Offline Ed25519 signed receipt
Code retention Local or harness cloud Sent to model providers Retained in CI logs/cache 0 bytes stored (memory only)

Artifacts

A common language for agents, CI, and auditors.

policy.json versioned per project
{
  "policyId": "payments-core",
  "scope": {
    "allow": ["src/**", "tests/**"],
    "protect": ["src/billing/**", "src/auth/session.ts::rotateKey"]
  },
  "actors": {
    "owners": ["prn_owner_01"],
    "allowedPrincipals": ["prn_agent_04", "prn_ci_main"]
  },
  "approval": { "expiresHours": 24 },
  "evidence": {
    "tests": { "required": true },
    "coverage": { "required": false },
    "custom": [{ "name": "license-scan", "required": true }]
  },
  "reuse": { "enabled": true }
}
Function-level scope: protect whole directories or single symbols like session.ts::rotateKey.

Delivery

One core, two deployment models.

Cloud

Hosted Control Plane

Stateless managed API for multi-repository engineering teams.

  • Organization and project isolation with role-scoped keys
  • Versioned policies, owner approvals, and NDJSON audit export
  • Public verification keys published for offline checks
Dedicated

On-Premises

For regulated environments where changed source stays inside the perimeter.

  • Pure, I/O-free decision core inside customer infrastructure
  • Identical policy schema, CLI, MCP, and receipt format
  • Delivered under dedicated enterprise agreements

Autonomous velocity. Deterministic trust.

DATAFEW LOCUS