Memory-Maze: Memory in Navigation & Systems
- Memory-Maze is a cluster of research scenarios where successful action relies on reconstructing and integrating latent, delayed memory across time.
- It spans assistive visual language navigation, 3D reinforcement learning tasks, and systems engineering challenges, each testing memory inference under partial observability.
- Practical applications include guiding blind individuals, evaluating memory-driven agents, and optimizing context-specific memory management in computing.
Memory-Maze denotes a family of research problems in which successful action depends on information that must be retained, reconstructed, and reused over time rather than read directly from the current observation. In recent arXiv usage, the term names a scenario-driven visual-language navigation benchmark for guiding blind people from route instructions recalled from human memory (Kuribayashi et al., 2024), overlaps with the 3D reinforcement-learning benchmark “Memory Maze,” introduced specifically to evaluate long-term memory in partially observed agents (Pasukonis et al., 2022), and also appears in systems research as a label for the situation in which engineers are told to “optimize memory” even though the relevant memory quantity is highly context-dependent (Kudrjavets et al., 2023). Taken together, these uses suggest a shared concern with delayed relevance: route structure, object locations, latent map topology, evolving task state, or operating-system memory accounting must be inferred across time rather than observed once and for all.
1. Terminological scope
In current research usage, Memory-Maze is not a single canonical object. It is better understood as a cluster of related terms that organize distinct but structurally similar problems around memory, partial observability, and delayed action.
| Usage | Domain | Defining characterization |
|---|---|---|
| “Memory-Maze” (Kuribayashi et al., 2024) | Assistive VLN | Scenario driven benchmark with route instruction data from human memory |
| “Memory Maze” (Pasukonis et al., 2022) | Reinforcement learning | 3D domain of randomized mazes for evaluating long-term memory in agents |
| “Memory-Maze” (Kudrjavets et al., 2023) | Systems engineering | Situation in which engineers must optimize “memory” without a single stable meaning |
The assistive-robotics benchmark and the RL benchmark are closely aligned in spirit but differ in modality and evaluation. The former centers on natural-language route descriptions in public indoor spaces; the latter centers on first-person navigation, object-location memory, and within-episode map-building. The systems usage is unrelated to maze navigation, but it preserves the same basic metaphor: the solver is “lost in the maze” because relevant state is fragmented across multiple partially overlapping representations.
A plausible implication is that “Memory-Maze” has become a useful umbrella for problems in which action depends on a memory substrate that is neither immediate nor singular. In navigation, that substrate may be a route description, a latent map, or a cue-dependent state. In systems engineering, it may be an OS-specific accounting metric rather than programmer-visible heap size.
2. Scenario-driven benchmark for guiding blind people
The most explicit hyphenated usage appears in “Memory-Maze: Scenario Driven Benchmark and Visual Language Navigation Model for Guiding Blind People” (Kuribayashi et al., 2024). The benchmark is motivated by a practical assistive-robotics setting: a blind person, accompanied by a navigation robot, asks a sighted passerby how to reach a destination in an unfamiliar public building. The central claim is that standard VLN data are mismatched to this setting because real passersby describe routes from memory rather than from a concurrent “think-aloud” observation of the route. As a result, the instructions contain stutters, uncertainty, omissions, mistakes, ambiguity, and varied wording.
The environment is a virtual reconstruction of a real university building floor, modeled in Fusion 360 and implemented in CARLA. It includes major route-relevant objects such as doors, chairs, and a statue. The robot is controlled through a Python API with primitive functions move_forward(distance), detect_turing_point(), turn(direction), and detect_from_RGB_image(object). Corridor following uses PID steering control, turning points are represented as pre-annotated areas, and object-conditioned instructions are grounded with Grounding DINO plus tracking. A depth threshold of is applied so that only nearby objects count for landmark-based instructions.
The benchmark contains at least two canonical routes: and . Instruction collection was split between an online condition, where participants watched first-person walkthrough videos and could replay them, and an onsite condition, where participants described a familiar route from memory without seeing the route during the experiment. The corpus totals 212 instructions: 132 online instructions from 33 participants and 80 onsite instructions from 40 participants.
| Condition | R1 | R2 |
|---|---|---|
| Online | mean 60.8 words; 0% failure | mean 89.8 words; 6.06% failure |
| Onsite | mean 88.4 words; 25.0% failure | mean 139.1 words; 37.5% failure |
A central empirical result is that onsite instructions were not shorter but longer and more variable. Despite fewer samples, onsite instructions used 515 different words versus 377 in the online set. The paper interprets this as evidence that memory-based directions are more descriptive, more conversational, and more error-prone than think-aloud VLN instructions.
The proposed model is a zero-shot, single-inference VLN pipeline based on GPT-4. First, the instruction is parsed into step-by-step brief sentences. Second, GPT-4 generates Python code over the robot-control API. This code-generation strategy is intended to avoid dependence on a prebuilt navigation graph and to avoid repeated LLM calls during execution. Evaluation uses Success Rate (SR), Oracle Success Rate (OSR), Shortest Path Distance (SPD), and Coverage weighted by Length Score (CLS), with CLS computed on a dense graph made from corridor grids.
The main comparison is against NavGPT. Under the reported conditions, NavGPT and NavGPT with parser achieved $0.00$ SR and $0.00$ OSR on both routes and both instruction sources, whereas the proposed method reached $0.30$ SR on Route 1 for both online and onsite instructions, $0.04$ SR on Route 2 online, and $0.03$ SR on Route 2 onsite. The benchmark’s broader conclusion is cautionary: real assistive VLN remains substantially harder than traditional benchmarks suggest.
3. The 3D reinforcement-learning benchmark “Memory Maze”
A closely related but separately named benchmark appears in “Evaluating Long-Term Memory in 3D Mazes” (Pasukonis et al., 2022). Here, Memory Maze is a 3D first-person navigation domain introduced specifically to evaluate long-term memory in partially observed reinforcement-learning agents. The paper’s central claim is that many existing RL benchmarks do not isolate long-term memory: they are either only weakly memory-dependent or confound memory with other difficulties such as hard exploration or trivial localization cues.
Memory Maze is implemented in MuJoCo with dm_control. A typical observation is a RGB image, and the current target is indicated by a colored border around the observation image. The environment uses a 6-dimensional discrete action space with noop, forward, turn left, turn right, forward left, and forward right. The agent receives 0 reward when it reaches and touches the object of the prompted color; touching the wrong object does nothing. Immediately after a successful touch, another object is randomly selected as the next target. Within an episode, maze layout and object locations remain fixed, so the reward structure directly incentivizes memory accumulation.
The online benchmark contains four task sizes: Memory 9x9, 11x11, 13x13, and 15x15. These differ in number of objects, number of rooms, and episode length. For example, Memory 9x9 contains 3 objects and has episode length 1000 steps at 4Hz, whereas Memory 15x15 contains 6 objects and has episode length 4000. Oracle mean maximum scores are 34.8, 58.0, 74.5, and 87.7 respectively. The benchmark is accompanied by two 30-thousand-trajectory offline datasets, one for 9x9 and one for 15x15, plus an offline probing benchmark that tests whether learned latent states encode wall layout and object locations.
A distinguishing feature is that the benchmark requires both map-building and localization. The agent must remember wall layout, room connectivity, object positions, and its own current location and orientation relative to the remembered map. The paper emphasizes that there are no trivial global orientation cues like a skyline; self-localization must be inferred from temporally integrated first-person observations.
Human data provide a strong validation of the benchmark’s memory demands. Ten recorded episodes per maze size produced scores of 1 on 9x9, 2 on 11x11, 3 on 13x13, and 4 on 15x15. The paper reports that human reward accumulation is slow early in an episode and faster later, reflecting the gradual construction and retention of memory.
Among algorithmic baselines, Dreamer with truncated backpropagation through time was the strongest on small mazes, reaching 5 on 9x9 against the oracle’s 34.8, while IMPALA performed better on larger mazes, reaching 6 on 13x13 and 7 on 15x15. Standard Dreamer without TBTT collapsed sharply with maze size, falling to 8 on 15x15. The paper’s main conclusion is that current methods can succeed on small mazes but remain far below human performance on large mazes, and that TBTT materially improves long-term memory learning.
4. Mechanistic accounts of memory-dependent maze behavior
Beyond benchmarks, several papers use maze tasks to isolate particular memory mechanisms. These studies differ in biological plausibility, task design, and training regime, but they converge on a common claim: maze competence often depends on latent state that persists across delays, repeated junctions, and temporally separated cue-reward relationships.
| Work | Memory substrate | Relation to maze behavior |
|---|---|---|
| “A Neural Network Model of the Entorhinal Cortex and Hippocampus for Event-order Memory Processing” (Nakagawa et al., 2021) | Cue-place cells, heteroassociative event-order memory, reward-gated consolidation | Figure-eight maze, “mind travel,” distal reward recall |
| “Hippocampal representations emerge when training recurrent neural networks on a memory dependent maze navigation task” (Jude et al., 2020) | 380-unit LSTM plus predictive sensory loss and Q-learning | Delayed-cue T-maze with forward sweeps and place-cell-like activity |
| “From implicit learning to explicit representations” (Chaix-Eichel et al., 2022) | 1400-unit Echo State Network with memory in reservoir dynamics | 8-shaped alternation maze without explicit working-memory variable |
| “Maze Learning using a Hyperdimensional Predictive Processing Cognitive Architecture” (Ororbia et al., 2022) | Working-memory slots, MINERVA 2 short- and long-term memory, predictive processing | MiniGrid memory task with delayed cue recall |
| “Recurrent Action Transformer with Memory” (Cherepanov et al., 2023) | Segment recurrence and learned memory tokens | Relevant to long cue-decision gaps, but the paper does not evaluate Memory Maze |
The event-order model of entorhinal cortex and hippocampus stores cue-place conjunctions in a heteroassociative network and consolidates them with dopamine-like reward gating. Retrieval proceeds by repeated multiplication of a memory matrix, 9, so that an impetus input can internally trace a route toward reward (Nakagawa et al., 2021). This makes maze memory explicitly order-sensitive: the agent must remember not only what was seen, but in what order cue-place events occurred.
In the delayed-cue T-maze model, a 380-unit LSTM is first trained to predict future wall colors and then optimized jointly with Q-learning. The cue occurs 5 steps before the choice point, and the paper reports that combined predictive and reward learning yields place-cell-like representations, forward sweeps at decision points, and faster learning than Q-learning alone (Jude et al., 2020). This suggests that world-structure prediction can stabilize the latent spatial memory needed for delayed decisions.
Reservoir-computing work reaches a different conclusion. In an 8-shaped maze alternation task, an Echo State Network with 1400 reservoir units solves the task without an explicit stored memory variable. Future left-versus-right choice is perfectly decodable from reservoir state with accuracy 0, whereas decoding from raw sensor values yields SVM accuracy 1 and KNN accuracy 2 (Chaix-Eichel et al., 2022). The authors interpret this as dynamic working memory embedded in ongoing recurrent dynamics rather than in an explicit symbolic register.
CogNGen pushes in the opposite direction by adding explicit internal memory actions. On MiniGrid tasks with 3 partial observations and six actions, it uses a working-memory slot buffer, short- and long-term MINERVA 2 memories, and predictive processing circuits. On the Memory task, CogNGen reaches 98.5% success, compared with 48.5% for RnD, 48.0% for BeBold DQN-CNT, and 40.0% for DQN (Ororbia et al., 2022). This is a strong indication that delayed recall may benefit from explicit store/ignore decisions rather than from exploration bonuses alone.
RATE, finally, argues for recurrent transformer memory in memory-intensive offline RL. The paper does not evaluate Memory Maze; its memory-focused benchmarks are ViZDoom-Two-Colors and T-Maze. Still, its result that recurrent memory improves when the relevant cue and decision point are separated by a long temporal gap is directly relevant to Memory-Maze-style tasks (Cherepanov et al., 2023).
5. Language-first and dynamic successors
Recent benchmarks generalize the Memory-Maze problem into language-first or dynamically changing environments. These works retain the core requirement of remembering hidden state over long horizons, but they shift the emphasis from fixed maze recall toward belief maintenance, mechanic induction, or cross-episode strategy consolidation.
AGI Maze is a benchmark framework for world-modeling agents in grid-based, text-mediated environments (Potapov, 1 Jul 2026). Typical maze sizes range from 3x3 to 8x8. The agent receives only the start position and grid size, not the map itself, and must infer and remember its own location, walls, traversable passages, inventory, and hidden mechanics. The environment contains an outer “monolith” with exactly one opening as the exit, a treasure chest, its key, and in some variants an exit key. More difficult instances add rivers and pit cycles, so “the same observation can correspond to multiple locations, and the agent must maintain a belief (not precise knowledge) over where it might be.” No tested vanilla LLM reaches 100% even on small TRAINING mazes, and none of the light models outperformed the random-walk agent for mazes 5x4 and larger. A crude working-memory note-taking baseline improves stronger models substantially on S3-03, raising GPT-5.5 from 30% to 60% and Gemini 3.5 Flash from 40% to 70%.
EvoEmpirBench extends the idea further by making the maze dynamic and multi-objective (Zhao et al., 16 Sep 2025). Its locally observable maze uses a 4 grid, hidden cells denoted by 5, and 12 movement actions corresponding to 1-, 2-, and 3-step moves in the four cardinal directions. Easy levels contain 5 coins and no monsters; medium adds 2 moving monsters; hard adds the same monsters plus four items: Pickaxe/Shovel, Sword, Magnet, and Key. The scoring system assigns 6 for a new cell explored, 7 for a coin, 8 per step, 9 for life loss, and 0 for reaching the goal. Full-Vision ablations sharply improve performance, with GPT-4.1 rising from 73.33 success in standard EEB maze evaluation to 93.33 under full visibility, indicating that partial observability and memory are major sources of difficulty. The paper’s Agent-ExpVer framework uses subjective experience summaries and a validated truth repository; on the maze task it raises GPT-4.1 from 73.33 to 78.89 success and Qwen2.5-32B from 42.22 to 54.44.
These benchmarks suggest that the Memory-Maze concept is expanding from static spatial recall toward a broader evaluation of persistent state representation. In AGI Maze the critical variable is often a belief over hidden topology or hidden transition dynamics. In EvoEmpirBench it is a changing world state with hazards, tools, and persistent modifications. Both retain the defining Memory-Maze constraint that local perception is insufficient.
6. Systems-engineering usage of “Memory-Maze”
In an unrelated but technically revealing usage, “Memory-Maze” denotes the condition in which engineers are told to “optimize memory,” even though the relevant notion of memory no longer has a single stable meaning (Kudrjavets et al., 2023). The paper identifies four reasons for the maze: the prevalence of OOM killers, implicit allocations in modern languages, Linux’s default overcommit behavior, and the rise in complexity and terminology related to memory management.
The core argument is that memory is “highly context-dependent.” Depending on operating system and runtime, memory may refer to virtual address space, resident pages, quota-relevant accounting, programmer-visible heap allocations, or runtime-managed object graphs. The paper explicitly lists Linux terms such as PSS, RSS, USS, and VSZ; Apple terms such as physical footprint, resident, wired, compressed, purgeable, and working set; and Windows terms such as commit size, paged pool, non-paged pool, and reserved memory.
This matters operationally because engineers usually want to do three things: “(a) avoid premature termination of their applications, (b) stay under a certain quota or limit of memory usage, and (c) optimize the metrics that matter in a particular context.” The missing bridge is a mapping between intents and actions. On iOS, for example, OOM behavior is tied to physical footprint rather than to a simple heap-size notion. The paper reproduces the XNU definition:
1
In this systems sense, the maze is conceptual rather than spatial. The programmer’s mental model may be object counts, heap allocations, or ARC references, while the OS decision model is an aggregate over categories such as internal_compressed, iokit_mapped, and page_table. A plausible implication is that the non-navigation use of Memory-Maze generalizes the same structural problem seen in maze benchmarks: success depends on reconstructing hidden state from partial and context-dependent signals, and generic folklore breaks down without an explicit mapping between observation, latent mechanism, and actionable intervention.