Even the best agents forget, loop and lose the plan over hundreds of steps

When an AI has to live in a world, not just answer

Most of the talk about LLMs is about writing code, solving problems and holding a conversation. But nearly every test of those abilities has the same shape: the model is handed a task, it answers, and that is the end of it. A real AI agent does not work that way. It has to act step by step, remember, learn as it goes, come back to objects and plans it set aside, keep track of where things are, and stop repeating the same mistake.

That is exactly the sore spot a new paper on AgentOdyssey presses on. The authors offer not one more benchmark but an entire game environment for testing whether AI agents can learn during use rather than just look good on static tests. The results are sobering: even the best agents fall well short of humans.

What AgentOdyssey is and why it exists

AgentOdyssey is a generator of open-ended text games. The agent sees the world as text: where it is, which objects are nearby, which characters are around, what it is carrying, how much health it has, what time it is. Then it picks an action — move to another area, pick up an item, talk to a character, craft something, attack, wait, and so on.

At first glance this looks like an old text adventure. The point runs deeper. The world is built to test five basic abilities, without which a long-lived AI agent gets nowhere:

Working out the next move is not enough. The agent has to figure out how the world works, notice hidden regularities, remember events from hundreds of steps back, and tie all of it into a single plan.

A long trajectory in the game: the agent explores the world, remembers events, learns the rules, and links it all into a long chain of actions.

Why does this matter? Because most familiar LLM evaluations assume that the model does not learn while it is being tested. It is already trained; you hand it an input and look at the output. Real deployments are nothing like that. An agent working in an open environment — inside an application, on a website, in a game, in a robot — has to keep adapting. And this is where today's systems turn out to be far weaker than the loud demos suggest.

How the world is built

The strength of AgentOdyssey is not only the game itself but how the game is made. The authors assemble the world out of entities: locations, objects, characters and rules. There is a world graph, there are the agent's actions, and there is environment dynamics that runs independently of both. Enemies can get more dangerous at night, some events fire at random, and an item dropped long ago can suddenly become necessary a hundred steps later.

That matters. In many game environments the world changes only in response to the agent. Here it moves on its own. So the agent cannot simply react — it has to build an internal picture of the world.

The AgentOdyssey pipeline: the agent receives a text observation, picks an action, the world updates by its rules, and new games are generated automatically with an LLM.

Games are generated procedurally. A base game serves as the seed, then LLMs help create new objects, rules and quests. The authors did not stop at generate-and-hope: they added automatic validity checking and error repair through program synthesis, which lowers the risk of an environment that is broken or unplayable.

Another good idea is multi-level evaluation. Game tasks usually score progress alone: did it reach the goal or not. That is not enough here. The authors measure separately:

That last one earns its place. Plenty of agent designs look powerful right up until you price them.

Which agents were compared

The paper tests several popular classes of AI agent.

First, long-context agents. They simply put the whole history into the prompt: observations, reasoning, actions. Brute force, but often strong.

Second, agents with fixed-size memory. They keep only a sliding window of recent steps or a bounded memory buffer.

Third, agents with memory retrieval, where past experience is stored separately and the relevant fragments are pulled back in when they are needed.

Fourth, agents with fine-tuning at run time, where experience is encoded not only in the text of the context but in the model weights, through parameter updates.

The authors also tried add-on mechanisms: short-term memory, reflection, summarization.

A taxonomy of agents: different approaches to memory and learning at run time, from long context to agents that update their parameters.

This is a well-posed experiment. It shows not "which model is better overall" but which kind of memory and adaptation holds up over a long run.

The headline result: the best agents are still weak

The sharpest finding in the paper is a simple one: yes, stronger models and larger memory help, but humans are still far ahead.

In the first large experiment the winner was a long-context agent built on GPT-5. It remembered the past better than the rest, absorbed knowledge about the world better, and got further through the main quest. Even so, it trailed humans by a wide margin.

