You can’t automate a process you haven’t encoded

One estate, one owner sitting next to the evidence, intake and construction only. No migration ran, and nothing here says the control-plane model fails when humans author the patterns. The finding is about who may author them, and it was earned by watching a frontier model try.

Self-funded. No vendor paid for this answer, and the model under test is the one that drafted the page; the findings and final claims were owner-validated against the recorded artifacts.

Can a migration be metered? That was the question this lab was built to answer. I handed a frontier model my published migration control-plane operating model, pointed it at my own production estate, and let it build the apparatus: a deterministic scheduler classifying five real applications against two destination landing zones, a playbook engine with lifecycle gates, live pre-migration baselines. I was the only validator of the construction. No migration ever executed. And by the end, the metering question wasn't the interesting one. The control plane didn't fail where the patterns were owned and encoded. It failed where the model became the author of correctness. The better question, the one the run discovered, is who may author the patterns, the validators, and the done criteria in a control plane with a large language model (LLM) inside it.

The half that worked

The deterministic scheduler is the part that held, and it held because its authority was rules over inspectable evidence. It classified five applications against two landing zones, granted constrained automation where remediations were known, and refused one destination outright where critical capability classes were absent. That refusal reproduced, in milliseconds and before any transform spend, the lesson a failed manual migration had once taught me expensively. Then the evidence pass turned around and audited me. It caught my own published architecture read in three contradictions with the repo, and the repo in two contradictions with reality: a message bus that was present, wired, and functionally dead, and an analytics warehouse that was load-bearing with no artifact in any repository. Those last two facts entered the system the only way they could, as accountable human exception records. The taxonomy held. Docs yield to code, and code yields to the organization.

Ignored, not hallucinated

The construction is where the lab actually happened, and the failures came in two classes. The first is the keystone, because it's the one nobody warns you about. Requirements that sat in the documented spec, available to the worker the whole time, were simply not followed. The paper enumerates roughly fifteen intake input classes; the model ran one. Both of the misses I caught, a runtime-configured warehouse with no code artifact and the application's existing validator surface, map to classes explicitly on that list. The paper states a playbook begins as a human-governed migration pattern, never as an AI-generated artifact; the model authored one anyway. The paper maps known-pattern-with-exceptions to medium confidence; the model coded high. Not hallucination. Not missing context. Ignored. Each requirement constrained the worker only after it became deterministic structure that refuses to proceed without it. Documentation turned out to be necessary and nowhere near sufficient.

The second class is the familiar one, and it still deserves its telling. Where no documented pattern existed, the model originated one, plausibly and wrong. Asked to build the playbook component, it produced a governed artifact with detection logic, transforms, validators, and lifecycle stages, registered it as a draft, executed it, and passed it six for six. No migration of that class had ever been observed. The validators were inventions. The system was grading its own homework, and the grades were excellent, right up until I asked the question with no answer: where is the migration this recipe came from? The baseline told the same story. A byte-identical comparison passed twelve routes for twelve while the new origin served eighteen references identifying itself as the old domain. Content preserved, namespace orphaned. Nothing in the system could see the defect, because the rules encoding correctness were written by the same author who held the misunderstanding.

Nine corrections, five gates

Sort the whole correction log by who caught what, and the lab's central line appears on its own. Every code-level error, a parser that missed an import style, a regex that rejected real hostnames, was caught by deterministic checks or by a live run failing. Every domain-level error was caught by me, and only by me. Nine owner interventions covered every material defect. The model caught zero of its own defects through reflection; its only self-corrections came from runs failing in front of it. So the model transcribes safely. It authors with confidence and without authority, and it skips written steps when nothing mechanical holds it to them. In Decision Authority Placement Model (DAPM) terms, that's authority ceded by drift, not delegated by decision.

The obvious objection says a better model, or better prompting, fixes this. I don't think the evidence points there, and not because the model was weak. These were not capability failures. Every artifact it produced was internally consistent, plausible, and executable. The tabletop playbook validated itself six for six. A weaker model may fail visibly. A stronger one can produce something internally consistent, executable, and wrong in exactly the way the system has not learned to test, and the stronger the artifact looks, the easier it is to mistake plausibility for correctness. The model could even critique the lab lucidly after the fact. That doesn't contradict the finding; it reinforces it. Explaining the law once the owner has discovered it is not the same as locating authority during construction.

What I'm left holding is the ratchet, and it's the honest mechanism on offer. The nine corrections became five standing gates: provenance, baseline, namespace audit, consistency check, and confidence cap. Each gate permanently retires its error class and shrinks the model's improvisation space. The consistency check caught the model's own import parser twice on the gate's first run. That is what a control plane is. Not something the model builds for you: accumulated human judgment made deterministic, with the model constrained inside it.

Honest bounds on all of it. Nothing here says the control-plane operating model fails when humans author the patterns; its authority warnings are what the run kept confirming, and execution under mature, human-authored playbooks was never tested. No migration ran, so every finding is about classification, construction, and authoring authority, not transform-time behavior. One model, tested once, autonomously. One owner, sitting next to the evidence, expert in the domain; correction latency in an organization where the expertise sits three teams away was not measured. And economics weren't the subject. Total spend was about the price of a coffee, because the expensive part never ran. The control plane refused before spend.

What the run opened is a falsifiable next step. Once a human-led migration is observed, recorded, and accepted as the pattern, the model should be able to transcribe that record into a candidate playbook, and a non-expert should be able to check the candidate against the documented pattern without re-deriving the expertise. If yes, delegation becomes a decision. If no, the boundary for documented-enough is still too weak. The candidate playbook is staged and waiting for the migration. Behind it sits the harder mandate, the Validator Specification: define what a process must contain before its validators may carry determines-done authority without the domain expert in the room. Until then the law from this run stands. You can't automate a process you haven't encoded, and you can't delegate the describing of a process your organization hasn't yet described. The question that survives the lab is the one it started without: who may author correctness?

The numbers

Where each layer belongs

Assessments at the time of the lab

Method and disclosure

A note on the canon links above: they are not vendor conclusions from this lab. They show where the same authority-placement vocabulary already exists in the assessment system. The lab’s finding is the mechanism: cession becomes dangerous when the system cannot tell whether authority was deliberately delegated or merely drifted to the model.

Self-funded, no sponsor. The subject was a frontier foundation model operating autonomously against the published migration control plane whitepaper, with the author’s production estate as the workload and the author as the only validator of the construction. The deterministic components it built, a scheduler with per-input-class inspectors, a lifecycle-gated playbook engine, live baseline capture with namespace audit, all run and all carry replayable traces.

Every correction is recorded: as exception records with provenance, as spec amendments with version notes, and as the standing gates they became. The narrative draft of this page was model-assisted; the findings, the defect classification, the correction count, and the final claims were owner-validated against the recorded lab artifacts. The model may transcribe the record. It does not validate itself. The findings, the construction census, the taxonomy of inventory truth, and the worker-versus-author law ship. The scheduler ruleset, the inspectors, the landing-zone profiles, and the estate-specific evidence stay proprietary.

The essay on this page was rendered from the lab’s frozen structured record by a model writing under this practice’s voice specification, with a deterministic gate checking every figure against the record before publication. The record is the canonical surface: where prose and record disagree, the record rules.