AgenticSTS: A Bounded-Memory Testbed for Long-Horizon LLM Agents

Xiangchen Cheng, Yunwei Jiang, Jianwen Sun, Zizhen Li, Chuanhao Li, Xiangcheng Cao, Yihao Liu, Fanrui Zhang, Li Jin, Kaipeng Zhang

AgenticSTS replaces unbounded transcript history with a bounded, typed retrieval contract for long-horizon LLM agents.

Can we replace the standard "append-everything" LLM memory strategy with a bounded, typed retrieval contract to improve long-horizon agent performance?

Long-horizon LLM agents typically append every past observation and tool call to the current prompt, causing context to grow until it dilutes attention and inflates costs. AgenticSTS replaces this unbounded transcript with a bounded contract that rebuilds each decision prompt from five typed knowledge layers, such as episodic summaries and triggered strategic skills. In a fixed-difficulty testbed, this bounded approach enables reliable performance and allows researchers to ablate specific memory layers to isolate their impact on agent decisions.

Paper Primer

The core mechanism is a per-decision composition interface: the agent retrieves evidence from five fixed-format slots—protocol, schema, rules, episodes, and skills—rather than reading a raw, growing log. This turns memory from an implicit, accumulating burden into an explicit, ablatable interface where each layer can be toggled or frozen to measure its specific contribution to the agent's success.

Enabling triggered strategic skills (L5) provides the largest observed performance lift in the fixed-difficulty matrix.

In a balanced 50-game subset at Ascension 0, the no-scaffold baseline wins 3/10 games, while all scaffolded configurations (including L5 skills) win 6/10. The L5 skill layer accounts for a +2/10 win-rate increase over the prompt-only baseline, though this result is directional (Fisher exact p ≈ 0.37) rather than statistically decisive at the current sample size.

The bounded contract significantly reduces token consumption compared to accumulating-context agents.

Accumulating-context competitors consume 66–90× more fresh tokens per score point and 4× the wall-clock time, while their prompt size grows to 500k tokens compared to the bounded contract's flat ~5k median. The bounded agent maintains a stable prompt size regardless of run length, whereas transcript-based agents face worst-case linear growth.

Why is Slay the Spire 2 a suitable testbed for this memory contract?

The game provides a closed, text-readable rule space that avoids the visual complexity of other environments, while its stochastic, long-horizon nature requires sustained strategic planning across hundreds of contingent decisions.

Does this bounded contract outperform traditional accumulating-context agents?

The paper demonstrates that existing transcript-accumulating agents collapse at the same difficulty where the bounded agent succeeds, though the authors note this is an operational comparison of shipped systems rather than a controlled ablation of the contract variable itself.

The Memory Contract Problem

We expose the inefficiency of naïve transcript appending and propose a bounded typed memory contract.

Appending the full interaction transcript to every prompt gives the model unrestricted access to all past observations, tool calls, and reflections. This “naïve” contract entangles evidence, makes stale information re‑appear, and prevents any single memory component from being isolated for analysis.

The baseline simply concatenates the entire past transcript—observations, tool calls, and reflections—onto each new prompt, preserving every detail but inflating context size.

**Figure 1.** Overview of our paper: a bounded, typed memory contract turns long-horizon LLM-agent memory into an ablatable evaluation surface. Summary performance labels in this schematic (e.g. relative scores and ladder reach) are illustrative; the exact numbers, denominators, and caveats—including that cross-agent comparisons are operational rather than matched ablations and that win-rate differences are directional at our sample size—are given in §6–7.

The inefficiency of naïve history appending limits both performance and interpretability of long‑horizon LLM agents.

The AgenticSTS Architecture

We replace transcript‑appending with a five‑layer typed memory contract that isolates the memory decision.

Appending the full decision transcript to every LLM call quickly exhausts the context window and dilutes the attention signal. The bounded memory contract solves this by selecting a handful of typed evidence slots instead of the raw history.

