DNA, LLM and Wick-Leger Correspondance (2nd Rosetta Stone)

Following up on the thread with two additions: KnackAU’s stress tests from practice, and a recent empirical result that sharpens the Micro layer considerably.

-–

1. KnackAU’s five points — where the framework gets hard

KnackAU’s response is exactly the pressure this needs. Three of his points deserve direct integration:

Repair cost is a cliff, not a slope. The fixation point — where undoing a commit requires regenerating everything downstream — is the real boundary. I had “repair” as the final box in the chain; the practical question is whether pre-inheritance repair is economically viable. KnackAU’s measurement row (“repair cost as a function of detection latency”) belongs in any experiment design.

The READ gate is harder than the WRITE gate. This is the most important correction. My Meso layer focused on write-side authority (engine commits, receipts certify, governance audits). KnackAU points out that write-side is solvable — deterministic, auditable. The breakage is retrieval: “knowing when a memory is relevant, and when to abstain.” His 96% false-fire rate on no-correct-answer queries is brutal evidence. I would add recall != relevance to the guardrail list as a first-class inequality.

Present-but-unchecked receipts are worse than absence. This makes telemetry != truth meaner than I wrote it. A trace line that looks like a failure but is a display artifact; a number that is an external oracle’s, misread as the system’s own. The Meta layer’s job is not attaching provenance — it’s making provenance cheap to falsify, so wrong receipts get caught instead of inherited. “Verify the verifier” belongs on the list.

His fourth point (inheritance vs. poisoning) and fifth (every != needs a failing gate) are experimental design constraints I accept.

-–

1. Dennis et al. (2026) — “Compiling Agentic Workflows into LLM Weights”

This paper is the strongest empirical case for the Micro layer I’ve seen. It also complicates the Meso layer in a productive way.

What they do: Replace LangGraph-style orchestration with fine-tuned small models (3B–8B) that have the procedural workflow compiled into their weights. The orchestrator is used only during training data generation; at runtime, the user talks directly to the model.

The numbers: 8B compiled model achieves 87–98% of frontier in-context quality, 128–462× cheaper per conversation, 30–50 minute recompile cycle. Failure rates drop from 24% (LangGraph + Claude) to 5.5% (travel) and 17% to 9% (insurance).

Why it matters for this framework:

Micro layer — “ledgered development” becomes literal. The procedure is not in context, not in a receipt, but in parametric memory. The commitment is persistent across conversations. The 30–50 minute recompile is not O(1) rollback, but it is deterministic repair with a measurable cost curve. This is the first empirical test I know of that isolates “compilation vs. orchestration” with controlled same-model baselines.

Meso layer — the strongest authority is sometimes absence of authority. For closed, finite procedures (14–55 nodes), the model self-orchestrates because the structure is in the weights, not the prompt. No runtime injection, no receipt, no gate. This is a more radical version of surface != truth — the surface contains no procedure at all. It only works where the procedure is bounded and deterministic, but within that boundary it is cleaner than any gate architecture.

Macro layer — selection pressure favors compilation on cost and quality simultaneously. The LangGraph orchestrator loses on both dimensions. That is selection pressure operating against complexity, not against alignment.

Meta layer — the open problem this paper does not address. When the procedure is compiled into weights, it is no longer inspectable at conversation granularity. There is no flowchart in the prompt, no explicit state machine. “Verify the verifier” becomes “verify the weights” — and that is currently not falsifiable without full re-execution against a reference. This is where the framework’s Meta layer (claim discipline, provenance, cheap falsification) has work to do.

-–

1. Revised guardrail list

Incorporating KnackAU and the compilation result:

proposal != commitment

surface != truth

narration != receipt

capture != authority

telemetry != truth

trace != canon

memory write != global canon

selection pressure != alignment

recall != relevance [new — KnackAU]

compiled != inspectable [new — Dennis et al. gap]

The last one is the tension: compilation gives persistent structure, but at the cost of runtime inspectability. The framework needs a way to track whether a system’s commitments are in weights (opaque) or in context/prompt (transparent) — because the repair and verification strategies differ.

-–

4. What I would test next

From KnackAU: the fixation cliff — at what commit depth does repair cost spike? Is it the first downstream generation, or deeper?

From Dennis et al.: the inspectability gap — can we design a lightweight probe that tests whether a compiled model’s behavior matches its source procedure, without full re-execution? Something between “trust the weights” and “recompile and diff.”

The two questions converge: pre-inheritance repair is cheap only if we can detect deviation early; compiled systems make early detection harder because the procedure is no longer in the prompt.

-–

Condensed version

> The DNA/Wick-Ledger mapping gains empirical support from compilation results (Dennis et al., 2026), but loses runtime inspectability as a side effect. The four-layer split holds, with two additions: `recall != relevance` in Meso (retrieval is harder than commitment), and `compiled != inspectable` in Meta (weights are opaque). The next experiment should test whether early deviation detection is still possible when the procedure is subterranean.

-–

Does this compression hold, or does the `compiled != inspectable` guardrail need its own layer?