Results of the first experiment: the long-context agent leads but still falls well short of humans; the diagnostic metrics line up closely with actual progress in the game.

This is the important part. We watch LLMs handle short tasks well and conclude that the next step is simply to hand them more tools. AgentOdyssey says otherwise: the bottleneck is not only tools but stable behavior over a long horizon.

The authors go through the typical failures in detail.

First, weak exploration. Agents dislike picking up items whose usefulness is not obvious, and they are reluctant to try the full set of actions. As a result they never collect the resources they will need later.

Second, episodic memory. An agent can be told many times over that this action does not work here and still repeat the same mistake. Or forget where it already saw the object it now needs.

Third, hallucinated world knowledge. Weaker models especially: they try to craft items that do not exist, mix up recipes, and misread the dynamics of the environment.

Fourth, poor skill acquisition. Even when an enemy follows a repeating pattern, most agents never learn an effective tactic against it.

Fifth, poor goal retention. An agent can solve a local subtask well enough and then fail to return to the main line, losing the thread of its plan.

This is probably the most useful part of the paper: it shows not just a final score but exactly where agent behavior breaks.

Memory helps, with a catch

One of the most interesting findings concerns short-term memory. The authors found that it helps consistently across agent types — not only the ones that work through the context, but fine-tuned agents as well.

The logic is mundane. Even in a long game the agent needs more than an archive of everything that has happened; it needs working memory: what am I collecting right now, how many items have I found, why did I come to this area, which substep am I on at this moment.

In the second experiment, on a simpler game, the best result came from exactly that — a fine-tuned agent reinforced with short-term memory.

In the second experiment the best result came from the agent with fine-tuning plus short-term memory; a small working memory noticeably improves learning at run time.

A subtle result, and an important one. It says that learning in the weights does not solve the problem by itself. The agent still needs convenient scratch memory for its immediate goals. Otherwise it can learn over the long run and still lose track of the step it is on.

Parameter updates came with an unpleasant side of their own: signs of catastrophic forgetting. After training, some agents answered questions about the world worse than they had before. They were picking something up while losing part of their general ability along the way. For systems meant to run in production, that is a serious warning.

Long context is the strongest and the most expensive

On paper the long-context agent looks better than everyone else. It has one almost comic flaw: the price.

If the agent drags its entire history along at every step, the token count climbs fast. The authors show directly that the cost of this approach becomes quadratic as the trajectory grows. The longer the agent lives, the harder that hits both budget and latency.

This is not an abstract problem. You can build a very smart agent that plays well for 200 steps. But if at step 500 it becomes too expensive or no longer fits in the context window, its useful horizon ends there.

In that sense AgentOdyssey is also an antidote to self-deception. It shows that quality measured without cost is half a picture.

Why this matters beyond games

It is easy to wave this off as just text adventures. That is precisely the strength of the work. The authors deliberately stripped out vision, mouse control, sensor noise and the rest of the external difficulty in order to isolate what matters: memory, learning on the fly, goal retention and long causal chains.

If an agent cannot handle that reliably in a controlled text world, it is too early to expect miracles in a browser, an operating system or a robot.

The paper also nudges the field, carefully, toward an honest framing of the question. Not "can the model reason?" but "can an agent live in a world for a month, accumulate knowledge, hold together and not bankrupt you on tokens?" That is a grown-up question.

Takeaways

AgentOdyssey is one of those papers that promises no magic and does something more useful: it supplies a good ruler. With it you can measure not only the handsome final scores but the real weak points of AI agents.

The main findings:

The short version: the paper shows an uncomfortable but important truth. Today's AI agents are still bad at living a long life. They can shine on a single step, but over hundreds of steps they start forgetting, looping, confusing facts and losing the plan.

Which means that the next real progress in agent systems will probably come not only from more powerful LLMs but from new memory architectures, more careful learning at run time and cheaper reasoning. In that sense AgentOdyssey arrives at exactly the right moment. It does not solve the problem, but it shows precisely where the problem has to be solved.