Researchers behind a project called AgenticSTS say they have improved long-horizon AI agent performance in the card game Slay the Spire 2 by replacing the usual ever-growing chat history with a structured memory system. In reported tests covered by The Decoder, the agent won 6 of 10 runs on the game’s lowest difficulty when a tactical skill layer was enabled, while two public comparison agents using traditional transcript-heavy prompting reportedly failed to win any of their runs.

The result matters beyond a game benchmark because it targets a practical bottleneck for AI agents: long tasks tend to accumulate huge prompts, driving up cost, latency, and error rates. AgenticSTS’s core claim is that an agent does not need to keep replaying its full conversation to act coherently over hundreds of steps. Instead, it can rebuild each prompt from a compact set of memory slots that store only specific kinds of information.

According to The Decoder’s report on the paper, the work comes from Alaya Lab, Shanghai Jiao Tong University, and other institutions. The researchers used Slay the Spire 2 as a test case because a run involves many sequential choices, the rules can be represented in text, and randomness makes brittle strategies easier to expose. For AI builders, that makes the study less about beating a game and more about whether memory architecture can substitute for brute-force context expansion.

Why Slay the Spire 2 is a useful stress test

Slay the Spire 2 is unusually punishing for agent design. A single run can involve route planning, deck construction, combat tactics, store purchases, and event decisions spread across hundreds of steps. That makes it a better test of persistence and planning than a one-shot benchmark. The Decoder notes that human players win about 16 percent of the time on the lowest difficulty, A0, according to the game’s developers, while frontier-model agents in the AGI-Eval assessment reportedly did not win a single game across five tested setups.

That backdrop is important because the researchers are not arguing that a new model suddenly solved the game. Their argument is narrower and more actionable: the same class of large language model can perform differently depending on how its history is represented and retrieved.

Traditional agent designs such as ReAct and Reflexion often append observations, tool outputs, and self-reflection to the next prompt. That pattern is easy to build, but it creates a prompt that grows every turn. As runs get longer, the agent risks either hitting the context limit or diluting its own attention across stale information. This is the same failure mode many practitioners now describe as context rot.

How AgenticSTS reorganizes memory

AgenticSTS reportedly avoids feeding the model its raw running transcript. Instead, each decision prompt is assembled from five memory layers. The Decoder describes them as a fixed instruction layer, a current-state layer, a retrieved game-rules layer, a summary layer for previous runs, and a strategy-skills layer that stores reusable tactical rules for recurring situations.

That separation is the main design contribution. If information from a previous step matters, it must first be written into one of those memory stores. In practice, that means the model sees a shorter, curated prompt rather than a giant log of everything it ever did. The reported prompt length stays around 5,000 tokens even late in a run, versus prompt growth into the hundreds of thousands of tokens for baseline agents that resend the full history.

This also gives researchers a cleaner way to inspect what actually helps. Instead of treating “memory” as one vague blob, they can switch layers on or off. In the main comparison described by The Decoder, an agent without memory layers won 3 of 10 runs. Adding the L5 tactical skill library increased that to 6 of 10. The article says this held whether the skills were handwritten or generated from templates.

That is a notable result, but the researchers themselves appear to have been careful about overstating it. With only 10 runs per condition, they reportedly acknowledge that the improvement could partly reflect noise.

The strongest gains may be cost and latency, not just wins

The cleaner performance story may be operational rather than purely benchmark-driven. The Decoder reports that public comparison agents STS2MCP and CharTyr, which use a growing-transcript approach, did not win any of five runs each under the reported setup. More strikingly, they reportedly consumed 66 to 90 times more tokens per point scored than AgenticSTS.

One cited example illustrates why. In STS2MCP, a late-game model call reportedly reached about 527,000 tokens because the entire game history was resent. AgenticSTS, by contrast, held the active user text around 5,000 tokens. The article also says transcript-heavy agents took about four times longer to reach the same level, with provider statistics attributing 96 percent of that slowdown to model latency rather than orchestration overhead.

