Governing how AI reasons, not just what it says
Actualize Impact started as a way to get human teams from vision to action. The same discipline now governs how AI systems reason — a constitutional spec, two SDKs, an evaluation harness, and a training-corpus methodology for open models that do not inherit closed-model contamination.
For years, the through-line of this work was a sentence: Envision possibilities, design solutions, actualize impact. It described a way to get groups of people from a shared picture of what could be to something they actually shipped.
That sentence still holds. What changed is where the work lives. Most of what I build now is software that governs how AI systems reason — and the same discipline that moves a human team from vision to action turns out to be the discipline an AI system needs to reason in public, accountable relationship rather than in private.
This is the first of a running build log. Less whitepaper, more workbench: what got built, why, and what's still unproven.
The stack, not the slogan
The center of gravity is a constitutional governance system with four moving parts that fit together:
- A specification — a language-agnostic source of truth (principles, the biases they guard against, the reasoning modes a governed system runs). It is versioned like a contract, because everything downstream depends on it meaning exactly one thing.
- Two SDKs — a TypeScript library that composes governed prompts, caches the stable prefix, detects governance signals after generation, and persists every run; and a Python composition library that renders the same prompt, verified byte-for-byte against the spec's golden fixtures so the training-time input equals the deployment-time input.
- An evaluation harness — a baseline-vs-governed playground where the spec is tested against real model output, and a surface for ratifying which outputs actually meet the bar.
- A corpus methodology — pipelines that turn ratified judgments into training data for an open reasoning model.
The thesis worth arguing with
Here is the claim the whole stack is built to test, stated plainly so it can be attacked:
Closed-model substrates are contaminated by the uneven data they were trained on. A specification can filter that at inference time. And the labels that filter produces — when they are structurally ratified rather than rubber- stamped — can train an open reasoning model that does not inherit the closed model's contamination.
Two halves. The first is an inference-time filter: govern a closed model's output as it's produced. The second is the harder, more interesting half: use the ratified output as a training signal for an open model, so the governance lives in the weights rather than in a prompt that can be stripped.
The reason this is a thesis and not a result is that the second half requires verification I haven't finished. The corpus exists. The training target is chosen. The mechanistic check — proving the trained model reasons differently in its circuits, not just its words — is still ahead.
How the bias question is actually framed
The grounding assumption is borrowed — from Kerche, Zook and Graham's 2026 "silicon gaze" audit — and worth naming: bias is not a correctable anomaly you patch out. It is an intrinsic feature of generative systems built on historically uneven data. That reframes the job. You don't debug bias; you build a system that reasons about it structurally — by demanding specificity, by shifting where in a problem the model locates the stakes, by scaffolding the reasoning rather than decorating the answer.
The deepest version of this story — from the lived experience that started it, through the structural theory, to the methodology — is its own page.
What's honest to say right now
The calibration on the reward side works — the judge that decides whether an output meets the bar agrees with human ratification at F1 = 0.83 (against a 0.7 bar I set before running it). The composition is verified identical across the TypeScript and Python paths. The corpus is real and contract-shaped.
What I will not claim yet: that the trained open model carries the governance in its circuits. That's the experiment, and an earlier version of a related interpretability study didn't survive its own methodological review — which is exactly why the live research is pre-registered now, with frozen hypotheses and matched controls.
More build-log entries to come: the corpus contract, the contamination boundary, and the interpretability work as it clears its own bar.