The Context Window Is Working Memory. Keep Yours in Plain Text.

An AI's context window is its working memory — the finite space everything you send has to fit inside. The lever most people reach for is a bigger window. The lever that actually pays is curating a small body of plain-text context you own and load by hand. Capacity is not curation.

Redis describes the window plainly: "Think of it as the model's working memory: everything you send in your prompt, any retrieved documents, conversation history, and the response all need to fit within this limit."¹ That single sentence reframes the whole problem.

Working memory is not storage. It is the bench you clear before you start — the few things you hold in front of you while you think. A wider bench does not make you think better. What you choose to put on it does. The skill is not waiting for a larger model. It is deciding, deliberately, what gets loaded and where that context comes from.

What is a context window, and why call it working memory?

A context window is the fixed amount of text an AI can consider at once: its working memory for a single exchange. Redis frames it exactly: everything in your prompt, any retrieved documents, the conversation history, and the answer all share that one limit.¹ Nothing outside the window exists for the model in that moment.

The word "memory" misleads people, so be precise. This is not the model's long-term knowledge, baked in during training, and it is not a saved file on a disk. It is transient: it lasts one turn, then resets.

Think of human working memory: the handful of items you can keep in your head while solving a problem right now, distinct from everything you know and everything you have ever written down. The window is that, for the machine. It is large, but not infinite, and it is the wrong place to dump everything you have.

That distinction matters for what follows. If the window is working memory, then the question is never "how much can I cram in," but "what is the smallest set of things I need in front of the model to get this answer right."

How much can a context window actually hold?

A context window is measured in tokens, not words, and OpenAI's own rule of thumb is the durable one: "1 token ≈ ¾ of a word," and "100 tokens ≈ 75 words."² So a window's size in tokens times three-quarters gives you a rough word ceiling. Large, yes. Unlimited, no.

Two honest caveats before you anchor on any number. First, advertised window sizes drift; vendors raise them constantly, so a figure you memorize today is stale next quarter. That is exactly why the rule of thumb, not a model spec, is the fact worth keeping.

Second, the advertised number is not the working number. Atlan, an enterprise data firm, names the gap directly: a model has a "real performance ceiling, not its advertised limit."³ The capacity a vendor prints on the box is the ceiling of what fits, not the ceiling of what the model uses well. Which raises the question everyone eventually asks.

Does a bigger context window mean better answers?

No. A bigger window holds more; it does not read more carefully. Performance does not scale cleanly with length — past a point, more context makes answers worse, not better. The window's size is a capacity claim. The window's quality of attention is a different thing, and that is the one that decides your answer.

The research is consistent. A 2025 Chroma technical report by Kelly Hong, Anton Troynikov, and Jeff Huber tested models across input lengths and found "model performance varies significantly as input length changes, even on simple tasks."⁴ Their term for it is context rot: models "do not use their context uniformly; instead, their performance grows increasingly unreliable as input length grows."⁵ More fuel, dirtier burn.

Where information sits inside the window matters as much as how much there is. Liu and colleagues, in "Lost in the Middle" (TACL, 2023), found that "performance is often highest when relevant information occurs at the beginning or end of the input context, and significantly degrades when models must access relevant information in the middle of long contexts, even for explicitly long-context models."⁶ Bury the one fact that matters in the middle of a giant paste, and even a model built for long contexts can miss it.

To be fair to the big window: it is not useless. Large windows genuinely help some tasks — summarizing a long document, holding a sprawling conversation. The claim here is narrower and harder to dodge: capacity does not substitute for curation. The studies show degradation with length, not that large windows are bad.

What works instead: curate a small, high-signal context

The move that works is the opposite of "load everything." It is finding the fewest, highest-signal pieces of context that get the job done, and treating the window as a budget you spend, not a bucket you fill. This is the discipline the field now calls context engineering, learned the hard way by people building agents at scale.

Anthropic's engineering team defines the work cleanly: "Context engineering is the art and science of curating what will go into the limited context window from that constantly evolving universe of possible information."⁷ Curating — not accumulating.

The same team states the economics. "Every new token introduced depletes this budget by some amount, increasing the need to carefully curate the tokens available to the LLM,"⁸ they write, concluding that "Context, therefore, must be treated as a finite resource with diminishing marginal returns."⁹ The target they name is the one to internalize: "good context engineering means finding the smallest possible set of high-signal tokens that maximize the likelihood of some desired outcome."¹⁰

Industry practice has converged on the same instinct. Docker's engineering blog, writing on context packing, starts from the constraint — "We can't indefinitely increase the context size" — and describes the standard response: summarize the history and "replace the history with this summary and thus free up space in the context."¹¹ The frontier work is not making the window bigger. It is keeping what goes in it small and clean.

One caveat to hold onto: curation is a lever, not a magic filter. A small, well-chosen context improves what you feed the model. It does not fix the model's own reasoning or stop it from inventing things. You are improving the input, not the engine.

Where should that context come from?

