Anchors
Human-owned statements of intent: a named owner (a person, never a team alias), acceptance criteria as machine-checkable assertions, a risk class, and a version history. Nothing ships unanchored.
The control plane for the software factory
Agent Speed. Human Authority.
KeelAI binds every agent-built change to intent a human owns, checks the work deterministically, pauses for a named person when the risk calls for it, and seals the result in evidence a reviewer or auditor can replay.
Works under the tools you already use
Claude Code
Cursor
Codex
Any MCP agent
GitHub & GitLab
Jira
Slack
The problem
The software factory can prove work ran. It can't prove the work is right.
Builders now ship with fleets of coding agents: isolate each feature, build it, prove it with before-and-after evidence, and loop through review until a score says ship. It is fast and it works, for one builder.
But the proof is produced by the agent being judged. The spec is a prompt. The review is a vendor score with no record of who accepted it. At the scale of a team, a regulated product, or an audit, four questions go unanswered.
Whose intent is this?
The spec lives in a prompt, not in an owned object with a version history.
Is it still aligned?
Tests check what the author thought to test. Drift that passes its tests becomes the incident that arrives weeks later.
Who decided?
Permissions record who could merge, not who approved, with what evidence.
What did we learn?
When output diverges from intent it gets patched or retried, never captured as a signal.
The model
Five objects that make agent work accountable.
KeelAI is the reference implementation of the Anchor Model: humans own truth, AI authors its representation. Every construct is stored, versioned, and has an owner, and the engine refuses to run work that isn't bound to one.
Guardians
Deterministic checks between every step: schema, assertions (CEL), policy-as-code (OPA/Rego), and state-diff. No model grading a model. Every verdict is itself evidence.
Gates
Risk-routed human approval in Slack or GitHub. Above the threshold the engine pauses, assembles the evidence, and asks a named person. Low-risk work never waits in a queue.
DriftEvents
Work that passed but diverged from intent. Drift goes to the Anchor owner with the delta, so the automation, the check, or the spec itself can change. It is the most useful signal the factory produces.
Evidence packets
Every run seals a bundle: inputs, Anchor version, model calls with prompts and outputs, Guardian results, Gate decisions with the approver's identity, and timing. Packets are SHA-256 hash-chained, immutable, exportable, and replayable with keel guardian replay. Chain heads live outside KeelAI, so you can verify your own evidence without us.
How it runs
Keep your factory. Add the keel.
KeelAI changes nothing about how your agents build and everything about what happens between the stations. Keep Claude Code, Cursor, or Codex. Keep your skills and your review loop. KeelAI supplies the spec they run against, the checks that judge them, the sign-off, and the record.
Spec
The feature becomes an Anchor with an owner, criteria, and a risk class.
Isolate
Work runs in its own worktree; the Anchor's file scope becomes an enforced boundary.
Build
Your agent builds as usual. KeelAI records which model, prompts, and tools produced each change.
Prove
Guardians judge the output instead of the agent judging itself.
Ship
Risk routing decides whether a named person must approve before merge.
Learn
Drift queues to the Anchor owner with five clear resolutions.
PassLow risk and green: no human involved. That is how a factory stays a factory.
BlockScope violation or failing tests: the run goes back to Build with the finding attached.
DriftTests pass but intent isn't met: the Anchor owner sees it, not a green check.
ErrorThe check itself couldn't run: recorded as evidence, never silently skipped.
Why a keel
A real factory isn't only a line.
It has a specification for every part, inspection the line doesn't grade itself, a supervisor who signs off on anything out of tolerance, and a record of which batch came from which run. Today's agent factory has the line. KeelAI supplies the rest.
Anchors
are the
Specification
Guardians
are the
Inspection
Gates
are the
Sign-off
Evidence
is the
Batch record
Drift
is the
Signal to improve
Who it's for
Built for the people accountable for what agents ship.
Run a factory you can trust
Start free on one binary. Guardians judge the proof instead of the agent judging itself, you get a packet per merge, and drift surfaces before your users find it.
No new editor, no slowdown
One-line install. Compose workflows from your harness through MCP or the CLI. Your agent drafts Anchors and the owner approves them, so the line keeps moving.
Your intent, enforced
Write acceptance criteria in plain language in Jira. Get a drift queue and notice when a spec change invalidates running work.
Evidence, not screenshots
Policy-as-code Guardians, replayable hash-chained packets, and export to the SIEM and GRC tools your auditors already read.
One screen for the automation estate
What runs, who owns it, who approved what, and where drift is accumulating, across every product and codebase.
Regulated operations
The same engine governs cloud configuration-drift remediation on AWS, where every run has an obvious Anchor (the control), Guardian (the control test), and Gate (the approver of record).
Throughput without accountability is a liability. A factory that ships ten times faster and can't say who approved what has multiplied its exposure by ten. The factory makes agent work repeatable; KeelAI makes it accountable.
Put a keel under your agents.
KeelAI is in active development with a small group of design partners. Tell us about your factory and we'll be in touch.