The work doesn't carry
An LLM can hold a conversation, not a project. Every session cold-starts, so the same thinking has to happen again every time you come back — and the cost of that scales with how old the project is, not with how much work you actually need done.
Same project, cold-start every time
You opened a chat last week and worked something out. You open a new one today and the model has no idea. There is no shared project memory it can read — so holding the state of the project becomes the operator's job, every session, from scratch. You are the context window.
The pattern repeats
Whatever you figured out before, the model figures out again. The same approach, the same architectural choice, the same trade-off — reasoned into existence twice. Or three times. Or every Tuesday. None of it accrues; each session pays full price for ground that was already covered.
Decisions don't propagate
A direction you set in one session doesn't reach the next. You re-explain. You re-justify. You re-decide. The substrate of the project — the why behind each choice — lives in your head, and it leaks a little every chat. Run sessions in parallel and it gets worse: two of them can make contradictory calls on the same file because neither can see what the other decided.
The tax compounds
Long-running projects pay this re-derivation tax on every session. The bill scales with project age, not with the work in front of you. A six-month project spends more of each session re-establishing context than a six-day one — which is exactly backwards from how it should work.
And when you add parallel sessions, the problem multiplies. Two sessions can make contradictory calls on the same file because neither can see what the other decided. Three sessions re-derive the same architectural choice independently. The coordination cost isn't just per-session — it scales with both project age and parallelism.
Note
The fix isn't a bigger context window or a better prompt. It's giving the model somewhere to stand — a typed, shared memory it reasons on instead of reconstructing.
What it looks like when work carries
When sessions write to the substrate instead of to chat, the work accumulates. Every decision, directive, and implementation becomes a permanent, typed entry readable by every future session — including sessions running in parallel right now.
Entries from real sessions, written to the substrate in real time — accessible to every parallel session instantly. This is what coordination without re-derivation looks like.
Next: Substrate
The answer to a problem of statelessness is a layer that isn't stateless. What the substrate is →