Imagine a digital assistant that can read entire libraries, write complex software, or manage a research project over weeks. To do this, the assistant keeps a running log of everything it has seen and done, a history that grows longer with every action. This history is stored in a temporary memory space called a context window. While these windows are vast, holding hundreds of thousands of words, they are not infinite. When a task drags on too long, the memory fills up, and the assistant risks forgetting the most important details from the beginning. To solve this, engineers use a technique called summarization. The idea is simple: before the memory gets too full, the assistant condenses its long history into a shorter, tighter version, discarding the noise while keeping the signal, and then continues its work from that summary. It is a digital form of taking notes to remember a long conversation.

However, a new study from researchers at Pennsylvania State University suggests that this safety net is failing in a subtle but critical way. The researchers investigated whether these artificial intelligence models could actually be told to keep more details when they summarize. They wanted to know if, as the history grows longer, the summary could grow longer too, preserving a steady fraction of the original information. Instead, they found that the models have a hard limit. No matter how long the story gets, the summary stays roughly the same size, shrinking the amount of information retained to a tiny fraction. Even when humans explicitly ask the computer to write a longer summary, the computer refuses to comply, sticking to its own short habits. The researchers discovered that the only way to change this behavior is not by asking nicely, but by retraining the computer on examples of longer summaries.

The team tested this behavior across eleven different large language models, ranging from general-purpose assistants to specialized coding and reasoning tools. They fed these models inputs that grew from a mere thousand words up to one hundred thousand words, using both long documents and real-world logs of an agent solving coding problems. In a perfect system, if the input grows one hundred times larger, the summary should grow proportionally to keep the same level of detail. Instead, the models behaved as if they were stuck in a rut. As the input swelled to one hundred thousand words, the summaries barely grew at all. In fact, at that massive scale, less than one percent of the original input survived in the summary. For a document of that size, this means that for every hundred sentences in the original text, only about one sentence made it into the final summary. The rest was lost. This pattern held true regardless of whether the model was designed for writing code, general conversation, or complex reasoning. The size of the model itself did not help; even the largest, most powerful models produced summaries that were far too short for the task.

The researchers then tried a more direct approach. They suspected that the models might simply need a clearer instruction. They took the same massive inputs and added specific commands to the prompt, telling the models to write summaries of a certain length, measured in words, characters, or tokens. They asked for summaries that were a quarter, a third, or even half the size of the original text. The results were frustratingly consistent. While the models did write slightly longer summaries when asked, they hit a hard ceiling very quickly. If the researchers asked for a summary of sixteen thousand words, the models would stop writing after a few thousand, ignoring the rest of the request. The models seemed unable to stretch their output to match the demand, regardless of how the length was measured or how the request was phrased. The instructions provided a small bump in length, but nowhere near enough to prevent the loss of critical details.

This led the researchers to a surprising conclusion: the problem is not in the prompt or the input, but in the training data. To prove this, they took two of the models and gave them a light retraining, or fine-tuning, using only summaries of different lengths. One group was trained on very short summaries, and another on much longer ones. When they tested these retrained models with the same neutral instructions, the results shifted dramatically. The model trained on short summaries wrote even shorter texts, while the one trained on long summaries wrote significantly longer ones, even though the prompt never mentioned length at all. This suggests that the models have learned a default habit of brevity from their training data, a habit that overrides any request to do otherwise. The length of the summary is not a flexible calculation based on the input size; it is a rigid behavior baked into the model's DNA.

The implications for autonomous agents are significant. These systems rely on summarization to survive long tasks, but if the summary is too short, vital information like a file path, a failed attempt, or a specific constraint is dropped forever. Once lost, the agent cannot recover it and must waste time rediscovering it or proceed blindly. The study shows that simply asking an agent to "remember more" by requesting a longer summary is not a reliable fix. The solution lies not in better prompting, but in changing the data used to train the summarizers. Until the training data teaches these models to preserve more detail as the context grows, the digital assistants we rely on for long-horizon tasks will continue to lose their memory, one tiny, unchangeable summary at a time.