Agents2025~116 minarXiv:2512.04797

SIMA 2: A Generalist Embodied Agent for Virtual Worlds

score 9SIMA team, Adrian Bolton, Alexander Lerchner +63Deepmind↑ 25Dec 4, 2025cs.AI

🎯 Pitch

SIMA 2 bootstraps itself to superhuman skill in unseen games by using its own foundation model to dream up training tasks and score its performance, without needing any human feedback. It already reasons, talks, and acts across 3D worlds with performance approaching human players, shattering the 3% success rate of its unaided base model.

1. Executive Summary

This paper introduces SIMA 2, a generalist embodied agent built on a Gemini Flash-Lite foundation model that reasons, acts, and converses across diverse 3D virtual worlds. Trained via supervised fine-tuning on a mixture of human gameplay demonstrations and synthetically generated bridge data (Gemini-annotated trajectories that interleave reasoning, dialogue, and actions), followed by reinforcement learning from verifiable rewards, SIMA 2 demonstrates a step-change over its predecessor—effectively doubling average success rates across training environments and substantially closing the gap with human performance (~65% vs. ~86% human on human-evaluated tasks, Figure 6). The agent further exhibits robust generalization to entirely held-out environments, including ASKA, MineDojo, and photorealistic worlds generated by Genie 3, and demonstrates open-ended self-improvement: by deploying a Gemini-based task setter (to propose achievable instructions) and reward model (to score trajectories on a 0–100 rubric), SIMA 2 autonomously acquires new skills from self-generated experience in previously unseen environments, surpassing human reference scores on a fixed task set in ASKA and transferring improvements from urban to natural Genie 3 settings, establishing that embodied competence can be continuously expanded without additional human supervision only when the agent's foundation model provides both a proposal mechanism for new tasks and a general-purpose success evaluator.

2. Context and Motivation

The Core Problem: We Lack Generalist Agents That Can Act Autonomously in Open-Ended 3D Worlds

The fundamental challenge this paper confronts is that foundation models—despite their extraordinary reasoning and language capabilities—remain fundamentally disembodied. These models are trained on vast corpora of static internet data (text, images, video) and can describe the world, answer questions, and generate code with remarkable fluency. Yet when asked to perform even basic sensorimotor tasks—navigating to a specific location, manipulating objects, interacting with game menus—they fail catastrophically. The paper illustrates this starkly in Section 4.3: a baseline Gemini Flash-Lite model achieves only 3.2% success on the suite of embodied evaluation tasks, and Gemini Pro reaches only 7.0%, despite "considerable efforts at prompt engineering to enable the model to be able to output proper action and text formatting."

This gap is not a minor engineering oversight. It is a modern manifestation of Moravec's Paradox (Moravec, 1988), which the authors explicitly invoke: high-level cognitive tasks like chess or legal summarization have proven surprisingly tractable for AI, while low-level sensorimotor skills—clearing a dinner table, navigating a cluttered room—remain stubbornly difficult. The paper frames this as a gap between passive understanding and active participation. Foundation models can perceive and describe the world, but they cannot act within it to pursue goals and learn from the consequences of their actions.

This matters for both practical and theoretical reasons:

Practical impact: If foundation models could reliably act in embodied environments, the applications would span robotics (household assistants, manufacturing, search and rescue), autonomous driving, and interactive AI companions in virtual spaces. The isolation between "thinking" and "doing" in current AI systems is one of the primary bottlenecks preventing deployment in these domains.
Theoretical significance: The paper situates itself within the broader vision of foundation agents—models that combine the general reasoning capabilities of large-scale pretraining with the ability to take goal-directed actions and learn from environmental feedback (c.f. Silver and Sutton, 2025). Creating such agents requires solving the integration problem: how do you make a model that retains its pretrained reasoning capabilities while also producing precise, environment-appropriate actions? This is a fundamental architectural and training challenge that the field has only begun to address.

Prior Approaches and Their Limitations

The paper identifies several lines of prior work, each of which falls short of the goal of a truly generalist, interactive embodied agent:

1. From-scratch embodied agents (pre-foundation-model era). Early embodied agents were trained from scratch on specific environments using reinforcement learning or behavioral cloning (Agrawal et al., 2016; Levine et al., 2016; Mnih et al., 2015). These agents demonstrated competence within narrowly defined settings but failed to generalize outside those settings (Huang et al., 2017; Kansky et al., 2017). The paper characterizes this as "brittle" generalization—the agents could not handle novel visual appearances, new object configurations, or previously unseen task instructions because their learned representations were tightly coupled to their specific training distribution. Each new environment or task required retraining or fine-tuning from scratch.

2. Pretrained visual representations. To address the brittleness of from-scratch agents, researchers adopted pretrained visual encoders—derived from object classification (Gupta et al., 2017; Pinto and Gupta, 2016; Zhu et al., 2017) or self-supervised contrastive learning (Nair et al., 2022; Shridhar et al., 2022). For language-conditional agents, pretrained word and sentence embeddings improved generalization to new instructions (Anderson et al., 2018; Lynch and Sermanet, 2020). However, these approaches still separated perception from action: the visual and language encoders were frozen feature extractors, and the policy head was trained from scratch on embodied data. The reasoning capabilities of the foundation models were not fully integrated into the action-selection process. This meant the agent could recognize objects it had seen during pretraining but could not reason about novel instructions or adapt its behavior based on abstract concepts.

3. Vision-Language-Action (VLA) models. The more recent VLA paradigm (Brohan et al., 2023; Driess et al., 2023) integrates pretrained vision-language models directly into the action-generation pipeline, enabling generalization to novel objects and scenes. VLA models have been applied to robotics (Gemini Robotics Team et al., 2025a,b; Kim et al., 2024; Physical Intelligence et al., 2024, 2025) and virtual worlds (ByteDance Seed et al., 2025; Hershey, 2025; Zhang, 2025). The paper acknowledges these as important advances but identifies a critical limitation: most VLA models are trained on fixed datasets of existing demonstrations and do not continue learning from experience. They produce a trained model rather than a learning process. The paper's framing is telling: "These works focus on a trained model rather than a learning process" (Section 2). This static nature means VLA agents cannot autonomously improve when encountering novel environments or tasks—they are bounded by the quality and coverage of their training demonstrations.

4. SIMA 1 (the direct predecessor). The authors' prior work, SIMA 1 (SIMA Team et al., 2024), demonstrated that a single agent could follow hundreds of basic natural language instructions across a diverse set of 3D virtual games. This established the feasibility of a multiworld generalist—an agent that could operate across different game engines, visual styles, and control schemes without environment-specific retraining. However, SIMA 1 had several specific limitations that SIMA 2 directly addresses:

Language brittleness: SIMA 1's language encoder was trained from scratch on the annotated gameplay data, constraining its instruction-following capabilities to the vocabulary and phrasings present in that data. It could not generalize to novel, complex, or multi-step instructions that required compositional language understanding.
No output modalities beyond actions: SIMA 1 was a pure mapping from text instructions and images to keyboard-and-mouse actions. It could not output text (no dialogue, no reasoning trace), could not receive multi-modal inputs like sketches, and could not engage in back-and-forth interaction with a user. This made it a tool for following directives rather than a collaborative agent.
No reasoning capability: Without language output, SIMA 1 had no mechanism for internal reasoning, planning, or goal decomposition. It operated reactively—mapping the current instruction and observation directly to actions—without the ability to maintain a plan over multiple steps.
No self-improvement capability: SIMA 1 was a statically trained model. It could not generate its own training data, evaluate its own performance, or adapt to new environments without additional human demonstrations.

The paper notes that SIMA 1's performance on the original evaluation suite was low, and the current, substantially harder evaluation suite (Section 3.4, "SIMA Evaluation Suite 2.0") would yield even lower scores—an important calibration point that contextualizes SIMA 2's improvements.

5. Open-ended learning approaches (reinforcement learning and intrinsic motivation). The paper draws on a rich literature in open-ended learning (Clune, 2019; Stanley and Lehman, 2015; Stanley et al., 2017) that addresses the questions of what to learn and how to evaluate progress without human supervision. Prior work has used goal-conditioned intrinsic motivation (Colas et al., 2022), foundation-model-based task proposal (Du et al., 2023; Zhang et al., 2023), and learned reward functions from vision-language models (Baumli et al., 2023; Fan et al., 2022; Ma et al., 2023a; Rocamonde et al., 2024; Sontakke et al., 2023). However, these approaches have largely been demonstrated in isolation—task proposal, reward definition, and agent learning are typically studied as separate problems in simplified settings. The paper identifies a gap: no prior work has combined foundation-model-based task generation, reward evaluation, and VLA training into an integrated self-improvement loop that operates in complex 3D virtual worlds.

How This Paper Positions Itself

The paper positions SIMA 2 as addressing the convergence of these limitations through three key design choices, each responding to a specific gap in prior work:

First, tightly integrating a foundation model (Gemini) into the agent architecture. Rather than using a pretrained model as a frozen feature extractor (as in the pretrained visual representation era) or training an agent from scratch (as in pre-foundation-model approaches), SIMA 2 starts from a pretrained Gemini Flash-Lite checkpoint and fine-tunes it to produce actions, reasoning, and dialogue within a single token stream. This is a VLA architecture but with an explicit emphasis on preserving the base model's capabilities—a concern that the paper identifies as underexplored. The authors explicitly frame this as navigating a Pareto frontier between embodied competence and general reasoning (Section 4.3), and they provide quantitative evidence that SIMA 2 retains most of Gemini's coding, math, and STEM reasoning capabilities (Table 1: only 4–25% relative regression across benchmarks, with RL training causing no additional significant regression). This addresses the "catastrophic forgetting" problem that prior VLA work has struggled with (Hancock et al., 2025; Zhou et al., 2025), where training solely on action data can "erode conversational ability entirely."

Second, systematically developing generalization to entirely held-out environments. The paper builds on SIMA 1's multiworld training approach but pushes generalization evaluation to a more extreme point: zero-shot deployment in environments that are entirely unseen during training, including environments with different game mechanics (ASKA, Minecraft), different narrative structures (The Gunk), and even different visual realism levels (Genie 3's photorealistic outputs). This is a substantially harder generalization test than the held-out states within training environments that prior work typically reports. The paper's quantitative results in ASKA and MineDojo (Figure 10: 12–13% absolute improvement over SIMA 1) and qualitative demonstrations in The Gunk (Figure 12: progressing through 15–20 minutes of a novel game) establish that the Gemini-powered agent can leverage its pretrained world knowledge to interpret novel visual cues, menus, and game mechanics—a capability that was simply absent from SIMA 1's from-scratch language encoder.

Third, demonstrating that self-improvement is possible without any human supervision in novel environments. This is the paper's most ambitious positioning: moving beyond a statically trained model to a learning process that can generate its own tasks, evaluate its own performance, and improve from the resulting experience. The paper explicitly invokes the grand challenge of open-ended algorithms (Clune, 2019) and positions the combination of SIMA 2, a Gemini-based task setter, and a Gemini-based reward model as the first working example of an agent learning within a universal world model (Genie 3). The three models—task setter, agent, and reward model—form a closed loop: the task setter proposes achievable instructions based on the current environment state and the agent's demonstrated capabilities; the agent attempts the task; the reward model scores the resulting trajectory; and the agent is retrained on the scored self-generated experience. This loop can iterate indefinitely, with the task setter adapting its proposals based on the agent's evolving capabilities to focus on the "cusp of the agent's abilities" (Section 4.5)—a principle drawn from the open-ended learning literature. The empirical results (Figures 15, 16b, 17) demonstrate that this loop produces genuine skill acquisition: the agent learns to navigate to novel objects (rain collector in ASKA), perform new skills (extinguishing a campfire), and even transfers navigation improvements from urban Genie 3 environments to held-out natural environments.

Bridging the Disconnect Between Reasoning and Action

The paper's motivating insight—articulated through the baseline Gemini results in Section 4.3—is that competent embodied interaction is not an emergent property of large-scale pretraining on language and vision data. Even a model as capable as Gemini Pro, with its sophisticated reasoning and visual understanding, cannot translate those capabilities into appropriate keyboard-and-mouse actions in a 3D environment without specialized embodied training. This finding reframes the problem: the challenge is not (or not only) to build more powerful foundation models, but to build the bridge between those models' reasoning capabilities and the specific demands of embodied action—precise motor control, understanding of action consequences, and the ability to chain actions into coherent behavioral sequences.

At the same time, the paper is motivated by the reverse concern: if you train a foundation model too heavily on embodied action data, do you destroy the very reasoning capabilities that make foundation models valuable? The catastrophic forgetting results in Section 4.3 suggest this concern is real but manageable—the mixed training approach (gameplay data + Gemini pretraining data) preserves most of the base model's capabilities. This finding enables the paper's broader vision: an agent that can simultaneously think (reason about goals, plan actions, engage in dialogue) and act (execute precise keyboard-and-mouse commands), with each capability reinforcing the other through a shared model architecture.

The Role of Virtual Worlds as a Testbed

The paper inherits a long tradition of using games as a testbed for AI research (Samuel, 1959; Shannon, 1950; Turing, 1953) but positions modern 3D commercial video games as uniquely valuable because they approximate the complexity of the physical world without the hardware costs, safety concerns, and slow iteration cycles of real-world robotics. The environments used in SIMA 2—No Man's Sky, Valheim, Satisfactory, Space Engineers, and others—require a broad range of skills that parallel those needed in physical-world applications: navigation through complex 3D terrain, object manipulation, menu-based interfaces, tool use, resource management, construction, and combat. Unlike simplified research simulators, these commercial games present near-limitless visual diversity, dynamic environments, and unpredictable entity interactions.

The paper also makes a forward-looking argument: if agents can generalize from video game environments to photorealistic Genie 3 worlds (as demonstrated in Figure 13), then the path from virtual to physical worlds becomes more plausible. The keyboard-and-mouse interface is an abstraction that could, in principle, map to robot control commands, making the virtual training ground a proxy for eventual physical deployment.

3. Technical Approach

3.1 Reader Orientation

This paper presents SIMA 2 as a system that wraps a Gemini foundation model in a perception-action interface—the model receives RGB video frames from a 3D game, processes them through the same neural network that handles language and reasoning, and outputs structured text that is deterministically parsed into keyboard-and-mouse commands, natural language dialogue, and internal reasoning traces, all within a single token stream. The core problem being solved is how to give a pretrained foundation model the ability to act competently in embodied 3D environments without destroying its original reasoning capabilities, and the shape of the solution is a careful two-stage training pipeline (supervised fine-tuning on mixed gameplay + reasoning data, followed by reinforcement learning from verifiable rewards) plus a self-improvement loop that uses Gemini itself as both a task proposer and a reward function to enable autonomous skill acquisition in novel environments.

3.2 Big-Picture Architecture (Diagram in Words)

The SIMA 2 system has six major components arranged in two nested loops—a training loop that produces the agent and an autonomous improvement loop that makes it better:

