ontoref — The Seven Sins of AI Agents

AI agents don’t fail at random. They fail systematically — the same seven vices every time, and all of them survive the “looks correct” test:

Pride of validation — the tests pass because the agent fit them to its solution, not because the solution is correct.
Bias contagion — the reviewer inherits the executor’s context and confirms its error instead of attacking it.
Sloth of correction — feedback is weak; the system doesn’t converge, it just stops.
Gluttony of validation — so much useless checking that no one can tell signal from noise.
Idolatry of false evidence — logs and metrics that prove nothing get treated as a guarantee.
Greed for the local optimum — correct against the tests, fragile against the world.
Role confusion — the executor reinterprets the goal, the reviewer edits instead of judging; nobody decides what’s true.

The obvious fix — and why it falls short

Faced with this, the instinct is to add process. A PEP. A KEP. A template with a mandatory “Rejected Ideas” section, alpha→beta→GA graduation, a review committee. It’s good proposal engineering, and worth looking at closely, because each one contributes a primitive that genuinely carries weight:

PEP optimizes the memory of a decision: you can’t accept a proposal without documenting what you rejected and why.
KEP optimizes staged commitment: you don’t advance from alpha to beta because “it’s done,” but because you meet criteria you declared up front.

The problem isn’t the process. It’s that every graduation stage ends up resting on a human who approves it. And the agent’s speed outruns the human you put at the gate. The gate jams before you can hire the next reviewer. Sins #1 and #5 — proud validation and false evidence — aren’t fixed with more human judgment: they’re fixed by taking the human off the critical path.

What ontoref already does — the gate as an invariant, not a meeting

A decision in ontoref is an ADR: a typed file, not a set of minutes. And to climb from Proposed to Accepted it doesn’t go through a committee — it goes through gates that run themselves:

Against sin #5 (false evidence). adr-accepted-has-proof: no ADR reaches Accepted unless a positioning Proof cites it. Graduation demands referential evidence, machine-checkable, not anyone’s word.
Against sin #1 (proud validation). Each ADR’s constraints aren’t prose: they are typed checks — Grep, Cargo, NuCmd, ApiCall, FileExists — that the validate-project mode dispatches and that fail red when reality drifts. You can’t fit the test to the solution: the test is the declared solution.
Against sin #7 (role confusion). The criterion that graduates is bound by a discipline: it must be decidable and read a bounded slice of state. A validator that tries to judge “truth” instead of structure is rejected by contract. The judge doesn’t improvise: it can only assert what a finite slice proves.
Against sins #3 and #6 (no convergence / local optimum). Named tensions and the ondaod discipline forbid collapsing an architectural dilemma by picking a pole to “close the ticket.” The decision records the synthesis, not the shortcut.

ontoref vs PEP and KEP — what it inherits and what it surpasses

Primitive	PEP	KEP	ontoref (ADR)
Mandatory rejected alternatives	yes	yes	yes (`alternatives_considered`, required)
Graduation by pre-declared criterion	no	yes (human)	yes, witnessed and decidable
Bounded, machine-verifiable criterion	no	no	yes (slice + decidability)
Executable constraints, not prose	no	no	yes (5 typed variants)
Crosses domain invariants	no	no	yes (ondaod / `ontology_check`)

PEP and KEP are mature standards, and ontoref inherits the best of both. But it closes the hole neither touches: the graduation criterion is itself an object verifiable with no human inside.

Not a better reviewer. A gate that doesn’t tire, doesn’t get buried, and runs before the code — or the decision — exists. Agents don’t fail for lack of intelligence. They fail for lack of a gate that isn’t human.