It should come from a small body of notes you own and control — plain text, on your own device, that you can read, edit, and carry between any tool. If you are going to hand-pick a few high-signal pieces, the source has to be something you can pick from. Portable, durable, and yours, not locked inside an app.

This is where the durability argument and the AI argument meet. Steph Ango, CEO of Obsidian, put the durability case in one line: "Apps are ephemeral, but your files have a chance to last."¹² He frames it as a discipline: "File over app is a philosophy: if you want to create digital artifacts that last, they must be files you can control, in formats that are easy to retrieve and read."¹³

Easy to retrieve and read is exactly what a good context source needs to be — by you, and by whatever model you point at it.

A few concrete things worth keeping as owned, loadable context:

• A system prompt in a file. The standing instructions you reuse every session, version-controlled and yours, rather than retyped or trapped in one vendor's settings panel.
• A plain-text glossary. The dozen terms, names, and definitions specific to your work, so the model speaks your vocabulary instead of guessing.
• A short, curated note set. The handful of pages that actually bear on the task, not your entire archive.

Each is small, plain, and portable. Each is something you load into the window on purpose, then take back out. That is the whole discipline: a context you own, loaded by hand, kept lean.

Two boundaries to draw clearly. This is the human-side discipline: what you choose to load and why a small set beats a bigger window. The mechanics of plumbing notes into a model live next door, as does the question of long-term memory; both are linked below.

And this post takes no position on your tool's internal machinery. The context window, tokens, and context rot described here are facts about how LLMs work, the subject you are learning, not a description of any one note app's plumbing.

What to do tomorrow

Start small and deliberate. The shift is from "give the AI more" to "give the AI exactly the right little, from a source I own and can carry between tools." These three moves get you most of the way there:

1. Write your standing context down as plain files. A system prompt, a glossary, the few reference notes you actually reuse: see your AI system prompt belongs in a file and a plain-text glossary your AI can read.
2. Load by hand, not by hose. Paste the two or three notes that bear on the task, placed at the start of the prompt. Resist dumping the whole folder; the middle is where context goes to die.
3. Keep the source portable. Notes you can export and own outlast any single tool, which is the only way a curated context survives the next app you try.

For the step-by-step of wiring notes into a model without a vector database, see markdown notes as AI memory, the how-to companion to this principle. For the persistent, across-session side of the problem, see AI agent memory in plain text; the window is transient working memory, that is the long-term store. And if you do decide to embed at scale, own the vector index next to your files is the companion at the opposite end.

A last note, because curation does not waive judgment: if your context touches medical, legal, or financial matters, a model's answer is not professional advice, however well you curated the input.

Frequently Asked Questions

What is a context window in an LLM?

A context window is the fixed amount of text an AI can consider in a single exchange: its working memory. Redis describes it as "the model's working memory: everything you send in your prompt, any retrieved documents, conversation history, and the response all need to fit within this limit."¹ Anything outside it does not exist for the model.

How much can a context window hold, and how many words is that?

It depends on the window's token size, which vendors keep raising, so anchor on the conversion, not a model spec. OpenAI's rule of thumb is "1 token ≈ ¾ of a word" and "100 tokens ≈ 75 words."² Multiply a window's token count by roughly three-quarters for a ballpark word ceiling. Large, but finite.

Does a bigger context window mean better answers?

Not reliably. Chroma's research found "model performance varies significantly as input length changes, even on simple tasks,"⁴ and that models grow "increasingly unreliable as input length grows."⁵ Liu et al. showed performance "significantly degrades when models must access relevant information in the middle of long contexts."⁶ Capacity is not curation.

Why does my AI give worse answers when I paste in more context?

Two well-documented effects. Chroma calls it context rot: performance "grows increasingly unreliable as input length grows."⁵ And "Lost in the Middle" found that facts buried in the middle get used least; performance is "highest when relevant information occurs at the beginning or end."⁶ More text dilutes attention and hides what matters.

What should I put in an LLM's context window?

The smallest set of high-signal pieces the task actually needs. Anthropic's engineers frame the goal as "finding the smallest possible set of high-signal tokens that maximize the likelihood of some desired outcome."¹⁰ In practice: your standing instructions, a short glossary of your terms, and the two or three notes that bear on the question, placed at the start.

Where should my AI's context come from?

From a small body of notes you own and control — plain text, on your own device, portable across tools. Steph Ango's case for files applies: artifacts that last "must be files you can control, in formats that are easy to retrieve and read."¹³ A source you can read, edit, and carry is curatable. An app-locked one is not.

What is context engineering?

Anthropic defines it as "the art and science of curating what will go into the limited context window from that constantly evolving universe of possible information."⁷ It treats the window as a finite budget rather than a bucket, deciding what earns a place in working memory and what stays out.

A wider bench does not make you a better thinker, and a larger window does not make a model a better reader. The leverage was never in the size of the space — it was always in the small, deliberate set of things you choose to put in front of it. Curate the context you own; keep it in plain text you can carry anywhere, including mnmnote.com.