James Wiesebron Intentional agentic work · Attention

Attention is all you need (to protect)

Human attention is the scarcest resource in AI-assisted work. AI output can spend it or save it, and people can only choose where to spend it once they trust what the agent did.

James Wiesebron · October 2026 · Examples from an AI code reviewer I built and ran in production, and from my personal research systems

The first week an AI code reviewer I built ran on real pull requests, it caught real problems, including a compile break across packages. It also left one PR seven non-blocking comments on a single push and five more two days later. The team that owned that repo turned it off.

The findings held up. What the reviewer got wrong was how much of people's attention it spent.

Every AI tool makes that trade. It can take load off people or add to it, and accuracy alone doesn't decide which. That depends on how carefully the tool spends attention, and on whether people trust its work enough to stop checking all of it. The second is what I mean by runtime alignment, keeping an agent doing what you intended while it runs, with evidence you can check.

The same trade shows up whenever AI reviews or produces work for people. An assistant that flags every possible issue in a contract, drafts dozens of support replies, or summarizes a week of research can bury the one thing a person needed to see. I've seen it most clearly in developer tooling, so that's where the examples here come from.

Every output spends attention

A comment, a summary, a notification, a request for approval. Each one asks a person to read, decide and maybe act, and each one costs something even when it's right.

The fix is attention triage. For every output, decide whether it needs a person now, later, or never, and route it there. In the reviewer, blocking findings always post. Other findings are ranked, only a few post inline, and the rest go into a collapsed section. Nitpicks never post inline, and fixes run only when the author asks for one.

Whatever does reach a person should be short. Each comment became two layers: a sentence or two written for a person, with the model's full reasoning collapsed underneath for any agent that picks up the work. The first fixes shipped within about a day and the rest over the next few weeks.

Nowblocking · auth check missingquestion · edge case
Latersuggestion · test coverage▸ 3 more, collapsed
Nevernitpicks droppedfixes on request
review comment · illustration

issue (blocking): this endpoint skips the permission check the others run.

Context for agentsThe full reasoning, evidence and suggested fix, collapsed.

Illustration, not measured data.

Too many comments teach people to skim, so they miss the feedback that matters.

Supervision is the hidden cost

The other way AI spends attention is quieter. If you can't tell whether an agent stayed within what you asked, you check everything it did. At that point delegation saves you nothing, because you've traded doing the work for re-reading it.

What changes that is evidence you can check quickly. The work arrives with what was done, how it was validated, anything that departs from what was agreed, and what's still uncertain. Decisions that belong to you arrive as decisions, with the options, a recommendation and the evidence, while everything else the agent is allowed to do keeps moving. Your attention goes to judgment instead of reconstruction.

In my research systems, an agent that wants to report there's nothing for a person to decide has to list the questions it considered and say why each one isn't theirs. That list is what gets confirmed, so the person checks specific reasoning instead of waving through a paragraph. Give agents a contract goes into how that works.

Output with no evidence
Agent output→Re-read everything→Re-run the checks→Decide
Output with evidence attached
Agent output→What ran, what's uncertain→Decide what's yours

Illustration.

Trust has to be earned while the agent runs

Trust that actually saves attention can't come from a good prompt or a good model alone. It comes from structure around the model, checked while the work happens. Start with intent written down somewhere the agent can't rewrite.

Then check each handoff against it: the plan against the original request, the implementation against the plan with no unexpected additions, and the docs against the implementation. Agents wrote the reviewer's code, checks like these ran at every handoff, and I read the sensitive parts myself.

Enforce limits outside the prompt. The reviewer's agents held no credentials. They read what the pipeline gave them and wrote results back, and the pipeline did the posting. Opening a PR, merging it and rolling it out are separate permissions, and handing work to another agent shouldn't widen them. Stop telling agents what not to do has more on this.

And put required steps in code. The reviewer's orchestrating model was told to dispatch its specialist reviewers before posting. In a seeded trial, all five runs posted a review that looked fine, and two of them had skipped dispatch and written the review themselves. Dispatch moved into code, the model kept the judgment calls, and the orchestrator went from about 80 percent of a review's cost to about a quarter.

Intentwritten down
✓checked against
agents · no credentials
Plan
✓checked against
Code
✓checked against
Docs
review posteddispatched
review posteddispatched
review posteddispatched

Check the checkers

Trust in the measurements matters as much as trust in the agent. In one of the reviewer's evals, a case looked flaky, so I read all 28 runs.

The reviewer had found the defect every time. The scorer only accepted one source location. Fixing the scorer changed the numbers without changing the reviewer. A broken scorer looks just like a weak model, and an evaluator you just changed can't be the only evidence that its change helped.

Monitors need the same treatment. One of the first monitors in my research systems ran a model over everything it saw and produced a stream of false alarms that people learned to ignore. Once people learn to ignore a monitor, they ignore the real alarm too. Measure the system, not just the model covers how to test the watchers.

28 runs, scored as missed28 runs, defect found every time

The scorer was wrong, not the reviewer

Carry the follow-through

A correct finding still leaves someone to interpret it, make the fix, and check that it worked. A tool that stops at the finding has handed most of the job back to a person.

The reviewer's first step was small. An author could reply "ship" on a comment, and an agent would make that one fix. The fuller version, which I'd build toward, routes findings to a fixing agent, sends the result to independent review so the fixer can't declare its own work done, and checks after deploy whether the fix actually worked. A result nobody could verify goes back to triage instead of counting as done because a PR merged.

Feedback deserves the same treatment. A pipeline read every reply to the reviewer's comments, decided whether it pointed at a real problem, and opened or updated a ticket, so engineers never had to file anything.

Give shared tools an owner

Most internal AI tooling starts as somebody's side project and ends up maintained in their spare time. Regressions sit, people stop trusting the tool, and they go back to checking everything themselves.

Shared tools need an owner who keeps them working, tracks what they cost, and decides what to keep, change or stop based on feedback and evidence. That owner should also prefer existing tools when they meet the need, and accept that a fix without AI is sometimes the right answer. The evidence that counts is whether other teams keep using it.