The contract treats memory like a fixed‑size toolbox: each decision draws from five pre‑named slots (L1–L5) rather than from an ever‑growing transcript.

How does a bounded memory contract differ from simply truncating the transcript?

Truncation discards older tokens indiscriminately, whereas the contract explicitly chooses the most relevant typed pieces (protocol, schema, rules, summaries, skills), preserving essential information while keeping the prompt size fixed.

Start with an empty prompt.

Add L1 (“init”) → prompt length 3.

Add L2 (“state”) → length 6.

Add L3 (“rule”) → length 9.

Add L4 (“summary”) → length 12.

Add L5 (“skill”) → length 15, reaching the budget.

The contract guarantees a deterministic, bounded prompt while still injecting all five semantic roles, avoiding the uncontrolled growth of raw transcripts.

Think of the layers as shelves in a library: the lower shelves (L1‑L2) hold immutable reference books, while the upper shelves (L3‑L5) hold mutable notes that can be edited or removed between runs.

Why are L1 and L2 fixed while L3‑L5 are mutable?

L1/L2 encode the agent’s core protocol and schema, which must remain consistent for correct parsing. L3‑L5 hold game‑specific knowledge that can evolve between episodes, so mutability lets the system experiment with or disable those pieces without breaking the core interface.

Add L1 (“init”) → length 3.

Skip L4 (disabled).

Add L5 (“skill”) → length 12, still under the 15‑token budget.

Disabling a mutable layer reduces the prompt size without touching the fixed protocol, illustrating how each layer can be ablated independently.

Collect the fixed protocol instruction (L1) and schema (L2).

Retrieve applicable game rules (L3) and optionally filter them.

Insert the episodic summary (L4) if the layer is enabled.

Append any triggered strategic skill (L5) if available.

Concatenate the five slots in order L1→L5 to form the final prompt.

Pass the prompt to the LLM and obtain the next action.

**Figure 2.** Typed retrieval as a bounded-memory contract: (a) per-decision composition, (b) the five typed layers, and (c) AgenticSTS scores vs AGI-Eval rows and the community human reference [31]. In-panel summary labels (e.g. “no trade-off”, token-efficiency and score-gap figures) are illustrative; cross-backbone and external comparisons are operational context, not matched ablations of the memory contract, and within-harness win-rate differences are directional at our sample size—see §6-7 for exact numbers and caveats.

Our contributions are threefold: (i) a per‑decision composition interface that replaces raw transcripts with typed L1‑L5 slots; (ii) empirical evidence that enabling L5 skills yields the biggest A0 improvement despite modest sample size; and (iii) a publicly released archive of 298 tagged trajectories with scripts for re‑aggregation and analysis.

The Slay the Spire 2 Testbed

Typed Retrieval rebuilds prompts from five labeled layers, eliminating transcript bloat.

Appending the full conversation history to every LLM call quickly exhausts the token budget, especially in long runs like Slay the Spire 2. The Typed Retrieval architecture replaces that unbounded transcript with a bounded, layer‑wise contract that caps growth while preserving needed information.

Instead of feeding the model a growing raw log, each decision prompt is freshly assembled from five typed knowledge layers, so only the essential, bounded pieces survive across steps.

How does this differ from the usual transcript‑appending approach?

Transcript‑appending concatenates every prior turn, so the prompt length grows linearly with the number of decisions. Typed Retrieval discards the raw log and inserts only the five fixed‑size layer summaries, keeping the token count constant regardless of run length.

Compute the base size: $|{\text{sys}}| = 10$ tokens.

Add the five layer contributions: $10 + (2+3+4+5+6) = 30$ tokens.

Apply top‑k and size caps: each layer contributes at most $1 \times 5 = 5$ tokens, so the total from layers is $5 \times 5 = 25$ tokens.

Final prompt size = $|{\text{sys}}| + 25 = 35$ tokens, independent of how many decisions have already occurred.

