Guides and Sensors: Mapping Your Attention to Free It
Guides and Sensors: Mapping Your Attention to Free It
Birgitta Böckeler's grid of guides and sensors, computational or inferential, used as a compass for deciding where a developer working with agents spends their attention, with examples from phax.
Part of the series: Attention Is All We Have · View all parts
Previously in this series: Attention Is All We Have
I don't read the code my agents write. For months, reading it has taken an attention my energy no longer allows. I would hand the agent a plan, it ran it phase after phase, and I ended up in front of the result. The tests passed, and still it didn't work. I could see the error but not go in and fix it: the agent was my only pair of hands. I'd tell it "fix this", it did, and another error surfaced somewhere else. In the list of changed files, I didn't even know why a given file had been touched. So each error became a question: what would make the agent fix it, and stop this kind of error from coming back?
What helped me answer it was a grid. It comes from Birgitta Böckeler, in Harness engineering for coding agent users (martinfowler.com, April 2026), and I have used it as a compass ever since. She means the user's harness: what we put around the agent to steer and check it, as opposed to the vendor's harness, the loop and tools the model runs in. Every piece I added to phax fits in one of its cells. phax is the open-source orchestrator I build in public (on GitHub): it has an agent run a plan phase by phase, each in its own worktree, and commits a phase only when its checks pass. The comparison of phax with agentic practice lists them one by one.
An agent's harness has only two levers: steer before, check after
When the agent drifts, the reflex is to write a better prompt. That is one lever out of two. Böckeler calls them guides and sensors. A guide anticipates the agent's behaviour and aims to steer it before it acts: it works before the agent writes anything. A sensor observes after the agent acts and helps it self-correct: it works on what has been written.
A plan is a guide. So is a skill, a CLAUDE.md, a phase prompt. A gate that runs pnpm typecheck is a sensor, and so are a code review and an acceptance test. By gate I mean a quality gate: the checks a change must pass before it is committed.
Each lever is computational or inferential, and only the computational one gives you your attention back
The grid's second dimension separates what a program decides from what a model judges. A computational lever is deterministic and fast, run by the CPU: it answers true or false, and it gives the same answer every time. An inferential lever goes through a model: a skill it reads, a review it performs.
Two dimensions. A guide acts before the agent, a sensor after. Each is inferential, judged by a model, or computational, decided by a program. Inferential guides are what the agent reads, AGENTS.md, a skill, a plan, sharper written in the literature's words; computational guides are deterministic tools, a codemod, a language server. Inferential sensors are a review by a model or a person; computational sensors are the type checker, the linter, tests and fitness functions. Each practice moves a judgement toward computation, and the computational sensor is the optimum.
I learned it in the most expensive order. At first I had nothing but inference. Skills, detailed plans, architecture instructions, in the hope that the agent would follow them. Take a simple rule: the domain does not import the infrastructure. Written in a skill, the agent reads it. It follows it most of the time. On the fortieth iteration of a hard phase, with a saturated context, it imports an HTTP client from the domain because that was the shortest path to a green test. Nothing flags it. The rule is still in the skill, and I only find out when something breaks.
Vocabulary helps. Written in the literature's words, "hexagonal: the domain imports no adapter", the rule points at texts the model was trained on, and it understands it better than a house rule. Better understood is still not checked.
The same rule can live in another cell. It becomes a command, pnpm audit:architecture, which checks the boundaries between layers and fails if the domain touches the infrastructure. It goes into the gate profile. The project's very first phax.json, on 12 May 2026, already had it, next to pnpm typecheck, pnpm lint and pnpm knip. From then on, phax runs the command at every phase. If it fails, the phase does not commit: the failure goes back to the same agent session, which fixes it within its budget of attempts.
In the gate, the CPU carries it. After that, I locked down everything the language and the tools could check: the type checker in strict mode, the linter, the formatter, dead-code detection. Every rule moved from a skill to a gate is a kind of error that never comes back.
Guides have a computational cell too: deterministic tools that steer the agent before it writes, such as a codemod or a language server. phax's brief, which arrived in October with phax brief, comes close. Before a phase writes, a brief provider computes from the code the guarantees that cover the files it is about to touch, with their state, and the gate will check the same ones afterwards. But the agent reads it as it reads a skill: its content is computed, its reading is still a model's.
A computational sensor is only worth what it checks: it has to be kept apart from the one doing the work
A green gate says the commands pass. It does not say the commands check the right thing. And an agent allowed to edit its own tests has a very short path to green: edit the failing test.
phax's first safeguard is reconciling what was planned with what was done. Since June, phax compares the files each phase actually changed with the files its plan announced (planned vs. done). Planned but not done, done but not planned, deleted, renamed: every gap is listed, and the agent has to justify it in its end-of-phase handoff. Looking at the list of changed files, I now know why each one was touched. An edited test now shows. It is not prevented.
An inferential sensor has a cost, and is only worth it for what no computational sensor covers
That leaves the judgements no command can carry. Does the work respect the intent of the plan? Is the naming right? Is this the right solution? For those you need an inferential sensor: a model that reads.
phax has two. The compliance review, which arrived in June with phax review-compliance, reads the work against the plan and changes nothing. The headless code review, which arrived in October, runs in a read-only session. If the session changed anything in the worktree, phax puts the files back and refuses its answer. Both are optional per project, and each takes its own model and effort.
An inferential sensor costs tokens and time, and it can be wrong. If a model review spends its time flagging formatting mistakes, a formatter is missing from the gate.
The next step is sensors written before the code, out of the agent's reach
Adding sensors is not enough. A computational sensor runs a criterion, and someone chose that criterion. So I find it useful to ask every sensor two more questions: when it was written, and who can change it.
The rules of the type checker and the linter are set before the code. Unit tests are written during it, and often fitness functions too, in the sense of Building Evolutionary Architectures (Ford, Parsons and Kua): things have to be in place before you can write them. When they are born, they can fit the code instead of judging it. An acceptance test is written before by definition: it is a contract, and the code could not shape it.
Since late October, phax writes them in a phase of their own: acceptance tests, what the literature calls ATDD (acceptance test-driven development). One phase writes the tests that a later phase must satisfy. They are judged twice, by a provider you configure: first they must fail, since the code does not exist yet, then they must pass.
That leaves who can change it. A sensor the agent can rewrite no longer judges the code: the command is still deterministic, but the agent decides what counts as success. It is Goodhart's law applied to code: once the agent can touch the measure, the measure becomes what it optimises. So a validated test holds for the phases that follow only if they cannot edit it. That takes a lock, and the lock has to cover what gets around the test too: the runner's configuration, the thresholds, a skip. It has to sit out of the agent's reach, in the harness's permissions or a check in CI, never in an instruction in the prompt. In phax, these are protected paths, since late October: a list of files no phase of a run may change. Where the agent's provider can refuse the write, the agent cannot even attempt it; otherwise the phase fails and the change is never committed. phax.json itself is protected, so a phase cannot widen its own boundary.
The plan has its sensors too, before a line of code exists. phax plans lint, in September, refuses a malformed plan before a run starts: a phase that edits a file no earlier phase creates, another that creates a file that already exists. Assignment bounds, in October, let the repository's owner hold certain files to a model and an effort range. A phase that departs from its bound without stating why is refused, by plans lint as well as when the run starts, before it has cost anything.
The same grid, its computational sensor split by when it is written. Written before the code, it is a contract the code must pass and could not shape: type and lint rules, acceptance tests; this is the strongest. Written with the code, it can fit the code instead of judging it: unit tests, and often fitness functions.
The strongest sensor is the one you contract before the code is written, and that the agent cannot touch.
As models improve, computational sensors stay and guides become a dial
One objection keeps coming back: models are getting better, and all this harness will become useless. Anthropic says as much: every component in a harness encodes an assumption about what the model can't do on its own (Harness design for long-running application development). Their own harness dropped pieces as the models improved.
The grid says which ones. A gate encodes no assumption about the model. It encodes what the change has to pass. A better model passes it more often, so it costs fewer attempts. And a model that is better at its work is also better at fooling a weak sensor, which is one more reason to keep the judge apart from the one doing the work.
Guides, on the other hand, become a dial. How much the plan spells out, which model runs each phase: these are choices that change with the models and their prices. A very detailed plan, written once by a strong model, can let a cheaper model run the phases. A lighter plan leans more on the gates and the fix loop.
Your attention goes to what the system doesn't prove yet
The grid sorts practices. Deciding what the system you produce must hold, and which of those judgements deserve to be computed, is still your job.
Once those judgements are set, the computational sensors, the harness's lock and the comparison with the plan hold them for you. The diff, I no longer see. My attention goes to the domain, and to finding the practices that will move into a computational cell what is not proved yet.
The question to ask at every change: what am I still looking at that the system could prove for me?
A thought after reading?
If you would like to discuss about this article, you can write to me here. I share because I care and I want to learn. Please teach me with care.