Latest / Embodied AI 101 / HyDRA: Hybrid Memory for Dynamic Video World Models
Transcript
- HyDRA: Hybrid Memory for Dynamic Video World Models. Generative video models have come a long way in just a few years. Once limited to short, stylized clips, they are now being pushed toward video world models – systems that can simulate extended scenes with moving cameras, characters, and objects over long duration. These models promise to become digital simulators of real or imagined environments, useful for robotics, VR, game engines, and more. But a key challenge has emerged: how to make these models remember coherently as they generate frame after frame. In particular, when an object or person moves out of one view and later reappears, naive video models often either freeze that subject in place or simply lose it altogether. The result is jarring — characters stand stock-still behind corners, or spontaneously vanish from the scene. The recent HyDRA model from Kuaishou’s Kling AI video team tackles exactly this problem by introducing a hybrid memory architecture that explicitly preserves the identity and motion of dynamic subjects even when they’re out of view. In this episode we’ll unpack what HyDRA does, why it matters, and how it fits into the emerging field of memory-augmented video generation. The key insight behind HyDRA is that world models need memory. When a camera or the viewpoint moves, or a character walks behind an occluder, we want our model to know “Aha, that was Bob the runner, and he’s still running off-camera.” Human perception does this automatically – toddlers learn object permanence early on. But many neural video models are effectively stateless: they process a sliding window of recent frames and don’t truly store any long-term object-centric state. As a result, once an object leaves the immediate context window, the model “forgets” it. HyDRA’s authors note that previous work has highlighted this issue. For example, a recent NeurIPS poster on Video World Models with Long-term Spatial Memory pointed out that standard models “often struggle to maintain scene consistency during revisits, leading to severe forgetting” of the environment. In that work and others, the solution was to build an explicit static 3D map or spatial memory of the scene geometry. But as the MosaicMem paper notes, explicit 3D memory is great for preserving static background landmarks, yet it still “struggle[s] to depict moving objects”. In practice, many moving characters or objects end up getting lost by the model: either they stop moving (frozen) or the model simply ignores them (vanishing). HyDRA tackles exactly this “dynamic chunk” of the memory problem, focusing on ensuring identity and motion continuity for objects that go out-of-view. The Memory Bottleneck in Video World Models. To see why memory is crucial, let’s briefly recap how modern video generators work. A common approach is latent diffusion: begin with a low- or medium-resolution video (or noise) and gradually refine it into a high-quality result, frame by frame, guided by text or other controls. Architecturally, these systems often use transformers or convolutional models that have a “temporal context window” – essentially keeping only the last few dozen frames in working memory. This works fine for brief clips. However, open-ended video tasks require much longer temporal consistency. As soon as an object leaves that context window, the model has no explicit record of it. The recent mechanistic survey of video models puts it well: moving from an “arbitrary video clip” to a world model (a continually evolving environment) demands adding data-structure-style memory into the architecture. In fact, researchers explicitly identify “enhancing persistence via data-driven memory” as one of the two big challenges to making robust video simulators. In other words, to build a model that “remembers” its simulated world like a human or a robot does, we need memory mechanisms. Several earlier works have added memory in various ways. One line of work (e.g. Wu et al.) built a long-term spatial memory: as the model generates frames and camera moves, it accumulates a 3D point cloud or map of what it has seen, and uses that map to re-render future frames consistently. This helps with static scene features (buildings, hills, etc.), but it typically treats moving objects as transient – once a person walks away and the static map is built without them, there’s no memory slot for the person. Another approach, MosaicMem, proposed a hybrid spatial memory which actually integrated both explicit 3D patches (for static structure) and the model’s native latent space (for everything else). MosaicMem was very promising for consistent backgrounds and camera moves, but by design it still relegates moving objects to the model’s latent inpainting, which can mis-predict their motion or appearance over time. As the MosaicMem authors note, while explicit geometry makes the camera motion and backgrounds coherent, it “struggle[s] to depict moving objects”. In contrast, HyDRA introduces a second kind of memory specifically for dynamics. In short, the emerging consensus is: video world models need two things in memory – the static layout of the scene (like a map of the apartment or city block) and the dynamic state of each moving object (think of it as a set of object-centric states). Prior work had mostly focused on the static side. HyDRA zeroes in on the dynamic side: it proposes keeping a persistent memory state for each moving subject, so that even if that subject goes off-screen, the model still “knows” who it was and where it is headed. This is what the “out of sight, not out of mind” title alludes to. As a result, HyDRA can continue to update each object’s trajectory and appearance in memory, leading to more realistic consistency when that object reappears. The Frozen and Vanishing Object Problem. Why is this memory for dynamic subjects needed? The root issue is simple: standard video models have fixed context windows. If you look at only, say, ten frames at a time, and an object has scurried out of that window, mathematically it’s treated as new when it comes back. In practice this means two broken behaviors:. Frozen objects: If the model doesn’t actively update what happens to an object behind the camera, it effectively “freezes” it in place. Imagine a car driving off to the right of the screen. Even after it’s out of view, the model’s internal state still remembers it in the original position (because nothing changed it) – so if the camera pans back, the car will reappear but it won’t have moved. This is clearly wrong physically, but happens because there’s no mechanism to keep “pushing” it forward when the camera isn’t looking. Some video models may dim or hide the object (conditioning problems), but if they do show it, it stays fixed. This is a kind of memory shortfall: the object’s state stopped updating the moment it left view. Vanishing objects: Worse, sometimes the model simply behaves as if the object never existed beyond a point. If the out-of-view gap is long or the model’s generation drifts, when the object should re-enter the frame, the model doesn’t have anything to put back in. The object effectively “vanishes.” It might look like a randomly sampled new object appears or an empty space where it should have been. This breaks identity continuity. For example, if Alice walks out of the frame and then back in, the model without proper memory might treat the newcomer as a generic person, not specifically Alice with her blue hat we saw before. Both behaviors violate physical intuition and are aggravating. In robotics or embodied AI scenarios, this kind of memory lapse is also problematic for planning: if a robot remembers a person or obstacle should be somewhere, it can act accordingly; if it forgets, it might act on a false scene. In computer vision terms, this is reminiscent of the object tracking challenge: when an object goes out of view of the camera, a robust tracker tries to predict where it will come back. HyDRA essentially builds that tracking ability into the generative model itself. It watches for out-of-view events and maintains a trail of breadcrumbs in memory for each subject. What makes this hard is that generative models don’t usually have a convenient “memory register” like traditional simulators might. You can’t just ask a Transformer “what was the red car’s last velocity vector?” without having specifically built an input/output pathway for it. HyDRA’s contribution is to design such a pathway. According to the summary, its memory is hybrid: it likely combines two different modes of memory to cover both identity and motion. HyDRA’s Hybrid Memory Architecture. Although we don’t have the paper text in front of us, the information suggests HyDRA uses a dual-memory system. We’ll infer how this likely works by analogy to other memory-augmented models. One memory stream is likely devoted to object identity (appearance features, maybe an embedding) and another to object motion state (position, velocity, etc.). The term “hybrid” implies they combine explicit and implicit representations. Here’s a plausible breakdown:. Persistent Object Slots: HyDRA probably allocates a slot or key-value entry for each dynamic subject. When a new video starts, every moving object that appears gets a memory slot assigned. That slot stores a fixed latent embedding that represents the object’s identity (appearance, ND identity cues). This is the “identity memory.” It ensures that when the object reappears, the model can infuse the frame with consistent visual features – say, the same face, clothing color, lighting, etc. This kind of mechanism is reminiscent of object-centric slot attention models, but here it’s used in a diffusion/Transformer setting. We suspect HyDRA’s memory keys might be learned vectors or embeddings associated with the object, and the values contain contextual information (like the latest feature or state). Dynamic State Tracker: In addition to appearance, HyDRA needs to remember where the object is. It likely keeps some form of state variables in memory – for example, a 2D or 3D position and velocity. When the object is visible, the model updates these via normal inference (e.g. derivative from frame to frame). When the object goes out of view, HyDRA doesn’t just drop it; instead it continues to update these variables based on the last known motion. In practice this could be done by a small learned model (perhaps a tiny physics module or even a linear extrapolation) that advances the object’s position in memory on each time step, even though it’s no longer observed. This way, the “time since last seen” is accounted for. When the camera comes back or the scene ends, the model “retrieves” that state and regenerates the object in the right place and pose. Putting these together, HyDRA’s memory looks something like this: for each subject, a memory entry holds. At each new frame, the generative network queries this memory (via attention perhaps) to help render the scene. If the object is present, the network both conditions on the memory and then updates it with the new observation. If the object is absent, the network still writes into memory by predicting how the state evolves. The term “hybrid” likely refers to mixing this object-level memory with the model’s native frame-level latent memory. In concrete terms, HyDRA might weave memory reads into the diffusion process. For example, a video diffusion model often uses cross-attention on frame-history latents. HyDRA could augment this by also cross-attending to the per-object memory values at each step. The retrieved memory then influences the sampling of new pixels such that an object’s color, shape, and implied motion remain consistent. On the flip side, after generating a frame, HyDRA uses its vision network to write back into memory: compressing (or "consolidating") whatever it just saw about each object into the memory slots. This design would address the identity and motion continuity very directly. The identity is preserved because the appearance feature is never lost; the model always has a pointer to what that object looks like. Motion is preserved because the memory continues to carry a moving estimate of where it is. This is quite different from a naive diffusion model, which only ever knows the object within a fixed sliding window of frames. It’s also worth contrasting HyDRA with the static-memory approaches. Pure 3D memory (like in some world models) focuses on building a map of the environment. That might tell you “there is a building at (x,y,z)” but not “Alice (the runner we saw) is currently sprinting upwind.” By focusing on dynamic objects, HyDRA fills that gap. In effect, it attaches semantic meaning (identity) and time evolution to what would otherwise be anonymous 3D points or blobs. Architecture in Detail (Hypothetical). We don’t have figures from the paper, but let’s imagine how HyDRA might be implemented under the hood. Based on the problem statement and prior art, here are possible components:. Memory Bank: A set of trainable key-value slots, one per tracked object (or a fixed maximum number). The keys might represent object identities (learned vectors or even class labels) and the values hold dynamic state. Update Mechanism: Whenever an object is visible in a frame, the system extracts its features (via the diffusion VAE’s encoder or a backbone network) and uses them to update the memory value. This could be done with gated updates (like GRU or attention-based writing). When the object isn’t visible, the update mechanism might instead use a motion model: e.g. value = value + velocity, or run a small prediction network. Retrieval Mechanism: During frame generation, before or during each denoising step, the model queries the memory. For example, it might use cross-attention where the memory values are the keys/values and the current frame's latent tokens are queries. This lets the network “remember” details from memory as it predicts pixel values. For instance, if generating the new frame and the object is partially leaving view, the network attends to memory to recall its appearance. Motion Integration: To explicitly handle spatial consistency, the memory could also encode the object’s last known 3D or 2D coordinates. The model’s camera or coordinate system is known (since this is a controlled world model with egocentric actions), so the memory slot might store a (x,y,z) and velocity vector. The generator would use these to put the object in the correct location in the new frame. Meanwhile, the velocity could get updated by the difference in positions when observed. Temporal Coherence Losses: Likely HyDRA training includes losses that penalize identity switches or motion discontinuities. For example, if an object reappears, the model should reconstruct it closely to what its memory says it should be. The frozen/vanishing problem might be explicitly addressed by training on sequences where objects exit the frame and re-enter, forcing the memory to be used. Many video generation papers train on synthesized camera or agent actions, and here they might ensure dynamic objects leave and re-enter as part of the dataset. Without the actual architecture diagrams, we can’t say exactly how HyDRA plugs into Kuaishou’s Kling backbone (which uses a 3D VAE and diffusion transformer). But conceptually it’s adding a separate memory branch that connects frames over time. The key is that this branch is instance-aware: it knows there is a distinct “subject A” that reappears, rather than treating all motion as generic background artifacts. HyDRA vs. Prior Hybrid Memory Models. HyDRA isn’t the first to hybridize memory, but its focus on dynamic persistence is novel. Let’s compare it to other memory ideas:. Static Spatial Memory (Wu et al.): The Stanford/CUHK team’s long-term spatial memory builds a shared map of the scene (e.g. a 3D point cloud) and retrieves from it to make revisited scenes consistent. This is great for stationary parts of the world (landmarks, rooms, terrain). But they acknowledge it doesn’t inherently handle dynamic subjects. If a scene has moving people, the static map will eventually become inconsistent (maybe it erases them or averages them out). HyDRA can be seen as complementary: it would handle those moving bits that a purely static map forgets. Mosaic Memory (Wei Yu et al.): The MosaicMem paper introduced the idea of retrieving spatial patches from 3D memory and stitching them into the view. It’s “hybrid” in that it uses explicit 3D for what stays the same, and lets the model’s implicit generation handle what changes. MosaicMem’s hybrid memory is spatial but not object-centric. It never explicitly says “this chair has left the room” and it actually lets the model predict changes in dynamic regions. HyDRA, in contrast, likely treats the object as an agent and explicitly pushes its predicted state into memory when it disappears. In their own words, MosaicMem observed that explicit 3D memory “struggle[s] to depict moving objects”. HyDRA directly addresses that shortcoming by dedicating memory to the moving objects themselves. One can almost think of HyDRA as adding a “Halo” to MosaicMem’s approach: not only will the static patches be retrieved, but also the moving patches (the faces, wheels, runners) are remembered so they can reappear correctly. Implicit Transformer Memory: Some video transformers use key-value caching (similar to GPT models) to handle longer time horizons. But those caches typically tunnel only a fixed number of past frames (not object ID tracking). HyDRA’s memory is likely more structured: it’s not just a queue of past latents, but a set of dynamic entities with roles. This is a much stronger form of continuity – think of it as storing meaningful chunks (object states) rather than a linear tail of frames. So in summary, HyDRA’s hybrid memory is explicitly object-aware and action-aware. It goes beyond purely spatial (3D map) or purely latent (perceptual cache) memories by tagging identity and motion to each entity. That is how it can preserve continuity in identity and movement. Addressing Identity Continuity. One of HyDRA’s promises is identity continuity: an object that leaves and re-enters should remain recognizable as the same object. Without HyDRA, a model might redraw a generic new object, or slightly change its appearance (e.g. hair color or shape might drift), because there is no memory enforcing it. With HyDRA, this is prevented in several ways:. Appearance Memory: The memory slot’s value likely contains a latent code of the object’s appearance (possibly disentangled to focus on appearance rather than pose). When re-rendering a frame, this code can be fed into the model to bias the generation. For example, if we see a person in a red coat in frame 10 and they leave frame, the memory retains a latent “red coat, blue hat, glasses” signature. When the person reappears, the diffusion model’s conditioning input could be augmented by this signature so it generates the person with the same coat and hat. If HyDRA is implemented via cross-attention, the model’s queries (the current frame features) can attend to the memory values (the stored appearance) and literally copy or refine those features into the output. This ensures the answer’s color scheme, textures, and even identity features match the memorized identity. Name or ID Tagging (if used): Some systems assign explicit ID tags to objects (like “Alice” vs “Bob”) as part of memory. HyDRA could optionally incorporate such discrete identity labels. If the model is told “this memory slot is Alice”, it can even be prompted in generation (“keep calling this person Alice’s name”) to avoid switching names. This might be more of an engineering detail, but it’s a strategy in certain multi-object tracking systems. Contrastive Training: Another possibility is that HyDRA’s training includes a loss that forces re-generated reappearances to match the memorized features of the original. For instance, reconstructing the same face or object might be supervised via a perceptual loss or a contrastive loss with the memory embedding. In any case, the core idea is: the memory enforces a kind of “content consistency” that typical attention alone would not. All of this preserves identity. HyDRA’s memory acts like a short biography for each object: “Who was it, and what did it look like last time we saw it?” This biography then flows into each new frame generation, preventing any hallucinated identity swap. Ensuring Motion Continuity. Identity is one piece; the other is motion continuity. If HyDRA just remembered how Alice looks but not how she moves, she could reappear at the wrong place or knee tilt. The HyDRA summary explicitly mentions motion continuity, which implies that memory also carries information about how the entity is moving. Here’s how that might work:. Predictive State Updates: Each object memory might include a notion of velocity or trajectory. For example, if the camera is static and Alice walks east at 1 m/s, every frame while she’s visible the model could estimate her velocity vector (maybe via displacement of her bounding box or world coordinates). Once she disappears, HyDRA uses that velocity to predict where she should be next. Concretely, each time step, the memory updates Alice’s position:. This is essentially a learned or even simple physics extrapolation done within memory. It ensures that as time goes on, Alice’s memory “position” drifts continuously, rather than sitting still. When the camera comes back or we roll forward video, the generator reads that updated position from memory to place her correctly. Action and Ego-Motion Conditioning: Often video world models are driven by “actions” (e.g. camera moves) or text controls. HyDRA can leverage those too. If the model generates “Walk forward 5 seconds”, HyDRA’s memory could tie that instruction to the object’s movement. For instance, if Alice is commanded to move right for 5 sec, the memory might be updated as if her velocity is to the right. Because HyDRA has a notion of discrete time-step updates, it can integrate these actions into the memory state. This way, the memory sequence becomes a dynamic trajectory in sync with the control inputs. Ego-Motion Compensation: In many scenarios, objects move relative to the camera. If the camera is moving, the model knows the camera’s viewpoint change; HyDRA could use that to also update object positions in a global coordinate frame. This is a bit like SLAM (simultaneous localization and mapping) but for dynamic objects. The memory might convert camera-relative motion into world-relative motion for each object. By doing this properly, even if the camera does a quick pan, the memory will track where the object would now appear in the new view. By maintaining and updating this motion state, HyDRA ensures continuity. If Alice disappeared behind a wall, the memory might end up with “Alice is now 10 meters to the right of the camera, moving west at 1.2 m/s.” When generating the next frame that brings her back, the model will render her at that predicted offset, rather than popping her at the old coordinate or magically at a random new spot. She will be in the expected place given how long she was hidden. In a sense, HyDRA is injecting a little bit of physics simulation into the world model, tailored specifically to each dynamic subject. Putting It All Together: A Generation Example. Let’s walk through a concrete hypothetical example of HyDRA in action. Suppose our system is generating a video of a soccer game under our control. We start with a text prompt: “A soccer field, players running, the camera decides to zoom in on one player and then pan away.” Traditional video diffusion or world models would produce frames one by one. With HyDRA, we also track players. Frame 1-50: The model sees two players (Alice in red, Bob in blue). It initializes two memory slots. Alice’s slot stores “red jersey, blonde hair” + her initial position (say, at field coordinates (10, 8)) and velocity (1 m/s northeast). Bob’s slot stores “blue jersey, dark hair” + his initial pos (12, 15) and velocity (1.5 m/s northwest). The model generates frames 1-50 with the usual diffusion transformer, but at each step it also reads from these slots (ensuring continuity of their appearances) and updates them based on computed displacements. Frame 51: The camera decides to zoom in on Alice, and then at frame 52 it pans away from Alice abruptly (Alice leaves view on the right side, off-camera). For frames 51-60, Bob might remain in partial view or also exit; HelDRA’s memory notices Alice is no longer in the frame (perhaps her detection confidence is low). It stops writing new visual input to her slot. Instead, each frame it continues her motion: position = position + velocity * dt (say dt=1 frame). So by frame 60, the memory says “Alice is now near coordinates (15,10) off-camera”. Her memory slot’s velocity might even update if she dribbles the ball (the model can infer a more complex motion from the action inputs). Meanwhile, Bob may remain or also exit, handled similarly. Frame 61-100: The camera eventually pans back and Alice enters the frame again, now at frame 70. When generating frame 70, the diffusion model queries Alice’s memory slot. It sees her identity (“red jersey, blonde hair”) and predicted position (“should be right of center now”). The output is conditioned on reconstructing Alice with those features at ~frame70’s frame. If the model’s latent missed some cycle, the memory slot nudges it with the correct appearance. Alice’s velocity may get fine-tuned if the model sees her, and memory is updated. Similarly, Bob might re-enter. Because memory never let Alice completely vanish from internal representation, she reappears seamlessly. If HyDRA were not used, a vanilla model might have lost track of Alice once she stepped out; upon return it might draw a generic red-shirt player, perhaps even changing her looks. With HyDRA, that doesn’t happen because the “who” and “where” of Alice were preserved. The model thus handles dynamic continuity the way we intuitively want. Experimental Evidence. Although we don’t have the paper’s figures here, we can discuss expected empirical outcomes. In practice, HyDRA should be evaluated on video generation tasks that involve moving subjects and out-of-view events. Likely metrics include consistency of identity (e.g. a learned embedding distance between reappeared object and original should be small), motion accuracy (predicted vs actual displacement), and visual quality (PSNR/LPIPS on reappearance frames). The summary claims HyDRA addresses the frozen/vanishing issues — qualitatively we’d expect before/after comparisons showing that models without HyDRA freeze or lose objects, while HyDRA keeps them alive. For example, if we compare HyDRA to a baseline on a test where a person walks out of frame for 30 frames and comes back, the baseline might give a mismatched face on return (identity error), whereas HyDRA should preserve the face. Or in a car scenario, a baseline might have the car appear in the wrong lane or vanishing entirely, but HyDRA restores it smoothly. The authors probably show side-by-side video frames highlighting this difference. Moreover, on longer videos HyDRA should yield better “long-term consistency” scores. The Wu et al. poster measured consistency improvements via spatial overlap or using pose estimators on static elements; HyDRA would similarly improve consistency of moving elements. In short, we anticipate experiments confirming that HyDRA significantly reduces those failure modes. Impact on Embodied AI and Robotics. While HyDRA comes from Kuaishou (a short-video company) and is framed in the context of text-to-video generation, its ideas have broader implications for embodied AI. In robotics, agents often operate under partial observability: they see only a part of their world at any moment, and must remember dynamic objects like people, other robots, or tools. A memory module like HyDRA’s could be integrated into a robot’s world model: if the robot sees a person and then loses sight, it can continue to reason about where the person went. Concretely, imagine a home-assistant robot. It watches a child go into the kitchen. If the child is momentarily out of view, the robot still needs to model that child’s location and trajectory (perhaps to avoid collisions or to bring the child a toy). HyDRA’s approach suggests that the robot’s perceptual system could maintain object-centric memories that persist off-camera. This could complement traditional SLAM (for static map) and multi-object tracking (for observed frames) by providing a generative or predictive memory for unseen motion. Another use case is simulated environments for training. For instance, in reinforcement learning, video world models are being considered as simulators. A HyDRA-like memory would make such simulators more realistic: a trained agent interacting with a HyDRA-driven simulator would see humans and vehicles move behind walls and reappear coherently, improving the realism of long-horizon planning tasks. In any scenario requiring multi-view or long-horizon consistency (e.g. following an object through a dynamic scene, dialogue with a person partially out of sight, or games that loop back on previously seen areas), HyDRA’s memory gives the model agency over “the memory of the world,” enriching the agent’s embodied experience. Limitations and Future Work. Of course, HyDRA is not a panacea. Explicitly tracking many dynamic objects may become complex if the scene is very crowded or if new objects enter and leave arbitrarily. How does HyDRA decide which in-view things to track? There's likely a maximum number of memory slots, which may limit scalability. Moreover, error can accumulate: if the predicted motion is slightly off while an object is out of view, it will reappear humanoidly but slightly misplaced unless corrected when seen again. This is a known challenge in any predictive tracking system. Looking ahead, a promising direction is integrating HyDRA with even richer memory systems. For example, one could combine the object memory of HyDRA with the static map memory of Wu et al., creating a full 3D world model that is both anatomically consistent (buildings, ground) and dynamically consistent (people, cars). Another idea is to have hierarchical memories: short-term frame buffer, HyDRA’s mid-term object history, and even longer-term “episodic memory” that remembers events (e.g. "Alice has entered the scene before, last time at deadline, etc."). It also raises questions about learning and supervision: HyDRA presumably needs data where objects leave/re-enter to train its memory. Crafting such datasets (or synthetic scenarios) is an open engineering task. Moreover, bridging the gap between this style of memory and controllers (LLMs or RL policies) is an exciting challenge: HyDRA currently sounds like a standalone video model module, but future AL agents might query it (“hey, where’s Alice since she left the room?”) or it might feed into scene understanding pipelines. The trend is clear: as video world models aim for “video game-like” consistency, architectures like HyDRA that incorporate specialized memory will become vital. The field is moving from generate plausible short clips toward simulate an ongoing story with cause and effect. Memory mechanisms are front and center in that shift. Conclusion. HyDRA’s Hybrid Memory tackles a crucial blind spot in video generation: the treatment of dynamic, out-of-view subjects. By design, it keeps track of who is moving and where they go, thus eliminating the frozen/vanishing artifacts that plague simpler models. This approach is a natural next step in video world modeling, building on recent advances in spatial memory and object-centric generation. For roboticists and embodied AI researchers, HyDRA offers a concrete method to imbue neural world simulators with more “common sense” about object permanence and motion. As these world models become components of planning and perception systems, having a memory to watch over moving entities is likely to be indispensable. HyDRA shows one promising way to do it: literally remembering to remember, so that no moving subject (or important action) is ever truly out of mind. Sources: The discussion above draws on the HyDRA summary and related literature on memory in video world models, including techniques from hybrid spatial memory approaches. These highlight both the problem of forgetting behind-the-scenes objects and the emerging solutions using long-term memory and object tracking.