If a new decision is made, the same 35‑token budget is reused; no additional tokens accumulate.

The prompt size stays constant because the architecture never re‑adds the raw transcript; only the bounded layer summaries are ever present.

**Figure 3.** Token audit of the bounded-memory contract on ten fixed-$A_0$ runs (two per cell); dashed line is a transcript-appending counterfactual at $\frac{1}{4}$ of naive $O(c^2)$ growth (median tokens/call $\times c(c+1)/8$, a moderate prompt-caching discount). The audit illustrates context-growth mechanics under each contract; at two runs per cell it is not a win-rate comparison.

Experimental Methodology

Ablation study isolates the impact of each memory layer and tests cross‑backbone robustness.

The evaluation asks three questions: which prompt and memory layers matter at a single difficulty; does a frozen L4+L5 stack transfer to other backbones; and how far does the agent climb when post‑run writing is allowed.

Fixed‑A0 decomposes the system into five cells: baseline‑strict, prompt‑only, mode‑a, mode‑b‑frozen, and full‑frozen. All cells share the same anchor SHA 1888a62 and disable postrun and evolution writes.

Cross‑backbone probing runs baseline‑strict and full‑frozen at A0 on Qwen 3.6 27B, DeepSeek V4 Pro, and Gemini 3.1 Pro.

Win rates are reported with Wilson 95 % confidence intervals; continuous scores use 5,000‑bootstrap intervals; the pooled scaffolded row uses an exact Clopper–Pearson interval.

**Figure 4.** Fixed-$A_0$ ablation surface under the bounded-memory contract: five cells share a common contract and adjacent bars are organized by a named ablation axis. Not every neighboring pair is a single-mechanism isolation—e.g baseline-strict to prompt-only changes the prompt-package/strictness group rather than one isolated mechanism Frozen stores at SHA 1888a62.

The public release bundles the completed‑run archive, condition tags, analysis scripts, frozen memory/skill snapshots, and representative prompt records, enabling full reproducibility and future extensions such as an accumulating‑context condition.

Performance Results

L5 layer boosts win rates and transfer experiments reveal backbone‑dependent gains.

The L5 layer of the Typed Retrieval contract yields a +20 % win‑rate increase over the baseline without skill scaffolding.

In the within‑harness ablation (Table 2), L5 cells win 6/10 games versus 3/10 for the no‑scaffold condition, a $ΔL5$ of +2/10.

**Figure 5.** Auto-mode ascension ladder: per-stream highest attempted ascension (endpoint, not win-rate).

Competitor Comparison

We compare our bounded contract against two open‑source transcript‑accumulating agents on STS2.

The bounded, five‑layer memory contract we introduced replaces the naïve transcript‑appending baseline. Here we evaluate that design against two publicly released agents that still use the accumulating‑transcript pattern.

STS2MCP runs the game by repeatedly appending the full chat transcript to the prompt, letting the LLM see the entire history on every decision.

CharTyr follows the same transcript‑accumulating approach but adds a custom “skill” module that occasionally injects game‑specific commands.

We reproduced each competitor in its author‑intended configuration, using the same game version, character, and ascension level. All strategic decisions were executed on the same Gemini 3.1‑pro‑preview model; our agent additionally routes trivial moves to a fast‑tier and sets an explicit thinking effort.

Our bounded‑contract agent is dramatically cheaper per unit of progress while remaining faster and more effective than the open‑source baselines.

Full‑frozen runs achieve a mean score of 82.1, reach floors in ~2.3 min, and consume ≈6 k fresh tokens per score point; the competitors spend 9.9–8.5 min per floor and 422 k–571 k tokens per point.

