Statelessness

The default mental model is wrong, and designs inherit the error. People treat the agent as a stateful colleague: it read the file earlier, so it "knows" it; this turn builds on the last one inside the model; sending ten words costs ten words. Every one of those beliefs is false, and each quietly corrupts a design decision — what to re-send, what to persist, when to repair versus restart, why a long session degrades.

The shock that exposes the error: one message is never one message. Every API call re-ships the entire conversation — system prompt, tool schemas, full history — and the model re-reads all of it from scratch. A ten-word question at turn 30 ships the whole transcript behind it (the session-bill example measures the gap: a ~30k-token visible transcript, a ~680k-token actual bill).

The model is a pure function of the window. The window is the entire state; it is rebuilt, re-shipped, and re-read on every call. Nothing persists inside the model between calls — no memory of the last turn, no accumulated understanding of the session, no experience from yesterday. What looks like memory is residency: the earlier material is still in the window being re-read, not remembered.

Correct the one belief and the rest of the tree follows: continuity is something you construct in the window (or the world), never something the model provides.

The two faces are one coin — you cannot buy the feature without paying the cost. Re-shipping everything every turn is the price; disposable, reproducible, restartable actors are what it buys. Designs go wrong by seeing only one face: cost-only thinking hoards context and fights restarts (repairing in place to "save" the session); feature-only thinking fans out dispatches while ignoring the multiplier on every resident token. The tree's context-engineering family manages the cost face; the verification family spends the feature face.

(Concept/substrate — a fact to internalize, not a move to make.) Nothing here prescribes a design step: the node states a property and corrects the belief that hides it.

What it does not hold is the consequences themselves. This node owns the property, the wrong mental model it corrects, and the map — each consequence is taught by the node that owns it, and the price arithmetic the cost face generates is The Context Economy's, not this node's.

One property, two faces, and two nodes that make it survivable. This node owns the map; each consequence lives where it's taught:

• The cost face — re-shipping is a per-turn multiplier on every resident token; the whole price arithmetic derives from it. → The Context Economy (Statelessness — the first principle the arithmetic derives from), measured in its The Session Bill example.
• The feature face — a pure function of the window has no hidden state to lose, so discarding a bad run is cheaper than repairing it: re-dispatch, fresh-context resets, and parallel fan-out are all free moves. → The Contract Keystone (recovery role), validate at the return seam; re-dispatch over repair; bounded autonomy — the contract keystone, applied (the applied form), Momentum (fresh dispatch = zero momentum).
• The precondition — discard-is-free only holds if the run didn't change the world; effects must be pure, idempotent, or isolated. → Effect Discipline.
• The survivability move — state the dispatch can't hold lives in the world instead: config, durable state, the shared workspace. → accumulated memory, a separate concern from config, episodic skills with persisted, context-specific behavior — incl. the free idempotent setup optimization.

One empirical claim, and it is measured rather than asserted here: the gap between what a turn looks like and what it bills is read off the The Session Bill example, itself stable. The rest is substrate — the consequence map is the proof, and each arrow is checkable at the node it points to. No example is manufactured for this node.

• Parent: Foundations — sibling of the other taken-for-granted pillars, Effect Discipline and Verification Asymmetry.
• Consumed by (the five dependents that motivated hoisting this to foundations): The Context Economy, Momentum, The Contract Keystone / validate at the return seam; re-dispatch over repair; bounded autonomy — the contract keystone, applied, accumulated memory, a separate concern from config, Deferred Context (deferral exists because frontloaded tokens get re-billed).
• Canonical definition: GLOSSARY → Statelessness.

The pure function, and stateless protocol design (HTTP, and REST's statelessness constraint): nothing is carried between calls, so every request must arrive complete. The window is the request.