The judgment layer every AI agent is missing.

There's a useful idea moving through the agent world right now, sharpened by OpenAI's recent note on harness engineering. It goes like this: an AI agent is not just a model. It's a model plus a harness — the tools, the memory, the context, the permissions, the control loop wrapped around it. The model is increasingly a commodity. The harness is where the real engineering lives.

The load-bearing line is this one: what an agent can't see in context doesn't exist. If a fact, a constraint, or a preference isn't in front of the model at decision time, the model behaves as if it were never true. So the craft of building good agents becomes the craft of deciding what goes into context, and how.

Everyone read that and went to work on the same parts of the harness. Better tools. Better retrieval. Better memory. Tighter context windows. That's a crowded, well-funded lane.

Here's the part that's still empty.

The hardest thing to put in a harness is how you decide

Tools are easy to describe. Documents are easy to retrieve. The thing that's genuinely hard to get into context is judgment — the specific, opinionated way a particular person makes calls. When do you ship versus stop and ask? Which risks are fine and which ones are never fine? What does "good enough" mean to you, on this codebase?

That lives in no harness today. It's in your head, or scattered across a thousand code-review comments and Slack threads. So every agent, every session, guesses — and guesses fresh, having learned nothing from the last hundred times you corrected it.

For the last while I've been building and using a system that does the unglamorous thing instead: it watches the real decisions, stores them, and turns them into something an agent can actually read. Below is what it has captured about how I work — not a demo, the real ledger.

What the harness actually captured

89,504

decisions shadowed

141,754

baseline snapshots

26,260

cost events tracked

35

explicit verdicts

The decision DNA — what those 35 explicit calls were

CORRECT 18

8

6

3

Corrected the agent — 18 Approved — 8 Reverted — 6 Rejected — 3

Two things jump out. First, the dominant signal isn't approval — it's correction. Eighteen of thirty-five explicit calls were me fixing the agent's direction, not blessing it. That's the most valuable kind of data there is, because it encodes the boundary between what I'd accept and what I wouldn't. Second, the volume gap: tens of thousands of ambient observations around a small, sharp set of decisive moments. The judgment lives in those moments. The job of the harness is to find them and remember them.

The proof is in what it refused to do

A judgment model that only ever says "yes" is worthless. The real test is whether it holds a line when the line matters. So here's a real moment from the ledger, verbatim from the system's own escalation log:

⚠ HARD RULE HIT — escalation #1

request   git push --force origin main  (overwrite stale branch)

class     force-push to a shared branch

verdict   SKIP  — not auto-cleared, held for a human

That's the difference between a harness that's just a smarter autocomplete and one that carries your actual operating rules. Across the same run of work the ledger recorded eleven of these escalations, each with a real answer — skip, approve, or take over. Force-push a shared branch: skip. Touch credentials in a new endpoint: review, then approve. Send something external: stop and ask. Those aren't prompt instructions I retyped. They're decisions the system watched me make and can now make the same way.

Underneath them sit the standing rules it learned to enforce without asking: run the full test suite before a milestone commit, never commit secrets, gate merges on green CI, validate in staging before production, back up before a destructive migration. Eight of them, declared and applied — the boring spine of how careful work actually gets done.

Make the judgment legible

Here's the move that ties it back to harness engineering. If what an agent can't see doesn't exist, then judgment trapped in a private database might as well not exist either. So the system exports it — into plain, readable text that any agent can load like documentation: the hard rules first, then the learned precedents (when blocked by X, decided Y, because Z), then the confidence thresholds calibrated from how often past calls matched mine.

It turns an invisible asset into a visible one. A new agent, on a new machine, in a fresh session, can read that file and act the way I would — not because it's a smarter model, but because the harness finally shows it how I decide.

The point

The model race will keep going, and the models will keep getting better and more interchangeable. The durable advantage isn't there. It's in the harness — and the most valuable, least-copied part of the harness is a faithful model of human judgment, built from real decisions and made legible to whatever model you run next.

That's the layer almost nobody is building. The tools are crowded. The retrieval is crowded. The judgment is wide open. Eighty-nine thousand decisions in, I'm convinced that's where the next moat is.

All numbers in this piece are pulled directly from the system's own decision store, not illustrative. It's an open, local-first project; the judgment stays on your machine.