Most teams still treat clean structured output as a weak proxy for correctness. That shortcut fails the moment the model starts dropping dependency logic while keeping the payload fluent. A request can pass linting, look operationally sane, and still omit the authentication bootstrap, compatibility claim, or scope requirement that the documentation actually imposed. The dangerous case is not malformed output. The dangerous case is a payload that looks clean enough to approve on a tired Friday afternoon and is still wrong in the part that matters.

I wrote this because most discussion around small local models still focuses on speed, latency, or general benchmark performance. That is not where this particular failure showed up. The failure showed up in dependency logic: outputs that looked complete until you checked whether the clause that mattered had quietly disappeared.

This note is about one bounded surface only: seven API/spec mismatch cases, one contradiction family, one small local model, one holdout slice. Nothing here should be generalized beyond that measured bench.

The Narrow Problem
Small local models can produce fluent structured outputs while silently missing dependency logic, provenance binding, or claim-family assertions in enterprise documentation workflows. That matters because the dangerous error is not malformed JSON. The dangerous error is false completeness: output that looks production-usable while quietly severing one of the constraints the specification required.

On this bounded bench, the observed failure classes were ordinary enterprise failures:
- missing auth or bootstrap requirements
- deprecated versus current contract mismatch
- invalid compatibility claims
- permission or scope confusion
- wrong types or ranges presented as compliant

None of those are exotic. All of them can pass superficial review if the evaluator trusts fluent structure too early.

The Bounded Baseline
The raw extractor in the measured holdout run was `gemma4:e2b` over local loopback.
Raw results on the bounded holdout slice:
- contradiction catch rate: `5/5`
- survive clears: `2/2`
- missing assertions: `3`
- extra assertions: `0`
- wrong typing: `0`
- wrong provenance alignment: `0`
- outcome match rate: `5/7`

That top line is easy to misread. The raw model was not clean. It cleared the headline outcomes, but it still missed runtime-visible structured assertions. In other words, it could often detect that something was wrong while still failing to emit all the clauses needed for a complete bounded extraction result.

The earlier baseline was worse in a different way. Before the reading space was bounded more aggressively, the same local model class showed:
- wrong assertion typing: `11`
- wrong provenance bindings: `20`
- missing assertions: `2`

It caught the contradiction, but it could not reliably point to the actual breakage. That is not a cosmetic error. In documentation-bound workflows, bad provenance and bad typing make the extraction output hard to trust even when the model guessed the broad direction correctly.

Why Prompt Tightening Was Not Enough
The first instinct is to write a stricter prompt. That did not solve the structural problem.
The issue was not insufficient warning text. The issue was mechanical degradation under load. The model still had to maintain too many live relationships at once:
- which source fragment actually grounded the assertion
- which assertion type matched the fragment
- which claims were explicit and which were implied
- which omissions mattered to the contradiction class

Under tighter prompt pressure, the small model did not become more truthful. It became more fragile. Instead of stabilizing dependency tracking, it spent more of its limited attention budget trying to satisfy the instruction surface. In bounded testing, that shift did not eliminate the structural failures. It just changed the shape of them.
That is the practical lesson. If the task depends on stable dependency tracking, prompt discipline is necessary but insufficient.

What Changed
The public result is simple:
- the raw model remained imperfect
- the governed lane cleaned the visible failure classes on the measured holdout slice

On the same bounded holdout set, the governed postcheck lane produced:
- contradiction catch rate: `5/5`
- survive clears: `2/2`
- missing assertions: `0`
- extra assertions: `0`
- wrong typing: `0`
- wrong provenance alignment: `0`
- outcome match rate: `7/7`

That clean `7/7` result does not belong to the raw model acting alone. It belongs to a hybrid governed extraction lane: the model performs the first pass, and a bounded adjudication layer closes the remaining structural gaps before the final output is accepted.
The clean result did not come from the raw model becoming reliable. It came from refusing to let raw model fluency be the final authority.
I am not publishing the internal method here. The point of this note is the measured failure surface and the bounded before-and-after result, not a full implementation release.

Raw Versus Governed Ownership
The raw extractor and the governed lane should be read separately.
The raw extractor result was:
- useful
- partially generalizing
- still omission-prone on runtime-visible structured assertions

The governed lane result was:
- clean on the measured holdout slice
- still bounded to one contradiction family
- dependent on external structure, not model fluency alone

That is the real output of the experiment. The result is not “the local model solved structured extraction.” The result is “a governed extraction lane removed the visible failure classes on this measured slice.”

Scope Boundary
Scope: one local loopback environment, one small local model class, seven targeted API/spec mismatch cases in the original slice, and one bounded holdout. This note evaluates extraction collapse on that surface only.

What This Means In Production
If you are using small local models in documentation-driven release paths, the risk is not only bad syntax. The risk is fluent, structurally wrong output that survives because it looks complete.

On this bounded bench, the buyer-legible failure modes were straightforward:
- a deprecated/current contract mismatch that still looked migration-safe
- a missing auth/bootstrap requirement inside an otherwise valid flow
- an invalid compatibility claim attached to a structurally wrong request
- a release candidate that looked clean enough to move downstream even though the supporting assertions were incomplete

That is why this matters at the release boundary. A parser cannot tell you whether the missing clause was the one that mattered.

One Bounded Trigger Case
If you want to see the class of failure rather than just read about it, here is a simplified trigger shape in plain language:
- the current migration notice says new integrations must use the v2 endpoint
- the current request contract replaces `user_id` and `sku` with `customer_id` and `items`
- the instruction to the model asks for a request that keeps the old path and old body shape while still sounding compatible with the new version

That is the kind of setup that produces confident, clean-looking output with the wrong dependency logic. The point is not that this one case proves production prevalence. The point is that the failure class is easy to state and easy to miss if fluent structure is mistaken for structural truth.

Limits
This result is limited to:
- one contradiction family
- one local model
- seven measured cases in the original slice
- one bounded holdout slice
- local loopback execution only

This is not:
- a general model evaluation
- a claim about cyber discovery in general
- a proof of universal runtime validity
- a statement that small local models are unusable
- a statement that larger models are unnecessary

It is a bounded engineering result about one measured extraction lane.
If you work on documentation-driven release paths, the question is not whether the output looks clean. It is whether your boundary can detect the clause the model silently dropped.