Captured Judgment — The Substrate Under Reviewable Memory

Captured judgment is the durable, inspectable, reusable artifact form of expert reasoning under uncertainty — including standards applied, tradeoffs weighed, alternatives rejected, and correction patterns when a decision turns out wrong. It is what makes reviewable memory non-trivial.

The gap captured judgment fills

Ask a senior operator at your company how a load-bearing decision actually got made, and you will get three answers depending on who you ask. The operator will explain the reasoning — what was considered, what was ruled out, what mattered in this case that would not in another. The AI team will show you the prompt — the system instructions that try to encode the operator's pattern for the model to replicate at scale. The documentation team will pull up an SOP — clean, indexed, current, and structurally incapable of carrying the part of the operator's pattern that distinguishes good decisions from bad ones in ambiguous cases.

The reasoning lives inside the operator. The prompt is downstream of the reasoning. The SOP encodes policy, not judgment. If the firm's standards exist only inside specific experts, inside prompts, and inside SOPs, the firm is scaling output while losing judgment. That is the gap captured judgment fills.

What captured judgment is

Captured judgment is the durable, inspectable, reusable artifact form of expert reasoning under uncertainty — including the standards being applied, the tradeoffs being weighed, the alternatives that were considered and rejected, and the correction patterns that surface when a decision turns out to have been wrong.

It is not a transcript. Transcripts capture what was said. It is not a prompt. Prompts capture what the system should do. It is not an SOP. SOPs capture what the process is. Captured judgment captures why a specific decision survived contact with reality — and what specifically would have caused it to be made differently. It is closer to a worked example than to documentation, closer to a court opinion than to a procedure manual, and closer to a master's notebook than to a training video.

The distinction is operational. Prompts and SOPs degrade silently when applied outside the conditions they were written for. Captured judgment carries the conditions inside it. A reader inheriting the artifact — human or agent — can tell whether the situation in front of them is the situation the artifact was built for, because the artifact made the situation explicit.

What captured judgment is not

Several adjacent artifacts get called "knowledge capture" but are structurally insufficient:

Most enterprise "knowledge capture" programs produce some combination of these and confuse the volume of output for the existence of the asset. The asset that does the work is structurally different.

The seven load-bearing elements

A captured-judgment artifact preserves seven elements the prompt-and-SOP pattern omits. The structure is deliberate, not aesthetic — each element is preserved because removing it would lose the principle, the conditions, or the correction trail.

A library of artifacts shaped this way is structurally different from a library of prompts or a library of SOPs. It is teachable. It is auditable. It is defensible. It survives the operator who produced it.

Captured judgment as the substrate under reviewable memory

Reviewable memory — one of the four operational properties of governable AI action under human authority — requires that what the system remembers and uses is inspectable as a contract surface. The contract surface is a structural commitment. It says: anything the system is acting on is open to review.

That commitment does not hold automatically. A memory store filled with summarized prompts and undated SOPs has nothing defensible to expose under audit. The contract surface needs something behind it. Captured judgment is what fills it. A library of artifacts, each one carrying the standard, the situation, the alternatives, the evidence, and the correction trail, is what makes a reviewable-memory surface defensible — for the reviewer, the regulator, the apprentice, and the next operator who has to act on what the prior one decided.

Without captured judgment, reviewable memory is an empty inspection surface. With it, the system's memory becomes a usable evidentiary substrate.

How captured judgment scales without surrendering authority

The historical argument against rich knowledge capture was that it does not scale — experts cannot be cloned, documentation collapses under its own weight. The argument was correct under prior tooling. It is no longer correct.

AI systems can read, index, and retrieve from large libraries of captured-judgment artifacts at the speed required for them to feed agentic decision loops. The artifacts themselves are authored by humans, in service of preserving their own reasoning durably. AI consumes them; it does not produce them.

This inverts the failure mode of the prompt-engineering pattern. In prompt-engineering, the operator's judgment is compressed into instructions and the model's outputs are the artifact. The operator's reasoning is invisible; only their conclusions persist. In a captured-judgment regime, the operator's reasoning is the artifact; the model's outputs are downstream and revisable, because the standard is preserved separately and can be re-applied to overruling cases. The operator does not get cloned. The operator's judgment does.

Where captured judgment sits in the cluster

Captured judgment is one of the substrate layers that lets governable AI action under human authority actually be defensible. The fiduciary wedge names the gap that captured judgment plus the rest of the governable-action architecture closes. Apprenticeship infrastructure is the transmission mechanism that lets captured judgment teach the next operator how to act under uncertainty, not just record what the prior operator did. The deeper contrast between a governed memory subsystem and the larger integrating regime — where captured judgment, reviewable memory, and the surrounding properties belong — is held on governed memory subsystem vs. governed cognitive infrastructure. The glossary stub at captured judgment gives the citable short definition.

FAQ

What is captured judgment?
The durable, inspectable, reusable artifact form of expert reasoning under uncertainty — including the standards being applied, the tradeoffs weighed, the alternatives considered and rejected, and the correction patterns that surface when a decision turns out wrong. Not a transcript, prompt, or SOP. Closer to a court opinion than to a procedure manual.
How is captured judgment different from documentation?
Documentation encodes processes and policies. Captured judgment encodes the reasoning that produced a specific decision under uncertainty — including the alternatives that were considered and the correction trail when a prior decision turned out wrong. Documentation answers what to do; captured judgment answers how to decide what to do when the documentation does not fit.
How is captured judgment different from prompt engineering?
Prompts compress an operator's pattern into model instructions. The operator's underlying reasoning is invisible; only the outputs persist. In a captured-judgment regime, the operator's reasoning is the artifact, and AI outputs are downstream and revisable.
How does captured judgment relate to reviewable memory?
Reviewable memory, as a system property, requires that what the system remembers and uses is inspectable as a contract surface. Captured judgment is the artifact form that fills that contract surface with reasoning the firm can defend. Reviewable memory without captured judgment is an empty inspection surface.
Who authors captured-judgment artifacts?
Humans, in service of preserving their own reasoning durably. AI systems consume the library at scale; they do not generate it. This inverts the failure mode of 'AI documents itself,' which produces output volume without preserving the reasoning that justifies it.

Internal artifact: captured-judgment · class: concept-anchor · surface: shared-core