The Desk: Context Windows & Statelessness
The model cannot see your screen, your repo, or yesterday's chat. Only what is on the desk exists, and the desk has edges.
Three mysteries, one explanation:
- Yesterday the model helped you name a function. Today it has no idea what function you mean.
- "Look at my code and fix it" produces generic advice about code it clearly hasn't seen.
- An hour into a long chat, the model starts ignoring an instruction you gave at the start.
The explanation is the context window: the complete text the model can see when producing one reply. That's the system prompt (the app's standing instructions, Module 5), the conversation so far, and your latest message. Nothing else exists. Not your screen, not your files, not your other chats, not yesterday.
This is the intern's desk 🗒️. The intern is brilliant, but they can only work with what is physically on the desk right now. The desk IS the model's entire universe for this one reply.
You type "fix the bug in my code" into a fresh chat, without pasting any code. Why does the model respond with generic debugging advice?
- ANothing on the desk contains your code, so the model can only continue from the words "fix the bug in my code"
- BThe model is trained to withhold specific help until you ask twice
- CIt needs permission to access your files and defaults to generic advice until granted
- DFree-tier models only give generic answers
Now the part that surprises even experienced developers: the API is stateless.
Each API call is a complete, self-contained package. The model keeps nothing between calls. (Some platforms now offer server-side conversation storage, but that is the platform replaying stored history into the context window for you; the model still starts blank every call.) When a chat app feels like it remembers, here is what actually happens:
Call 1: [system prompt] + "My name is Sara" → "Nice to meet you, Sara!"
Call 2: [system prompt] + "My name is Sara"
+ "Nice to meet you, Sara!" + "What's my name?" → "Sara!"The app resent the entire conversation. Every single turn, the whole history is placed back on the desk, and the intern reads it all again from scratch. The "memory" is a mail clerk stapling the full correspondence to every new letter.
Two consequences you now understand for free:
- Long conversations get more expensive per message (you re-bill the whole history as input tokens, every turn).
- Any "memory" feature is just software choosing what to put back on the desk. Which means you can engineer it: that's Module 7's context engineering.
A chatbot correctly uses your name from 30 messages ago. What made that work?
- AThe app resent those 30 messages (or a summary of them) in the context window of the newest API call
- BThe model stored your name in its neural network during message 1
- CThe model's neural network briefly retains recent conversations in short-term memory
- DModels automatically remember anything formatted as a name
The desk has edges. Context windows are measured in tokens, and mid-2026 models commonly offer 200,000-token desks, with some stretching to a million.
200k tokens is roughly a 500-page book, which sounds infinite. It isn't:
- A real production call carries the system prompt + tool definitions + conversation + retrieved documents + your request. It adds up shockingly fast.
- Exceeding the window is a hard API error, not a graceful degradation. The call is rejected; nothing is generated.
- So apps trim before that: usually dropping or summarizing the oldest messages. That instruction you gave an hour ago? It may literally no longer be on the desk. That is your third mystery solved 😌
And one more thing, which becomes a whole lesson in Module 7: a big desk is not a tidy desk. Models pay less reliable attention as the window fills. More context is not automatically better; relevant context is better.
An app naively stuffs a 600,000-token document into a single request to a model with a 200,000-token context window. What happens?
POST /v1/messages
context window: 200,000 tokens
request size: ~600,000 tokens- AThe API rejects the request with an error; no reply is generated
- BThe model reads the first 200,000 tokens and answers from those, silently
- CThe model automatically summarizes the document to make it fit
- DThe request succeeds but is billed at triple rate
Complete the first commandment of context: if you want the model to consider something, it must be on the ____ for THIS call.
No repo access. No yesterday. No screen. Only the ____.- The context window is everything the model sees for one reply: system prompt + conversation history + your message. Nothing outside it exists for the model.
- The API is stateless: apps fake memory by resending the whole conversation (or a summary) every call. Long chats therefore cost more per turn.
- Windows are finite (commonly 200k tokens in mid-2026). Overflow = hard error, so apps trim, and trimmed instructions silently vanish.
- A bigger desk is not a tidier desk: attention gets less reliable as context fills. Relevant beats voluminous.
- Course rule #1: if it should influence the answer, put it on the desk, this call.
That's the free trial's foundation trio done. Next: why the same prompt gives different answers on different runs, and what the temperature dial really does.