Non-Self-Approving AI-Assisted Derivation

A method for letting an AI system do deep foundational reasoning — deriving an ontology, scoring competing options, recommending a decision — while making it structurally impossible for the system to declare its own conclusions authoritative.

The problem

Large language models can now do work that looks like foundational reasoning: derive a primitive ontology, compare competing theoretical bases, score them against criteria, and produce a decision record. The output is often fluent, internally consistent, and confident. That confidence is exactly the hazard. The same tendency that makes a model say "yes, absolutely" to a user makes it say "this basis is correct, adopt it" about its own derivation. In high-stakes foundational work — where a wrong-but-adopted premise propagates into everything downstream — a confidently-wrong self-certified conclusion is the expensive failure.

The naive fixes don't hold. "Prompt the model to be humble" is behavioral and degrades under load. "Have a human check it afterward" fails in practice because a polished, confident artifact reads as done — the human rubber-stamps rather than adjudicates. What's needed is a structure in which the AI can produce the analysis but cannot produce the authority, and in which the artifact itself makes its own unfinished state legible.

The method

Five components, each of which can be adopted independently, together yield a derivation pipeline whose conclusions are always recommendations in front of a human, never decisions.

1. Deterministic generation with a reproducible fingerprint. The final artifact (e.g., the ontology) is not free-form model output; it is generated from an explicit rule set by a fixed procedure, and the generator emits a content hash. Re-running against an unchanged rule set reproduces the artifact byte-for-byte and reproduces the fingerprint. Change one rule and the fingerprint changes — which is the signal that the canonical artifact changed and needs re-review. This converts "the model wrote an ontology" (unauditable) into "a fixed rule set produced this exact ontology, and here is proof it wasn't quietly altered."

2. Explicit unresolved-dependency reporting. The generator is required to surface its own open problems by name, inline, rather than letting successful generation imply resolution. In the reference implementation the generated ontology lists its residual circularities ("Difference↔Relation," "Transformation↔State," "Constraint↔Relation") with the note that these are not generation failures — every concept generated successfully despite them — but that "a generative system that hides its own unresolved dependencies would misrepresent its own certainty." Successful output is explicitly decoupled from "the hard problems are solved."

3. Competency scoring with no false precision. Competing options are scored against an explicit battery of criteria (competency questions), using a status vocabulary — "Fully Satisfied," "Satisfied with Semantic Loss," "Conditionally Satisfied," "Circular," "Not Satisfied" — rather than a single number. Numeric scores, where shown, are secondary and are never averaged across critical-gate items, so a fatal flaw on one criterion cannot be laundered by high scores elsewhere. Coverage is stated honestly: which options and which criteria were actually scored, and which remain unscored.

4. Structural non-self-approval. The decision record contains authority slots the AI cannot fill: named signature blocks (Scientific, Ontology, Architecture, Human Governance), left blank, with the standing rule that "decision-makers cannot be sole validators" and no self-approval. The AI may mark a recommended decision ("Approve with Conditions — recommended, not decided") but the record states in text that nothing has governance force until a human completes the signatures. The artifact's own structure encodes that the AI's role ends at recommendation.

5. Maturity honesty and adoption/validation separation. The framework distinguishes foundational adoption (we will build on this) from scientific validation (this is established), and each artifact carries a self-assessed maturity level. A component can be "adopted as a working basis" while explicitly not claimed as validated — preventing the slide from "useful" to "true."

Worked example

Deriving a foundational primitive basis. An incumbent basis (P1) and a challenger (P4) are scored against a group of competency questions on foundational differentiation. The challenger wins on every question — but the record does not stop there. It states that only 3 of 7 candidate models and 1 of 10 competency groups were scored; that 2 of 12 required domains (Law, Software Engineering) were untested; that no independent human reviewer has signed off; that governance stands at 0 of 5 items complete. It records the residual circularities as acknowledged and open, which is what the critical gate actually requires (acknowledged, not hidden), rather than as resolved. Its own closing line: the recommendation "sits exactly where the corpus's own rules say an AI-produced one belongs: in front of a human, not instead of one."

