Agent statelessness makes routing architectural, not learned

Type: note · Status: seedling

A human developer who works in a knowledge base gradually builds intuition: "for this kind of task, look here." They learn which wiki page covers authentication, which convention governs naming, which template fits a design note. Eventually they navigate without conscious effort.

An LLM agent never does this. Each session starts cold. It cannot learn "last time I needed the structured-claim template, I found it in notes/types/." It cannot develop a hunch that a relevant skill might exist. Every session is day one.

This means every mechanism that directs the agent to the right knowledge at the right time — routing tables, skill descriptions, type templates, naming conventions, directory structure, activation triggers, area indexes — is permanent architecture. For a human, these are conveniences you outgrow. For an agent, they're prosthetics you never stop needing. The methodology enforcement as stabilisation note describes practices hardening from instruction → skill → hook → script. The practices mature. The agent stays exactly as raw as it was on day one.

Progressive disclosure replaces navigation intuition

A human holds an approximate mental model of the whole knowledge base. An agent can only hold what's loaded. Since context efficiency is the central design concern, you can't load everything — so you must route to the right layer at the right time. In this KB, the loading hierarchy is our concrete progressive disclosure system:

  1. CLAUDE.md loads unconditionally — the agent always knows where to route
  2. Skill descriptions load cheaply — the agent decides whether to load the full skill
  3. Skill bodies load on activation — imperative instructions for the current task
  4. Type templates load per directory — structural guidance matching the destination
  5. Methodology notes load on demand — deep reasoning for edge cases

Each layer filters what the agent needs to consider, and each layer must route correctly to the next. A gap at any level creates unreachable knowledge.

The degradation cliff

When a human encounters a situation their routing aids don't cover, they reason from experience — slower, less confident, but adequate. They notice "something feels off" and search more broadly.

An agent has no equivalent signal. When its loaded context doesn't cover a situation, it falls back on training — which may have no relationship to the KB's methodology. It doesn't degrade into "the same agent, but less certain." It degrades into a different system — a generic LLM rather than a KB-augmented one. The human system degrades along a continuum: expert → competent → novice → uncertain. The agent system has a cliff: KB-augmented → generic.

This makes every omission in routing infrastructure dangerous. A routing table missing an entry means the agent doesn't know the destination exists. A skill omitting edge-case reasoning produces confident execution with systematic errors. A naming convention not followed makes the note unfindable. The agent executes confidently within whatever scope is loaded, unaware of what wasn't routed to it.

Source vs. compiled

Methodology notes are source code. Skills, routing tables, type templates, and naming conventions are compiled artifacts. You maintain the source (read methodology when revising routing); you ship the binary (load routing artifacts at runtime). The context loading strategy says "match instruction specificity to loading frequency." Agent statelessness explains why this is load-bearing: the agent cannot compensate for missing specificity by drawing on remembered methodology. If the specific routing isn't loaded, it doesn't exist.

The two genres have structurally different quality criteria. Source can be exploratory, tentative, argumentative — it's for reasoning. Compiled artifacts must be imperative, complete, unambiguous — they're for execution. This follows from the consumer difference: the methodology reader has rich context and time to deliberate; the routing consumer has limited context and must act. The agent isn't a learner; it's a runtime. The KB isn't a curriculum; it's a deployment environment. For why pedagogical metaphors mislead — and why ignoring human traditions entirely is equally wrong — see human-LLM differences are load-bearing for knowledge system design.

Design consequences

Routing infrastructure needs the same engineering discipline as production code — versioned, tested, reviewed. Routing maintenance needs a staleness mechanism: when methodology changes, routing artifacts derived from it silently drift, and the agent has no "that doesn't seem right" intuition to catch it. And all routing artifacts must be behaviourally complete within their scope — including enough reasoning for edge cases and explicit boundaries so the agent recognizes when it's outside scope.

Future architectures with persistent memory across sessions would weaken the statelessness argument — an agent that remembers where it found things last time is closer to a human navigator. But any memory system has limits, and routing scales with the knowledge base itself. Knowing where to look is as big a problem as the knowledge it points to.

Relevant Notes:

Topics: