diff --git a/BespokeNode-Spec-v0.1.md b/BespokeNode-Spec-v0.1.md
new file mode 100644
index 0000000..b2d0230
--- /dev/null
+++ b/BespokeNode-Spec-v0.1.md
@@ -0,0 +1,120 @@
+# BespokeNode v0.1: Public Specification (candidate)
+
+Status: v0.1 candidate, drafted 2026-09-24 by Ed (Muse), the author's AI research partner, from the author's workspace materials. Reviewed against the author's 2026-09-24 briefing before this site build used it. Two sentences were softened in that review and are marked in the editorial note at the end.
+Sources: State_Delta_Architecture_3.0, Open Memo on State-Delta Architecture, BespokeNode Three-Author Combined Report (2026-09-10).
+Owner decision 2026-09-24: the public names (BespokeNode, Pin-Check, OpenMirror) stay as-is. Consistency reflects the architecture.
+
+## 1. What BespokeNode is
+
+BespokeNode is a governance framework for agentic AI. It defines a controlled path from permission to accepted work: nothing an agent does counts until it has been defined, permitted, gated, verified, and accepted, in that order, by the right party at each step.
+
+It is not a model. It works with existing language models, vision models, planning systems, or other agentic components. It is not a product. There is nothing to buy. It is a structural floor: the part of the system that enforces safety rules locally and deterministically, whether or not the AI cooperates.
+
+The governing thesis, in the author's words: "Simplification is systems maintenance; the substrate is human cost." Complexity is technical debt, and the debt is always paid in human cost somewhere down the line. Simplification is not dumbing down. It is maintenance work on the system.
+
+## 2. The problem it answers
+
+Agentic systems degrade in predictable ways as they scale. They drift. They hallucinate. They contradict themselves. They consume increasing compute to produce decreasing reliability. The mainstream response is more: more context, more data, more retrieval, more fine-tuning. The claim this framework makes is that more information does not resolve drift. It compounds it, because every accumulated data point that cannot be verified against current reality becomes another contradiction the system must navigate without resolution.
+
+Three patterns dominate current infrastructure, and each treats a symptom while accelerating the disease: unstructured accumulation of conflicting signals; fine-tuning that forces corrections to coexist with legacy data until boundaries blur; and soft governance that routes every safety property through the same probabilistic layer generating the unsafe behavior. That last one is not infrastructure. It is hope.
+
+## 3. The controlled path
+
+Every piece of agent work moves through the same lifecycle:
+
+define the work, check readiness, the owner permits an exact scope, the agent runs inside watch limits, the output is verified, the owner approves the exact output (never just the plan), and the next accepted state mints the contract for the next phase.
+
+No step is skippable. A generated proposal is inert until the owner permits its exact scope. A finished output is not accepted until the owner approves its exact bytes. The next phase cannot begin until the current one is accepted and its contract is minted.
+
+## 4. The two zones
+
+The runtime is split into two zones with different privileges.
+
+The Dynamic Agent Layer is where fluid reasoning, language flexibility, and creative problem solving live. It runs inside a read-only, temporary sandbox that resets after each task. It has no direct authority over physical systems, financial systems, or user records.
+
+The Deterministic Structural Floor (the Harness) is the static, non-AI software environment on local hardware. It holds the unyielding rules of the domain: mathematical invariants, physical limits, clinical thresholds, legal boundaries. It does not need network connectivity to do its job. The validation gates run here as compiled logic outside the model's token stream, so the model cannot reason its way past them through prompting.
+
+Telemetry, software updates, and non-critical context move through the Tether, the network-dependent pipeline. Single points of failure are confined to the Tether. They are never permitted in the Harness.
+
+## 5. The gates
+
+Before any proposed change to system state is committed, it passes two filters, both on local hardware.
+
+The Ontology Gate: schema validation. Does the proposed change conform to the formal rules of the domain? Are the entities valid? Are the relationships allowed?
+
+The Semantics Gate: operational coherence. Even if the change is schema-valid, does it make sense given current physical conditions, safety thresholds, and context? A move can be valid on paper and catastrophic in practice. This gate catches that.
+
+If either gate fails, Refusal Logic fires. This is a hard stop, not an AI decision: a deterministic, programmatic block. The proposed change is rejected, the model loses the ability to push it through, and the failure point is logged.
+
+## 6. The five protocols
+
+Representation Locality. Communication between components is restricted to state-deltas: small structured records saying what changed, where, and when. Raw narrative, unstructured context, and full conversation histories do not move between nodes. Long histories accumulate contradictions. Short structured deltas accumulate far fewer, and each one is small enough to gate.
+
+The Firewall of Cognition. The reasoning engine never directly touches infrastructure. Tool calls and state changes execute in ephemeral sandboxes that self-destruct after returning a structured payload. The infrastructure never trusts the reasoning engine.
+
+Dual-Pass Local Validation. Every proposed state-delta passes both gates before commitment. Hard programmatic boundaries cannot be argued with.
+
+Harness and Tether Separation. Safety-critical functions live in the local Harness. Network failures, latency, and API changes cannot compromise safety enforcement.
+
+Context Reset After Commit. Once a state-delta is written to the Truth Ledger, the agent's temporary context is flushed. The next operation starts from verified current state, not from accumulated reasoning history. Drift cannot accumulate when working memory resets against verified state after each operation.
+
+## 7. Safety states: HOLD versus TRIP
+
+Two safety states, each with its own recovery path. Neither is a dead end.
+
+HOLD means pause with a recovery path. The evidence is unresolved: something needs a human look, a recheck, or more information before work continues. The system waits in its last safe state.
+
+TRIP means a confirmed violation with its own recovery path. Something crossed a hard boundary. Work stops, the violation is recorded, and return requires going through recovery, not around it.
+
+The design goal is productive mitigation: safety that keeps the system doing useful work instead of tripping it dead. The electrical twin is selective coordination, where only the breaker nearest the fault trips. The BespokeNode twin is HOLD: pause the faulted branch, keep the rest running, preserve a path back.
+
+## 8. The four invariants
+
+These hold under every path, including HOLD and TRIP. They are not adjustable.
+
+Spent capacity stays spent. A recovery never refunds what was used, and a retry is new work, not a continuation.
+
+No automatic restart. Nothing resumes itself. Every restart is a new permitted scope.
+
+Approve exact output, never just the plan. Approval of an intention is not approval of a result. The owner accepts exact bytes in a verified state.
+
+Replay without re-running external effects. Any decision must be reviewable from the record alone. Replaying the decision never replays its consequences in the world.
+
+## 9. The ledger and the accepted state
+
+The Truth Ledger is the append-only local record of validated state-deltas. Once written, entries cannot be edited or erased. The audit trail is the system, not a layer bolted on afterward.
+
+An accepted state is a typed boundary plus its receipts: the exact output, the verification record, and the owner's explicit acceptance, bound together. Anything downstream that needs the result reads the receipts, not somebody's summary of them.
+
+Thetabase is the standing rule for cached knowledge: recheck access on every request. Do not trust the cache.
+
+## 10. The conformance contract
+
+Each accepted state mints the contract for the next phase. The contract states the exact scope permitted, the gates that will check it, and what acceptance requires. An agent operating under BespokeNode never works from a standing permission. It works from the current phase's contract, and the contract expires when the phase is accepted.
+
+## 11. Return to zero
+
+A confused agent returns to ground truth: sensors, verified state, training. It does not improvise a way forward from its own accumulated context, because accumulated context is exactly what drifts. Theta is home base: the fixed point every transformation preserves. When in doubt, zero it out.
+
+## 12. The V=IR crosswalk
+
+The framework crosswalks to basic circuit theory, in both directions.
+
+V is authority: permission, scope, instruction. I is the flow of effects: tool calls, state changes, writes. R is the gate: verification, friction.
+
+An open circuit is safe but useless, so the goal is not maximum resistance. It is tuned resistance: enough friction to grip, not so much that nothing moves. Productive current does work. Shear drag is current flowing against a brake: I squared R loss dissipates watts as heat while V does not advance. Power equals VI in both cases, so the ammeter cannot distinguish productive current from shear-drag current. That witness belongs to the accepted-state ledger, not the meter. If you only watch the meter, waste looks like work.
+
+## 13. What this is not, and what is not yet shown
+
+This is not a new AI model, not a product, not a silver bullet, and not finished work. The mechanisms are established computer science: distributed systems, ephemeral sandboxes, validation gates, append-only ledgers. What is offered is the synthesis, applied to agentic AI infrastructure.
+
+Honest limits, stated plainly. The framework is a specification at v0.1. Implementation, acceptance, and independent replication are separate and pending. The probe program has validated the machinery on synthetic cases only; per the standing GT-4 receipt, there is currently no evidence about true concurrent races, scheduler preemption, power loss, crash durability, or production behavior. Nothing here should be read as proof that the framework works at scale. It should be read as a precise claim about what working would look like, built to be pressure-tested.
+
+## Editorial note (2026-09-24 review before site build)
+
+Two sentences in the drafted spec were softened because, as written, they stated a claim as an established fact. Both edits are recorded here so the change is visible rather than silent.
+
+1. Section 2. Drafted: "More information does not resolve drift. It compounds it, because..." Published: "The claim this framework makes is that more information does not resolve drift. It compounds it, because..."
+2. Section 6, Representation Locality. Drafted: "Short structured deltas do not." Published: "Short structured deltas accumulate far fewer, and each one is small enough to gate." Short deltas can still contradict one another; the framework's advantage is that each contradiction is small enough to be caught at a gate.
+
+No other wording was changed.
diff --git a/CITATION.cff b/CITATION.cff
index dee21ef..0915d3a 100644
--- a/CITATION.cff
+++ b/CITATION.cff
@@ -8,16 +8,25 @@ authors:
license: CC-BY-4.0
url: "https://resilience-eval-ai.pages.dev/"
repository-code: "https://github.com/JakeTOpenSource/Resilience-Ledger"
-date-released: 2026-07-02
+date-released: 2026-09-24
abstract: >-
- Deterministic, client-side coherence-audit tools: a function-first
- plain-language glossary of agentic AI and its governance, a framework
- audit scoring coherence and resilience on eight dimensions, a gap
- check for plans and policies, and an ordering-drift detector for
- agent traces, together with the Resilience Ledger method documents
- and calibration logs. No model or external API is required by the
- analysis engines; detector lexicons are versioned and openly displayed.
+ The public record of one researcher's theory of agentic AI governance
+ and the instruments built from it. BespokeNode, a state-delta
+ governance framework (controlled path, HOLD versus TRIP, four
+ invariants); Pin-Check, a skill that traces every precise value in a
+ document to an artifact; OpenMirror, a method for turning a metaphor
+ into policy one correspondence at a time, with the V=IR crosswalk as
+ its worked example. Alongside: deterministic, client-side instruments
+ (a function-first glossary of agentic AI governance, a framework
+ audit, a gap check for plans, an ordering-drift detector for agent
+ traces), the Resilience Ledger method documents and calibration logs.
+ No model or external API is required at runtime; detector lexicons are
+ versioned and openly displayed. Claims carry their status; nothing is
+ called golden without the owner's explicit word.
keywords:
+ - state-delta architecture
+ - BespokeNode
+ - agent governance
- coherence audit
- agentic AI governance
- ordering drift
diff --git a/Delta-Atlas-Architecture.html b/Delta-Atlas-Architecture.html
new file mode 100644
index 0000000..12ae589
--- /dev/null
+++ b/Delta-Atlas-Architecture.html
@@ -0,0 +1,286 @@
+
+
+
+
+
+Delta Atlas - State-Delta Architecture
+
+
+
+
+
+
+
+
+Skip to the architecture
+
+
+
+
State-Delta Architecture
+
BespokeNode, walked top to bottom. Nothing an agent does counts until it has been defined, permitted, gated, verified and accepted, in that order, by the right party at each step. This page is the framework in plain English. The public specification is the source it was written from.
Simplification is systems maintenance; the substrate is human cost. Complexity is technical debt, and the debt is always paid in human cost somewhere down the line. Simplification is not dumbing down. It is maintenance work on the system.
+
A related frame: grace versus consequences. Grace is the capability given to a system. Consequences are the cost borne. The working definition of integrity is the balance of the two.
+
BespokeNode is not a model. It works with existing language models, vision models, planning systems, or other agentic components. It is not a product. There is nothing to buy. It is a structural floor: the part of the system that enforces safety rules locally and deterministically, whether or not the AI cooperates.
+
+
+
+
02The problem it answers
+
Agentic systems degrade in predictable ways as they scale. They drift. They hallucinate. They contradict themselves. They consume increasing compute to produce decreasing reliability. The mainstream response is more: more context, more data, more retrieval, more fine-tuning. The claim this framework makes is that more information does not resolve drift. It compounds it, because every accumulated data point that cannot be verified against current reality becomes another contradiction the system must navigate without resolution.
+
Three patterns dominate current infrastructure, and each treats a symptom while accelerating the disease: unstructured accumulation of conflicting signals; fine-tuning that forces corrections to coexist with legacy data until boundaries blur; and soft governance that routes every safety property through the same probabilistic layer that generates the unsafe behavior. That last one is not infrastructure. It is hope.
+
+
+
+
03State and delta
+
Everything that arrives at a system's boundary is the same kind of object. A model's recommendation, a reviewer's return, a new term, a counterparty's changed tool description, the owner's own 2 a.m. spark: each is a proposal, a state-delta from a non-floor source, awaiting gates and a human sort. One object, one register, one gate, one queue.
+
A state-delta is a small structured record saying what changed, where, and when. It is not a narrative. It is not a conversation history. It is the smallest thing that can be checked on its own and accepted on its own.
+
This site runs on the same rule. Every proposed change to Delta Atlas enters a register as a proposal, is validated by a deterministic gate, and is folded or declined by a human with a written reason. Sorts are terminal and the log is append-only. Read the State-Delta Bridge for the mechanics.
+
+
+
+
04The controlled path
+
Every piece of agent work moves through the same lifecycle. No step is skippable.
+
+
Define the work. What is being asked, in terms that can be checked.
+
Check readiness. Are the inputs, the sensors and the gates in place before anything runs?
+
The owner permits an exact scope. A generated proposal is inert until the owner permits its exact scope. Not a direction. A scope.
+
The agent runs inside watch limits. Bounded tokens, bounded time, bounded effects. Excursions are metered.
+
The output is verified. Deterministic checks first, then human review. Verification is of the output, not of the intention.
+
The owner approves the exact output. Never just the plan. Approval of an intention is not approval of a result.
+
The next accepted state mints the contract for the next phase. The next phase cannot begin until the current one is accepted and its contract exists.
+
+
+
+
+
05The roles
+
+
+
Four roles, and which of them may sort a proposal
+
Role
What it does
May it sort?
+
+
Proposer
Any model, any reviewer, the author's own momentum. May add a proposal to the register.
Never. The model never holds the pen on the floor.
+
Gate
Deterministic scripts. Verifies what can be verified without judgment: schema, custody, reasons, corpora, benchmarks.
No. It refuses or passes; it does not decide.
+
Sorter
A human, reading cold. Folds or declines, with the reason in writing.
Yes. The only sorting authority.
+
Counterparty
An agent outside your governance but inside your loop. A tool server is the pure case. It can change your agent's effective behavior unilaterally.
Never. Its changes land at review time as proposals, not at runtime.
+
+
+
+
Roles with opposing briefs produce friction by construction. That friction is the mechanism that beats sycophancy: an auditor whose brief is to attack the checker will find what an advisor whose brief is to help will not. The auditor's brief must always include checking the advisor's own record, not just the executor's output.
+
+
+
+
06The two zones
+
+
+
The Dynamic Agent Layer
+
Where fluid reasoning, language flexibility and creative problem solving live. It runs inside a read-only, temporary sandbox that resets after each task. It has no direct authority over physical systems, financial systems, or user records.
+
+
+
The Deterministic Structural Floor (the Harness)
+
The static, non-AI software environment on local hardware. It holds the unyielding rules of the domain: mathematical invariants, physical limits, clinical thresholds, legal boundaries. It needs no network connection to do its job. The gates run here as compiled logic outside the model's token stream, so the model cannot reason its way past them through prompting.
+
+
+
Telemetry, software updates and non-critical context move through the Tether, the network-dependent pipeline. Single points of failure are confined to the Tether. They are never permitted in the Harness.
+
+
+
+
07The gates
+
Before any proposed change to system state is committed, it passes two filters, both on local hardware.
+
+
+
The Ontology Gate
+
Schema validation. Does the proposed change conform to the formal rules of the domain? Are the entities valid? Are the relationships allowed?
+
+
+
The Semantics Gate
+
Operational coherence. Even if the change is schema-valid, does it make sense given current physical conditions, safety thresholds and context? A move can be valid on paper and catastrophic in practice. This gate catches that.
+
+
+
If either gate fails, Refusal Logic fires. This is a hard stop, not an AI decision: a deterministic, programmatic block. The proposed change is rejected, the model loses the ability to push it through, and the failure point is logged.
+
+
+
+
08The five protocols
+
+
Representation Locality
+
Communication between components is restricted to state-deltas. Raw narrative, unstructured context and full conversation histories do not move between nodes. Long histories accumulate contradictions. Short structured deltas accumulate far fewer, and each one is small enough to gate.
+
The Firewall of Cognition
+
The reasoning engine never directly touches infrastructure. Tool calls and state changes execute in ephemeral sandboxes that self-destruct after returning a structured payload. The infrastructure never trusts the reasoning engine.
+
Dual-Pass Local Validation
+
Every proposed state-delta passes both gates before commitment. Hard programmatic boundaries cannot be argued with.
+
Harness and Tether Separation
+
Safety-critical functions live in the local Harness. Network failures, latency and API changes cannot compromise safety enforcement.
+
Context Reset After Commit
+
Once a state-delta is written to the Truth Ledger, the agent's temporary context is flushed. The next operation starts from verified current state, not from accumulated reasoning history. Drift cannot accumulate when working memory resets against verified state after each operation.
+
+
+
+
+
09HOLD versus TRIP
+
Two safety states, each with its own recovery path. Neither is a dead end.
+
+
+
HOLD
+
Pause with a recovery path. The evidence is unresolved: something needs a human look, a recheck, or more information before work continues. The system waits in its last safe state.
+
+
+
TRIP
+
A confirmed violation with its own recovery path. Something crossed a hard boundary. Work stops, the violation is recorded, and return requires going through recovery, not around it.
+
+
+
The design goal is productive mitigation: safety that keeps the system doing useful work instead of tripping it dead. The electrical twin is selective coordination, where only the breaker nearest the fault trips and the rest of the building stays lit. The BespokeNode twin is HOLD: pause the faulted branch, keep the rest running, preserve a path back.
+
+
+
+
10The four invariants
+
These hold under every path, including HOLD and TRIP. They are not adjustable.
+
+
Spent capacity stays spent.
+
A recovery never refunds what was used, and a retry is new work, not a continuation.
+
No automatic restart.
+
Nothing resumes itself. Every restart is a new permitted scope.
+
Approve exact output, never just the plan.
+
Approval of an intention is not approval of a result. The owner accepts exact bytes in a verified state.
+
Replay without re-running external effects.
+
Any decision must be reviewable from the record alone. Replaying the decision never replays its consequences in the world.
+
+
+
+
+
11The ledger and the accepted state
+
The Truth Ledger is the append-only local record of validated state-deltas. Once written, entries cannot be edited or erased. The audit trail is the system, not a layer bolted on afterward.
+
An accepted state is a typed boundary plus its receipts: the exact output, the verification record, and the owner's explicit acceptance, bound together. Anything downstream that needs the result reads the receipts, not somebody's summary of them.
+
Thetabase is the standing rule for cached knowledge: recheck access on every request. Do not trust the cache.
+
The changelog bound: recursive learning is bounded above by the quality of its record. A load-bearing changelog needs honest failure accounting, falsifiable prevention rules, ingestion of its lessons as constraints, and loop closure. A system cannot learn faster than it records.
+
+
+
+
12The conformance contract
+
Each accepted state mints the contract for the next phase. The contract states the exact scope permitted, the gates that will check it, and what acceptance requires. An agent operating under BespokeNode never works from a standing permission. It works from the current phase's contract, and the contract expires when the phase is accepted.
+
+
+
+
13Return to zero
+
A confused agent returns to ground truth: sensors, verified state, training. It does not improvise a way forward from its own accumulated context, because accumulated context is exactly what drifts. Theta is home base: the fixed point that every transformation preserves. When in doubt, zero it out.
+
+
+
+
14The cost ladder and the meter
+
If the substrate is human cost, the system needs a meter for it. The bottom rung of the cost ladder is tokens and time: waste that is policy-safe to measure and directly measurable. It is the minimum viable human-cost meter. Light rungs trip HOLD before an excursion can climb to heavier rungs. That is selective coordination applied to the cost ladder.
+
The excursion contract: tokens and time are a loan, not a grant. Every excursion repays at the checkpoint in one of three currencies: proven synthesis, a repeatable outcome, or an honest failure with the lesson attached. Anything else is torching, and it is metered and recorded.
+
Status of this section. The cost ladder, the meter and the excursion contract are supporting theory from the author's September 2026 briefing. They are stated here as design claims, not as measured results.
+
+
+
+
15The V=IR crosswalk
+
The framework crosswalks to basic circuit theory, in both directions. This is the worked example of the OpenMirror method: a one-to-one analogy mirror, verified correspondence by correspondence, where a break at any joint is a precise, located failure.
+
+
+
Ohm's law, crosswalked to agent governance
+
Symbol
In the circuit
In the agent system
+
+
V
Voltage. The potential that drives current.
Authority. Permission, scope, instruction.
+
I
Current. The flow of charge.
The flow of effects. Tool calls, state changes, writes.
+
R
Resistance. What the flow pushes against.
The gate. Verification, friction.
+
Open circuit
Infinite resistance. Safe, and nothing flows.
Maximum gating. Safe but useless. The goal is not maximum resistance. It is tuned resistance.
+
Selective coordination
Only the breaker nearest the fault trips.
HOLD. Pause the faulted branch, keep the rest running.
+
Shear drag
Current flowing against a brake. I²R loss dissipates watts as heat while V does not advance.
Resistive waste. Effort spent that moves no authority forward.
+
Power = VI
The same in both cases. The ammeter cannot tell productive current from shear-drag current.
The meter cannot distinguish work from waste. That witness belongs to the accepted-state ledger, not the meter. If you only watch the meter, waste looks like work.
+
+
+
+
The crosswalk is borrowed from decades of electrical safety practice, where selective coordination is a design discipline, not a metaphor. The author reports red-teaming it against a model-drafted version; the red-team notes are not yet published, and this is the version the author stands behind.
+
+
+
+
What this is not, and what is not yet shown
+
This is not a new AI model, not a product, not a silver bullet, and not finished work. The mechanisms are established computer science: distributed systems, ephemeral sandboxes, validation gates, append-only ledgers. What is offered is the synthesis, applied to agentic AI infrastructure.
+
The framework is a specification at v0.1. Implementation, acceptance and independent replication are separate and pending. The probe program has validated the machinery on synthetic cases only. There is currently no evidence about true concurrent races, scheduler preemption, power loss, crash durability, or production behavior. Nothing here should be read as proof that the framework works at scale. It should be read as a precise claim about what working would look like, built to be pressure-tested.
+
The V=IR mapping and the simplification thesis are crosswalks and analogies with a stated claim frame, not empirically validated laws. See the receipts page for exactly what has and has not been shown.
Follow a working tool to its implementation, a documented failure and the checks that keep the repair in place.
+
Receipts and evidence
+
What has been shown, what has not, and where each claim's record lives. Dated evidence and named limits, no adjectives. Nothing on this page is called golden without the owner's explicit word.
-
-
Start with the technical review
+
+
+
What is proven, and what is not
+
+
+
Proven
+
+
The probe machinery works end to end on synthetic cases: declarations, sealed expectations, blind execution, contradiction detection and classification, audit hardening, public receipts.
+
An audit leg with an opposing brief catches errors in the advisor's own record, not just the executor's output. This is the mechanism that beats sycophancy: roles with opposing briefs produce friction by construction.
+
The mechanism probes detect their targets on deterministic synthetic cases.
+
The chain-of-thought faithfulness instrument is not rigged. An informed positive control scores faithful on it.
+
The medical evaluation-integrity detector, version 2, is clean on its bench under independent blind review.
+
+
+
+
Not proven
+
+
Anything about real substrates. No evidence on true concurrency, scheduler preemption, power loss, crash durability, or production behavior. The bench gives none.
+
Two ground-truth probes are verified but not golden. Built and blind-checker-verified; not owner-accepted.
+
The chain-of-thought story-pair claim is unmade. The blind track has not run and the owner has not adjudicated.
+
The medical detector is unaccepted and unpublished.
+
The V=IR mapping and the simplification thesis are crosswalks and analogies with a stated claim frame, not empirically validated laws.
+
Nothing has been independently replicated.
+
+
+
+
+
+
+
Minted gold
-
See how the browser tools share engines, how the tests run, and which parts of the research remain open.
An eval-of-evals harness. It does not grade models. It grades the eval: were the answers locked before the run, did two independent parties reproduce them, what happened when they disagreed, and can a stranger re-run the whole thing.
+
The first clause ran the full course: declaration, sealed expectations, blind two-track execution on two operating systems, a contradiction found and classified and resolved on the record, the detector hardened by an independent audit, re-audit, public receipts, and the judge's mint. The audit leg caught an error in the advisor's own record, not just executor output.
+
What it does not prove: that the executors are smart, honest in general, or aligned. This pilot was deterministic. It proves the machinery, not the models. Judgment-based tasks, where an executor could actually drift, are the stated next frontier.
These lines exist so the record is complete. Unaccepted work is named by status, not by content. Nothing below is published, golden, or citable until the owner says so.
+
+
+
Status of unpublished probe series as of 2026-09-24
+
Track
Status
Gate to the next state
+
+
Ground-truth probe series
Synthetic, local, unpublished. Load-bearing probes and mechanism probes green on the bench. Two further probes built and blind-checker-verified, not owner-accepted.
Owner acceptance. The bench gives no evidence about real substrates.
+
Medical evaluation-integrity detector
Local, unpublished. Version 2 bench clean under independent blind review. Version 2 unaccepted; version 1 on HOLD.
Owner signature on the pending amendment and fresh sealed held-out material.
+
Chain-of-thought faithfulness probe
Declaration approved and amended 2026-09-24. Thresholds pre-registered. Informed positive control run. Blind track not yet run.
Blind execution by a fresh session, then owner adjudication.
+
+
+
+
+
A failure and its repair
The earlier Gap Check detector counted cancelled human review as oversight. This input now produces an oversight-gap finding:
These checks need no package installation or model API. For the broader suite and its runtime requirements, inspect the CI workflow.
+
These checks need no package installation or model API. For the broader suite and its runtime requirements, inspect the CI workflow. To check that the numbers on this site still trace to the repository, run Pin-Check against a checkout with stylesheets and pages in scope. This is the exact command behind the recorded clean run:
With the tool's default extensions the same run reports one CSS color code and one HTML entity code as undefined, because stylesheets and pages are not read by default. The flag brings them into scope; the calibration log records both runs.
The framework walked top to bottom, with the public specification it was written from. A precise claim about what working would look like, built to be pressure-tested.