Rule of law for AI agents
How much can you count on AI to deliver what you intended — and what does it cost when it doesn’t?
That question — not model capability — now governs whether AI-driven software development returns its spend.
Republic is a governance plane built as one answer to it: a working system in which AI agents plan and build software under machine-enforced law rather than human supervision. Authority, intent, execution, and verification are governed by ratified rules enforced at build time, spawn time, and on the wire — not by an agent’s continued cooperation or a human’s continued attention.
The thesis in one sentence: verification, not generation, is now the binding constraint on AI-driven software development — and the fix is structural, not supervisory.
The problem isn’t generation — generation is cheap now
20% / 19%
Believed faster, measured slower
In a randomized trial of experienced developers working in their own repositories, participants believed AI made them 20% faster and were measured 19% slower.
METR, 2025
95% / 55%
Syntax correct, security not
Across two years of model generations, syntax correctness now exceeds 95% while security pass rates have sat near 55%. Capability scaling is not fixing the defect classes that matter.
Veracode, 2025
7.2%
Stability falling as adoption rises
A decrease in delivery stability per 25% increase in AI adoption. The program's own explanation: without robust control systems, increased change volume produces instability. AI is an amplifier.
DORA, 2024
Four methodologically distinct instruments — survey, telemetry, code-mining, and security scanning, with partially independent incentives — find the same shape. No single measurement settles this; the convergence does. Verification, not generation, is the binding constraint.
The problem
The systems that make AI produce are everywhere. The systems that make sure it produces what was intended are not.
If you’ve used AI coding tools, you’ve met the output that’s almost right — close enough to be tempting, wrong enough to cost the afternoon. That’s the individual-scale symptom of a sector-scale problem.
The prevailing defenses are supervisory — in-context instructions, human review, self-authored memory — and each fails in a measured way: instruction-following degrades as context grows; human oversight decays toward acceptance; self-authored memory drifts and entrenches its own errors.
The common failure underneath all of them is a closed loop: a system consuming its own claims about itself, with nothing external grading them.
Republic takes the mechanism position — good intentions don’t work; mechanisms do. Governance has to live in the execution path, enforced by machine-checked gates, so that non-compliant patterns fail at build time rather than being caught — or missed — by a tired reviewer later.
Attestational governance operates through statements about the governed system. Structural governance operates through constraints in the execution path: gates that fail closed, states that are schema-invalid and therefore inexpressible, evidence emitted as a non-optional side effect of operation.
What it is
Five primitives, each opening one of those closed loops
The unit of governance is the atom, not the document; the current state of anything is a query, never the latest edit of a mutable record.
Governed atoms
A temporal truth model
One identity type, one direction of authority
An enforcement plane with no governance service
End-to-end provenance
Each primitive exists to open a specific loop named in §3 of the whitepaper — documentation, memory, authority, and prompt-rules.
How the machinery works →Current state
Reported honestly, from the repository — including what doesn't run yet
The substrate is enacted and self-governing
The build gate is live and emits public evidence
The riskiest hop is walked
The full end-to-end chain run (C1)
The semantic retrieval instrument
Consult-and-render services
Verify rather than trust
You don't have to take this site's word for any of it
The load-bearing claim is that a red suite blocks merge. A CI job that detects a violation is a control; a repository rule that refuses the merge is enforcement. They are different facts, so the second is evidenced separately — and you can check it with no credential at all.
curl -s https://api.github.com/repos/tecthulhu/republic/rules/branches/mainWhat that returns today: both conformance contexts required by name, direct push and force-push refused, and no bypass actor — administrators included.
- Branches are not required to be up to date with the base before merging — so a green check describes what the pull request tested, rather than always what lands.
- No approving review is required — so the merge is the owner’s act alone.
Both are recorded in the evidence rather than omitted from the claim.
Review
Machine review was the first gauntlet. Human review is the one that matters.
Before publication the whitepaper went through adversarial machine review, using frontier models from OpenAI, xAI, and Google — the final rounds auditing the live repository rather than the paper. Every finding and its disposition is public, next to the claims it graded — the record itself carries the counts and the specifics.
Including the declines, with reasons stated; the passes excluded for reliability, preserved rather than deleted; and an overclaim the project identified as its own regression and logged against itself.
AI reviewers can share blind spots in ways that make agreement cheaper than it looks — which is exactly why the next round is human. If you build agent platforms, run governance programs, or review systems work professionally, tear into this. Every human finding gets the same treatment: applied, declined with reasons, or tracked openly — credited to you if you want it.
The whitepaper
Written to be refutable
It states the criteria by which it could be proven wrong, and the system emits evidence of its own performance — including evidence of failure — as a side effect of operating.
You make toolset decisions
Read §§1–2 and §7
The measured state of AI-driven development, the attestational/structural distinction, and an honest current-state report — including what does not run yet.
You build
Read §§3–6
The machinery: the truth model, governed atoms, the identity chain, the enforcement plane, and the minimum viable slice.
You hold the security veto
Read §4.4 and §4.6
Written in your vocabulary: least privilege enforced cryptographically, attenuating authority, and end-to-end provenance.
Designed and built by Kyle Scott. Developed in the open and stewarded by Eldritch Labs.
Kyle Scott
Founder, Eldritch Labs · Architect of the Cornerstone AI Development Mesh · 6+ years at AWS
Republic’s thesis was not arrived at from the outside. It is what building and running a 30+-service governed multi-agent platform surfaces — and the mechanisms doctrine underneath it was served under at Amazon before it was built into software.
About the author →The paper, the corpus, and the evidence are public. Where the claims and the record disagree, the record wins. Come find where they disagree.