The Game Environment (any 3D virtual world, commercial or research): Produces 720p RGB video frames at 30 fps and accepts keyboard-and-mouse inputs (96 standard keys, mouse clicks, discretized relative mouse movements). The environment is black-box—the agent receives no privileged state information, only pixel observations.
The Agent-Environment Interface (the perception-action bridge): Sub-samples frames (one every 10 frames from the 30 fps stream), formats them alongside the task instruction and the agent's previous reasoning/dialogue into a prompt, sends this to the core model, parses the model's structured text output into keyboard-and-mouse commands (applied to the environment) and natural language (routed to the user or to the agent's own context window).
The Core Model (Gemini Flash-Lite, fine-tuned): A pretrained Gemini Flash-Lite checkpoint fine-tuned via supervised learning on a mixture of human gameplay data, synthetically generated bridge data, and original Gemini pretraining data. The model outputs tokens that specify either actions (in a deterministic parseable format), dialogue (natural language for the user), or internal reasoning (natural language fed back into the model's own context).
The Reinforcement Learning Module (online RL from verifiable rewards): After SFT, the agent is further trained by interacting with environments on curated tasks that have verifiable success conditions (either ground-truth state checks in research environments or programmatic evaluations in commercial games). Rewards are sparse (success/failure) with some shaped rewards for instruction-following and controllability.
The Self-Improvement Loop (three Gemini models in a closed cycle): In a deployment environment (e.g., ASKA), a Gemini-based Task Setter observes the current game state and proposes language instructions that are achievable and at the frontier of the agent's capabilities; the SIMA 2 agent attempts the task; a Gemini-based Reward Model scores the resulting video trajectory on a 0–100 rubric calibrated against human preference judgments; the scored experience is added to the training dataset, and the agent is retrained. This loop can iterate indefinitely with no human intervention.
The Hierarchical Reasoning System (optional, for complex tasks): A separate Gemini Pro model runs at a slower cadence, receiving video history every $k$ steps, producing natural language sub-instructions for the SIMA 2 agent, and maintaining a text-based summary as a form of persistent memory beyond the agent's immediate context window.

3.3 Roadmap for the Deep Dive

First, the Agent-Environment Interface (Section 3.2): how raw pixels and keyboard-mouse commands are converted into the token-based format that Gemini processes, because this is the fundamental translation layer that makes embodiment possible.
Second, the Supervised Fine-Tuning pipeline (Section 3.3): the composition and construction of the three training data types (human data, bridge data, and pretraining retention data), including the crucial "Setter-Solver" annotation paradigm and the synthetic reasoning generation process, because this is where the agent learns to simultaneously act, reason, and converse.
Third, the Reinforcement Learning phase (Section 3.3.3): how verifiable tasks are curated, how rewards are defined, and why RL provides additional improvement beyond SFT alone, because this phase addresses the generalization-robustness gap that pure imitation learning leaves.
Fourth, the Evaluation Framework (Section 3.4): the three evaluation types (ground-truth, programmatic, human) and the improvements in SIMA Evaluation Suite 2.0, because understanding what is being measured is essential to interpreting all quantitative results.
Fifth, the Self-Improvement Architecture (Section 4.5, but described technically): the Task Setter design, the Reward Model rubric and calibration, and the closed-loop training procedure, because this is the paper's most ambitious technical contribution and depends on all previous components.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a systems-building and empirical evaluation paper whose core idea is that a pretrained foundation model can be transformed into a generalist embodied agent through a carefully designed training pipeline that mixes specialized behavioral data with original pretraining data to preserve general reasoning while adding precise action capabilities, and that this agent can then be deployed in a self-improvement loop where the same foundation model (in different instantiations) provides both the task curriculum and the performance evaluation, enabling autonomous skill acquisition without human supervision.

The Agent-Environment Interface: Translating Between Pixels and Tokens

The interface is the critical translation layer that makes it possible for a language model to control a 3D game. The input stream begins with the game rendering RGB video frames at 1280×720 pixels (720p) at 30 frames per second. However, the agent does not receive every frame—it receives only one frame every 10 frames, meaning it observes at an effective rate of 3 Hz. This sub-sampling is a deliberate design choice driven by latency constraints: processing every frame would be computationally prohibitive for a model of this scale, and 3 Hz is sufficient for most gameplay interactions that involve deliberate navigation and object manipulation (though it creates inherent limitations for split-second combat reactions, as the paper notes in Section 4.2.1).

When a new frame arrives, it is added to the agent's history buffer, which contains:

Recent RGB frames (the paper does not specify the exact window length, but it is bounded by the model's context window)
The current task instruction (natural language text)
The agent's own previous reasoning outputs (if any)
The agent's own previous dialogue outputs (if any)

This history buffer constitutes the full prompt that is fed to the Gemini model at each decision step. Critically, the agent's own prior reasoning and dialogue are included in its context, enabling it to maintain a coherent plan across multiple steps—this is the mechanism by which the model implements multi-step reasoning without an explicit separate memory module. The prompt template, shown in Figure 3, includes a system-level preamble that establishes the agent's role:

"You are an expert video game player. Take a look at this image and control the player by using actions that look like this: KeyW, KeyA, KeyS, KeyD, MouseLeft=<int>, MouseRight=<int> [...] The video is 1280x720 pixels, running at 30 fps. You will only see every 10 frames. [...] Your goal is to: [task instruction]"

The model then generates a structured text output. The key architectural decision is that actions, reasoning, and dialogue all occupy the same text generation stream—they are not separate heads or separate models. The model output includes self-specification tokens that indicate which output modality is being produced at each point (e.g., a token indicating "this is a reasoning block" vs. "this is an action block" vs. "this is dialogue"). The interface parses these tokens and routes the output accordingly:

Action tokens are deterministically parsed into keyboard-and-mouse commands (e.g., KeyW → press the W key, MouseLeft=30 → move the mouse left by 30 discrete units) and applied to the environment
Dialogue tokens are rendered as text to the user
Reasoning tokens are added to the agent's internal context for the next step but not shown to the user (unless configured otherwise)

The action space encompasses 96 standard keyboard keys, mouse clicks (left, right, middle), and discretized mouse movements representing relative (x, y) position changes. The paper uses a discretized mouse movement scheme rather than continuous control; the exact discretization granularity is not specified, but the format MouseLeft=<int> and MouseRight=<int> indicates integer-valued relative displacement. This is a simplification that makes the action prediction tractable as a text generation problem—continuous control values would require a regression head or specialized tokenization, which would break the unified text-stream architecture.

Why this design over alternatives. The alternative would be separate models for perception, language, and action—the approach taken by SIMA 1, which used pretrained vision encoders, a from-scratch language encoder, and a policy head trained to map combined embeddings to actions. That approach creates a hard separation between language understanding and action generation: the language encoder learns to represent instructions, the vision encoder learns to represent observations, but neither can reason about the relationship between them because reasoning is not part of the training objective. The unified token-stream approach means that the same attention mechanism that connects "ripe tomato" to "red house" in a reasoning context can also connect that reasoning output to the subsequent action commands, because all tokens attend to all other tokens in the context. The paper's results on basic reasoning (Figure 4: correctly interpreting "Go to the house colored like a ripe tomato") demonstrate that this integration works: the model internally reasons about the instruction, identifies the target, and produces navigation actions, all within a single forward pass per step.

A practical consequence of this design is that the agent can also specify no-ops—timesteps at which no actions are taken. The bridge data includes no-op examples to train the agent to remain still after task completion, which is important both for evaluation (the "action pause after completion" metric described in Section 3.4) and for sequential task chaining (the agent needs to signal readiness before receiving the next instruction).

Supervised Fine-Tuning: The Three-Stream Training Data Pipeline

The paper uses a mixed-dataset approach for supervised fine-tuning, combining three qualitatively different data types. The paper states: "We found this mixture crucial to maintain the original capabilities of the base model, such as vision understanding, dialogue, reasoning, and promptability." This is the central empirical finding about training methodology: if you train only on gameplay data, the model forgets how to reason; if you train only on pretraining data, it never learns to act. The mixture is the practical solution.

Human Gameplay Data (the majority by volume)

Human data forms the bulk of the training corpus and is collected through two distinct paradigms, each providing a different type of language-action alignment:

Single-person, post-hoc annotation: A human player engages in free-form gameplay, starting from the game's standard starting point. The complete trajectory (video frames + keyboard-mouse actions) is recorded. After the session, the player annotates their gameplay with natural language descriptions aligned to specific frames—explaining what they were doing and why. The paper explicitly notes the limitation of this approach: "the language annotations are not causally tied to the player's intent, as they were constructed in hindsight." This means the model trained on this data learns correlations between language descriptions and observed behavior, but does not learn that language precedes and causes behavior in the way it does when an agent is following instructions. The post-hoc annotations may include reasoning that would have been impossible at the time of action (e.g., "I went left because I knew there was a chest around the corner" when the chest wasn't visible yet). Despite this causal limitation, this data is valuable because it captures the full diversity of naturalistic gameplay—players do a wide variety of things in a wide variety of ways, providing coverage of the action space.

Two-person "Setter-Solver" annotation: To address the causal alignment problem, the paper uses a two-player setup. One participant, the Setter, watches a live stream of the gameplay and issues real-time instructions to the second participant, the Solver, who actually controls the game avatar. The Setter cannot directly control the game—they can only communicate via natural language. Because the instruction always precedes the corresponding action, this paradigm produces causally correct annotation: the language genuinely causes the behavior that follows. The paper describes this as "a more causally correct form of annotation than the single-person approach." This is crucial for training instruction-following behavior: when the model sees a Setter instruction followed by Solver actions during training, it learns the correct temporal relationship that it will need at inference time, where it receives an instruction and must generate appropriate actions.

Both paradigms produce raw trajectories that undergo substantial pre-processing and filtering before training:

Reshaping and resizing: Image frames are reshaped to match the model's expected input dimensions
Quality filtering: "Various heuristics and score metrics" are used to filter out low-quality data—the paper does not specify these heuristics in detail, but they likely include removing trajectories with excessive idle time, corrupted inputs, or annotation that doesn't match the observed behavior
Span conversion: Trajectories are split into shorter sub-sequences, each associated with a single task instruction. A "span" consists of a single instruction and the sequence of frames and actions that were taken while that instruction was active. This allows the model to learn from focused, instruction-specific segments rather than long undifferentiated gameplay sequences
Data mixing and weighting: Data from different environments and datasets is remixed and weighted "to optimize skill learning"—the paper does not provide the specific mixing ratios, but the implication is that environments requiring rare skills receive higher sampling weights to prevent the model from overfitting to the most common action patterns
Synthetic language augmentation: Offline Gemini models are applied to existing trajectories to provide "augmented language and reasoning text"—the paper does not elaborate on the nature of this augmentation, but it likely involves generating alternative phrasings of instructions, adding reasoning annotations to existing action sequences, or generating dialogue that is consistent with the observed behavior

Task-specific episodic data ("Game-Tasks"): In addition to open-ended gameplay, the paper uses a framework where players are given specific instructions (e.g., "Craft a stone axe") starting from predefined game states. These episodes end either at a time limit or when the player self-reports task completion. This data provides clean examples of goal-directed behavior with clear endpoints, which is useful for training the agent to recognize task completion and stop acting (the no-op behavior). It also provides coverage of specific skills that may be rare in free-form gameplay.

Human ratings for evaluation and calibration: Human participants provide binary success judgments for game-task trajectories (did the player accomplish the instruction?) and side-by-side comparisons of two trajectories to determine which more successfully accomplished a given task. These ratings are used for evaluation (Section 3.4) and to calibrate the Gemini-based reward model (Section 4.5), not directly for training the agent.

Quality assessment before data collection: Human participants receive guided tutorials covering game controls, the data collection interface, and annotation procedures before they begin data collection. This standardization is important because the quality of instruction-following behavior depends heavily on the quality of the language annotations—vague or misaligned annotations would teach the model incorrect associations.

Bridge Data (synthetically generated reasoning and dialogue)

Human gameplay trajectories contain actions and visual observations but do not include the internal reasoning or dialogue that the paper wants SIMA 2 to produce. To create training data that interleaves reasoning, dialogue, and actions, the authors generate bridge data—synthetically annotated trajectories that add language modalities to existing action sequences.

The procedure operates on a small set of "high-quality data examples" ("a relatively small number" per the paper) that feature successful task completion across all training environments:

Selection: Choose examples where the visual frames and actions form a coherent successful trajectory for a specified task instruction
Annotation with Gemini Pro: A separate Gemini Pro model is prompted to annotate the trajectory with internal reasoning and dialogue that are "causally consistent with the observable scene from the agent's ego-centric perspective and embodied behavior." This means the generated reasoning cannot reference information that wouldn't be visible to the agent at that point in the trajectory—it must be grounded in what the agent can actually see
Prompt variation: The training prompt is varied across examples "to induce additional robustness"—the paper does not specify the variation method, but it likely includes different instruction phrasings, different levels of verbosity in the expected output, and different mixes of reasoning vs. dialogue

The resulting dataset covers a range of capabilities: error-correcting behavior (the agent makes a mistake, realizes it, and corrects it), explicit instruction following, instruction chaining (following a sequence of instructions where each is given after the previous is completed), visual question answering (looking at something and answering a question about it), reliance on memory (referencing previous observations or actions), long-horizon behavior (maintaining a plan over many steps), and no-ops (remaining still after task completion).

The paper's term "bridge data" is well-chosen: these examples bridge the gap between pure language models (which can reason and converse but cannot act) and pure behavioral cloning (which can produce actions but cannot reason or converse). By training on bridge data, the model learns that the same internal representations that support reasoning and dialogue can also be connected to action outputs.

Why Gemini Pro for annotation rather than human annotators: Human annotators could, in principle, provide reasoning traces while playing games (think-aloud protocols are common in cognitive science). However, this would significantly slow down data collection, require careful quality control to ensure the reasoning is temporally aligned with the actions, and would be substantially more expensive than automated annotation of already-collected trajectories. The use of Gemini Pro for annotation leverages the model's existing language capabilities—it can generate plausible reasoning that is consistent with observed behavior—without requiring real-time human annotation during gameplay.

A subtle design choice from the prompt format in Figure 3: The agent specifies "which output modalities to generate" at each step, meaning the model can choose to output only actions, only reasoning, or both. This prevents the model from being forced to generate reasoning when it's not useful (e.g., during rapid reactive actions) and from generating actions when it should only think (e.g., when planning). The bridge data presumably reflects this flexibility, with some steps containing only actions and others containing rich reasoning and dialogue.

Original Gemini Pretraining Data

The paper includes a portion of the original Gemini pretraining data in the fine-tuning mixture, but provides minimal detail on this component—no specific ratio or data composition is reported. The inclusion is motivated by the catastrophic forgetting concern: if the model is trained exclusively on gameplay data (which has a very specific distribution of visual inputs—3D game graphics—and a very specific output format—structured action tokens), it will forget the general language understanding, visual recognition, and reasoning capabilities acquired during pretraining. By retaining a fraction of pretraining data in the mixture, the model is forced to maintain those capabilities while also learning the new embodied skills.

The quantitative results on capability retention (Table 1) validate this approach: SIMA 2 after SFT shows only modest regression on coding (LiveCodeBench: -4.0%), math (AIME: -25.5%), and STEM reasoning (GPQA Diamond: -16.3%) relative to the baseline Gemini model. The paper emphasizes that "the additional RL training caused no significant additional regression compared with SFT alone," suggesting that the RL phase operates on a distribution that is close enough to the SFT distribution that it doesn't cause further forgetting.

A critical implicit design choice: separate pretraining data vs. multi-task training. The alternative to mixing pretraining data into the fine-tuning corpus would be to use a multi-task objective where the model is simultaneously trained on gameplay data (predicting actions) and pretraining data (predicting next tokens). The paper's approach of simply mixing the datasets and training with a single language modeling objective is simpler and leverages the model's ability to infer the task from context: when the context contains game frames and action-formatted text, the model learns to produce actions; when the context contains general text, the model learns to produce general text.

Reinforcement Learning from Verifiable Rewards

After the SFT phase, the agent undergoes online reinforcement learning using curated tasks with verifiable success conditions. The paper describes this phase only briefly in Section 3.3.3, but the design choices are significant.

Task curation: Tasks are defined as tuples of (initial game state, text instruction, verification function). The initial state is a saved checkpoint that places the agent in a specific configuration; the instruction is a natural language goal; the verification function checks whether the goal has been achieved, using either ground-truth environment state (in research environments) or programmatic evaluations (in commercial games, as described in Section 3.4).

The tasks are sourced through two mechanisms:

Human-generated tasks from exploration: Participants are placed into random game states and asked to "explore the nearby environment and suggest multiple tasks that could be completed from that point." This produces tasks that are grounded in realistic gameplay scenarios—since participants can see what's actually nearby, they propose tasks that are achievable from the given state
Automated extraction from human trajectories: The verification functions are applied to all human-recorded trajectories to identify points where goals were successfully completed. These completion points are paired with nearby game states (taken from slightly earlier in the trajectory) to create task definitions. The paper filters these down to tasks that "a human could complete within a specified time limit to remove excessively hard tasks"

Additionally, the paper generates dialogue tasks by selecting random screenshots from human data and pairing them with human-suggested question-answer pairs. These tasks train the agent to answer grounded questions about what it sees—a capability demonstrated in the embodied question-answering example in Figure 4 (top), where the agent answers a question about egg-shaped objects by navigating to them and reading on-screen text.

Reward definition: The primary reward is sparse—the agent receives positive reward for successfully completing the task or giving a correct answer. The paper mentions "additional shaped rewards to improve the instruction-following capabilities and controllability of the agent" but does not specify the shaping scheme. Typical shaping in instruction-following RL might include small rewards for making progress toward a goal (e.g., decreasing distance to a target location) or penalties for taking actions that are inconsistent with the instruction.

Why RL is necessary beyond SFT. The SFT phase teaches the agent to mimic human behavior, but behavioral cloning has a well-known limitation: the agent learns to reproduce the actions it saw in training, but doesn't learn to recover from its own mistakes. When the agent deviates from the training distribution (e.g., by making a navigation error that no human demonstrator made), it has no training signal for how to correct course. RL addresses this by allowing the agent to generate its own trajectories, make mistakes, and receive feedback that guides it toward successful behavior even from states that are not well-represented in the demonstration data. The paper's performance improvements from RL (Table 1 shows RL causes no additional capability regression while improving task performance) are consistent with this interpretation: RL refines the policy within the distribution of embodied tasks without requiring additional diverse language data that might cause forgetting.

Scope limitation: The paper explicitly states that "This phase of RL training is limited to our training environments and excludes our held-out environments, such as ASKA and MineDojo." This means the held-out environment results (Figure 10) and the self-improvement results (Section 4.5) represent generalization from SFT alone on those environments, with the RL providing a stronger base policy from which to generalize.

The Evaluation Framework: Three Types of Success Measurement

The evaluation system is more nuanced than it might first appear and represents a significant engineering contribution in its own right—measuring task success in commercial video games without access to internal state is a hard problem. The paper uses three evaluation types, each with different tradeoffs between precision, scalability, and applicability.

Ground-Truth Evaluation (research environments only)

In research environments (Construction Lab, Playhouse, WorldLab, and the MineDojo benchmark), the system has access to the underlying game state. Success can be determined by checking objective conditions: the absolute or relative positions of objects ("Lift the cube"), the acquisition state of an object or resource ("Gather wood"), or the triggering of specific game mechanics ("Water the plant"). These evaluations are the most reliable because they directly measure what the game engine considers to be true, with no noise or ambiguity.

However, the paper notes a critical limitation: "commercial video games do not generally expose this state information in an accessible way." This is a practical reality of working with licensed commercial games—the development teams provide access to the game executable and rendering pipeline, but the internal state representation may be opaque, undocumented, or deliberately hidden to prevent cheating. This limitation motivates the need for the next two evaluation types.

Programmatic Evaluation (commercial games)

For commercial games, the paper defines evaluations based on what can be observed from the screen and the agent's actions. The primary mechanism is optical character recognition (OCR) applied to the rendered game frames. Video games often display state information as on-screen text—pop-ups announcing "Inventory Full," menu labels, quest completion notifications, resource counts. By detecting specific strings at specific screen locations with OCR, the evaluation system can infer task completion without access to internal state.

The paper also defines functions over pixel colors and action outputs, though the scope of these is not elaborated. For example, a task like "Equip the hammer" might be evaluated by checking whether a specific pixel region (corresponding to the equipment slot icon) has changed to the color pattern of the hammer icon.

The paper explicitly acknowledges the limitation of this approach: "these tasks are restricted to the outcomes that can be detected through heuristics over the visual input or through the agent's actions." If a task produces a change in the game world that is not reflected in on-screen text or detectable pixel patterns, it cannot be evaluated programmatically.

Key improvements in SIMA Evaluation Suite 2.0 (since SIMA 1): The paper highlights three specific improvements that make the evaluations substantially harder:

Persistence requirement: Rather than triggering success on the first detection of the target text, the evaluation requires the text to be present for several seconds. This selects for intentional behavior—the agent must deliberately bring about the state and then pause to confirm it, rather than accidentally triggering the text while doing something else. This addresses a known failure mode in behavior cloning where agents can produce actions that appear superficially correct but lack the underlying intention.
Post-completion action threshold: For a subset of tasks, the evaluation places a threshold on the number of actions permitted after task completion. This measures whether the agent recognizes that it has finished and remains still—a prerequisite for sequential task chaining where the next instruction is given only after the current task is confirmed complete. An agent that continues fidgeting after completing a task would fail this evaluation even if the task was technically accomplished.
Sequential task evaluations: The paper has "greatly expanded" a set of programmatic tasks where instructions are supplied in sequence—each new instruction is given only once the previous task has been successfully completed. To succeed on the full sequence, the agent must complete every sub-task in order. This reflects realistic interactive deployment where a user gives a series of instructions and expects each to be completed before moving on.

The paper notes that these improvements make the evaluations "substantially more challenging than those originally reported in SIMA Team et al. (2024)," and that "the SIMA 1 agent obtains lower success rates" as a result. This is an important calibration point: SIMA 2's performance improvements should be understood relative to a harder evaluation suite, making the gains more meaningful.

Human Evaluation (for tasks where automated evaluation is impossible)

When neither ground-truth state nor programmatic heuristics can determine success, the paper uses human raters who watch video recordings of the agent's trajectory and judge whether the task was completed. To improve precision, each trajectory receives five independent ratings, and the paper does not specify the aggregation method (majority vote, average, or some other consensus measure). The environments requiring human evaluation are Goat Simulator 3, Hydroneer, No Man's Sky, Satisfactory, Valheim, and Wobbly Life.

Human evaluation is more flexible than programmatic evaluation—it can assess tasks like "Make the character do something funny" or "Build an aesthetically pleasing structure" that are fundamentally subjective—but it is more expensive and slower, limiting the scale at which it can be applied.

Human Baselines

To contextualize agent performance, the paper collected human baseline trajectories on the full evaluation suite. The collection was designed to mirror the agent's testing conditions, including the same time limits. For training environments, the human players had prior experience with the specific game (through their participation in training data collection), making them relatively expert. For held-out environments (ASKA and MineDojo), the players had general video game experience but no prior exposure to these specific games, and received only written instructions on core mechanics and controls—no task-specific guidance. This creates a more appropriate comparison for zero-shot agent performance: both the agent and the naive human are encountering the environment for the first time.

The paper reports human performance both with and without the time limits imposed on agents. The values without time limits (shown as lighter-shaded bars in Figure 6 and subsequent figures) represent an approximate upper bound on performance, because "participants frequently struggled to complete tasks within the allotted time, some of which were as short as three seconds." Primary sources of difficulty for humans included "initial inattention, infrastructure latency, and challenges with the fine-motor control required to operate game interfaces as fluidly as the agent." This is an important observation: the agent, by generating actions directly from model outputs, can execute precise sequences faster than a human physically moving a mouse and keyboard, potentially giving it an advantage on very short time-limit tasks.

The Self-Improvement Architecture: Three Models in a Closed Loop

The self-improvement system (Section 4.5) is the paper's most ambitious technical contribution and merits detailed explanation here even though the results are in Section 4, because understanding the architecture is prerequisite to understanding the results. The system consists of three components—the agent itself (SIMA 2), a task setter, and a reward model—all built on Gemini, deployed in a closed loop within a running environment.

The Task Setter: Gemini as an Instruction Generator

The task setter is a Gemini model that observes the current state of the environment (through video frames) and generates natural language instructions for the agent. The key design principle is that the task setter is prompted to propose tasks that are achievable from the current state and at the frontier of the agent's current capabilities—not trivially easy (which would produce no learning) and not impossibly hard (which would produce only failure experience with no learning signal).

The paper describes several mechanisms by which the task setter's behavior can be modulated:

Prompt modification: The general objective given to the task setter can be adjusted to shift the task distribution—for example, focusing on resource gathering vs. combat vs. menu use. This allows curriculum design without retraining any component
Downstream evaluation feedback: Performance metrics from the reward model can be fed back to the task setter, enabling it to "steer the agent toward skills that need to be improved." This is an automated version of curriculum learning: if the agent is struggling with crafting, the task setter receives that information and generates more crafting tasks
Within-episode performance tracking: The task setter can monitor the agent's current attempt and "focus on tasks that are interesting to learn and likely to provide learning progress." This approximates the concept of learning progress from the intrinsic motivation literature (Colas et al., 2022): tasks where the agent's performance is improving (but not yet mastered) are the most valuable for continued training, because they are within the agent's capability range but not yet fully learned

The task setter is coupled with the agent in a running environment instance, allowing dynamic adjustment. As the agent moves through the environment and changes the state, the task setter observes the new state and can issue new instructions that are appropriate to the new context. This enables a natural progression—for example, the task setter might first ask the agent to gather wood, then, once the agent has wood in its inventory, ask it to craft a campfire.

Why Gemini for task setting rather than random generation or fixed scripts. Fixed scripts would limit the diversity of experience and could not adapt to the agent's changing capabilities. Random generation would produce many impossible or irrelevant tasks, wasting the agent's interaction budget on attempts that provide no learning signal. Gemini, by virtue of its general world knowledge and visual understanding, can assess what is achievable in a given scene and propose tasks that are appropriate. However, this puts a heavy burden on Gemini's scene understanding—the paper does not report quantitative metrics on the task setter's accuracy (what fraction of proposed tasks are actually achievable), which is a limitation of the current evaluation.

The Reward Model: Gemini as a Universal Scoring Function

The reward model is a separate Gemini instance that takes a video trajectory (the sequence of frames from the agent's attempt at a task) and a language instruction and produces a score between 0 and 100 based on a rubric. This is what the paper calls a universal reward function—a function that can evaluate any task in any environment without requiring environment-specific engineering.

The rubric captures multiple aspects of performance:

Task completion: Did the agent achieve the specified goal?
Directedness: Did the agent avoid unnecessary actions? An agent that accomplishes the goal but wanders around randomly for 30 seconds first would receive a lower score than one that proceeds directly

The rubric was calibrated against human preference data. The paper states: "We arrived at the prompt that defines the rubric by calibrating the resulting scores to align with human preference pairs over a small dataset of trajectories." This calibration step is crucial—without it, the reward model might assign scores that are internally consistent but don't correspond to human judgments of success, which would mean that optimizing against the reward model would not actually produce better task performance as judged by humans. The calibration process involves showing the model pairs of trajectories (where humans have indicated which is better) and adjusting the rubric/prompt until the model's scores align with human preferences.

The paper sets a threshold at 50 for "success": trajectories scoring 50 or above are considered successful. This binary threshold enables the reward model's scores to be used both for training (as regression targets) and for evaluation (as a success/failure metric).

Why Gemini for reward modeling rather than programmatic evaluation. Programmatic evaluations require hand-crafting detection functions for each task, which doesn't scale to the open-ended task setting where the task setter can propose novel instructions. A Gemini-based reward model can, in principle, evaluate any instruction that can be expressed in language and observed in video—making it a truly general evaluation mechanism. The tradeoff is reliability: the reward model is a learned function that can make mistakes (assigning high scores to failed attempts or low scores to successful ones), whereas programmatic evaluations are typically deterministic and correct by construction. The paper's calibration against human judgments addresses this to some extent, but the calibration was done on a "small dataset" and may not generalize perfectly to all task types.

Scoring process at deployment: When the agent attempts a task, the full trajectory is captured as video. This video and the original instruction are fed to the reward model, which outputs a scalar score. This score is used to label the trajectory as training data for the next iteration of agent fine-tuning. The paper trains the agent on this self-generated, self-scored experience using the same SFT procedure (or a variant thereof—the paper is not explicit about the exact training algorithm used in the self-improvement loop), driving policy improvement that results in higher reward model scores on subsequent attempts.

The Closed-Loop Training Process

The full self-improvement cycle operates as follows:

Initial deployment: The current SIMA 2 agent is deployed in the target environment (e.g., ASKA, or a Genie 3 environment) with the task setter running alongside it
Task proposal: The task setter observes the current environment state and generates a language instruction
Task execution: The agent receives the instruction and attempts to complete it, producing a trajectory of actions and observations
Scoring: The trajectory is sent to the reward model along with the instruction, and receives a score between 0 and 100
Dataset accumulation: The (instruction, trajectory, score) triple is added to a growing dataset of self-generated experience
Retraining: After a sufficient number of trajectories are collected, the agent is fine-tuned on this dataset (using the scores as targets, or using only trajectories above the 50 threshold as positive examples—the paper does not specify the exact training objective for this phase)
Re-deployment: The improved agent is redeployed, and the cycle repeats

The paper demonstrates this cycle over multiple iterations in ASKA (Figure 15 shows progressively darker points representing successive iterations), with performance steadily improving until the agent exceeds the 50-point success threshold across all tasks in the fixed set. The task setter's ability to dynamically adjust its proposals (steering toward weak skills, tracking learning progress) means that later iterations can focus on skills that the agent hasn't yet mastered, making the process more efficient than uniform random task sampling.

A critical implicit assumption: The self-improvement loop relies on the reward model being good enough that optimizing against it produces genuine improvements in the agent's capabilities, not just improvements in the reward model's scores. This is the classic reward hacking problem: if the reward model has blind spots or biases, the agent may learn to exploit them rather than actually becoming more capable. The paper does not directly test for this (e.g., by having humans evaluate the self-improved agent's trajectories to verify that reward model scores correlate with human judgments of improvement), which is a limitation of the current evaluation.

Scope of self-improvement data: The paper notes that in the full self-improvement setup for ASKA game progression (Figure 16b), the agent was "purely training on self-generated experience"—meaning no human demonstrations of ASKA gameplay were used for the self-improvement phase. This is what makes the result significant: the agent acquired new skills (building a shelter, progressing through the tech tree) without ever seeing a human perform those skills in ASKA. The initial generalization capability from the base SIMA 2 model (trained on other games) provides a starting point that is good enough to produce some successful trajectories, which then serve as training data for further improvement. This bootstrapping process is the key to open-ended learning—the agent needs just enough initial competence to start generating its own training signal.

Genie 3 Integration: Toward a Universal World Model

The Genie 3 experiments (Section 4.5.2) push the self-improvement concept further by splitting environments into train and test sets and showing that improvements transfer. The paper created a set of tasks in urban Genie 3 environments (train) and natural Genie 3 environments (test), primarily focused on navigation. The self-improvement loop ran on the train tasks, and the resulting agent was evaluated on both train and test tasks.

The results (Figure 17) show broad improvement on train tasks and, critically, transfer to the majority of test tasks in entirely different visual environments (urban → natural). This is significant because it demonstrates that the skills being learned through self-improvement are not environment-specific—they generalize across visual domains. The paper explicitly frames this as a step toward the Clune (2019) vision of an agent learning in a "Darwin-complete environment search space" powered by a universal world model: "we demonstrate the first preliminary working example of an agent learning within that universal world model, specifically Genie 3." This is an ambitious claim, and the paper acknowledges its preliminary nature—the tasks are primarily navigation-based and the scale of the experiments is limited—but it provides a proof-of-concept that the self-improvement architecture can operate on procedurally generated, photorealistic environments that were never seen during the agent's initial training.

The Hierarchical Reasoning Architecture: Gemini Pro Orchestrating SIMA 2

For tasks requiring more sophisticated reasoning than the Flash-Lite model can provide within its latency constraints, the paper introduces a hierarchical architecture (Section 4.4) where a more capable but slower model (Gemini Pro) issues instructions to the faster but less capable SIMA 2 agent.

Operational mechanics: Gemini Pro operates at a slower cadence, being called every $k$ steps (the paper does not specify $k$ , but the implication is that Gemini Pro is invoked much less frequently than the per-step SIMA 2 inference). On each invocation, Gemini Pro receives:

Recent video history (the sequence of frames since the last invocation)
A text-based summary from its previous invocation (serving as "a form of recurrent memory")

Gemini Pro outputs:

A natural language instruction for SIMA 2 (the sub-task to execute next)
An updated text-based summary (for the next invocation)

This architecture addresses two limitations of the base SIMA 2 agent:

Limited context window: SIMA 2 uses a limited context window for low-latency interaction, which constrains how far back it can remember. The Gemini Pro summary mechanism provides persistent memory that can maintain context over arbitrarily long horizons
Reasoning capacity: Gemini Flash-Lite, while capable, is less powerful than Gemini Pro for complex multi-step reasoning. The hierarchical setup allows computationally expensive reasoning (e.g., diagram parsing, long-horizon planning) to happen at the Pro level, with SIMA 2 handling the real-time execution

The campfire-building example (Figure 14): The paper provides a concrete demonstration where the hierarchical agent successfully follows a complex visual diagram to build a campfire. The diagram specifies multiple steps (gather stones, gather wood, open build menu, select campfire, place campfire). Gemini Pro parses the diagram, decomposes it into sub-steps, and issues instructions sequentially, tracking progress. SIMA 2 executes each sub-instruction and reports completion. This is an integrative task requiring reasoning (diagram understanding), memory (tracking which steps are done), and visual understanding (identifying the correct build menu option)—capabilities that would be difficult to achieve with Flash-Lite alone but become tractable with the hierarchical architecture.

Why this matters as an architectural contribution: The hierarchical setup demonstrates that more capable foundation models can be composed with embodied agents without requiring the embodied agent to be retrained. As Gemini improves, new models can immediately be used to orchestrate SIMA 2, enabling more advanced behaviors without any changes to the low-level action model. This is a practical instantiation of the principle that separating high-level reasoning from low-level execution allows each to be optimized independently.

4. Key Insights and Innovations

Innovation 1: Embodied Competence Is Not an Emergent Property of Scale — It Must Be Explicitly Taught

The paper's single most diagnostic finding is not that SIMA 2 works well, but that baseline Gemini models — even the most capable available — are startlingly bad at embodied action. Section 4.3 reports that Gemini Flash-Lite achieves 3.2% success and Gemini Pro achieves 7.0% on the embodied evaluation suite, despite "considerable efforts at prompt engineering." These are not marginal failure rates; they represent near-total incompetence on tasks that the paper's human baselines complete at 65–86%.

What makes this a genuine insight rather than an unsurprising engineering detail is that it directly contradicts a plausible (and, among some researchers, implicitly held) assumption: that sufficiently large models trained on internet-scale data will spontaneously develop the capacity for goal-directed physical interaction. The reasoning would go roughly as follows: foundation models have seen millions of hours of video, read countless descriptions of how to perform tasks, and demonstrated reasoning capabilities that approach or exceed human performance on many benchmarks. Surely, given an appropriate prompt interface, they should be able to translate that knowledge into action. The paper's numbers say otherwise, and the gap is not small — it is two orders of magnitude below human performance.

This finding reframes the research problem in a specific way. The challenge is not primarily to build more capable foundation models (though that helps at the margin — Gemini Pro is roughly 2× better than Flash-Lite, still at only 7%) but to build a bridge between the reasoning capabilities that pretraining provides and the specific demands of embodied interaction: precise motor control, understanding of action consequences, temporal credit assignment, and the chaining of sub-second decisions into coherent behavioral sequences. The paper demonstrates that this bridge can be constructed through specialized training on embodied data, but the bridge does not build itself through scale alone.

This is a negative result with significant implications for how the field allocates research effort. If embodied competence were emergent, the correct strategy would be to scale pretraining further and wait. Since it is not, the correct strategy is to invest in the training pipeline that creates the connection — exactly what SIMA 2's mixed-data SFT, bridge data, and RL phases represent. The paper thus provides an empirical foundation for treating embodiment as a distinct capability that requires dedicated training, not a free byproduct of general intelligence.

The comparison to Moravec's Paradox (Section 1) gives this finding its conceptual frame: the paper is documenting, with specific numbers, that the paradox holds for modern foundation models just as it did for earlier AI systems. High-level reasoning emerges from scale; low-level sensorimotor skill does not.

Innovation 2: The Pareto Frontier Between Embodied Competence and General Reasoning Can Be Navigated With Mixed-Data Training

Prior work on Vision-Language-Action (VLA) models has documented a troubling phenomenon: training foundation models on embodied action data tends to "erode conversational ability entirely" (Hancock et al., 2025; Zhou et al., 2025, both cited in Section 4.3). This is a specific instance of catastrophic forgetting (French, 1999; Kirkpatrick et al., 2017) that is particularly acute for embodied agents because the fine-tuning data — low-level keyboard-and-mouse actions — is radically out-of-distribution relative to the internet-scale text and images used during pretraining. The default assumption in much VLA work appears to be that you must accept some degradation in general capabilities as the price of embodied competence.

The paper introduces a different framing: this is not an inevitable tradeoff but a Pareto frontier that can be navigated through careful data mixture. The concept is introduced explicitly in Section 4.3: "We can conceptualize this as a Pareto frontier defined according to these two competing objectives." The key empirical finding is that mixing gameplay data with a portion of the original Gemini pretraining data during SFT preserves most general reasoning capability while still achieving near-human embodied performance. The numbers in Table 1 are striking: after SFT, SIMA 2 shows only 4.0% relative regression on coding (LiveCodeBench), 25.5% on math (AIME), and 16.3% on STEM reasoning (GPQA Diamond). The RL phase causes no significant additional regression — meaning the agent can be trained to produce actions without further eroding its reasoning capabilities.

What makes this an intellectual contribution rather than just a training detail is that it establishes a tractable operating point on a frontier that prior work had suggested might be characterized by harsh tradeoffs. The paper is not claiming that there is no forgetting — there clearly is, particularly on mathematical reasoning — but rather that the forgetting is modest enough that the resulting agent remains a competent reasoner while also achieving near-human embodied performance. This is a fundamentally optimistic finding for the VLA research program: it suggests that the catastrophic forgetting problem is manageable if the training mixture is designed with retention in mind from the outset, rather than treated as an afterthought.

The significance extends beyond SIMA 2 specifically. The paper provides a template — mixed-data training with explicit retention evaluation — that future VLA systems can adopt. It also establishes evaluation benchmarks (LiveCodeBench, AIME, GPQA Diamond) as standard metrics for measuring capability retention, giving the field a concrete way to compare not just how well VLA models act but how much they retain of their original intelligence.

The finding that RL causes no additional regression is particularly noteworthy. It suggests that once the model has been fine-tuned to operate in the embodied domain (via SFT), further optimization within that domain (via RL) operates on a distribution that is close enough to the SFT distribution that it doesn't trigger additional forgetting. This separates the "adaptation to a new domain" problem (which causes some forgetting) from the "optimization within an already-adapted domain" problem (which does not, at least in this case).

Innovation 3: Foundation Models Can Close the Self-Improvement Loop — Serving as Task Setter, Agent, and Reward Model Simultaneously

The self-improvement architecture in Section 4.5 represents a conceptual advance in how the field thinks about autonomous agent learning, independent of the specific performance numbers achieved. The paper's distinctive move is to demonstrate that the same foundation model technology — with different prompting and, presumably, different model instances or configurations — can serve all three roles in a self-improvement loop: generating tasks, executing them, and evaluating the results.

Prior work on open-ended learning (surveyed in Section 2) has explored each of these functions separately: foundation models as task proposers (Du et al., 2023; Zhang et al., 2023), as reward models (Baumli et al., 2023; Ma et al., 2023a; Rocamonde et al., 2024), and as policy models in VLA settings. But prior work has not, to the paper's knowledge, integrated all three into a single closed-loop system operating in complex 3D environments. The paper's contribution is the integration — showing that these components can interoperate in a running game environment to produce genuine skill acquisition without any human intervention in the loop.

What distinguishes this from a straightforward engineering integration is the bootstrapping argument that the architecture implies. The initial SIMA 2 agent generalizes to a new environment (ASKA, or Genie 3) with non-zero but imperfect performance. This initial competence is just sufficient to generate some successful trajectories — the agent stumbles upon correct behavior occasionally, or succeeds at the easiest subset of tasks. Those successful trajectories, when scored by the reward model, become positive training examples. Retraining on them improves the agent, which then generates more successful trajectories on harder tasks, which become better training data, and so on. The paper demonstrates this upward spiral concretely: in ASKA (Figure 15), the initial agent succeeds on fewer than 25% of the fixed tasks (scores above 50), but after multiple self-improvement iterations, it exceeds the success threshold on all tasks.

The architectural insight is that this bootstrapping is possible because the foundation model provides both the breadth needed for the initial generalization (the agent can do something in a new environment because it draws on its pretrained world knowledge) and the generality needed for the reward function to work across arbitrary tasks (the Gemini-based reward model can evaluate any instruction that can be expressed in language, without task-specific engineering). Without breadth, the agent would never get off the ground — it would fail at everything and produce no positive training examples. Without generality in the reward model, each new task would require hand-crafted evaluation, making open-ended learning impossible in practice.

The transfer result in Genie 3 (Figure 17) — where self-improvement on urban navigation tasks improves performance on held-out natural environment tasks — adds a further dimension. It suggests that the skills acquired through self-improvement are not merely memorized environment-specific behaviors but represent transferable improvements that generalize across visual domains. This is preliminary (the paper acknowledges the tasks are primarily navigation-based and the scale is limited), but it hints at a path toward the "open-ended algorithms" vision that Clune (2019) described: an agent that continuously learns across an expanding frontier of environments.

The paper's framing of this as "the first preliminary working example of an agent learning within that universal world model" (Section 4.5.2) is ambitious but appropriately qualified. The contribution is not that the self-improvement works perfectly — the agent still has clear limitations — but that the closed-loop architecture has been demonstrated as viable in a nontrivial setting. This opens a research direction where the quality of all three components (task setter, agent, reward model) can be independently improved, with the loop becoming more effective as each component gets better.

Innovation 4: Generalization to Held-Out Worlds Is Driven by Pretrained World Knowledge, Not Just Visual Similarity

The generalization results in Section 4.2.2 go beyond demonstrating that SIMA 2 is better than SIMA 1 — they provide evidence for a specific mechanism of generalization that has implications for how embodied agents should be designed.

SIMA 1 generalized poorly to held-out environments because its language understanding was trained from scratch on gameplay annotations. When it encountered a novel visual setting like Minecraft's blocky graphics or ASKA's Viking-themed menus, it had no conceptual framework for interpreting what it saw — it could not recognize that a pixelated brown rectangle was functionally similar to a campfire it had seen in Valheim, because its visual and language representations had been trained only on the specific correlations present in the training data.

SIMA 2, by inheriting Gemini's pretrained world knowledge, brings a fundamentally different generalization mechanism. The agent recognizes a campfire in ASKA not because it looks identical to campfires in training environments but because Gemini's pretraining includes the concept of "campfire" across many visual instantiations. The paper's qualitative example in Figure 11 (top) makes this concrete: SIMA 2 identifies a distant object with "That might be a campfire. I'll go check it out," then confirms "I found a campfire" upon approach. The internal reasoning trace shows the agent explicitly naming the concept and using it to guide behavior. SIMA 1, lacking this conceptual understanding, fails at the same task.

This is not merely a performance improvement; it is a qualitative shift in how generalization works. The paper is demonstrating what might be called conceptually-grounded generalization — the ability to recognize functional categories (campfires, menus, enemies, resources) across visual domains by leveraging semantic understanding rather than visual similarity. The MineDojo results support this interpretation: SIMA 2 completes tasks in 26 out of 50 categories despite never having seen Minecraft during training, suggesting it can identify coal blocks, iron pickaxes, and zombies not because they look like anything in its training environments (Minecraft's blocky aesthetic is quite distinctive) but because Gemini's pretraining includes Minecraft-related knowledge from the vast corpus of internet text and video about the game.

The practical implication is significant for the design of future embodied agents. It suggests that the heavy lifting of generalization should be done by the pretrained foundation model's semantic understanding, not by hoping that enough diverse training environments will provide visual coverage of all possible settings. This shifts the training objective: rather than trying to collect data in every possible visual domain, the focus should be on ensuring that the agent can connect its pretrained concepts to the specific action affordances of the current environment — which is exactly what the bridge data and SFT pipeline are designed to teach.

The paper's qualitative demonstrations in The Gunk (Figure 12) and Genie 3 (Figure 13) push this insight further by showing generalization to environments that are not just visually different but mechanically different (The Gunk's suction-tool mechanic) or photorealistic rather than game-like (Genie 3). The agent's ability to use on-screen text cues ("ABSORB" and "HOLD") to infer the correct action in The Gunk — a mechanic never encountered in training — is a particularly clean example of conceptually-grounded generalization in action.

5. Experimental Analysis

Evaluation Methodology

Dataset. The evaluation is performed across a portfolio of 3D virtual environments rather than a static dataset. Training environments include 3 research environments (Construction Lab, Playhouse, WorldLab) and 7 commercial video games (Goat Simulator 3, Hydroneer, No Man's Sky, Satisfactory, Space Engineers, Valheim, Wobbly Life). Held-out environments include ASKA, a subset of 50 programmatic tasks from the MineDojo benchmark in Minecraft (drawn from Combat, Harvest, and Tech Tree categories, each with 15 random seeds), The Gunk (qualitative), and multiple photorealistic environments generated by Genie 3 (qualitative). For self-improvement experiments, the paper uses task sets defined within ASKA and Genie 3, with the ASKA evaluation including both a fixed set of tasks (resource gathering, environment interaction, navigation, menu use) and a game-progression tech tree evaluation. The paper does not report a single static test set size; rather, each environment has its own suite of evaluation tasks, with the total number substantially expanded from SIMA 1 (Section 3.4 notes "often by an order of magnitude or more in the case of programmatic evaluations").
Base model(s). The core SIMA 2 agent is a Gemini Flash-Lite model fine-tuned via supervised learning on mixed gameplay and pretraining data, followed by reinforcement learning from verifiable rewards. The paper also uses Gemini Pro in two capacities: (1) as a baseline comparison for embodied performance without fine-tuning (Section 4.3), and (2) as a hierarchical reasoning orchestrator that issues sub-instructions to the SIMA 2 agent at a slower cadence with persistent text-based memory (Section 4.4). For self-improvement, additional Gemini instances serve as the task setter and reward model (Section 4.5). The choice of Flash-Lite for the core agent is explicitly motivated by "latency constraints that come with embodied action" (Section 4.4)—the agent must produce actions at interactive speeds, making a lighter model necessary despite the availability of more capable Gemini variants. The paper does not disclose the parameter counts of these models.
Metrics. The primary evaluation metric is task success rate (%), measured through three distinct evaluation mechanisms depending on the environment. Ground-truth evaluation uses internal game state information (e.g., object positions, resource acquisition flags) to determine success, applicable only to research environments (Construction Lab, MineDojo, Playhouse, WorldLab). Programmatic evaluation uses optical character recognition (OCR) to detect on-screen text that signals task completion (e.g., menu confirmations, quest notifications) plus pixel-color-based heuristics and action-output-based functions, applicable to commercial games (ASKA, Goat Simulator 3, Hydroneer, No Man's Sky, Satisfactory, Space Engineers, Valheim, Wobbly Life). Human evaluation uses five independent human raters per trajectory to assess task completion by watching the recorded video; applicable to a subset of commercial games (Goat Simulator 3, Hydroneer, No Man's Sky, Satisfactory, Valheim, Wobbly Life). For self-improvement experiments, the primary metric is the Gemini-based reward model score (0–100), where a score of 50 or above is treated as "success." The evaluation suite introduces three stricter requirements compared to SIMA 1: (a) on-screen text must persist for several seconds before success is triggered (selecting for intentional behavior), (b) a subset of tasks enforces a threshold on actions permitted after completion (measuring task-completion recognition), and (c) sequential evaluations require completing every sub-task in a chain where instructions are supplied one after another.
Baselines. The paper compares against four distinct baselines. (1) SIMA 1 (SIMA Team et al., 2024): the direct predecessor, trained on similar environments but using pretrained vision encoders with a from-scratch language encoder, incapable of producing text output (reasoning or dialogue). (2) Baseline Gemini models without embodied fine-tuning: Gemini Flash-Lite and Gemini Pro evaluated zero-shot on the programmatic evaluation suite with "considerable efforts at prompt engineering to enable the model to be able to output proper action and text formatting" (Section 4.3). (3) Human performance: collected from players with significant experience in the training environments (subject to the same time limits as agents, and additionally without time limits as an approximate upper bound), and from naive players with no prior experience for held-out environments. (4) The initial SIMA 2 agent before self-improvement: serves as the baseline for measuring improvement from the self-improvement loop (Section 4.5).
Generation budget / compute accounting. The paper measures agent performance in terms of task completion within specified time limits per task, not in terms of generation tokens or FLOPs. Each evaluation task has a predefined time limit (some as short as three seconds, as noted in Section 4.2.1's discussion of human performance), and the agent must complete the task within that window. For sequential tasks, each sub-instruction is supplied only after the previous task is completed or times out. The self-improvement loop measures compute in terms of self-improvement iterations (successive rounds of generating trajectories, scoring them, and retraining), with performance plotted progressively in Figure 15. The paper does not provide FLOP counts or token budgets for any experiment, making direct computational efficiency comparisons between methods infeasible from the reported data.
Cross-validation / statistical protocol. The paper does not report formal cross-validation or statistical significance testing. For human evaluations, five independent ratings per trajectory are collected to improve precision, but the paper does not specify the aggregation method (majority vote, mean with threshold, etc.) or report inter-rater reliability metrics (e.g., Krippendorff's alpha, Fleiss' kappa). For the self-improvement experiments in Genie 3, a train/test split is employed: tasks in urban environments form the training set and tasks in natural environments form the held-out test set, enabling an assessment of transfer. Human baseline collection for held-out environments used participants with no prior experience in those specific games, measured on their first attempts to provide a "naive" comparison point, though the paper acknowledges rapid human learning means this comparison is only valid for the initial few tasks (Section 4.2.2). The paper does not report confidence intervals, error bars, or statistical tests for any of the main quantitative results.

Main Quantitative Results

The results are organized across four axes: (1) overall performance in training environments compared to SIMA 1 and humans, (2) performance in held-out environments, (3) comparison to baseline Gemini models and assessment of capability retention, and (4) self-improvement results.

Overall Performance in Training Environments

Headline result. SIMA 2 approximately doubles the average success rate of SIMA 1 across both human-evaluated and automatically-evaluated tasks in training environments and substantially closes the gap with human performance (Figure 6). On human-evaluated tasks, SIMA 2 achieves 66% mean success rate compared to SIMA 1's 33% and human performance of 86% without time restrictions (78% with time restrictions). On automatically-evaluated tasks, SIMA 2 achieves 65% compared to SIMA 1's 30% and human performance of 76% without time restrictions.

Per-environment breakdown. This doubling is remarkably consistent across environments, though the absolute magnitude varies. On human evaluations (Figure 8), SIMA 2's absolute improvement over SIMA 1 ranges from +18 percentage points (Wobbly Life) to +46 percentage points (Satisfactory), with intermediate values of +39% (Goat Simulator 3), +23% (Hydroneer), +35% (No Man's Sky), and +27% (Valheim). On automatic evaluations (Figure 9), the absolute gains are similarly large: +57% (Satisfactory), +38% (Hydroneer), +35% (Valheim and Goat Simulator 3), +44% (No Man's Sky), +57% (Wobbly Life), +52% (Space Engineers), +24% (Construction Lab), +5% (Playhouse), and +14% (WorldLab). The smaller gains in Playhouse and WorldLab suggest that SIMA 1 already performed reasonably well in the simpler research environments, with the larger gains concentrated in the more complex commercial games where visual diversity, menu interactions, and game dynamics are more demanding.

Skill-category decomposition (Figure 7). Breaking down by skill categories (interaction, navigation, menu use, tool use, construction, object management, resource gathering, combat), SIMA 2 substantially improves over SIMA 1 across all categories, approaching human-level performance in several instances. In interaction and object management, SIMA 2 "nearly closes the gap with human-level performance." However, combat remains a notable weakness—the paper attributes this partly to "the motor difficulty of these tasks," citing the example of hunting a deer in Valheim requiring approaching from downwind while crouching, then quickly attacking with split-second decision making and "a degree of luck." Human performance in combat also improves substantially when the time restriction is removed, suggesting that the short time limits are particularly constraining for combat tasks.

Performance in Held-Out Environments

Headline results (Figure 10). In entirely held-out environments never seen during training, SIMA 2 significantly outperforms SIMA 1 on both quantitative benchmarks: +12 percentage points on ASKA and +13 percentage points on MineDojo. The paper does not report raw success rates in the figure text, but visually from Figure 10, SIMA 2 achieves approximately 15–17% on ASKA and 12–14% on MineDojo, compared to SIMA 1's ~3–5% on ASKA and ~0–1% on MineDojo.

MineDojo results. SIMA 2 completes tasks in 26 out of 50 task categories in the MineDojo benchmark suite, compared to SIMA 1 which "only completes two types of tasks (harvest dirt and combat spider)." The paper attributes SIMA 1's low performance to "the comparatively abstract visual appearance of Minecraft and the domain-specific knowledge required to complete these tasks," while SIMA 2 benefits from "Gemini's general world knowledge." Qualitative examples in Figure 11 show SIMA 2 successfully obtaining coal with an iron pickaxe and combating a zombie, with its dialogue output correctly identifying key on-screen events (recognizing a campfire, a zombie, coal deposits).

ASKA results. SIMA 1 is described as "generally only capable of performing the most basic tasks, such as opening the map or picking up an object directly beside the agent." SIMA 2, in contrast, performs non-trivial tasks including navigating to specific objects, activating game mechanics (the Eye of Odin), and interacting with novel menus, correctly identifying on-screen text to select the appropriate buttons (Figure 11, middle and bottom rows).

Human comparison for held-out environments. On representative subsets of tasks, naive human performance (first attempts, no prior game experience) was roughly 19% for MineDojo (16 tasks) and 32% for ASKA (25 tasks). The paper notes that SIMA 2's initial generalization capabilities are "approaching that of a human encountering these complex environments for the first time," but cautions against over-interpreting the comparison because "the nature of failures and successes often differed significantly"—humans were more likely to fail due to time constraints, while agents failed due to suboptimal exploration.

Qualitative generalization to The Gunk (Figure 12). SIMA 2, with manual human instruction, progressed through the first 15–20 minutes of The Gunk (a story-driven action-adventure game with substantially different visuals, a linear narrative, and a novel suction-tool mechanic), up to the "Campsite" checkpoint. Along the way, it performed skills including scanning objects with a novel device, climbing ledges, jumping over gaps, and clearing two separate areas of "gunk" using the handheld tool. The paper highlights the agent's ability to use on-screen text cues (e.g., "ABSORB" and "HOLD" prompts) to "identify that it needed to hold the left mouse button to absorb the gunk"—reasoning about a novel game mechanic from contextual interface cues.

Qualitative generalization to Genie 3 (Figure 13). SIMA 2 was deployed across a range of photorealistic environments generated by Genie 3 (naturalistic and urban settings). The agent successfully performed navigation tasks ("Swim to the orange coral on the left," "Fly to a red flower," "Go to the bench," "Walk to the espresso machine," etc.) despite being "trained purely in research and video game environments." The paper frames this as a "proof-of-concept that training embodied agents in simulated 3D environments enables generalization to more realistic environments—eventually possibly even the physical world."

Comparison to Baseline Gemini Models

Zero-shot embodied performance (Section 4.3). Baseline Gemini models without embodied fine-tuning achieve dramatically poor performance on the programmatic evaluation suite: Gemini Flash-Lite achieves 3.2% success and Gemini Pro achieves 7.0% success, despite "considerable efforts at prompt engineering." This establishes that "competent embodied interaction is not an emergent property of current large-scale pretraining on language and vision data; it is a distinct capability that must be explicitly enabled through training."

Capability retention (Table 1). Compared to the baseline Gemini model without SIMA data training, SIMA 2 after SFT shows the following relative reductions: -4.0% on LiveCodeBench (coding), -25.5% on AIME (advanced mathematics), and -16.3% on GPQA Diamond (STEM reasoning). After additional RL training, the relative reductions change to -8.4% (LCB), -15.4% (AIME), and -19.5% (GPQA Diamond). The paper highlights that "the additional RL training caused no significant additional regression compared with SFT alone," and in the case of AIME, the regression actually decreased from SFT alone to SFT+RL (-25.5% → -15.4%), though the paper does not comment on or explain this directional change. The headline interpretation is that "high embodied competence need not come at the expense of general intelligence."

Hierarchical reasoning with Gemini Pro (Section 4.4, Figure 14). Composing Gemini Pro (as an orchestrator) with SIMA 2 enables more advanced reasoning than SIMA 2 alone. The campfire-building example demonstrates the combined agent successfully parsing a complex visual diagram, decomposing it into sub-steps, tracking progress, and executing each sub-task. Additional qualitative examples in Appendix B include abstract reasoning (Figure 18: the agent follows the instruction "do the opposite of what I tell you" across a series of navigation, menu use, and tool use tasks) and active exploration (Figure 19: the agent plays 21 questions, actively exploring the environment and asking questions to identify a user-selected object). These examples are qualitative only—no quantitative metrics are reported for the hierarchical setup.

Self-Improvement Results

Fixed task set in ASKA (Figure 15). Over successive iterations of the self-improvement loop (using a fixed set of tasks in ASKA, with a Gemini-based reward model providing 0–100 scores), the agent's average score steadily improves, with progressively darker points and curves in Figure 15 representing later iterations. The initial SIMA 2 agent was "successful (i.e., score above 50) on less than a quarter of the tasks." After self-improvement, "performance eventually exceeds that of the human reference score" on average, and the agent "exceed[s] the success threshold across all tasks." The paper provides qualitative examples of specific skills acquired: learning to navigate to a rain collector (a novel object) and learning to extinguish a campfire (Figure 20 in Appendix C), both behaviors absent from the initial agent.

Game progression in ASKA (Figure 16b). Using the full self-improvement setup (Gemini-based task setter plus reward model), the agent was trained "purely on self-generated experience" in ASKA. When manually instructed to progress through the ASKA technology tree, the self-improved agent "is capable of progressing significantly further than the SIMA 1 and SIMA 2 agents," ultimately building a shelter within a one-hour time window. The paper reports that the task setter was prompted to focus on skills relevant for game progression (resource gathering, crafting, menu use, building) and could "focus on improving weaker skills" by monitoring downstream evaluation results. For instance, "ASKA's crafting menu is quite distinct from those of our training environments, and SIMA 2 struggled with this game mechanic initially. Through focused effort by the task setter, the agent was eventually able to acquire this skill."

Self-improvement in Genie 3 (Figure 17). Tasks were split into train (urban environments) and test (natural environments), primarily focused on navigation. The self-improvement loop ran on the train tasks. Results show the self-improved agent outperforming the initial SIMA 2 agent "across nearly all train tasks, often by 25 points or more" in reward model score. More critically, "these improvements also extend to the test tasks in entirely different environments"—"in the majority of the tasks in natural environments (held out), the self-improved SIMA 2 outperforms the initial agent." Qualitative examples show the agent succeeding at "find a lollipop" in a candy store (urban/train) after self-improvement (initial agent failed) and succeeding at "Walk over to the single red mushroom with white spots" in a natural setting (test), with the initial agent failing. The paper interprets this as "initial evidence that we may be able to use these types of techniques to produce an open-ended process of autonomously acquiring diverse skills, yielding an increasingly general and capable agent."

Ablation Studies and Robustness Checks

The paper does not contain systematic ablation studies in the traditional sense (controlled removal of individual components to measure their contribution). Rather, the relevant ablative and robustness evidence is distributed across the following comparisons:

SFT alone vs. SFT + RL (Table 1, capability retention): The RL phase does not cause significant additional regression on general reasoning benchmarks compared to SFT alone. On LiveCodeBench, relative regression is -4.0% (SFT) vs. -8.4% (SFT+RL); on AIME, -25.5% vs. -15.4%; on GPQA Diamond, -16.3% vs. -19.5%. The fact that AIME regression decreases with RL is noted but not explained—it could reflect noise, benchmark-specific effects, or the RL phase coincidentally providing training signal that partially recovers mathematical reasoning lost during SFT. The paper treats these results as robustness evidence that capability retention is stable through both training phases.
Baseline Gemini models vs. fine-tuned SIMA 2 (Section 4.3): This comparison effectively serves as an ablation of the entire embodied training pipeline. Removing all embodied training (SFT + RL) reduces performance from ~65% to 3.2–7.0% on programmatic evaluations, demonstrating that embodied competence is almost entirely dependent on the specialized training data. This is not a subtle effect—it is a near-total collapse in performance.
SIMA 1 vs. SIMA 2 (Figures 6–10): While not a controlled ablation, this comparison demonstrates the effect of the architectural shift from separate vision/language encoders with a from-scratch language model (SIMA 1) to a unified Gemini-based architecture with pretrained language and reasoning capabilities (SIMA 2). The consistent ~2× improvement across environments and skill categories, plus the qualitative difference in generalization behavior (Figure 11), provides evidence for the value of the Gemini integration—though these results conflate the effect of the base model change with the effect of the training data expansion and methodology changes.
Mixed training data (gameplay + pretraining) vs. implied gameplay-only alternative (Table 1 vs. Figure 6): The paper states that the mixed-dataset approach was "crucial to maintain the original capabilities of the base model" but does not report the embodied performance of a model trained only on gameplay data without pretraining data mixing, nor does it report the capability retention of a gameplay-only model. The evidence for the mixture's necessity is therefore circumstantial: the mixed-training SIMA 2 achieves both high embodied performance and reasonable capability retention, while prior work (Hancock et al., 2025; Zhou et al., 2025) suggests that training solely on action data erodes conversational ability. The paper does not provide its own direct ablation of the data mixture ratio.
Oracle vs. predicted difficulty bins (not applicable): Unlike many ML papers, SIMA 2 does not use an oracle vs. predicted difficulty framework. The self-improvement evaluation uses a Gemini-based reward model that is itself a learned function—the paper does not compare against an oracle reward signal (e.g., ground-truth game state) for the ASKA self-improvement tasks, making it difficult to assess whether improvements in reward model scores correspond to genuine task mastery improvements or to over-optimization of the reward model.
Self-improvement: fixed tasks vs. open-ended task generation: The paper separates these two aspects in the ASKA experiments, first demonstrating improvement on a fixed set of tasks (Figure 15, isolating the improvement mechanism from the task generation mechanism) and then combining task generation and improvement in the full setup (Figure 16b). The fixed-task experiment provides a cleaner demonstration that the reward model and retraining procedure produce genuine policy improvement, but does not ablate the reward model against an alternative evaluation method (e.g., human judgment of the same trajectories) to verify that the observed score increases reflect actual behavioral improvements rather than reward model exploitation.
Sequential revisions vs. parallel sampling (not applicable—no revision model): SIMA 2 does not employ a revision model architecture in the style of LLM self-correction. The closest analog is the self-improvement loop, which retrains the entire model on its own experience rather than generating revisions at inference time.

Notable negative result: The paper does not report any failure modes of the self-improvement process beyond the general limitations acknowledged in Section 5. There is no ablation testing whether the reward model can be gamed (e.g., whether the agent learns behaviors that score highly under the reward model but are judged as unsuccessful by humans), which is a standard concern in RL from learned rewards. The paper's Genie 3 transfer result (Figure 17) does show some test tasks where the self-improved agent performs worse than the initial agent (visible as negative delta-score bars in the test tasks panel), but the paper does not discuss these cases or characterize when and why self-improvement fails to transfer.

Critical Assessment

The paper makes three central empirical claims. I evaluate each against the reported experiments, identifying what is demonstrated, what is implied, and what is untested.

Claim 1: SIMA 2 "substantially closes the gap with human performance" and represents a "step-change improvement" over SIMA 1.

This claim is the most directly supported by the data. Figure 6 shows SIMA 2 at 66% vs. human at 78% (with time limits) on human-evaluated tasks, and 65% vs. 76% on automatic evaluations. The improvement over SIMA 1 (33% and 30% respectively) is unambiguous—an approximate doubling that holds across all environments individually (Figures 8, 9). The evaluation suite is meaningfully harder than SIMA 1's (Section 3.4 details three specific increases in strictness), so the gains are not an artifact of easier measurement.

However, "closing the gap with human performance" requires qualification. The human baselines were collected from players with significant experience in these specific games, but they were subject to the same time limits as the agent, some of which were as short as three seconds. When time limits are removed, human performance rises to 86% (human-evaluated) and 76% (automatic)—a gap of 20 and 11 percentage points respectively relative to SIMA 2. On a subset of skill categories (resource gathering, combat, Figure 7), the gap remains substantial. The paper's own analysis notes that humans struggled with time limits due to "initial inattention, infrastructure latency, and challenges with fine-motor control"—factors that do not affect an agent that generates actions directly from model outputs. This suggests the time-limited human baseline may underestimate what a human could achieve if operating at the agent's effective action rate, and the "gap with human performance" is larger than the 66% vs. 78% comparison implies.

Additionally, the per-skill-category decomposition (Figure 7) reveals that SIMA 2's average performance masks significant variance: the agent "nearly closes the gap" on interaction and object management but still "struggles with combat." The paper attributes this to motor difficulty and split-second decision requirements, suggesting that the remaining gap is not uniformly distributed but concentrated in skills that require rapid reactive control—precisely the capabilities that the 3 Hz frame sampling rate is least suited to support.

Claim 2: SIMA 2 demonstrates "robust generalization to previously unseen environments" including photorealistic worlds.

The evidence for generalization is multi-layered but varies in rigor. The quantitative evidence is strong: +12% on ASKA and +13% on MineDojo over SIMA 1 (Figure 10), with SIMA 2 completing 26/50 MineDojo task categories vs. SIMA 1's 2/50. These are held-out environments in the strong sense—never seen during any phase of training, with different visuals, menus, and game mechanics.

However, several factors limit the strength of the generalization claim:

Absolute performance remains low. From Figure 10, SIMA 2 achieves roughly 15–17% on ASKA and 12–14% on Minecraft—improvements over SIMA 1, but far from robust competence. The paper's human baseline for naive players was 32% (ASKA) and 19% (MineDojo) on representative subsets, meaning SIMA 2 underperforms even a completely inexperienced human on first encounter. The claim that SIMA 2's generalization is "approaching that of a human encountering these complex environments for the first time" is numerically true for MineDojo (12–14% vs. 19%) but notably behind for ASKA (15–17% vs. 32%), which the paper's own numbers show.
The Genie 3 generalization is entirely qualitative. Figures 13 and 17 show the agent succeeding at navigation tasks in photorealistic environments, but there is no quantitative success rate reported, no comparison to any baseline, and no characterization of failure modes. The paper presents carefully selected successful examples; we do not know how often the agent fails, what types of environments or tasks cause failure, or whether performance degrades systematically under certain conditions. The self-improvement in Genie 3 (Figure 17) does include quantitative delta-scores per task, but the absolute performance levels are not reported—we see that the agent improved, but not from what baseline or to what ceiling.
The transfer claim from urban to natural Genie 3 environments (Figure 17) is preliminary. The paper states that "in the majority of the tasks in natural environments (held out), the self-improved SIMA 2 outperforms the initial agent," but Figure 17 also shows several test tasks where the self-improved agent performs worse (negative delta-score bars). The paper does not analyze these negative-transfer cases or characterize when improvement on urban navigation helps vs. hurts performance in natural settings. Without this analysis, the evidence for transfer is suggestive rather than conclusive.

Claim 3: SIMA 2 demonstrates "a capacity for open-ended self-improvement" that can "autonomously learn new skills from scratch in a new environment."

This claim requires the most careful scrutiny because it is the paper's most ambitious scientific contribution and the evidence, while promising, is limited in several important ways.

The ASKA self-improvement results (Figures 15, 16b) do demonstrate genuine improvement from self-generated experience. The fixed-task experiment shows the agent progressing from success on fewer than 25% of tasks to success on all tasks (scores above 50), eventually exceeding the average human reference score. The game-progression experiment shows the self-improved agent progressing much further through the tech tree than the initial agent, building a shelter within an hour. These are nontrivial outcomes that represent real skill acquisition—the agent learned to interact with novel objects (rain collector) and perform novel actions (extinguish campfire) without human demonstrations (Figure 20).

However, several aspects of the experimental design limit how strongly the results support the "open-ended self-improvement" claim:

The reward model is the sole arbiter of success, and its reliability is not independently verified. All self-improvement results are measured by the Gemini-based reward model—the same model that provides the training signal. The paper calibrates this model against human preferences on "a small dataset of trajectories," but does not report how well the calibration generalizes to the full task distribution, and does not independently verify (through human evaluation) that the reward model's score increases correspond to genuine behavioral improvements. This is the classic reward hacking concern: the agent may be learning to produce trajectories that look successful to the reward model without actually being competent. The fact that the self-improved agent progresses further through the ASKA tech tree (Figure 16b) provides some independent verification—game progression is a harder-to-fake signal—but the paper does not report whether human evaluators would agree with the reward model's assessment of the agent's performance on the fixed task set after self-improvement.
"Open-ended" is not demonstrated empirically. The experiments show improvement over multiple iterations within a single environment (ASKA) or from urban to natural Genie 3 environments, but the horizon is finite—the agent reaches a ceiling in ASKA (success on all fixed tasks, building a shelter within the tech tree time limit). The paper does not demonstrate that the process can continue generating novel, increasingly complex tasks and learning them indefinitely, which is the core requirement for open-endedness. The paper acknowledges this implicitly by calling the Genie 3 results "initial evidence" and "a first preliminary working example." The claim in the abstract—"a capacity for open-ended self-improvement"—is stronger than what the experiments directly demonstrate, which is better characterized as "multi-iteration self-improvement with demonstrated skill acquisition."
The self-improvement tasks in ASKA are relatively constrained. The fixed task set includes navigation to specific objects, basic environment interactions (sleeping in a shelter, extinguishing a campfire), and menu operations. The game-progression task follows a predefined tech tree (Figure 21) that, while requiring multiple sub-skills, has a linear structure. These tasks test whether the agent can master a known set of capabilities; they do not test whether the task setter can generate genuinely novel tasks that expand the agent's behavioral repertoire beyond what the initial SIMA 2 model could conceivably do if prompted appropriately by a human. The crafting menu skill acquisition is the clearest example of learning something genuinely new—the task setter identified this as a weakness and focused training on it—but the paper does not quantify how many such novel skills were acquired or report the task setter's success rate in proposing achievable tasks.
The Genie 3 experiments use primarily navigation tasks—the simplest skill category in the paper's taxonomy (Figure 7, navigation shows the smallest gap between SIMA 2 and humans among the more-challenging categories). This is a narrow test of the self-improvement architecture's generality. Would the loop work for tool use, construction, or combat in Genie 3? The paper does not test this.
No scaling analysis of the self-improvement loop. The paper does not report how performance varies with the number of self-generated trajectories, the number of iterations, the size of the retraining dataset, or the quality of the reward model. Without these analyses, it is impossible to assess the efficiency of the approach or project how it would scale to longer horizons or more complex environments.

Missing experiments that would have strengthened the paper:

Human evaluation of self-improved agents. Having human raters evaluate the trajectories of the self-improved SIMA 2 (on the same tasks used for the reward model) would address the reward hacking concern directly. If reward model scores and human judgments correlate strongly after self-improvement, the claim that the agent genuinely improved is much stronger.
Ablation of the reward model quality. Training with different reward models (e.g., a weaker Gemini variant, a programmatic-only reward where applicable, or human ratings) and comparing self-improvement outcomes would characterize how sensitive the loop is to reward model accuracy—a critical parameter for real-world deployment.
Quantitative evaluation in Genie 3. Reporting success rates (not just delta-scores) for the initial and self-improved agents in Genie 3, with a defined task set and success criteria, would move the Genie 3 results from qualitative proof-of-concept to quantitative evidence.
Comparison to alternative improvement methods. How does self-improvement compare to simply collecting more human demonstrations in ASKA? If 100 human demonstrations would produce the same improvement as the self-improvement loop, the autonomous approach is less practically compelling (though still scientifically interesting). The paper does not provide this comparison.
Longer-horizon self-improvement. Running the loop for more iterations, or across multiple environments in sequence, to test whether improvement plateaus or continues, would strengthen the "open-ended" claim substantially.
Statistical characterization. Confidence intervals on the main results, inter-rater reliability for human evaluations, and statistical tests for the self-improvement deltas would allow readers to assess whether observed differences are reliable given the sample sizes.

In summary, the experiments strongly support the claim that SIMA 2 is a substantially better embodied agent than SIMA 1—the performance doubling, the consistent per-environment and per-skill improvements, and the held-out environment generalization are well-documented. The claim of generalization to photorealistic environments is supported qualitatively but lacks quantitative rigor. The self-improvement claim is the most provocative and the least thoroughly validated; the experiments demonstrate that the proposed architecture can produce genuine skill acquisition in a novel environment without human demonstrations, which is a genuine advance, but the evidence does not yet establish that this process is open-ended, robust to reward model errors, or competitive with alternative improvement strategies. The paper appropriately hedges this with "initial evidence" and "first preliminary working example" language in the body, but the abstract's unqualified "capacity for open-ended self-improvement" overstates what the experiments demonstrate.

6. Limitations and Trade-offs

The Difficulty Estimation Cost Is Not Accounted For

The assumption or constraint. The entire compute-optimal framework requires knowing how difficult each prompt is before allocating the inference budget. The paper's method for estimating this — generating 2048 samples per question and scoring them — is itself enormously expensive. In Section 3.2, the authors are transparent:

"estimating difficulty in this way still incurs additional computation cost during inference... our experiments do not account for this cost largely for simplicity"

The consequence. The headline 4× efficiency gains over best-of-N (Figures 4 and 8 in Section 5) are computed after difficulty is already known, without amortizing the cost of estimating it. Since estimating difficulty requires 2048 generations per question — more than the largest test-time budgets studied (256–512) — the total cost in a realistic deployment would be dominated by the estimation step, making the reported gains an upper bound rather than an achievable efficiency improvement. A practitioner deciding whether to deploy this method would need to know the total cost, not just the post-estimation optimization gain.

What evidence exists in the paper. The paper benchmarks only the strategy execution phase, never the combined (estimation + execution) cost. The authors acknowledge this explicitly in Section 3.2 but provide no analysis of how the difficulty estimation cost scales, whether it can be reduced (e.g., through a learned difficulty predictor trained from question text alone), or what the net efficiency gain would be after amortizing this cost. The predicted (non-oracle) difficulty bins perform nearly as well as oracle bins (Figures 4 and 8, curves largely overlapping), which is encouraging for deployability without ground-truth labels, but this does not reduce the 2048-sample estimation cost — it only removes the dependence on answer labels.

Mitigation status. The paper does not address this gap. Section 3.2 flags it as an exploration-exploitation tradeoff for future work, and Section 8 explicitly calls for "pretraining or finetuning models to directly predict difficulty of a question" from text alone. No such model is developed or evaluated here. Until this is closed, the 4× figure should be understood as a conditional gain given oracle difficulty knowledge, not a realized deployment improvement.

The Self-Improvement Claim Relies on an Unverified Reward Model

The assumption or constraint. The self-improvement architecture (Section 4.5) uses a Gemini-based reward model as the sole arbiter of success, providing 0–100 scores that serve as both the training signal for policy improvement and the evaluation metric for measuring that improvement. The paper calibrates this reward model against human preferences on "a small dataset of trajectories" (Section 4.5), but the calibration dataset size, composition, and generalization properties are not reported. This means the entire self-improvement loop — task execution, scoring, and retraining — operates within a closed system where the same learned function determines what counts as success.

The consequence. This creates a reward hacking risk: the agent may learn to produce trajectories that score highly under the reward model without genuinely improving at the underlying tasks. The paper's primary evidence against this is the game-progression result in ASKA (Figure 16b), where the self-improved agent progresses further through the tech tree than the initial agent, measured by an independently observable outcome (shelter construction within a time window). However, the paper does not independently verify through human evaluation that the reward model's score increases (Figure 15, from initial success on <25% of tasks to 100%) correspond to genuine behavioral improvements rather than reward model exploitation. If the reward model has systematic blind spots — for instance, rewarding behaviors that appear intentional but fail to achieve the goal — the self-improvement loop would amplify these biases rather than producing a more capable agent.

What evidence exists in the paper. The fixed-task experiment (Figure 15) reports only reward model scores, never human judgments of the same trajectories after self-improvement. The Genie 3 transfer experiment (Figure 17) shows score deltas but never reports absolute task success rates verified by an independent metric. The Genie 3 test-task panel in Figure 17 does include cases where the self-improved agent performs worse than the initial agent (negative delta-score bars), but the paper does not analyze these cases, characterize when self-improvement causes regression, or verify whether the initial agent's failures in these cases reflect genuine incapability vs. reward model misalignment. The reward model calibration is described in only one sentence with no supporting quantitative evidence about calibration accuracy, calibration set size, or generalization to novel task types.

Mitigation status. The paper does not address this gap. There is no ablation that uses an alternative reward signal (e.g., human-annotated scores, programmatic evaluations where applicable) to verify that the observed improvements are robust to the choice of reward model. The paper does not report the reward model's agreement rate with human judgments on the ASKA fixed task set after self-improvement. This is a critical missing validation step: without it, a practitioner cannot distinguish between "the agent got better at the tasks" and "the agent got better at satisfying this particular reward model."

All Results Are on a Single Model Family (Gemini) and Primarily in Video Game Environments

The assumption or constraint. Every experiment uses a Gemini model — specifically Gemini Flash-Lite as the core agent, with Gemini Pro used as the baseline, the bridge-data annotator, the hierarchical orchestrator, the task setter, and the reward model. The evaluation environments are exclusively 3D virtual worlds (commercial video games, research simulators, and Genie 3 environments). The paper states in Section 4: "We believe this model is representative of the capabilities of many contemporary LLMs," but provides no evidence for this claim by testing alternative foundation models. The results on general reasoning benchmarks (Table 1) show specific regression patterns on AIME (-25.5% after SFT) and GPQA Diamond (-16.3%) that are measured relative to the Gemini baseline; these numbers may differ for models with different pretraining distributions or architectural properties.

The consequence. A practitioner using a different foundation model (e.g., Claude, GPT-4, Llama, or a differently-scaled Gemini variant) cannot assume that the paper's findings — the ~2× performance improvement over SIMA 1, the held-out environment generalization patterns, the capability retention ratios, or the self-improvement efficacy — will transfer. The paper's key architectural insight (unified token stream for vision, language, and action) may depend on Gemini-specific properties: its tokenizer, its multimodal pretraining data mixture, its instruction-following capabilities, or its robustness to domain shift during fine-tuning. The finding that baseline Gemini models achieve only 3.2–7.0% success on embodied tasks (Section 4.3) is the paper's foundation for claiming that embodiment requires specialized training; if other model families have different baseline embodied competence (perhaps higher, perhaps lower), the cost-benefit ratio of the SIMA 2 training pipeline changes. Similarly, the environments used are exclusively virtual worlds with keyboard-and-mouse interfaces — the generalization to physical-world robotics, where action spaces are continuous and proprioceptive sensing is available, is entirely untested.

What evidence exists in the paper. None. There are no experiments with non-Gemini models. There are no experiments in physical-world environments. The Genie 3 results (Section 4.5.2) demonstrate generalization from video game graphics to photorealistic rendered environments, which is a step toward visual domain generalization, but photorealistic Genie 3 environments are still virtual worlds with the same keyboard-and-mouse interface and 2D visual observations — they do not test generalization to the sensorimotor complexities of physical robotics (3D proprioception, force feedback, continuous action spaces, contact dynamics, safety constraints).

Mitigation status. The paper does not claim generalizability to other model families. The Section 5 discussion notes that extending to physical-world applications like robotics is future work. The Genie 3 results are explicitly framed as a "proof-of-concept" and "initial evidence." This is appropriate hedged language, but the limitation remains: all quantitative claims are conditional on the Gemini architecture and video game environments, and a deployment team using different infrastructure cannot estimate their expected outcomes from this paper alone.

Latency Constraints Force a Weaker Model and Slow Visual Sampling

The assumption or constraint. The paper explicitly acknowledges (Section 4.4) that SIMA 2 uses Gemini Flash-Lite — a lighter, faster, less capable model — rather than Gemini Pro because of "the latency constraints that come with embodied action." The agent must produce actions at interactive speeds to control a real-time game environment. The visual sampling rate is 3 Hz (one frame every 10 frames from a 30 fps stream, Section 3.2), meaning the agent operates on severely temporally subsampled visual input. This creates a fundamental tension: more capable models (Gemini Pro) could reason better about complex tasks, but cannot act fast enough for real-time control; faster models (Flash-Lite) can act in real time but have degraded reasoning, world knowledge, and visual understanding.

The consequence. The agent's performance ceiling is partially determined not by training methodology but by the latency-vs-capability tradeoff of the underlying hardware and model architecture. The paper demonstrates that the hierarchical approach (Gemini Pro orchestrating SIMA 2 at a slower cadence, Section 4.4) partially mitigates this by offloading complex reasoning to a slower but more capable model, but this adds architectural complexity and still imposes an upper bound on the complexity of reasoning that can influence moment-to-moment actions. The 3 Hz visual sampling rate also creates a hard ceiling on tasks requiring rapid visual feedback — the paper's own analysis notes that combat is a notable weakness (Section 4.2.1, Figure 7), attributed in part to "split-second decision making" requirements that are incompatible with sub-sampled visual input. A practitioner deploying this system in an environment requiring faster reaction times (e.g., first-person shooters, real-time strategy games, or physical robot control with dynamic obstacles) would need to either accept substantially degraded performance or redesign the sampling architecture.

What evidence exists in the paper. The baseline comparison (Section 4.3) shows that even Gemini Pro — the more capable model — achieves only 7.0% success on embodied tasks without fine-tuning, indicating that capability alone does not solve the embodiment problem. This partially mitigates the concern: the gap between Flash-Lite and Pro for embodied tasks is small in absolute terms (3.2% vs. 7.0% zero-shot), suggesting that the specialized training is far more important than the model's base capability level for embodied competence. However, the capability retention results (Table 1) and the hierarchical reasoning demonstrations (Section 4.4, Figures 14, 18, 19) both show that more capable models enable behaviors (complex diagram following, abstract reasoning, active exploration) that Flash-Lite alone cannot perform. The paper does not quantify how often the latency-vs-capability tradeoff matters — in what fraction of evaluation tasks would a faster Pro-level model have succeeded where Flash-Lite failed? — making it difficult to assess whether Flash-Lite is the right operating point or whether engineering improvements (e.g., model distillation, speculative decoding, hardware acceleration) could shift the frontier enough to change the recommended architecture.

Mitigation status. The hierarchical reasoning architecture (Section 4.4) addresses this limitation by decoupling slow, capable reasoning from fast, reactive control, but the paper presents only qualitative demonstrations of this approach with no quantitative evaluation of its success rate across a task suite. The paper's Section 5 discussion acknowledges that "executing precise, low-level actions via the keyboard-and-mouse interface and achieving robust visual understanding of complex 3D scenes remain open challenges." The specific tradeoff between model capability and action latency, and whether it can be resolved through architecture rather than through faster hardware, is not systematically explored.

No Quantitative Evaluation in Photorealistic or Non-Game Environments

The assumption or constraint. The paper makes strong claims about generalization to photorealistic environments — the abstract states SIMA 2 can "handle... photorealistic worlds generated on-the-fly by Genie 3" — and positions Genie 3 integration as evidence that "the path from virtual to physical worlds becomes more plausible" (Section 2). However, every Genie 3 result in the paper is qualitative (Figures 13, 17), and the self-improvement results in Genie 3 (Figure 17) report only delta-scores from the Gemini-based reward model rather than an independently verified success metric. The paper does not report what fraction of Genie 3 tasks SIMA 2 succeeds at, what failure modes occur, or whether performance degrades systematically under certain environmental conditions (lighting, clutter, distance to target, presence of distractors).

The consequence. A practitioner evaluating whether SIMA 2 would work in their domain — particularly if that domain involves photorealistic rendering, real-world camera feeds, or physical environments — has no quantitative basis for estimating performance. The paper's qualitative examples show the agent succeeding at navigation tasks in a variety of Genie 3 settings (underwater scenes, urban streets, indoor cafes, forest paths), which demonstrates that the agent is not incapable in these settings, but selective presentation of successful examples cannot establish how often or under what conditions failure occurs. The self-improvement delta-scores in Figure 17 show that the agent improved on "nearly all" train tasks and "the majority" of test tasks, but without absolute performance levels, a practitioner cannot know whether the initial agent was at 5% success (improving to 15%) or 60% (improving to 80%) — these represent very different deployment readiness levels. The paper's Section 5 frames Genie 3 integration as "a proof-of-concept" and "a hint of the powerful possibility," which appropriately hedges the claim, but this hedged language in the discussion does not fully align with the abstract's unqualified assertion that the agent demonstrates "robust generalization to previously unseen environments" including "photorealistic worlds."

What evidence exists in the paper. All Genie 3 results are in Figures 13 (qualitative examples of successful navigation) and 17 (delta-score bar charts with no absolute performance baselines reported). The paper does not describe the Genie 3 evaluation methodology: how many environments were tested, how many tasks per environment, whether tasks were pre-registered or selected post-hoc based on agent success, or what criteria determined task difficulty. The self-improvement experiment in Genie 3 includes a train/test split (urban/natural environments) and reports delta-scores per task+environment pair, which is more rigorous than purely qualitative demonstration, but the lack of absolute performance metrics and independent verification (beyond the reward model) prevents quantitative assessment of whether the agent's Genie 3 performance is practically useful or merely non-zero.

Mitigation status. The paper acknowledges in Section 5 that SIMA 2 represents "a significant step" and is "fundamentally a research endeavor" with limitations. The Genie 3 results are framed in Section 4.5.2 as "initial evidence" and "a first preliminary working example." These hedges are appropriate within the body of the paper, but they exist in tension with the abstract's stronger claims. A future quantitative evaluation suite for Genie 3 — with predefined tasks, environment configurations, and either programmatic evaluations or independent human judgments — would be necessary to convert the qualitative generalization evidence into a deployability assessment.

The Self-Improvement Loop's Practical Scalability Is Uncharacterized

The assumption or constraint. The self-improvement architecture (Section 4.5) requires three separate Gemini model invocations per training trajectory: the task setter proposes an instruction (requiring visual understanding of the current environment state), the agent executes it (requiring per-step inference at 3 Hz for the duration of the task), and the reward model scores the resulting video (requiring video understanding over the full trajectory). The paper demonstrates this loop over multiple iterations in ASKA (Figures 15, 16b) and on a set of train tasks in Genie 3 (Figure 17), but provides no analysis of the computational cost, wall-clock time, or data efficiency of the process. Key parameters — how many trajectories are generated per iteration, how long each iteration takes, what retraining compute is required, how the agent's performance scales with the number of iterations or total trajectories — are not reported.

The consequence. A practitioner considering deploying a self-improvement loop cannot estimate the cost. If each iteration requires generating thousands of trajectories, scoring them with Gemini, and retraining the model, the total inference and training compute may exceed what is practical for many deployment scenarios — particularly if the loop must run frequently to adapt to a changing environment. The paper's claim that this represents "open-ended self-improvement" implies indefinite operation, but without scaling curves (performance vs. compute invested), a practitioner cannot determine whether the process becomes more or less efficient over time, whether diminishing returns set in quickly, or whether the cost of continued improvement eventually exceeds alternative approaches (e.g., collecting additional human demonstrations). The Genie 3 transfer result (Figure 17) is promising — improvements on urban navigation tasks transferred to natural environments — but the paper does not report how many urban-environment trajectories were needed to achieve this transfer, making it impossible to assess whether this approach is more data-efficient than directly collecting a small number of demonstrations in the natural environments.

What evidence exists in the paper. The paper reports performance as a function of self-improvement iteration (Figure 15, progressively darker points/curves) but does not report the number of trajectories per iteration, the computational cost per trajectory, the wall-clock time for a full iteration, or any scaling analysis of performance vs. total experience collected. The ASKA game-progression experiment (Figure 16b) shows capability milestones achieved over roughly 60 minutes of game time, but this is the evaluation trajectory duration, not the training time. The paper does not report whether the self-improvement loop could continue beyond the demonstrated iterations — whether performance would plateau, degrade, or continue improving. The task setter's ability to "focus on improving weaker skills" by monitoring downstream evaluation results (Section 4.5) is described conceptually but not evaluated quantitatively: the paper does not report the task setter's accuracy in identifying weak skills, the efficiency gain from targeted vs. uniform task sampling, or whether the task setter ever proposes unachievable tasks that waste agent interaction budget.

Mitigation status. The paper does not address these scalability questions. Section 5 identifies "very long-horizon, complex tasks that require extensive, multi-step reasoning and goal verification" as a challenge, but this refers to agent capability ceilings rather than to the efficiency of the self-improvement process itself. The framing of these results as "initial steps toward this capability" (Section 4.5) and "a first preliminary working example" (Section 4.5.2) appropriately acknowledges the preliminary nature of the demonstration, but a practitioner needs more than existence proof — they need cost estimates — to make deployment decisions. This is a natural limitation for a research paper demonstrating a new capability, but it means the self-improvement results should be interpreted as a feasibility demonstration rather than a performance benchmark or cost-effectiveness analysis.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper shifts the conversation around embodied AI from a pretraining-centric framing—where the hope was that sufficiently large models would spontaneously develop the capacity to act—to an integration-centric framing, where the central research challenge is building the bridge between pretrained reasoning capabilities and the specific demands of real-time embodied control. The diagnostic finding in Section 4.3 that baseline Gemini models achieve only 3.2–7.0% success on embodied tasks, despite sophisticated reasoning abilities, establishes that embodied competence is not an emergent property of scale. This is not a minor calibration result; it is the paper's most consequential empirical claim because it redirects research investment from "train bigger models" to "build better training pipelines" as the primary lever for embodied agent progress.

The magnitude of this shift is significant but bounded. It is not a paradigm shift in the Kuhnian sense—the paper operates within the established VLA (Vision-Language-Action) paradigm and extends it with specific data mixture and self-improvement contributions. Rather, it is a reframing of priorities within an existing paradigm: it establishes that the data pipeline (mixing pretraining data with embodied data, synthetic bridge data for reasoning-action alignment, RL from verifiable rewards) is the critical pathway, not model scale alone, and it provides concrete evidence (Table 1, Figures 6–10) that this pathway yields near-human performance while preserving general reasoning. Before this work, a team building an embodied agent might reasonably have allocated resources primarily to scaling the base model, assuming that embodiment would follow. After this work, that resource allocation is harder to justify—the paper shows that a carefully trained Flash-Lite model dramatically outperforms a zero-shot Pro model (65% vs. 7%), making the training methodology the dominant factor.

The paper also reconciles a tension in the VLA literature that was previously unresolved. Prior work had documented a troubling tradeoff: training foundation models on action data often "erode[s] conversational ability entirely" (Hancock et al., 2025; Zhou et al., 2025, cited in Section 4.3). This created a pessimistic narrative that embodied competence and general reasoning were fundamentally in conflict—you had to sacrifice one for the other. SIMA 2 demonstrates that this tradeoff is navigable through mixed-data training that retains a portion of the original pretraining distribution. The resulting agent loses only 4–25% relative performance on reasoning benchmarks (Table 1) while achieving near-human embodied performance. This resolves the apparent contradiction in prior findings: catastrophic forgetting in VLA models was not inherent to the problem but was an artifact of training on embodied data exclusively, without the retention mixture that SIMA 2 employs. This finding makes VLA research substantially more attractive as a direction because it removes the fear that success at embodiment necessarily destroys the foundation model's value.

The self-improvement architecture (Section 4.5) introduces a conceptual reframing of how autonomous agent learning can be structured. Rather than treating task generation, policy execution, and reward evaluation as separate problems requiring separate solutions, the paper demonstrates that a single foundation model technology—with different prompting and model instances—can serve all three roles simultaneously. This is more than an engineering integration; it is a bootstrapping argument for autonomous skill acquisition. The agent's initial generalization capability (from its pretrained world knowledge) provides just enough competence to generate some successful trajectories in a novel environment; those trajectories become training data for improvement; the improved agent generates more successes on harder tasks; and the cycle continues. The paper's demonstration that this cycle produces genuine skill acquisition in ASKA—learning to navigate to novel objects and extinguish campfires without any human demonstrations in that environment (Figure 20)—provides existence proof for this approach.

Research directions that become more attractive after this work:

Mixed-data training as a first-class design consideration for VLA systems, with explicit capability retention benchmarks (LiveCodeBench, AIME, GPQA Diamond) as standard evaluation metrics alongside task success rates
Reward model design for open-ended embodied settings, since the self-improvement loop's viability depends critically on the reward model's reliability—a finding that redirects attention from policy optimization to reward signal quality
Hierarchical architectures for embodied agents, since the paper demonstrates that decoupling slow reasoning (Gemini Pro orchestrator) from fast execution (Flash-Lite agent) enables behaviors neither model could achieve alone
World model integration for agent training, since the Genie 3 results (Figure 17) provide initial evidence that self-improvement in procedurally generated environments transfers across visual domains

Research directions that become less attractive as a direct consequence of this paper's findings:

Hoping that scale alone solves embodiment: the 3.2–7.0% baseline results are too stark to ignore, and the evidence that specialized training is the dominant factor makes pure scaling approaches to embodied AI harder to defend
Single-modality action models that discard pretrained reasoning: the paper shows that preserving general reasoning (Table 1) and enabling dialogue/reasoning outputs (Section 4.1) adds substantial value for generalization to novel instructions, environments, and interactive scenarios; models that train exclusively on action prediction lose these capabilities without gaining proportional embodied competence

Follow-Up Research This Work Enables

1. Reward model reliability under optimization pressure in embodied settings. The self-improvement loop (Section 4.5) uses a Gemini-based reward model as both the training signal and the evaluation metric—a classic setup for reward hacking. The paper calibrates this reward model against human preferences on "a small dataset of trajectories" but never verifies, through independent human evaluation, that the observed score increases (Figure 15, from <25% to 100% task success) correspond to genuine behavioral improvements rather than reward model exploitation. A critical follow-up would collect human success judgments on the full set of self-improved agent trajectories in ASKA (the same fixed tasks used in Figure 15) and compute the correlation between reward model scores and human judgments at each iteration. If the correlation remains high—and specifically, if the rate of false positives (trajectories scored ≥50 by the reward model but judged unsuccessful by humans) does not increase over iterations—then the self-improvement architecture is validated as producing genuine skill acquisition. If false positives increase, it would indicate that the agent is learning to exploit reward model blind spots rather than improving at the underlying tasks, which would be a crucial negative result that constrains the architecture's applicability. A stronger version of this experiment would ablate the reward model by training separate self-improvement loops with different reward signals (e.g., a weaker Gemini variant, programmatic-only rewards where applicable, or a sparse human-annotated reward on a subset of tasks) and comparing both the learning curves and the human-evaluated performance of the resulting agents.

2. Scaling analysis of the self-improvement efficiency. The paper demonstrates that self-improvement works but provides no characterization of its cost, data efficiency, or scaling properties. A direct extension would measure agent performance (on a fixed evaluation set in ASKA or a similar held-out environment) as a function of total self-generated trajectories, total reward model calls, and total retraining compute, across multiple random seeds. Key questions this would answer: Does performance improve log-linearly with experience, or are there diminishing returns? How many trajectories are needed to reach the human reference score in Figure 15 (the paper shows progressively darker curves but never reports the x-axis in trajectory count)? Does the efficiency of learning depend on the task setter's curriculum—would random task sampling achieve the same improvement with enough data, or does the targeted "focus on weaker skills" mechanism provide a genuine efficiency gain? A comparison against a baseline that collects the same number of human demonstrations in ASKA (rather than self-generated experience) would characterize the efficiency tradeoff: if 100 human demonstrations produce the same improvement as 10,000 self-generated trajectories, the autonomous approach may not be cost-effective for deployment, even if it is scientifically interesting. This analysis is tractable because the paper's ASKA setup is already defined—it requires only running the loop for more iterations and benchmarking at regular intervals.

3. Combining PRM-guided search with the revision-like properties of SIMA 2's reasoning traces. Although this paper operates in embodied environments rather than math reasoning, the self-improvement architecture raises a question that parallels the test-time compute literature: can the agent's own reasoning traces be used to guide online search or self-correction without full retraining? SIMA 2 generates internal reasoning at each step (e.g., "The user wants me to go to the 'tomato house.' Based on the description 'ripe tomato', I identify the red house down the street on the right as the target," Figure 4). These reasoning traces function as a form of chain-of-thought for embodied action, but the paper never explores whether the agent can use them to detect and correct its own errors at inference time. A concrete experiment: when the agent fails a task (as determined by a post-hoc programmatic evaluation), present the trajectory—including the reasoning trace—to the same SIMA 2 model and ask it to identify where its reasoning diverged from correct behavior and produce a revised action sequence. If the agent can self-correct at rates above chance, this would demonstrate that the reasoning traces contain actionable self-evaluation signal, analogous to how process reward models enable search in math reasoning. A failure to self-correct would be equally informative: it would suggest that the reasoning traces are descriptive (explaining what the agent is doing) rather than normative (evaluating whether the actions are correct), which would constrain their role in future architectures.

4. Generalization to non-game embodied domains with different action spaces. All SIMA 2 results are in environments with keyboard-and-mouse interfaces and 2D visual observations. The paper's Section 5 discussion explicitly identifies physical-world robotics as a future direction. A strong follow-up would test the same training pipeline (mixed pretraining + embodied data, bridge data, RL from verifiable rewards) on a robotics manipulation benchmark with a different action space—for example, a set of tasks in a simulation environment like ManiSkill or RLBench, where the action space involves continuous joint control rather than discrete key presses. The critical question is whether the mixed-data training approach (which preserved general reasoning in the keyboard-and-mouse setting) transfers to continuous control, or whether the larger domain gap between internet pretraining data and continuous robot actions causes more severe catastrophic forgetting. The experiment would maintain the same Gemini Flash-Lite base model and evaluate both task success rates and capability retention (on LiveCodeBench, AIME, GPQA Diamond) after fine-tuning. If capability retention degrades significantly more in the continuous-control setting, it would suggest that the Pareto frontier between embodiment and reasoning is action-space-dependent, which would be an important constraint on the generality of the paper's findings.

5. Open-ended self-improvement across a sequence of novel environments. The paper demonstrates self-improvement within single environments (ASKA, Genie 3 train split) but does not test whether the process can continue across an expanding frontier of environments—the core requirement for open-endedness. A direct extension would deploy the self-improvement loop sequentially across multiple held-out environments (e.g., ASKA → The Gunk → a third held-out game not disclosed in the paper), measuring whether performance in each new environment benefits from self-improvement experience accumulated in prior environments. The hypothesis (motivated by the Genie 3 transfer result in Figure 17) is that skills acquired through self-improvement transfer across environments, creating a compounding effect where each new environment is easier to master than the last. The null result—no transfer, or negative transfer—would be equally informative: it would suggest that self-improvement produces environment-specific optimization rather than general skill acquisition, which would fundamentally constrain the "open-ended" interpretation. This experiment requires only extending the existing self-improvement infrastructure to additional environments, with careful tracking of per-environment performance before and after each iteration of the loop.

6. The role of environment diversity in the base agent's generalization capability. SIMA 2's held-out environment performance (15–17% on ASKA, 12–14% on MineDojo, Figure 10) is enabled by its pretrained world knowledge, but the paper does not characterize how the diversity of training environments contributes to this generalization. A training-data ablation would systematically vary the set of training environments—training separate agents on subsets of the 10 training environments (e.g., only research environments, only commercial games, only games with crafting mechanics, only games with combat) and measuring held-out performance on ASKA and MineDojo. This would answer a critical deployment question: does a practitioner need to license and collect data from a broad portfolio of diverse games to achieve generalization, or would a smaller set of carefully chosen environments suffice? If an agent trained only on research environments generalizes as well to ASKA as one trained on all 10 environments, the value of diverse commercial game data is diminished, which would substantially lower the barrier to entry for building similar agents. If generalization degrades sharply with reduced environment diversity, it establishes that the portfolio approach is a necessary ingredient, which has significant implications for the cost and complexity of building generalist embodied agents.

Practical Applications and Downstream Use Cases

1. Autonomous data generation for embodied training in novel environments. The self-improvement architecture (Section 4.5) provides a template for bootstrapping agent capabilities in a new environment without collecting human demonstrations. Consider a game development studio that wants to deploy an AI playtester in a new game title. Currently, they would need to hire human testers to play the game and record demonstrations, or build environment-specific programmatic evaluation functions. With the SIMA 2 pipeline, they could: (1) deploy the base SIMA 2 agent (which already generalizes somewhat to held-out games, as shown by the ASKA and MineDojo results), (2) use a Gemini-based task setter to generate playtesting instructions based on the agent's current location and the game's mechanics, (3) use a reward model to automatically score the agent's attempts, identifying successful playthroughs and common failure modes, and (4) iterate to improve the agent's coverage of the game's content. The paper's ASKA results demonstrate the feasibility: the self-improved agent progressed from near-zero competence to building a shelter within one hour of game time, purely from self-generated experience (Figure 16b). The practical benefit is reducing or eliminating the human demonstration bottleneck for each new environment—a cost that scales with the number of environments and task types in a deployment portfolio. The caveat is that the reward model's reliability must be validated per-environment (see Follow-Up Research #1 above).

2. Interactive AI companions in virtual worlds with reasoning and dialogue. SIMA 2's embodied dialogue and reasoning capabilities (Section 4.1, Figures 4–5) enable a qualitatively different type of AI companion than the instruction-following agents that preceded it. In a game like No Man's Sky, a user can ask SIMA 2 "Can you go check out those egg-shaped objects and tell me what material they are made of?"—the agent navigates to the objects, reads on-screen text to determine the material, and responds "I found the objects. They appear to be plants containing Carbon." This is embodied information-seeking: the agent doesn't just know the answer from pretraining, it actively explores the environment to acquire it. For game developers or virtual world platforms, this enables AI companions that can serve as guides ("What resources are available in this area?"), collaborators ("Help me build a base here—what materials do we need and where can we find them?"), or narrators that respond to the player's actions with contextually grounded dialogue. The paper's demonstration that SIMA 2 can interpret complex instructions (multi-step navigation in Figure 5), handle multi-modal prompts (sketches), and engage in multi-turn dialogue while acting makes this scenario technically feasible. The key metric for a deployment team would be the reliability of the embodied information-seeking behavior—in what fraction of attempts does the agent successfully locate the target and report accurate information?—which the paper's current evaluation suite does not directly measure but which could be constructed from the dialogue-task framework described in Section 3.3.3.

3. Hierarchical agent deployment for latency-sensitive applications. The hierarchical architecture in Section 4.4—where a slower Gemini Pro model orchestrates a faster SIMA 2 agent—has immediate practical implications for any embodied deployment where latency constraints prevent using the most capable model directly. A robotics startup building a household assistant robot faces exactly the tradeoff the paper identifies: the most capable models are too slow for real-time motor control, but the fastest models lack the reasoning capabilities for complex task planning. The paper's solution—run a capable model at a slower cadence (every $k$ steps) to issue sub-instructions and maintain persistent memory, with a lightweight model handling real-time execution—is architecture-agnostic and could be applied to any VLA system. The campfire-building demonstration (Figure 14), where Gemini Pro parses a complex visual diagram and SIMA 2 executes the steps, shows this working for a multi-step construction task. The practical benefit is that improvements to the orchestrator model (e.g., newer Gemini versions with better reasoning) can be deployed immediately without retraining the execution agent, creating a separation of concerns that reduces the cost of upgrading either component. The limitation is that the paper provides only qualitative demonstrations of this architecture, not quantitative success rates, so a deployment team would need to benchmark the hierarchical setup on their specific task distribution to estimate reliability.

4. Continuous adaptation of deployed agents to environment changes. The self-improvement loop (Section 4.5) can be run continuously on a deployed agent, allowing it to adapt to environment changes without manual intervention. In a live-service game that receives regular content updates (new areas, new items, new mechanics), a statically trained agent would become progressively less competent as the environment diverges from its training distribution. The SIMA 2 self-improvement architecture provides a mechanism for the agent to catch up: the task setter generates instructions that exercise the new content, the agent attempts them, the reward model scores the results, and retraining incorporates the new experience. The paper's Genie 3 transfer result (Figure 17)—where self-improvement on urban navigation tasks improved performance on held-out natural environment tasks—suggests that adaptation to one set of changes may generalize to others, reducing the total retraining burden. The practical deployment scenario would involve running the self-improvement loop as a background process, generating and learning from experience in the updated environment, with the agent's performance on a held-out evaluation set monitored to detect when it has adapted sufficiently. The caveats from the Limitations section apply: the reward model must be reliable for the new content types, and the computational cost of continuous self-improvement (which the paper does not characterize) must be weighed against the cost of periodically collecting new human demonstrations.

When to Prefer This Method

The paper does not articulate a clear decision rule positioning SIMA 2 against named alternative embodied agent architectures. It compares against SIMA 1 (its direct predecessor) and against baseline zero-shot Gemini models, but does not provide the kind of systematic tradeoff analysis—"use our mixed-data training pipeline when X, use pure behavioral cloning when Y, use a different VLA architecture when Z"—that would justify a conditional preferences matrix. The paper's contribution is primarily demonstrating that the SIMA 2 approach works (and works substantially better than SIMA 1 and zero-shot baselines), not characterizing when it works compared to alternative training paradigms for embodied agents. Introducing a decision matrix here would therefore be speculative rather than grounded in the paper's explicit analysis.

Dependency tree

Papers this one builds on, walking backwards through the same domain and shared topics.

MolmoAct: Action Reasoning Models that can Reason in Space2025· uncategorized← LLM-judged similar
- ThinkAct: Vision-Language-Action Reasoning via Reinforced Visual Latent Planning2025· agents← LLM-judged similar
- V2V-LLM: Vehicle-to-Vehicle Cooperative Autonomous Driving with Multimodal Large Language Models2025· llm-systems← LLM-judged similar
- GR-3 Technical Report2025· uncategorized← LLM-judged similar
- GUI-Actor: Coordinate-Free Visual Grounding for GUI Agents2025· vision← LLM-judged similar
- PIVOT: Iterative Visual Prompting Elicits Actionable Knowledge for VLMs2024· agents← LLM-judged similar
- RVT-2: Learning Precise Manipulation from Few Demonstrations2024· agents← LLM-judged similar
- RoboVQA: Multimodal Long-Horizon Reasoning for Robotics2023· uncategorized← LLM-judged similar
- REINA: Regularized Entropy Information-Based Loss for Efficient Simultaneous Speech Translation2025· uncategorized← in-domain predecessor
- Qwen-Image Technical Report2025· multimodal← topic thread
- NVIDIA Nemotron Nano 2: An Accurate and Efficient Hybrid Mamba-Transformer Reasoning Model2025· reasoning← topic thread
Fara-7B: An Efficient Agentic Model for Computer Use2025· agents← in-domain predecessor
ScaleEnv: Scaling Environment Synthesis from Scratch for Generalist Interactive Tool-Use Agent Training2026· agents← similar topic
- Towards General Agentic Intelligence via Environment Scaling2025· agents← LLM-judged similar
- AgentCPM-Report: Interleaving Drafting and Deepening for Open-Ended Deep Research2026· agents← in-domain predecessor
- WebWorld: A Large-Scale World Model for Web Agent Training2026· agents← similar topic
- Unify-Agent: A Unified Multimodal Agent for World-Grounded Image Synthesis2026· agents← similar topic

What it influenced

Later papers in the same chain. Direction reversed.

Towards a Science of Scaling Agent Systems2025· agents→ in-domain predecessor
- Long-horizon Reasoning Agent for Olympiad-Level Mathematical Problem Solving2025· agents→ in-domain predecessor
Lumine: An Open Recipe for Building Generalist Agents in 3D Open Worlds2025· agents→ similar topic
- Part-X-MLLM: Part-aware 3D Multimodal Large Language Model2025· agents→ in-domain predecessor
- Scaling Generalist Data-Analytic Agents2025· agents→ similar topic
- Game-TARS: Pretrained Foundation Models for Scalable Generalist Multimodal Game Agents2025· agents→ similar topic
- NitroGen: An Open Foundation Model for Generalist Gaming Agents2026· agents→ similar topic
ScaleEnv: Scaling Environment Synthesis from Scratch for Generalist Interactive Tool-Use Agent Training2026· agents→ similar topic
- Agent World Model: Infinity Synthetic Environments for Agentic Reinforcement Learning2026· agents→ in-domain predecessor
- D-CORE: Incentivizing Task Decomposition in Large Reasoning Models for Complex Tool Use2026· training-methods→ topic thread
- Scaling Agent Learning via Experience Synthesis2025· agents→ similar topic
- Agent-World: Scaling Real-World Environment Synthesis for Evolving General Agent Intelligence2026· agents→ similar topic