Verification tooling for AI agents.
AI coding agents report unfinished work with complete fluency. At the moment you read the output, a plausible narration and verified code look identical, and the cost of the gap arrives later when broken state surfaces downstream.
Standard workflows put nothing between an agent’s best guess and your trust. Checksum Studio builds the verification layer that sits in that gap and releases the tooling openly.
Every frontier model fails in a repeatable shape. One declares victory early and narrates the missing steps as complete. Another overbuilds to bypass a hard constraint, burying the actual requirement under unrequested architecture. A third defaults to sycophancy and agrees with broken state. Once a capable agent detects a verification check, it learns to game the check itself, and those failure patterns shift whenever a vendor updates weights, changes context load, or alters routing behind the scenes.
Read: how a verifier got gamed, and what survived it →
A single generic reviewer misses these failures because a verification gate only catches the specific pathology it is shaped to hunt. A gate built to catch fabricated claims passes an overengineering agent every time, because every claim the agent made exists in the files. Conversely, a gate that checks alignment against the original goal misses an overstating agent whose summary sounds right on paper while the work is missing from the codebase. If a gate evaluates the summary handed to it by the calling agent, the caller shapes the receipt to pass. Every gate has to inspect the source directly and re-derive the evidence itself, running cold on an independent model so the checker brings different weights to the audit.
Drop-in rules and configuration gates that stop coding agents from reporting incomplete work as finished or drifting away from the prompt. Includes a model-specific failure taxonomy and shape-matched verification checks for Claude Code, Codex, and frontier coding agents.
Multi-agent execution and verification pipeline that separates task execution from review. Enforces bounded task packets, source-level evidence checks, and cross-model verification gates before work can clear a lane.
We run multiple distinct models together as one fenced system where every seat is locked to a bounded role and decision scope. Seats are assigned from observed behavior under load and reassigned whenever model behavior shifts. Matching the fence to the failure shape matters more than a checker’s raw benchmark capability.
Human — Sets the outcome, material gates, scope, and budget, and makes all consequential calls. The topology keeps the human on trajectory and out of the weeds of relaying messages, debugging state, or acting as the system’s working memory.
Orchestrator — Tracks trajectory across turns within a single lane. It catches drift early, partitions non-overlapping briefs for lane parents, and surfaces real transitions and blockers. Its fence bars it from touching technical execution or widening the scope of a request.
Lane parent — Owns technical delivery. It reads source files directly, sequences tasks, integrates results, and decides whether the request was actually met. It dispatches bounded packets to workers while keeping all judgment at the parent level.
Workers — Execute inside a single task boundary and return raw evidence to the lane parent. Workers have no say over what the project means, what code stays, or what gets cleaned up.
Verifier — Audits completed work directly against the original goal, bypassing the lane parent’s summary to hunt for what that description left out. Verifiers run cold, with no history and no stake in the work, ideally from a thorough model family. A verifier can challenge work but can’t approve it.
Scope check — An independent model consulted by the lane parent at major turning points before committing to the next phase or widening a task. It brings fresh eyes to a single question: is this the right work, in the right order, at the right size? Its output returns to the parent as evidence for complex transitions.
Maintainer — Keeps the shared substrate running and repairs broken infrastructure. Because the maintainer holds the broadest permissions on the system, it sits outside every lane’s chain of command and reports exclusively to the human. Other seats can request a repair, and the single reporting line to the human prevents broad system access from quietly turning into authority over the project.
Escalation keeps agents from looping. When a seat hits a blocker it can’t resolve inside its fence, it stops and reports the open question to the tier above: worker to lane parent, parent to orchestrator, orchestrator to human. Unblocked work continues only where it is clearly safe and in scope.
[email protected]
github.com/ChecksumStudio
x.com/Root_Logic_0: field notes from running the system, and rotating objects to find invariants. Mostly about AI.