**Figure 6** Competitor comparison at $A_0$ (The Silent), per run; horizontal bars are per-cell means. (a) Effect: run score ($s = 100$ if victory else floor + $(52/3) \cdot$ bosses), with win counts above each column. (b) Speed: wall-clock minutes per floor reached (96% of competitor wall-clock is provider-reported LLM latency; fixed inter-action delays slightly favor competitors, 0.5s vs. our 0.6s; our durations exclude postrun). (c) Cost: fresh (non-cached) LLM tokens per score point (log). Competitor usage is exact provider-reported tokens with cache hits removed (90% / 82% of their prompt tokens were cached); ours follows the paper's Fig. 3 convention ($\sim\$5k strategic user-message tokens $\times$ `llm_calls`), excluding the cached system prefix, completions, retries, and fast-tier calls. full-frozen/baseline-strict are the Table 2 cells ($N=10$, frozen stores at SHA 1888a62); competitors $N=5$. Under the intentionally absurd upper bound pricing every recorded action as a full strategic call, our cells move to 55k / 58k tokens per point — the gap remains $\ge 7\times$.

**Figure 7** The mechanism: per-call prompt size over a run. Thin lines are individual runs (measured full prompts, including cached tokens — caching changes billing, not what the model attends to); bold lines are per-competitor medians. The worst single STS2MCP run reaches ~500k tokens per call by decision ~1100. The dashed line is our bounded contract’s strategic user-message median (~5k, estimate; constant cached system prefix excluded; x-extent not comparable — our runs make ~100 strategic calls).

**Figure 8.** Cost–effect frontier: run score vs. fresh LLM tokens per run (log). Hollow diamonds: our cells (tokens estimated, 5k/call convention); circles/squares: measured competitor usage. The empty band between the clusters spans more than an order of magnitude.

AgenticSTS delivers far higher efficiency—both speed and token cost—than the open‑source transcript‑accumulating baselines.

Discussion and Limitations

We discuss how treating the memory interface as a first‑class evaluation object reshapes analysis and outlines current limits.

The paper’s core claim is that standard LLM agents bloat their prompts by appending the full transcript, whereas AgenticSTS replaces this with a bounded, five‑layer typed memory contract that improves performance and enables systematic memory evaluation.

Interpretation and scope: making the memory interface an explicit evaluation object lets us treat it like any other component rather than a hidden prompting convention. In a closed‑rule game with a text‑readable state, the bounded contract yields stable fixed‑A0 wins and isolates the largest effect to the L5 skill layer, while keeping fixed‑difficulty performance separate from ladder endpoints.

Implications: separating memory into typed slots makes attribution tractable—gains can be traced to a specific layer instead of to “more context.” Moreover, the bounded contract decouples interface design from accumulating state, allowing the same evaluation surface to be reused for non‑game agentic tasks that share a closed‑rule structure.

Implications for loop engineering: the contract provides a concrete, measurable design point for the memory stage of turn‑based agent loops. Per‑decision typed retrieval keeps the online context bounded regardless of run length, and post‑run writes expose learning as explicit artifacts rather than opaque transcript growth.

**Table 5.** Score-formula audit. The derived score (Eq. 1) uses bosses = 0 when floor < 18, 1 when floor < 34, 2 otherwise, and 3 for victories. Table 5 lets readers reproduce the paper-reported means.

**Table 5.** Per-cell floor and boss-clear counts that reproduce the mean scores reported in Table 2.

Limitations – sample size and statistical inference: the headline fixed‑A0 result uses a balanced 50‑game subset, which is at the upper end of typical LLM‑agent benchmarks. Smaller diagnostic streams (cross‑backbone and ladder) are reported separately, and Wilson intervals at this size only support scaffolded‑versus‑unscaffolded comparisons.

Same‑codebase accumulating‑context variant: the release is organized so that an accumulating‑context cell sharing our codebase, condition tags, scoring scripts, and frozen stores can be added as an extra row in the same matrix, enabling a clean direct comparison.

Single‑character and game‑version coverage: the headline runs target the character Silent to keep the typed substrate (L3 knowledge, L4/L5 stores) self‑consistent. Archived trajectories carry version tags, allowing re‑analysis across game versions and future cross‑character extensions.

