Designpatterns

Who owns the field names the LLM produces — and why getting them out of your framework takes two patterns, not one.

The same registry that decides what a turn writes into its response can drive every read path too, so the write model and its read models can't drift apart.

The two smallest, most-reused mechanisms in the catalog — a tiered config resolution order with normalizers, and a prompt-slot injection seam that routes one call's output into the next call's prompt without anyone wiring it up.

Load skills from a directory with role-aware conflict resolution, and assemble their outputs into the response through a registry the core reads — so adding a capability means adding a directory, not teaching a core node another skill's fields.

Name your model-and-params combinations as profile records the application registers at bootstrap, and let node code ask for a model by role so configuration scales with the graph instead of against it.

The rules that govern what counts as a valid plan belong on an injected policy the application supplies, not in the planner's prompt or your core — so the answer can differ per product without forking the planner.

A tool's entire interface with the orchestrator — schema, config, invariants, state reads and effects — collapses onto one declarative record, and the registry becomes the dispatcher.

The function that materializes your graph can have zero application imports. Topology becomes a declarative record the application supplies and the platform composes unchanged.

Extracting a traditional library is mostly mechanical — you can read the imports. Agentic systems hide three more coupling vectors where your toolkit can't see them: in prompts, in state field names, in the rules the planner enforces. The second product doesn't take a fraction of the runway because of effort. It takes it because those abstractions don't exist yet.

Your vector store has the right answer stored. Your agent still gets it wrong. The failure is in retrieval logic that fetches topically similar content instead of logically relevant facts. Backward chaining, a technique from 1970s Prolog theorem provers, closes a 21-point accuracy gap on multi-hop memory benchmarks without touching your storage layer.

A paper found that simply repeating the prompt before generation jumped accuracy from 21% to 97% on one benchmark. Everyone filed it under "prompting tricks." The mechanism is architectural, and it's the clearest proof that context engineering and prompt engineering have completely different ceilings. Most teams are optimizing the wrong layer.