Qwen's AgentWorld Beats GPT-5 by Teaching AI to Simulate Environments

Every major AI lab has been racing to build better agents. Qwen is asking a different question: what if the model learned to simulate the environment the agent lives in? That's the premise behind Qwen-AgentWorld, a new open-source language world model (LWM) that can faithfully predict what happens next in seven different agentic environments , from terminal sessions to Android UIs , within a single model.

The release includes two model variants (35B and 397B), a new evaluation benchmark called AgentWorldBench, and a technical paper laying out two distinct ways world modeling can make agents better. The 35B model is fully open-sourced under Apache 2.0.

The gap nobody was filling

The standard recipe for building agents is: take a capable LLM, give it tools, and train it to act better in real environments. The problem is that real environments are slow, expensive, and hard to control. You can't easily inject edge cases, scale to thousands of parallel rollouts, or construct fictional-but-consistent worlds for stress-testing.

A world model predicts environment dynamics based on current observations and actions, serving as a core cognitive mechanism for reasoning and planning. Frontier LLMs have picked up some of this ability incidentally from pretraining, but unlike prior approaches that treat world modeling as a post-hoc add-on, Qwen-AgentWorld is a native world model: environment modeling is the training objective from the CPT stage onward.

How it was built

Leveraging more than 10M environment interaction trajectories across 7 domains in real-world environments, Qwen-AgentWorld is developed through a three-stage training pipeline: CPT injects general-purpose world modeling capabilities from state transition dynamics and augmented professional corpora, SFT activates next-state-prediction reasoning, and RL sharpens simulation fidelity through a tailored framework with hybrid rubric-and-rule rewards.

Think of it as three layers of specialization stacked on top of the base Qwen3.5 architecture. The CPT stage (Continual Pre-Training) loads the model with raw knowledge of how environments behave. SFT then teaches it to express that knowledge as a reasoning chain , essentially, to think through what the next state should be before committing to an answer. Finally, RL tightens the output against ground-truth environment observations.

The seven domains covered are:

• MCP , tool-calling via the Model Context Protocol
• Search , web search interactions
• Terminal , Linux shell execution
• SWE , software engineering tasks (code editing, patching)
• Web , browser navigation
• OS , desktop operating system control
• Android , mobile UI interaction

Beating frontier models on the new benchmark

To measure world modeling quality, Qwen introduces AgentWorldBench. AgentWorldBench is a comprehensive benchmark constructed from real-world interactions of 5 frontier models on 9 established benchmarks , including Tool Decathlon, Terminal-Bench 1.0 and 2.0, and OSWorld-Verified , evaluating world modeling quality through ground-truth grounded rubric judging across 5 dimensions. Those five dimensions are Format, Factuality, Consistency, Realism, and Quality.

The results are striking. Qwen-AgentWorld-397B-A17B achieves the highest overall score (58.71), outperforming all frontier proprietary models including GPT-5.4 (58.25). Qwen-AgentWorld-35B-A3B shows a +8.66 improvement over Qwen3.5-35B-A3B without LWM training. That last number matters: it shows that world modeling training is doing real work, not just riding the base model's capabilities.

Two ways world modeling helps agents

The paper investigates two distinct paradigms for using a world model to improve agents. These aren't just theoretical , both show concrete benchmark gains.

Paradigm I: Decoupled Simulation (Sim RL)

Here, the world model acts as a stand-in for real environments during agent RL training. The key insight is controllability , you can inject targeted perturbations, construct fictional-but-self-consistent worlds, and scale to environments that don't exist yet. As a decoupled environment simulator, Qwen-AgentWorld supports scalable and controllable simulation of thousands of real-world environments for agentic RL, yielding gains that surpass real-environment training alone.

Concretely:

• Controlled Sim RL on MCP: +12.3 MCPMark vs. only +3.1 for uncontrolled simulation
• Sim RL on Search beats training against a live search engine: 50.3% vs. 45.6% F1
• Zero-shot generalization to 4,000 out-of-distribution OpenClaw environments: +4.3 Claw-Eval, +7.1 QwenClawBench

Paradigm II: Agent Foundation Model (LWM Warm-up)

This is the more surprising result. As a unified agent foundation model, world-model training acts as a highly effective warm-up that improves downstream performance across 7 agentic benchmarks. The model is trained only on single-turn, non-agentic environment prediction , no tool-calling, no multi-turn trajectories , and then tested directly on full agentic tasks. No task-specific fine-tuning.

Gains across in-domain and out-of-domain benchmarks:

• Terminal-Bench 2.0: +6.3
• SWE-Bench Verified: +3.4
• WideSearch: +12.8
• Claw-Eval (out-of-domain): +11.3
• BFCL v4 (out-of-domain): +9.0

The interpretation: learning to predict environment states internalizes a "predict before you act" reasoning pattern that transfers to acting tasks, even without ever training on them.

What's open-sourced and how to use it

The repository contains the model weights and configuration files for Qwen-AgentWorld-35B-A3B, a native language world model trained for agentic environment simulation. The 397B variant is available via API but not open-weighted. Both the 35B model and AgentWorldBench are released under Apache 2.0.

The model is a MoE (Mixture of Experts) architecture: 35B total parameters but only 3B active per forward pass, with a 256K context window. It runs on SGLang or vLLM with standard tensor parallelism. Here's the minimal inference setup:

from transformers import AutoModelForCausalLM, AutoTokenizer
model_name = "Qwen/Qwen-AgentWorld-35B-A3B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name, torch_dtype="auto", device_map="auto"
)
messages = [
    {"role": "system",
     "content": "You are a language world model simulating a Linux terminal. "
                "Given the user's command, predict the terminal output."},
    {"role": "user",
     "content": "Action: execute_bash\nCommand: ls -la /home/user/project/"}
]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer([text], return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=2048, temperature=0.6)
print(tokenizer.decode(outputs[0][inputs.input_ids.shape[-1]:], skip_special_tokens=True))

Domain-specific system prompt templates for all seven environments are included in the prompts/ directory of the GitHub repo. The HuggingFace collection also includes AgentWorldBench as a standalone dataset for evaluating your own world models.

What this changes about how we think about agents

The dominant assumption in agent research has been that the path to better agents runs through better acting: more RL, better reward signals, smarter tool use. Qwen-AgentWorld challenges that framing. If a model deeply understands what environments do in response to actions, it becomes a better actor , even without any actor-specific training.

The Sim RL results also reframe the "real vs. synthetic" debate. Controllable synthetic environments don't just substitute for real ones , they can outperform them, because you can engineer training distributions that real environments structurally cannot provide. That's a meaningful unlock for anyone building agentic systems where real-environment rollouts are expensive, slow, or unsafe.

The open-source 35B model is immediately useful for anyone building agent training pipelines who wants a fast, controllable environment simulator that doesn't require spinning up live infrastructure for every RL step.