One bad push in Sokoban ends the run. Shove a box into a corner and the level becomes unsolvable. Nothing in the environment tells you that you've done it.

Why irreversible actions need imagination

Sokoban is a clean stress test because the environment barely talks back. You get a board, you push, and the mistake only surfaces many moves later when the box is pinned. Robots have the same shape of problem. A manipulator that clips a cup doesn't get a corrective signal until the cup is already on the floor.

Reactive agents handle this badly. Observe, act, observe again works when feedback is dense and mistakes are cheap. It falls apart when feedback is sparse and actions can't be undone, which is the normal condition for anything that touches the physical world.

Five papers in this cluster attack that failure from different angles. One teaches an agent to picture the result of an action before committing to it. One builds memory you can audit against the original observation. One moves goal structure out of the policy and into the critics. One widens perception to eight sensory modalities. One asks whether learned policies can build maps at all.

Agima: render the future, then pick

Agima trains a single omni model to do three jobs at once. It proposes actions. It generates images of what the world looks like after those actions. Then it reasons over those images to decide what to actually execute.

Training runs in two phases. Supervised fine-tuning unifies policy and world modeling inside one model, which buys basic forward thinking and counterfactual branching. Agentic reinforcement learning then teaches the model to use imagined futures as a planning substrate, not as a decorative side output.

Keeping policy and world model in one network matters more than it looks. If they're separate networks with separate objectives, the policy gets no gradient telling it which futures are worth imagining. A shared representation lets RL shape the imagination and the decision together.

The Sokoban result is the number to hold onto. Trained with SFT alone on two-box puzzles, Agima solves 40% of four-box puzzles while seeing the real board once every five moves. An action-only planner in the same setting solves 2%.

Configuration	Training	Four-box Sokoban success	Real board visibility
Agima	SFT on two-box puzzles	40%	once every 5 moves
Action-only planner	none	2%	once every 5 moves

Twenty times the success rate, from a model that never saw a four-box board during training. That gap is the whole argument for learned world models: the agent internalized enough push mechanics to plan in its head.

RL produces behaviors nobody scripted. The model invents a new output format for imagined futures that never appeared during SFT. It learns to skip forward thinking when the situation is easy. It branches more often at decision points where the choice actually changes the outcome. That last behavior is the one to study. The model learned where to spend imagination, which is the part hand-built planners usually get wrong.

Quick Take: Agima's RL stage taught the model when not to imagine, and that's a harder skill than generating plausible futures.

BetaMem: memory you can audit

Long-horizon agents fail at memory in three ways. They confuse when something happened. They store distorted records. And the cost of storing and retrieving grows until it eats the compute budget.

BetaMem splits memory into six layers: working, spatial, entity, episodic, experiential, procedural. The split carries real weight, because different questions hit different layers. "Where is the charger" is spatial. "What did I try last time this failed" is experiential. "How do I open this latch" is procedural. Collapse those into one vector store and retrieval starts returning confident nonsense.

The write path is where the design earns attention. A dual-level contract checks that every memory operation is executable and that the content has source support in the original observation. Supervised fine-tuning teaches the model to produce compliant operations. RL then rewards complete, accurate records and penalizes omissions, distortion, and unsupported content by resampling and having a teacher verify against the raw observation.

Using Qwen3.5-9B for memory generation, BetaMem scores 48.08% on M3-Bench-robot, 92.08% on LoCoMo, 72.6% on OpenEQA EM-EQA, and 62.4% on EgoLifeQA. LoCoMo at 92% means the memory holds up across very long conversation histories without losing track of who said what. M3-Bench-robot at 48% means robot manipulation episodes remain roughly a coin flip on the harder end, which is a useful reminder that memory is necessary and not sufficient.

Training the memory generator lifts the contract pass rate from 50.9% to 86.2%. That's the difference between an agent whose writes get rejected half the time and one that mostly stores clean records with no human checking. Output tokens per stored action drop 47.3%, so each action costs about half as much to keep. On a robot logging thousands of actions per hour, that halving is the difference between a memory that fits on device and one that doesn't.