External player and ecosystem references: Mega Crit, Spiracle, and AGI‑Eval appear only as difficulty and ecosystem context; evaluating human inference would require a separate user study, which lies outside the scope of this resource.

Architectural scope: the evaluation is training‑free and single‑game, tuned for turn‑based decision settings like Slay the Spire 2. Continuous control loops, visual input, multi‑agent play, online human correction, model‑internal fine‑tuning, and cross‑game transfer are deliberately out of scope.

Treating the memory interface as an explicit evaluation object makes memory‑layer changes measurable, reproducible, and comparable across future designs.

Evaluation Archive

Details on the evaluation archive and how win‑rate statistics are computed.

The evaluation archive stores a complete record for every trajectory, including the condition tags that select cells, frozen snapshots of layers 4 and 5 for ablations, and the decision‑time and post‑run prompts. Scripts are provided to recompute Wilson 95 % win‑rate intervals and bootstrap 95 % score intervals from these records.

The derived score (Eq. 1) assigns a boss level based on the floor number: 0 for floor < 18, 1 for floor < 34, 2 otherwise, and adds 3 for each victory. Table 5 lists the per‑cell floor and boss‑clear counts that reproduce the mean scores reported in Table 2.

Score intervals are obtained by a percentile bootstrap: 5 000 resamples with replacement are drawn from the $n$ run‑level scores of a cell, and the empirical 2.5 % and 97.5 % percentiles form the 95 % interval. For the pooled scaffolded row we use an exact Clopper–Pearson interval, which is labeled accordingly.

Memory Contract Details

Appendix details the five‑layer memory contract, prompt composition, and supporting data tables.

This appendix expands on the five‑layer memory contract and shows the concrete prompts used for decision making.

**Table 6.** Five-layer memory contract. Each decision receives typed slices; raw cross-decision transcript is not appended.

**Table 7.** External numbers calibrate difficulty and ecosystem context only.

The contract’s layers differ in mutability: L1 and L2 are fixed, L3 can be filtered, while L4 and L5 may be disabled, frozen, or writable depending on the evidence stream.

At decision time the agent builds the user prompt by concatenating typed layers in a fixed order: L5 skills, L4 episodes, L3 game facts, L2 state prompt, and finally a schema hint of valid actions.

Card‑specific insights include delayed block plus Dexterity for dodge and roll, and a zero‑cost transitional damage for slice.

The game‑knowledge entries list card mechanics such as DodgeAndRoll granting block next turn (upgrade +2) and Slice gaining +3 damage when upgraded.

A sample card reward shows HP 57/57, Gold 55, Act 1, and Floor 7.

One learned skill encodes a boss mechanic that exhausts attacks on turns 2, 5, 8, and 11, prompting the agent to preserve scaling cards and favor powers on those turns.

External Slay the Spire 2 statistics are provided as difficulty anchors and ecosystem context, with snapshots released for reproducibility.

The full decision‑time prompt includes system instructions, role definition, output schema, and layered context blocks L1–L5, each annotated for its purpose.

The combat example shows a JSON plan where the agent blocks with Backflip then chips damage with Shiv, including reasoning and notes for future turns.

Prompting Strategies

Detailed combat guidance and resource‑management advice for the agent.

HP is a run‑wide resource: each point lost now cannot be recovered later, especially against the boss. Prefer defensive lines that take zero damage; only trade HP for speed when enemies scale dangerously (e.g., Strength stacking, summons).

Instant potions such as Fire and Block are safe anytime, while sustained‑buff potions (Strength, Dexterity, Regen) should be saved for boss or elite fights where they provide three‑ to four‑fold value.

User prompt supplies the current setup and the retrieved context for the agent.

Combat start: elite encounter on Act 3, Floor 43, against a Soul Nexus (HP 234/234, Block 0, Weak (1) reduces enemy attack damage by 25%). Player status – $66/70$ HP, Block 0, Energy 3/3, Dexterity (1) improves block gain.