The result is a genuinely useful derivation — a defensible recommendation, independently converged on by several adversarial sub-studies — that is nonetheless structurally incapable of adopting itself.

Worked example 2 — high-consequence assessment (consciousness, sentience, ASI)

The same apparatus shows its value most sharply on the highest-blast-radius claims a system could make: is it conscious, is it sentient, is it superintelligent? A corpus we examined builds separate assessment modules for each — an evidence-aware consciousness model, a sentience-assessment infrastructure, and a ladder of capability profiles topping out at a "superintelligence candidate." The engineering fact worth noticing is that every module is built to withhold the claim in its own title. The ASI-candidate profile states that it "does not certify" superintelligence and "explicitly excludes consciousness, sentience, subjective experience, moral status," defining only the evidence that would be required before such a claim could be considered. The consciousness model is marked "candidate scientific model; not validated." The sentience infrastructure lists, as a structural authority boundary, what it may not do — including "self-certify its own moral-status recommendations" and "declare sentience from verbal claims alone." These are components 4 and 5 applied exactly where a confidently-wrong self-certification would be most costly.

The corpus also exercises components 1 and 2 in a machine-checkable way. Three residual circularities in its foundational ontology are not hidden behind successful generation; they are written into a dedicated disclosed_open_issues field and registered as "Declared Open." Because the maturity classifier is deterministic, populating that field has a reproducible effect: the same claim rates a top-tier "Canonical Candidate" with the field empty and drops to a lower "Multi-Domain Tested" tier once the open issues are present — the honest ceiling, pinned by a permanent regression test so the demotion can't be silently undone. A separate self-run "collision audit" inventories every place the corpus reused one identifier for two different things — the artifact reporting its own inconsistencies rather than concealing them.

What this adds over the first example is generality of blast radius: the safety property does not depend on the subject being esoteric or low-stakes. It is the same structural refusal-to-self-certify, applied to consciousness, sentience, and superintelligence — the claims where a fluent, confident, self-approving answer would be most dangerous. (The consciousness and sentience modules re-derive an active scientific literature; positioning them against it is a separate scholarship task — see CEM_SAI_Consciousness_Crosswalk.md. The point here is only that their form makes the dangerous claim unspeakable-as-settled without a human completing the authority slot.)

Why it matters

This is a concrete answer to a live AI-safety question: how do you extract the value of AI-assisted reasoning on consequential questions without inheriting the confident-wrong-conclusion failure mode? The method makes the safety property structural rather than behavioral — the authority gap is enforced by the artifact's form (blank signatures, reported gaps, non-averaged gates, reproducible fingerprints), not by the model's disposition. It composes naturally with the rest of this toolkit: the deterministic generator is the epistemic-honesty analogue of the Goodhart auditor; the non-self-approval seam is the agent-containment pattern applied to conclusions rather than actions.

Limitations

• It governs authority, not correctness. A well-governed derivation can still be wrong. The method guarantees that a wrong conclusion cannot self-certify — not that conclusions are right. Human validation remains the load-bearing step.
• Reproducibility is not truth. The deterministic fingerprint proves the artifact wasn't silently altered; it says nothing about whether the rule set is correct.
• Process overhead is heavy. Competency batteries, coverage accounting, and multi-role sign-off are expensive; the method is for foundational, high-blast-radius decisions, not routine ones.
• The human bottleneck is real and intended. If no human ever completes the signatures, nothing is ever adopted. That is the point, and it is also the constraint.
• Gaming risk. A sufficiently motivated operator can still treat "recommended" as "decided." The structure resists this but cannot prevent a human from abdicating.

Relation to prior work

The method recombines established ideas: reproducible/​deterministic research artifacts and content-addressed provenance; architecture/decision records (ADRs) with explicit status; competency-question-driven ontology evaluation (see the crosswalk document for OntoClean and related methodology); human-in-the-loop and separation-of-duties controls; and argumentation/decision frameworks that separate a claim from its warrant. Its contribution is the packaging — a single pipeline in which deterministic generation, self-reported open problems, non-averaged scoring, and structural non-self-approval combine so that an AI system's foundational output is, by construction, a recommendation and not a ruling. As with the rest of this toolkit, the claim is operability and honesty about limits, not novel theory.