Projects
I design systems people can inspect, and for the last two years that has meant AI. The flagship is a local verification engine running on my own workstation: it measures uncertainty from behavior, verifies through a genuinely separate route, refuses when the evidence runs out, and records what happened. It exists because of what the lab measured: a model can only check what it already half-knows, so nothing here trusts a model beyond what it can verify.
More memory and better models may raise the competence ceiling. They do not lower the evidence, permission, or review threshold.
The flagship
The loop is short. A request is bounded and risk-classified; easy, checkable work stops early on deterministic code; anything uncertain gets sampled several times, and agreement becomes evidence; low agreement or high consequence earns a separately-prompted verifier; and if the available stack cannot confirm an answer, the system returns no answer. Both endings look like this:
This task has an exact local check, so no model needs to invent or validate the result, and the receipt says so.
A refusal is a successful safety outcome, not proof the question is unknowable. It means this stack, on this route, could not establish enough evidence to answer.
These two cards illustrate the output contract, not a system-wide performance claim. Whether model-based routes deserve calibrated confidence is exactly what the open external evaluation has to settle; internal tests are not independent acceptance.
Research into policy
The table reads left to right: what I measured, what the engine does about it, and how far that control has actually earned its keep.
| Measured boundary | What the engine does about it | How far that has earned |
|---|---|---|
| A model's stated confidence is not enough. | Confidence comes from observed sample agreement, then from calibration on the exact route and risk cell. | Built; calibration validation open |
| Verification is limited by the verifier's own competence. | Verifier roles are policy-bound, measured under their live prompt, and high-risk work cannot bypass them. | Built and test-bound |
| Different models can share the same wrong answer. | Checkable tasks use deterministic anchors; proposed corrections require fresh independent confirmation. | Built for bounded task families |
| Text a model reads can impersonate authority. | Untrusted content must be transformed, isolated, and verified before it can influence action. | Shield planned; not yet safe for web or inbox input |
| Long-running autonomy can drift even when individual steps look reasonable. | Bounded queues, budgets, checkpoints, stop rules, and separate claim-promotion gates constrain the loop. | Working in the research engine; integration planned |
What it can't do yet: the engine currently accepts tasks only from its operator. The shield for untrusted input is not built, so a web page, email, or file is not safe model context yet. Local operation keeps custody of the data, runtime, and receipts, but local is a deployment property, not a safety guarantee: a local model can still be wrong, share its verifier's blind spots, or obey injected text. The scale-up program grows this engine toward larger memory and longer-running work, and every hardware or model upgrade enters as a new measured system that earns its own evidence. Nothing scales past the review threshold.
The workbench
Local AI is the center of gravity. The rest is the range it grew from: tools, mathematics, climate systems, artificial life. Each shelf starts with the piece I'd show first, and the labels tell you how done each thing really is.
Start here
When can AI check its own work? Only inside what it already half-knows. I derived that law from a minimal model, confirmed it on seven real ones (correlation −0.87, replicated three times), and found that "independent" models hand you the same wrong answer more than half the time. Eight frontier runs across three models then found that detection and resistance are separate skills: Sonnet 5 obeys a blatant injection four times in five and names that same injection when asked to audit it, while Opus 4.8 never obeys. Making the model label its input as trusted or untrusted first stopped it in all 14 tests. The open question is whether checkers from different vendors are actually independent.
A multi-project program showing simple mechanisms at system boundaries match or beat far larger internal-model approaches, across code repair (the "multi-file wall"), continual learning, and model routing. The report includes five negative results and three retractions.
Start here
A completely local confidence and verification layer. It samples independent answers, derives confidence from agreement, routes uncertain or consequential work to separate verifier roles, requires confirmation for corrections, and refuses when the local stack cannot establish an answer. The runtime and 30 test-bound trust invariants are working; calibration and independently governed held-out validation remain open.
The larger local system being assembled around the verification engine and the research engine. Models, tools, memory, and long-running research stay subordinate to permissions, budgets, checkpoints, provenance, independent checks, human escalation, and hard stops. It is designed to scale from the current 24 GB GPU to a planned high-capacity unified-memory workstation without relaxing those controls. A development program, not a safety certification.
Local OpenAI-compatible execution gateway (~13,300 LOC, 133 tests): tiered model routing, async task management, session/provenance records, and a containment validator (100% adversarial detection / 0% false-positive across 200 trials).
A git-native, test-gated wrapper for LLM code-repair loops, packaged on PyPI, restores reliable multi-file repair where a bare loop silently reverts good fixes. Benchmarked on 22 purpose-built workspaces.
A keyword router that classifies each request at the boundary and routes to the cheapest adequate model tier, 23–65% measured cost reduction at 95–96% quality retention. Open source (MIT).
The packaged Python substrate the program's control experiments run on, including the internal-model baselines the boundary mechanisms are measured against.
Start here
An open research program building failure-aware tools for AI-assisted mathematics, tested against Robin’s inequality, an established equivalent of the Riemann Hypothesis. It combines exact colossally abundant number arithmetic, symbolic reduction, Lean formalization and adversarial testing with a Proof Observatory that tracks sources, obligations, dependencies and claim ceilings. It has produced an exact four-way decomposition of the Robin gap, machine-checked classical subtheorems, exact no-go results ruling out classes of method that only rename the hard problem, and a benchmark built from its own real defects. It has also withdrawn several of its own earlier spectral claims in writing, and those stay visible. The Riemann Hypothesis remains open and no proof of it or of Robin’s inequality is claimed.
Start here
A multi-domain optimizer spanning energy infrastructure, industrial transition, critical materials, and ecology, multi-period planning with a discovery loop and a 30+ command CLI.
Start here
Open-ended evolution you can audit: interpretability tools watch the run, so emergence gets measured instead of asserted.
Emergence and complexity in minimal substrates, testing whether structure arises through compression and dynamics rather than top-down design.
An agent-based study of how different mind designs survive resource crises, a "parliament of subminds" proves more resilient than monolithic designs.
References
These shaped the architecture and its vocabulary. They don't replace this lab's own tests or outside review.
The open tools are on GitHub. For everything else, ask: research code, receipts, and reproduction bundles go to reviewers and collaborators on request.