Stop Engineering the Harness. Engineer for Intent and Outcomes.

In April I published The 8 Layers of AI Engineering: prompt, context, agentic, harness, governance, evolution, ecosystem, emergence. Five months of running that ladder in production, with agents doing most of the work, gave us the upgrade.

The verdict: keep the eight layers, and ask two questions at every one of them. What did the person mean? Did it happen? The layers are the means. Intent and outcome are the end. A team that engineers those two questions directly gets more out of every layer it already has, at any altitude on the mountain.

The grade is one number: of the claims your system makes about itself, what fraction carry a check that can fail, wired to run unattended? Ours tonight: 905 checkers, 900 with a self-test, 871 wired into a lane. That number moves when real work is done, and it is the one we steer by.

The two questions

Intent: what does this person mean, stated as an outcome someone could observe? The prompt is evidence of the intent. "A blog post about X" means a titled post in the posts directory, rendering at a URL on the served site, linked from the article it updates, with that article pointing back. The person typed one of those four and expects all of them. Recovering the other three is the job. We described the mechanism in Environment Over Instruction: a rich environment lets a stream-of-consciousness prompt work, because the environment is where the intent lives when the prompt is short.

Outcome: what check, that can fail, run against the surface people actually look at, by something that cannot see your diff, proves the intent happened? The strongest proof is the served page, the running process, the reply the user receives. An independent judge looks at the same surface the person looks at and gives a verdict.

Everything between those two questions is instrumentation: prompting, context assembly, tool use, routing, budgets, policy. You engineer it the way you engineer logging, in service of the two questions.

Engineering for intent

Each of these is a rule the environment carries, so every agent inherits it on arrival.

• Agents act on reversible work. "Blocked" has exactly three codes. B1: physically impossible. B2: irreversible and destructive, such as deleting data, spending money or publishing externally. B3: the owner already said no to this specific action. Everything else is the agent's to do, at the owner's own tolerance for reversible risk. We measured 60 to 90 percent of "blocked" items as self-serviceable, and this rule hands that work back to the agents.
• A report is three sections and 150 words. What changed, one line per file. What was left, and why. What you need to decide. Verdicts are CLOSED with the check that passed, OPEN with a B-code, or PARTIAL with what remains. The owner reads three lines and has the whole picture.
• A decision card rides alongside the work. It is raised for B2 or B3, and the agent keeps working the rest of the list while the card waits for an answer.
• The doctrine loads with the file. Rules attach to path globs. Touching a compose file loads the deploy rules; touching a checker loads the checker rules. Intent survives a prompt typed at speed with the typos left in.

The discipline in one line: act on what the person meant, with the person's own tolerance for reversible risk, and stop where the person would have stopped.

Engineering for outcomes

These apply to every check we write. They are what turns a comment into a gate.

• Three exit codes. 0 clean, 1 violation, 2 could-not-judge. A probe always returns a verdict, and "I could not tell" is its own loud state.
• A detectable defect becomes a check. If a static check can see it, the check is the fix, and the class stays closed for good.
• Every check has a self-test that proves it can still fail. You have watched it go red, so you can trust it when it is green.
• Every check runs unattended. One line in a lane file: static in CI, live against the fleet, or live against the host.
• A deploy claim answers five planes. Published: reachable where people look. Documented: a stranger can read the truth. Integrated: composed with its peers. Live: the running artifact is byte-verified against source. Guarded: someone is paged when it regresses. Five pieces of evidence make "shipped" a fact.
• Improvement claims go through a blind gauntlet. Capture a baseline, change one thing, recapture, and let a judge who sees neither the diff nor the labels pick the better side.
• Facts about the fleet are measured. Which containers bake a library and which bind-mount it is a command's output, and the operating doc is generated from that output, so the doc and the fleet always agree.

The lanes, as of tonight: 470 checks run statically in CI, 134 live against the fleet, 267 live against the host. 104 entries carry a declared known-fail with a written reason, and we count those as an asset: a red gate with a reason is a state you can plan around.

The updated ladder

The eight layers stay, and so does their order: emergence needs governance, and governance needs a harness to constrain. The upgrade is a second column. Every layer keeps its means question from April and gains an outcome question.

The right-hand column turns a map into a grade. A team at layer 2 that answers its outcome questions is in excellent shape, and every layer it adds from there compounds.

What you keep as you climb

The April post ended on a pattern: every layer releases control over the layer below it. Context releases control of prompts, agents release control of context, the harness releases control of dispatch, up to emergence, where you garden instead of build.

Here is the second half of that pattern. What you release, layer by layer, is control over the means. What you keep, all the way up, is the definition of the outcome and the check that proves it. Those two live in the spec and in the checker, and they stay legible to a human at every altitude. Hold them, and you can hand everything else to the agents with confidence.

The mountain is real and worth climbing. Carry the two questions with you: what did they mean, and did it happen. Engineer for intent and outcomes, and let the layers be what they do best, the plumbing that gets you from one to the other.