Say Hi. Hello. Damn, Good Model. *Used 20% Context*

Level 1: The Exhausting Small Talk

Imagine asking a friend "say hi," and to answer, she first has to re-read every letter you've ever exchanged, your entire rulebook for how she's allowed to speak, and a manual for every favor you might possibly ask — just to send back one word: "Hello." You're delighted: what a great friend! She's face-down on her pillow, exhausted. The joke is that one side of the conversation sees a tiny effortless exchange, while the other side did a mountain of invisible homework to make it look effortless — and only one of them is smiling at their phone.

Level 2: What "Context" Actually Means

Key terms behind the punchline:

• Context window — the maximum amount of text (measured in tokens) an LLM can "see" at once: your messages, its replies, and a lot of hidden setup. Think of it as the model's working memory for the conversation.
• Token — the unit text is chopped into; roughly ¾ of a word in English. "Hello" is one token. The instructions wrapped around it can be 20,000+.
• System prompt — invisible instructions injected before your first message ("You are a helpful assistant…", rules, tool descriptions). You never see it, but it occupies context on every turn.
• Statelessness — the model retains nothing between messages. The entire chat history is re-sent each time, which is why long conversations get slower, costlier, and eventually hit a wall.

First encounter with this in the wild usually goes: you build a chatbot, demo it with "hi," check the usage dashboard, and discover your greeting cost more tokens than your README. That's the moment junior engineers learn that in AI/ML systems, the prompt around the conversation is the heavyweight, and "the model said hello nicely" tells you nothing about whether it can survive a real workload.

Level 3: The Hidden Cost of Hello

The four-panel "couple texting in bed" comic maps with eerie precision onto the modern LLM interaction loop. The boy types "Say Hi". The girl — playing the model — answers "Hello". He beams at his phone: "Damn this is a good model." And in the final panel she lies there visibly drained, side-eyeing her screen: Used 20% context.

What lands for anyone who runs agentic tooling is that the 20% figure is barely an exaggeration. The user typed two words; the model received a small novel. Before any greeting happens, the context window has already absorbed: a multi-thousand-token system prompt, full JSON schemas for every tool the model might conceivably call, safety scaffolding, project conventions, memory files, repo maps, and — in reasoning models — a budget reserved for thinking tokens the user never sees. The visible conversation is the tip; the iceberg is configuration. A Hello that costs tens of thousands of tokens isn't a bug, it's the architecture: transformers are stateless, so every single turn re-sends and re-processes the entire accumulated context. The girl isn't tired because the message was hard; she's tired because she had to re-read the whole relationship to answer it.

The boy's panel skewers a second industry truth: benchmarking by vibes. He evaluated the model on one trivial exchange and declared it good — which is, give or take, how most model comparisons happen on social media. Latency felt snappy, the greeting was polite, ship it. Meanwhile the real cost metrics (tokens burned, context fraction consumed, dollars per interaction) are invisible to him and painfully visible to her. It's the same asymmetry as any infrastructure: the user experiences the response; ops experiences the bill. Every developer who has watched an agent torch half its context window reading files it already read — then compact, forget, and read them again — recognizes panel four as a self-portrait.

There's also a quiet economic joke. Context isn't just memory, it's budget: once it's spent, quality degrades, earlier instructions fall out of effective attention, and the session needs summarization surgery. Spending 20% of that nonrenewable resource on pleasantries is the conversational equivalent of a microservice whose health check allocates 2 GB.