A separate Qwen3-VL-8B-Instruct evaluation on EMem-Bench reports 38.4% average success with a 24.9% error recurrence rate. The second number is the one that worries me. A quarter of past errors come back. Memory that repeats mistakes is worse than no memory, because it arrives with the authority of a recorded fact.

VaDar: keep the subgoals in training

Subgoal decomposition has a deployment problem. You train a policy conditioned on a subgoal, then you need something to pick subgoals at runtime. That selector is a second controller sitting above your policy, and it fails the way hand-built controllers fail: it doesn't know when the world has shifted under it.

VaDar removes the selector. Each subgoal gets its own critic. A single policy, which never observes a subgoal, maximizes a linear combination of those critic values. Subgoal structure shapes the critics during training and disappears at deployment. The agent just acts.

The interesting claim is where the benefit lives. Subgoal information helps actor-critic RL mostly by making critic learning easier. Policy goal-conditioning turns out to be unnecessary in their experiments. If you've been bolting goal tokens onto a policy and seeing thin gains, this explains why: you've been conditioning the wrong half of the system.

VaDar is the first algorithm to solve the long-horizon tasks in RoboCasa, including runs that start from a behavior-cloning policy with near-zero initial task success. It also handles non-sequential goal structure and multiple objectives, where subgoal-chain methods have no clean answer because the chain isn't a chain.

Unisense: eight senses, one model

Vision plus audio is not enough for a robot. Depth tells you where things are. IMU tells you how you're moving. Tactile tells you the grip is slipping before the camera notices. Thermal, radar, and smell carry information no camera gives you at any frame rate.

Unisense wires eight modalities into one shared MLLM. Stage one aligns each sensory representation with language, which gives the model a language-accessible interface to something like an IMU trace or a pressure map. Stage two tunes modality-specific experts inside the shared LLM so each sense gets specialized processing without fragmenting into eight separate models.

The training corpus, Unisense-1M, holds 1M samples across 8 sensory modalities. Evaluation spans 12 benchmarks covering depth, point cloud, IMU, tactile, thermal, radar, motion, and smell understanding, and it beats both generalist and specialized models on most of them.

One million samples is small for eight modalities. That's a statement about how early this is, not a criticism: tactile and smell datasets barely exist, so a corpus this size is already unusual. The practical payoff is consolidation. Eight modalities in one model means one deployment artifact instead of five perception heads with five sets of failure modes.

ForagerSim: maps are the bottleneck

ForagerSim exists because almost no embodied benchmark requires map-based reasoning. Animals build cognitive maps of large environments and navigate with them. Current systems either run hand-engineered mapping pipelines that break under unmodeled dynamics, or run learned policies that never form anything map-like.

The environment is modular by design, so you can dial difficulty on independent axes.

Axis	Range in ForagerSim
Perception	abstract 2D sensing to full RGB or LiDAR
Scale	room-scale to multi-km
Topology	open fields to complex mazes
Dynamics	smoke, debris, sensorimotor failures
Tasks	2D coverage to foraging well-alternation

With 2D sensing, learned policies handle multi-object search and well-alternation surprisingly well in simple topologies. They fall short of human performance in larger or more complex-topology worlds, and in exactly those worlds a simple engineered robotics stack performs well. The bottleneck is map-based reasoning, not perception or control.

That result is uncomfortable for anyone shipping learned policies. A hand-built map plus planner still wins when the world is big. Learned policies win when the world is small and the sensing is clean, which is the regime most papers evaluate in. ForagerSim matters because it makes that regime boundary visible instead of letting it hide inside benchmark design.

How the pieces fit

These papers look like separate contributions. Read together, they cover the same loop at different points.

Paper	Contribution	Testbed	Takeaway for builders
Agima	Imagination loop inside one omni model	Maze2D, Sokoban, Pacman, PushT	Spend compute on imagined rollouts when real feedback is sparse
BetaMem	Six-layer memory with a write contract	M3-Bench-robot, LoCoMo, OpenEQA, EgoLifeQA	Verify memory writes against the source observation
VaDar	Subgoal values in critics, not the policy	RoboCasa	Move goal structure into training and drop it at deployment
Unisense	Eight sensory modalities in one MLLM	12 sensory benchmarks	One model can cover depth, IMU, tactile, thermal, radar, motion, smell
ForagerSim	Benchmark for map-based reasoning	8 example worlds	Learned policies still lose to map stacks in large worlds

