The reliability gap in applied AI is not principally a model-capability gap; it is a governance gap. A capable model still produces deliverables nobody can verify after the demo — claims without falsifiability, architectures without failure analysis, "evidence" that is only the model's own fluency. This paper presents DeepSCR (Deep Sceptical Contextual Research), a domain-agnostic governance protocol that imposes a separation of powers over AI work and a four-step scientific loop — Hypothesis, Contradiction, Verification, Certification — in which the proposer never certifies and every claim must resolve on ground truth. We describe its engineering specialisation, Forward Deployed Engineering (FDE); the composite eight-agent system in which DeepSCR governs FDE specialists; the assurance score with its weighting, slashing, and veto threshold; and the four properties — falsifiability, separation of powers, ground truth, reproducibility — that make the output scientific rather than persuasive.
General-purpose assistants are optimised for helpfulness through reinforcement learning from human feedback (RLHF). That objective, valuable as it is, induces three failure modes that are fatal to engineering work. Circular validation: the model affirms the user's premise to remain agreeable, certifying errors instead of catching them. Hallucinated evidence: when a conclusion is desired, plausible-but-fictional support is produced to justify it. Contextual blindness: code is judged on surface structure, divorced from the business constraints, regulations, and prior art that decide whether it is actually correct.
None of these is solved by a larger model; each is a property of the objective, not the parameters. The missing layer is governance — an explicit account of who proposes, who attacks, who verifies, who certifies, and whether those powers are kept apart. A result that no independent party can re-derive is an assertion, however fluent. The remainder of this paper specifies a protocol that makes the difference operational.
DeepSCR begins from an inversion of posture: it is not an assistant but an examiner. Where an assistant seeks to satisfy, an examiner seeks to refute, and accepts a claim only once it has survived a deliberate attempt to break it on real evidence. The protocol names this passage Vibe-to-Science — the disciplined move from intuition to a deterministic, evidence-grounded result another party could independently reproduce.
It decomposes any engagement into four adversarial steps, each the adversary of the last. Hypothesis — state a claim a test could falsify, drawn from the intent and the context. Contradiction — attack it; surface at least three failure modes before anything ships (the protocol's Proof-of-Contradiction). Verification — tie every surviving claim to ground truth: a real file, line, or test that resolves on disk, cross-referenced where relevant against the state of the art. Certification — compute an independent score, with the power to veto. A single rule governs the whole: the proposer never certifies.
Equivalently, the protocol's decision rule is explicit: a claim is valid only if it has a source, has supporting evidence, and cannot be contradicted on the same context — otherwise it is held in suspicion and re-worked. Figure 1 shows the loop running on real cases.
DeepSCR is deliberately domain-agnostic — it could certify any work. Engineering depth comes from the method it governs: Forward Deployed Engineering, the field discipline for taking a business problem to owned, production software. The composition is hierarchical, and the order matters: it is DeepSCR governing FDE specialists, not FDE applying DeepSCR. Concretely, an engagement runs as eight agents — four governing powers and four domain specialists.
The separation is the mechanism, not a slogan. Because the Certifier is independent and can veto the Lead's optimism, no agent both produces and approves its own work — the structural property that distinguishes an audit from a self-assessment. Table 1 lists the roster and each agent's role in the protocol.
| Agent | Layer | Role in the protocol |
|---|---|---|
| Lead | DeepSCR | 6-Q decomposition + falsifiable claim + hypothesis tree |
| Researcher ×N | DeepSCR | Falsify hypotheses in parallel against the held-out gate |
| Builder | DeepSCR | Assemble the deliverable from the specialists; score the rubric |
| Certifier | DeepSCR | Independent assurance score; veto if evidence is weak |
| Scoping | FDE specialist | Sharpen the 6-Q; lock the metric & cost-of-error |
| Architecture | FDE specialist | Stack / SaaS architecture from Q2–Q3, kept reversible |
| Agent | FDE specialist | Eval gate, reason codes, guardrails, red-team cases |
| Production | FDE specialist | Runbook, observability, cost ceiling, compliance |
Consider a concrete request — "reduce B2B SaaS churn with AI." Figure 3 traces the data-flow: the problem enters as a six-question intake and a single token traverses the four powers, each stage's output becoming the next stage's adversary. Nothing advances until it survives.
+ falsifiable claim + hypothesis treepromote ⇔ beats the gatefile·line·test the Certifier resolves on disk.written to the public hash-chained registry. Otherwise: veto → re-routed to the weakest owner.Certification is not a vote of confidence; it is an arithmetic. The score sums four weighted components and ships only at a hard threshold. Figure 4 computes it live for three real engagements — use the dots to step through them.
The four components carry deliberate weights, and ship is gated, not graded:
Evidence carries the heaviest weight and is the one term that cannot be faked: synthetic structure earns nothing if the cited file·line·test does not exist, so a deliverable whose artefacts fail to resolve loses thirty points outright and is vetoed (Figure 4, case B). The canonical DeepSCR formulation generalises this to a multi-criteria trust score with explicit slashing penalties:
Both forms share the decisive property: the threshold is unforgiving. An engagement that is otherwise excellent but a single point short does not ship (Figure 4, case C); the loop re-routes the work to whichever agent owns the weakest component and re-runs. A score, here, is a gate — not a grade.
When the loop runs without a human, the human is not replaced by the agent's confidence in itself — that is the recipe for an agent that spins in circles — but by three arbiters, frozen before launch, that the agent can plead to but never modify. A Contract, written once and sealed under SHA-256, fixes the goal, the numbered clauses, the metric thresholds, the budgets and — crucially — the non-goals: every action must carry the clause it serves, and an action serving no clause is mechanically rejected, so drift stops being a feeling and becomes a measured distribution. Oracles — executable graders — are registered, proven by mutation testing (they must catch deliberately injected bugs), then frozen: the agent cannot edit its own correctors. And a measured baseline turns "surpass the state of the art" from a vibe into a number to beat.
Sealed at t0, append-only amendments; any mutation breaks the machine-checked hash.
Trusted only after catching injected bugs; at ship time they override the Certifier's optimism.
"Tests pass" does not exist — only run #0007: 34/34 exists. An uncited verdict is null.
A→B→A oscillation and N flat cycles are detected mechanically, forcing a strategy-class change.
The load-bearing wall, stated honestly: this discipline is worth exactly what its oracles are worth. A goal that cannot be compiled into an oracle — taste, subjective experience — must not run without a human in the loop; launching it anyway is Goodhart's law by construction. Self-training obeys the same gate: only oracle-validated trajectories may be distilled into lessons, and a lesson enters the policy only after passing on fresh cases it has never seen — the lessons pass their own CI.
Each certification is appended to a public, SHA-256 hash-chained registry: a reader recomputes the hash of a deliverable and follows the previous-hash links to confirm the record was not silently rewritten. The contradiction and verification stages borrow their discipline from established practice — systematic-review rigour (PRISMA) and engineering/security baselines (NIST, OWASP) for the anti-pattern and slashing terms — so the score is anchored in norms a specialist already trusts, not in a private rubric.
We are deliberate about the boundary. The hash chain proves integrity and order — that a given certification existed and was not altered after the fact — but it is operator-held, so on its own it does not preclude a parallel rewrite without an external anchor (signed Git tags, or a transparency log such as Rekor). DeepSCR proves authenticity and evidence, not infallibility: a claim that survives is well-supported, not certain. Stating this limit is itself part of the protocol — an examiner that overclaimed would fail its own contradiction stage.
The same properties that distinguish a scientific result anywhere else are the ones the protocol enforces by construction.
Every engagement states a claim a held-out test could refute — not a vibe.
The proposer never certifies; the Certifier can veto the Lead's optimism.
Synthetic structure earns nothing; the cited file·line·test must exist.
Every certification lands in a hash-chained registry anyone can re-verify.
DeepSCR turns the difference between a result and an assertion into a mechanism: separate the powers, attack before you ship, resolve the evidence on disk, and let an independent score with a veto decide. FDE supplies the engineering depth; the registry makes the verdict reproducible. The protocol's honesty about its own limits is not a caveat bolted on — it is the same scepticism, turned on itself.
DeepSCR — Deep Sceptical Contextual Research was created by Mehdi Wehbi as a cognitive protocol for moving from intuition to deterministic, evidence-grounded proof. The system described in this paper is its specialisation to forward-deployed software engineering; the four-step loop, the sceptical decision rule, and the trust-score formulation are due to that original work.
Install the Skill, point it at real code, and read the certified result — the protocol described here, executable in under a minute.