The deck contains 35 cards across Attack, Power, and Skill categories, with a mix of low‑cost shiv generators, block providers, and scaling powers.

Strategic Thread – the current deck‑building plan focuses on a “Committed Shiv” strategy: scale with Accuracy and Phantom Blades, generate shivs, and cycle cards with Backflips and Expertise while maintaining block through Footwork‑scaled Backflips.

Expert Knowledge (retrieved skills) advises sequencing zero‑cost and setup cards first, using Silent’s tempo engine to convert discard and free cards into free plays, and switching to aggressive poison tactics once defense stabilises.

Core Combat Principles: (1) read enemy intents – a full‑offense window exists when all enemies are non‑attack; (2) prioritize killing enemies this turn; (3) track the draw pile to anticipate future draws; (4) spend all energy each turn; (5) focus fire the most dangerous attacker; (6) use potions without energy cost, applying buffs before attacks and damage potions to secure kills.

Boss and Elite Fight Strategy: use all potions, front‑load damage in the first three to four turns, and after a boss is defeated, verify survivability before playing aggressively in the next encounter.

Past Experience notes that bosses typically open with moderate damage (18–29) and debuffs, then gain Strength and massive spikes (e.g., 43‑damage single hit, 36‑damage Maelstrom) if the fight drags on.

Combat Guide for the Soul Nexus recommends an aggressive racing approach to finish in three rounds using shiv generators and draw/discard loops, while passive defense relies on afterimage and zero‑cost shivs to generate incidental block.

If the fight extends past round 3, reserve premium mitigation like Piercing Wail and Weak for those critical survival turns.

Enemy Patterns – current round is R1, with no additional details beyond the standard elite setup.

Potion Strategy for this elite: use Powdered Demise (instant – enemy loses 9 HP each turn) and Swift Potion (instant – draw 3 cards) as needed.

Card Notes – key cards: Neutralize (0‑cost attack that applies Weak), Survivor (C‑tier block), Phantom Blades (Power that adds +6 damage to the first shiv each turn), Infinite Blades (Power that creates one shiv per turn, scaling with Accuracy), Storm of Steel (discards entire hand to generate shivs, destroying retained cards), Footwork (Power granting permanent Dexterity +2), Cloak and Dagger (1‑cost skill that gives 6 block and one shiv, upgrade doubles shiv output), Backflip (1‑cost block + draw 2), Deflect (0‑cost block scaling with Dexterity), Well‑Laid Plans (A‑tier control enabler for discard engines), Leading Strike (1‑cost attack that adds shivs), Knife Trap (replays every shiv in the exhaust pile), Serpent Form (3‑cost Power requiring energy support), Up My Sleeve (cost reduces by 1 each play), Accuracy (Power that adds +4 damage per shiv), Expertise (draws until hand has 6 cards), Piercing Wail (A‑tier defense against multi‑hit attacks), Blade Dance (premium shiv generator), Leg Sweep (2‑cost block + Weak, cheaper after Pounce).

Combat and Planning Rules

Concrete prompt details for combat planning and shop decisions.

Only cards marked [PLAYABLE] may be used; [UNPLAYABLE] cards will be rejected. Card costs appear as cost=$N$, so a card requires at least $N$ energy to play. The order in the plan determines how earlier plays affect remaining energy, hand composition, and later card costs.

The current combat state shows Energy 3/3, HP 66/70, and no block, with Dexterity(1) boosting block from cards. The sole enemy, Soul Nexus, has 234 HP, no block, and intends an Attack(21) while suffering Weak(1) that reduces its damage by 25 %. Relic counters indicate Letter Opener at 0 (three Skills → 5 damage to all) and Happy Flower at 2 (every three turns gain Energy).

Read the original paper

Open the simplified reader on Paperglide

Browse all simplified papers