On October 27, Google DeepMind released its fourth-generation world model, Genie 4, accompanied by official demo videos showcasing a wide range of new capabilities. Users can now modify scenes in real time using both keyboard inputs and natural language—such as making rain suddenly fall from the sky, shifting camera angles, or conjuring a new character out of thin air—while the generated footage incorporates synchronized audio and dialogue for the first time. Continuous single-session interaction has also doubled compared to last August’s third generation, expanding from one minute to two minutes. In addition, DeepMind demonstrated a clip of a humanoid robot playing checkers.
Yet a closer look at its technical architecture reveals something intriguing. Genie 4 achieves these complex capabilities not because the video model itself has learned physical laws and logical reasoning. On the contrary, DeepMind wrapped three distinct Gemini large language models around the video generator: one to supply commonsense knowledge during training, one to watch the screen at runtime and break complex tasks down into smaller steps, and a third dedicated entirely to calculating moves for the checkers-playing robot.
That design choice is worth pausing on. After all, if the goal were merely to simulate the physical world accurately and run collision detection, traditional 3D modeling and physics engines solved that problem with high precision decades ago—no massive AI model required. The reason the industry has poured billions of dollars and such high hopes into world models is the promise of emergent intelligence: without anyone manually building 3D assets or hand-coding physics equations, a model trained on vast troves of internet video would supposedly intuit physical laws and causality simply by predicting the next frame, much as large language models developed logical reasoning by predicting the next token. Why, then, by the fourth generation, has a top research lab like DeepMind abandoned the elegance of single-model emergence in favor of a multi-model assembly line? This architectural compromise explains why the broader world model field, despite generating enormous buzz over the past six months, has repeatedly hit walls when moving toward real-world deployment.
To understand why Genie 4 took this path, it helps to revisit the exact obstacle world models originally set out to overcome. While traditional physics engines calculate collisions and forces with pinpoint accuracy, every object and rule must be modeled and coded by hand, making them prohibitively expensive when scaling to the messy complexity of the real world. From the earliest prototypes two years ago through last year’s Genie 3, the academic ideal was to replicate the brute-force, end-to-end emergence of language models in the physical domain: train a generative model on enough video data to continuously predict the next frame from the previous frame and a player’s keystrokes, and an internal understanding of 3D space, object collisions, and causal laws would emerge on its own. Back then, aside from borrowing an image generator to produce the very first preview frame, the video model handled the entire interactive loop by itself.
Before long, however, that approach ran into a ceiling. Pure video models primarily learn short-term visual momentum spanning just a few seconds; once interactions stretch longer or require multi-step task completion, the scene gradually drifts and warps. In an interview with Bloomberg, Genie 4 co-first author Hang Qi candidly noted that even with single-session interactions extended to two minutes, the system still cannot guarantee consistent visuals and object permanence from start to finish.
Since relying on a standalone video model to shoulder every responsibility proved unworkable, the engineering team pivoted to a highly pragmatic alternative. From a pure research standpoint, bolting multiple models together lacks elegance; from an engineering standpoint, it makes complete sense. If no single model can do everything well, let each model handle what it does best and combine the pieces. The video model focuses strictly on rendering frames according to instructions, while commonsense grounding, task planning, and move calculation are offloaded to surrounding language models.
Each of the three external models directly patches a blind spot in
the pure video generator. During training, the team uses
Gemini Omni to inject commonsense knowledge about
real-world appearances and human motion. At runtime, when faced with
complex instructions, the backend calls Gemini 3.8 Flash as
a conductor model—both to monitor live frames and verify whether the
previous step has finished, and to rewrite user requests into detailed
text prompts that guide the video generator while automatically keeping
the camera coherent between keystrokes. As for the bipedal Apptronik
Apollo robot playing checkers in the official demo, the video model
itself has no idea how to play the game; an external
Gemini 4 Argon model calculates every move and feeds
step-by-step text instructions to guide the video model in rendering the
arm reaching out and sliding the piece.
Anyone who has built large-scale systems knows that cascaded pipelines carry an inherent vulnerability: the chain is long, and if any single link falters, the entire pipeline suffers. The outer language models responsible for reasoning operate on text, while the inner world model responsible for rendering operates on pixels, leaving the two sides to communicate solely by passing short text prompts back and forth.
It is like a director who cannot paint giving instructions over the phone to an illustrator who does not know how to play checkers. Text is a clumsy medium for specifying exact 3D coordinates or physical forces. Whenever the text script and the visual frame drift even slightly out of alignment, the robot’s motion distorts. Meanwhile, because the conductor model automatically takes over the camera between keystrokes to preserve visual continuity, it dulls the player’s sense of direct control. That DeepMind chose to accept the fragility and heavy compute overhead of this daisy-chained architecture—recruiting three language models to prop up a video generator—shows just how untenable the original dream of end-to-end physical emergence from video alone has become under current paradigms.
DeepMind’s architectural retreat is not an isolated case; the entire world model sector is undergoing a period of disenchantment. Why have world models struggled so much in practical deployment after commanding such sky-high expectations over the past two years? Much of the trouble stems from the industry conflating three fundamentally different capabilities.
In June this year, World Labs founder Fei-Fei Li published an essay on the functional taxonomy of world models to untangle this confusion. She pointed out that what people casually lump together as “world models” actually encompasses three distinct systems: first, renderers trained on internet-scale video to maximize visual realism; second, simulators trained on scarce 3D assets that demand exact spatial dimensions and faithful physical collisions; and third, planners that combine robot demonstration data to make action decisions. Optimizing for visual fidelity, she emphasized, is not the same as optimizing for physical accuracy. Over the past two years, the industry’s biggest misstep has been using the striking visuals of the first category—renderers—to promise capabilities that only the latter two can deliver.
Keeping that distinction in mind makes it clear why pure video world models struggle both to train factory robots and to replace modern game engines. For a robot operating on a factory floor, precise spatial dimensions and positional stability are non-negotiable. When the Niantic Spatial team benchmarked pure video models this September, they found that although the generated footage looked photorealistic, it lacked true metric scale and could not tell whether a corridor ahead was 30 centimeters or 35 centimeters wide. Worse, without an underlying 3D map to anchor the geometry, the generated spaces behaved like an M.C. Escher lithograph: a robot could make four consecutive 90-degree turns down a hallway to return to its starting point, only to find itself in a completely unfamiliar room.
To get around this limitation, teams focused on real-world deployment have turned to hybrid approaches. Niantic, for instance, simply has a person walk through a factory with a 360-degree camera to scan a centimeter-accurate 3D mesh in ten minutes, then uses generative models on top of that mesh to overlay varied lighting and environmental conditions for robot training. Meanwhile, AMI Labs, founded this March by Turing Award laureate Yann LeCun and Saining Xie, raised over $1 billion in seed funding with an explicit commitment not to generate pixels at all. In their view, predicting how leaves flutter in the wind or how ripples dance across water contributes nothing to understanding the physical world; burning compute on pixel prediction is a waste when models should instead predict future state transitions in an abstract representation space.
A similar dynamic has played out in game development. Back in January, when Google launched the web preview of its previous-generation Project Genie, Wall Street briefly feared that traditional game engines were headed for obsolescence, sending Unity’s stock plunging 24% in a single day and Take-Two down 14%, a sell-off covered in depth by The Guardian. Nine months later, not a single commercial game built on it has shipped. General Intuition founder Pim de Witte unpacked the reasons in a detailed essay. Traditional game engines run on deterministic code: how much health a player loses, how many weapons remain in an inventory, or whether a character has collided with a wall can be computed with total precision in microseconds. Asking a massive probabilistic video model to guess every second whether a wall is still there after the player turns around amounts to burning expensive GPU compute to clumsily approximate what traditional code already solves quickly and exactingly.
Feedback from working game developers echoes this reality. This year’s Game Developers Conference State of the Industry survey polled 2,300 professionals and found that more than half believe generative AI is having a negative impact on the industry; only 5% actually use such models in real-time gameplay loops, while the vast majority relegate them to early-stage brainstorming. Even DeepMind engineer Diego Rivas admitted in a TechCrunch interview that the team is still in an exploratory research phase and does not yet know what the final product form should look like—noting instead that film directors have been among the most active testers, using the tool to quickly pre-visualize camera angles and sketch out rough storyboards before principal photography.
That raises a natural question: if pure video architectures are retreating to multi-model pipelines and failing to displace game engines, why have tech giants recently shelled out $7 billion to $8 billion apiece to acquire these startups? The answer lies in the brutal unit economics of real-time consumer interaction.
The other practical barrier keeping world models from everyday users is the cloud inference bill ticking away every single second. When we play a traditional console or PC game, frame rendering happens on the player’s local GPU, meaning an extra hour of playtime costs the game publisher almost nothing in marginal cloud compute. Even on traditional cloud gaming services like GeForce NOW, amortized GPU hardware brings the cost down to roughly $0.30 to $0.50 per player per hour.
Real-time world models operate on a completely different cost curve, requiring data centers to continuously run massive video generation and language model inference every second. At public real-time video streaming rates on inference platform fal, running a session for a single hour costs between $144 and $288. Even startup Decart’s heavily compressed Oasis 3 real-time API charges two cents per second, which still adds up to $72 per hour—and when reporters tested it by making a U-turn in a car, the New York intersection they had just left still vanished into thin air.
Put simply, the cloud compute burned during a single hour of interactive play is enough to buy a flagship AAA game outright on Steam. That explains why Google, even while charging AI Ultra subscribers $250 a month, still caps individual Genie sessions at one to two minutes. If Google removed the cap and let a heavy user play for 40 hours a month, the cloud inference cost for that single user would leave Google losing nearly $3,000 a month—unit economics that no consumer subscription model can survive.
When consumer subscriptions cannot cover compute costs and independent startups lack the balance sheets to outlast Big Tech in a war of compute attrition, the most pragmatic exit is to sell to a chipmaker or vertical industry giant while valuations remain high. Three rapid-fire acquisitions over a mere 25-day span from late September to late October illustrate the exact predicament facing standalone world model startups.
The first landed in late September: just one month after unveiling its new Atlas framework, Fei-Fei Li’s World Labs sold to chip giant AMD in an $8.2 billion all-stock deal. In an open letter to her team, Li wrote that without dedicated hardware co-design, spatial intelligence would remain constrained in efficiency and scale, confined to the digital realm. For AMD, the prize was bringing World Labs’ core team directly into the design of next-generation GPU architectures to challenge NVIDIA in physical simulation ecosystems.
In mid-October, The Wall Street Journal reported that Amazon was in talks to acquire high-flying startup Decart for roughly $7 billion. One telling detail emerged from Israeli press reports: Anthropic had actually agreed in August to buy Decart for $6 billion to $7 billion, only to walk away in September after deep due diligence revealed that after three years of exploration, the startup still had no viable path to standalone profitability. When Amazon stepped in as the buyer, what it really wanted was DOS, Decart’s cross-chip inference optimization software stack, which can help AWS migrate enterprise customers’ compute workloads off NVIDIA GPUs and onto Amazon’s in-house Trainium3 chips.
Then in late October, Third Dimension AI, founded by former DeepMind researchers, announced its acquisition by electric automaker Rivian. In interviews, the founders acknowledged that a small startup simply could not serve customers across wildly different verticals like gaming, film, defense, and automotive all at once. Joining an automaker freed them from chasing commercial contracts across industries, letting them focus entirely on turning the 400,000 driving video clips uploaded daily by Rivian’s fleet into autonomous driving training scenarios—directly supporting the robotaxi partnership Rivian just signed with Uber.
At this point, one might wonder: if the end-to-end myth has unraveled and independent startups are folding into tech giants, do world models still hold irreplaceable value? They do—just not in consumer-facing entertainment, but in the backend of industrial simulation. Once stripped of the hype about replacing game engines, world models have quietly delivered substantial commercial results in low-fault-tolerance sectors like heavy industry and autonomous driving.
The cost equation flips completely depending on the domain. Burning $100 to $200 an hour on compute is a disaster for a consumer video game, but in autonomous driving and specialized robotics, crashing a real vehicle or robot on a physical test track can easily cost hundreds of thousands of dollars. Against that baseline, spending a few hundred dollars in a server rack to synthesize extreme edge cases is a bargain. A prime example is the Waymo World Model released this February, which builds directly on the previous-generation Genie 3 backbone—not for consumers, but exclusively to fill rare-scenario testing blind spots for Waymo’s autonomous fleet.
Traditionally, autonomous driving simulators have relied on 3D reconstruction techniques like Gaussian splatting to turn recorded street footage into 3D road environments. That approach, however, is tightly bound to the exact trajectory of the data-collection vehicle; if a test car makes an aggressive lane change that departs from the original camera viewpoint, large empty holes appear in the surrounding scene. With a world model, Waymo can plausibly fill in the new viewpoint after a lane change, simultaneously generating surround-view camera video and 4D lidar point clouds while synthesizing rare, hazardous scenarios—such as tornadoes, wildfires, or wrong-way semi-trucks—that would be impossible to stage safely in the real world.
A similar playbook is gaining traction across heavy industry. Startup FieldAI, which trains specialized robots for unmapped construction sites and mines for clients like Caterpillar and major builder Big-D Construction, grew its contracted revenue from under $10 million to $135 million in just one year, pushing its valuation to $10 billion. In manufacturing, NVIDIA’s new Cosmos 3 model not only predicts future video frames but simultaneously outputs robot joint actions. LG Electronics has already deployed the model inside its internal data factories to train household robots, with Samsung, Hyundai Motor, and Li Auto adopting the same foundation.
Looking back at what DeepMind research director Tejas Kulkarni told Bloomberg at the Genie 4 launch—that the next frontier lies in hybrid models where Gemini writes code and text in real time while Genie digests and simulates reality—the path forward comes into focus. Once the industry stops forcing a video generator to rediscover Newtonian mechanics and symbolic logic on its own, the division of labor across modules becomes much clearer: let deterministic code and 3D meshes govern spatial dimensions and foundational rules, let large language models handle high-level goals and logical planning, and let world models return to what they do best—turning complex real-world environments that resist neat mathematical formulas into a safe proving ground where intelligent agents can learn through trial and error before ever setting foot in the real world.