The agentic layer

In June I wrote down a position I was confident about: recognition stays deterministic; a router, not an agent. Hand-written rules, tie-breaks in the prompt, a fixed cascade of questions. Predictable, cheap, testable.

In August I reversed it. This page is why, and what I kept.

What changed my mind

Two things, one local and one general.

The local one. The rules had become the incident surface. A single sentence in a filing prompt, “one trip is one container”, caused a user’s trip to fragment into four separate containers. The fix was editing that sentence. When your decision logic is prose, your bugs are prose, and your regression tests are prose about prose. I was maintaining a rulebook that grew every time reality surprised it, which is the shape of a system that will keep surprising you.

The general one. Hand-written decision logic depreciates with every model release. The tie-breaks you wrote to compensate for last year’s model become this year’s handicap. You are actively instructing a more capable system to be less capable. Meanwhile everything around the decision (state, tools, receipts, gates, budgets, evals) appreciates: it gets more valuable as models improve, because a better model does more with a better environment. The sharpest public example is Claude Code deleting most of its system prompt for a new model generation and getting better.

So: invest in the environment, not the instructions.

What moved

The rule cascade that decided where a capture goes became an organiser. Instead of a scored shortlist, it now receives the full table of contents of your workspace (every container, its type, its district, its facets, how recently you touched it) plus a bounded tool to read further when something’s genuinely ambiguous. The instructions shrank from a rulebook to a constitution of three principles: bias toward stability, human legibility is the test for any structural change, and do less when unsure.

Build stopped interrogating. It used to walk a fixed one-question-at-a-time cascade over nine hard-coded project kinds, with no idea which project it was working on. Now it gathers context first, does the maximum amount of work it can alone, and comes back once with a draft and a single batch of two-to-four questions about the things neither the workspace nor its own research could answer.

And the five-way classification became plan synthesis: recognition produces a plan of one to three typed steps. The overwhelming majority is still a single “file” step, costing exactly what the old classification cost. The five modes didn’t get a sixth sibling. They became the rendering vocabulary the steps are drawn in.

What did not move

The spine (queues, retries, fallbacks, budgets, entitlement gates, receipts, the privacy walls, the structured-output contracts): none of that changed, and none of it should. What changed is what the model is told and shown, not what happens around the call.

And one rule I’d defend anywhere:

Autonomy is split by reversibility, not by size.

Filing is autonomous, because a misfiled capture is one tap from re-filed. Anything structural (merging two projects, renaming, promoting something to a resource, re-filing in bulk) is propose-only, applied on confirm, capped at one proposal per capture and a handful per day. Splitting a container isn’t even proposable, because over-splitting is the incident this system has already had.

The instinct to gate on size is the wrong one. A small irreversible change is worse than a large reversible one; the question is never “how big is this?” but “what does it cost the user to disagree with it?”

Triggers, and why timing is a design decision

The other thing I got wrong first time: deciding when to think about something is as important as what to think.

Capture time can only ever reason about this thought. Workspace-shape questions (should this be archived, should these two be merged, has this gone quiet) belong on a background cadence, because dormancy is evidence of absence, and a new capture is proof of life. Asking “shall I archive this?” at the exact moment someone adds to it is not just badly timed; it’s using the strongest possible evidence against its own conclusion.