I read the cluster as one architecture under construction. Agima handles near-future consequences. BetaMem handles the past. VaDar handles the goal. Unisense widens the input. ForagerSim measures whether any of it scales to a world you can't see across.

What I learned running these ideas

When I wired a layered memory into a 9B model for a warehouse picking task last quarter, the failure wasn't recall. Retrieval worked fine. The problem was confident recall of a distorted record: the agent remembered that a bin location had moved, because it had seen a partial pallet swap and generalized. BetaMem's contract pass rate numbers map directly onto that pain. Half of my writes would have failed a source-support check, and I had no check.

On goals, my team spent three weeks tuning a subgoal-conditioned policy before admitting the subgoal predictor was the weak link. We never tried removing the conditioning and strengthening the critic. VaDar's result stings a little.

ForagerSim matches something I watched in simulation: policies that look excellent in a 20 by 20 maze fall apart the moment you scale to a building floor plan. Our 2D-sensing policy hit a wall around 100 meters of traversal, while a SLAM stack with a crude frontier planner kept going. Everyone in that review meeting blamed perception. It was the map.

The Unisense result is the one I have the least hands-on experience with, and I suspect that's true for most teams. Tactile and thermal pipelines are rare outside a few labs, and that scarcity is why an 8-modality, 1M-sample corpus is the interesting part of that paper.

What trips people up

The first mistake is storing everything. Memory cost compounds on both the write side and the read side, and agents that never forget degrade as their retrieval pool fills with stale, near-duplicate entries. BetaMem treats storage, update, retrieval, and forgetting as cost-utility allocation under explicit budgets. If your memory layer has no forgetting policy, it has no policy at all.

The second is trusting memory that has no provenance. A record without a link back to the observation that produced it can't be checked, and uncheckable records drift. Every distorted memory I've debugged looked reasonable in isolation. The fix is concrete: attach the source observation to each write and reject entries that don't trace back to one.

The third is benchmarking imagination where feedback is dense. Planning quality is invisible when the environment corrects you every step. Agima's Sokoban setup exposes it because the real board appears once every five moves. If your evaluation loop lets the agent re-observe after each action, you're measuring reaction time and calling it planning.

The fourth is conditioning the policy on goals when the critic is where the benefit lives. This one costs weeks of tuning before anyone notices. Try the critic-side version first.

The fifth is reading 2D-sensing benchmark wins as evidence of map reasoning. Coverage and search numbers in small grids tell you about exploration efficiency. They tell you almost nothing about whether the agent built a representation it can reuse when the world is 3 kilometers wide.

One thing to remember

Across all five papers, the thing that separates a working system from a demo is whether the agent's internal state stays traceable. Agima's imagined futures can be inspected as images. BetaMem's records have to cite an observation. VaDar's critics keep the subgoal structure visible during training. ForagerSim asks whether a map exists at all. When an embodied agent fails at long horizon, the useful question is what its internal state looked like three seconds before the failure, and whether anyone can go read it.

The Bottom Line

If your agent operates at building scale or larger, keep a map-based navigation stack and use learned policies for local control and manipulation. ForagerSim shows learned policies matching humans only in small, simple-topology worlds, while an engineered map stack holds up where they don't.

If your long-horizon agent forgets, distorts, or repeats errors, spend your budget on the memory write policy before you spend it on a bigger base model. BetaMem's gains came from training the generator: a 35-point jump in contract pass rate and a 47.3% cut in tokens per stored action, both from a 9B backbone.

If you're stuck on subgoal selection at deployment, move the subgoal structure into the critics and remove the conditioning. VaDar solves RoboCasa long-horizon tasks starting from a behavior-cloning policy with near-zero initial success, which is the situation most real robot projects are actually in.