For teams building AI agents in enterprise settings, this may be the more transferable lesson. Many production workflows already suffer from ballooning context in coding assistant, customer support, research, and workplace automation use cases. If structured memory can preserve enough continuity while sharply reducing prompt size, the payoff is lower inference spend, better responsiveness, and potentially fewer reasoning failures caused by noisy history.

What the evidence supports, and what it does not

The evidence in this story comes from media coverage of the underlying research rather than a company launch or independent benchmark audit, so caution is warranted. The Decoder reports that the key metrics are based on 50 runs overall, with only one playable character, Silent, tested on one game version. That leaves open how well the approach generalizes across patches, characters, or other long-horizon environments.

The article also says this was not a clean apples-to-apples ablation against transcript accumulation inside the same codebase. STS2MCP and CharTyr differ from AgenticSTS in routing and decision batching as well as memory handling. So while the comparison is useful as a snapshot of the current public-agent landscape, it does not isolate structured memory as the only reason for the gap.

Cross-model transfer results also suggest the memory itself may be less reusable than some builders might hope. The researchers reportedly froze a memory stack accumulated by Gemini 3.1 Pro and then passed it to Qwen 3.6-27B and Deepseek V4-Pro. Qwen 3.6-27B’s average score reportedly rose by 84.5 percent, while Deepseek V4-Pro’s score fell by 18.1 percent. Neither model won a game. If that finding holds, memory formats may need to be tailored to the model that creates and consumes them.

Even so, the project appears to make a useful contribution to reproducibility. The Decoder says the team is publishing 298 full game runs, frozen memory snapshots, and evaluation scripts on Hugging Face. That should make it easier for outside groups to test alternative memory designs without rebuilding the environment from scratch.

Why this matters for AI agents and enterprise AI

The broad implication is that better AI agents may come less from ever-larger context windows and more from explicit memory management. That shifts the engineering problem. Instead of asking how to stuff more tokens into a model, teams can ask what information deserves long-term storage, how it should be summarized, when it should be retrieved, and which decisions require fresh state versus durable skills.

This aligns with a wider move across the market. The Decoder points to Anthropic work on Memory Tool and Context Editing, which aims to remove stale tool results from live context and move durable information into external storage. It also mentions GAM and Mastra as other efforts to manage memory outside the raw prompt. These projects vary in implementation, but they share a similar premise: letting context grow unchecked is often the wrong default for long-running AI agents.

For enterprise AI buyers, that suggests procurement questions should extend beyond model quality. Teams evaluating an agent platform should ask how it handles memory compaction, retrieval, schema design, and auditability. A flashy demo built on giant prompts may fail when workflows stretch into hundreds of actions or when inference budgets tighten.

For researchers, Slay the Spire 2 offers a useful intermediate benchmark between toy tasks and messy real-world deployment. It is structured enough for controlled study but long enough to reveal failures in planning and memory. If AgenticSTS’s approach reproduces across more settings, it could influence how coding assistant systems, browser agents, and business-process automation tools are architected.

What to watch next

The next signal is independent replication. If outside researchers using the Hugging Face artifacts can reproduce the win rates, token savings, and latency improvements, the memory-architecture claim will become more credible.

A second signal is stricter ablation. The most informative follow-up would compare AgenticSTS against a transcript-accumulating baseline inside the same codebase, with the same model, same routing, and same scoring.

Third, watch for broader generalization. Results on more Slay the Spire 2 characters, later patches, or other long-horizon tasks would say more about whether the design is robust or benchmark-specific.

Finally, keep an eye on productization. If framework providers or model companies adopt similar structured-memory patterns, concepts now tested in research may quickly flow into commercial AI agents, enterprise AI stacks, and developer tools.

Creati.ai perspective

The most important part of this story is not that an agent won a handful of game runs. It is that the researchers are treating memory as a first-class system design problem rather than a side effect of chat. That is exactly where many deployed AI agents still break down: they confuse persistence with replay, so every new step drags around too much irrelevant past.

If the AgenticSTS results hold up, they strengthen a view that many builders already suspect: raw context length is an expensive substitute for structured state. In practice, the next wave of reliable AI agents may depend less on bigger models alone and more on disciplined memory layers, retrieval policies, and tools that prevent context rot before it starts.