Qwen-AgentWorld: Language World Models for General Agents
or, A Mirror for Agents
Originally presented as a live talk on July 1, 2026
Paper · Blog · Repo · Benchmark · Model
Background
So, what are world models?
We’ve actually answered this question once before, back in November 2025, when I covered a paper called Benchmarking World-Model Learning. In it, we talked about how there are two ways to predict the future: statistical inference, and world modeling.
Let’s say you have a fair coin, and you want to predict whether it will land heads or tails. The statistical way to understand the odds is to gather a bunch of data on past coin flips, then calculate the odds as 50-50. From that finding, you infer the odds of the upcoming coin flip are also 50-50.
This is what language models generally do today. They have a ton of data about which token comes next given a series of previous tokens, and when you use them - when you run inference - you are asking for a statistical prediction, a distribution across all possible next tokens.
Now the world modeling way to predict the coin flip is actually much more familiar and intuitive to humans: look at the coin, feel it, see that it’s symmetrical on both sides, and think through how a coin flip actually works. It’s a rule-based approach, or maybe a heuristics-based approach given we’re not actually calculating any physics in our heads when we imagine a coin flipping. But ultimately it’s about how the world reacts to the action of the flipping.
This is not how language models work, at least not directly. Like the mechanics of LLMs is statistics and correlations and so on, but one level of abstraction higher they arguably are thinking, and it seems any thinking entity can think through the impact of actions on the world as we discussed with our coin flip. Like if you asked Claude right now to think through why a coin flip is 50-50, you’d get something pretty familiar back.
So the potential is there. The question the other paper asked is, can we activate it? If we subject the agent to a series of tests where world modeling beats statistical inference, will the agent make the leap?
The answer in that paper was: no, not really. At the time at least, agents were not adept at mentally simulating worlds like the one pictured above, which is from another benchmark called ARC-AGI-2 but is similar in spirit.
Another paper from around that time, Code World Model, gives us a look at explicit world modeling, where the agent actually writes out what each intermediate step looks like.
In the image here, you see a simple program for counting the number of letters in a word. Once they define the function, they call it to count the number of r’s in the word “strawberry”.
What Code World Model then does is to take the inputs and walk through each step of the code with them, tracking the values of each variable. So like in the first frame, the variable “s” holds “strawberry” and the variable “t” holds the letter “r”. Then in the second frame, the program defines a new variable “n” with value zero, which Code World Model then tracks in the third frame, etc. At the end of the program, where it returns a value, Code World Model has thought everything through and knows the returned value is three.
The goal of all this is not to substitute for running programs, but to engender greater understanding of code in order to improve coding performance. Like imagine if you were trying to write code by just copy-pasting stuff you didn’t understand and trying to run it. Obviously you could get somewhere - I’ve just described vibe coding after all - but you would hit a ceiling pretty quickly. You have to understand the rules and the “world” of code to work well within it.
Now one area of modern AI that is moving to world models already is robotics, now known as “physical AI”. Again, we covered a relevant paper called DreamZero, back in February 2026.
The dominant paradigm of physical AI in the gen AI era has been vision-language-action models, or VLAs. A VLA is basically an LLM with vision input added at the start and action output added at the end. So the core intelligence is an LLM, and it gets extra parts and extra training to be able to control a robot.
I always found that kind of odd. Like why would an expert in language, which is an abstraction of the world, be best suited for understanding the most concrete aspects of the world? Wouldn’t it be better if the native medium of the intelligence matched the world it was working in?
Well apparently some researchers found that odd too, so they switched the core of the model from language generation to video generation. After all, if your model can generate accurate videos of the world, doesn’t that mean it can model the world quite well? And then all you have to do is translate the predicted video into the actions for making that future come true, like having the robot use its gripper and move its arm to hit a cymbal with a drumstick.
These world-action models (WAMs) are starting to take off. I expect to see more of them.
World modeling in physical AI is making another impact too: it’s allowing researchers to synthetically create videos of rare events for training data.
Also in February 2026, Waymo announced their own world model, built on the Genie 3 world model from Google DeepMind. Waymo’s world model generates video and other sensor outputs for events that are too rare to appear in their real training corpus, but are still likely enough to need training on. For example, they have no real training data of snow on the Golden Gate Bridge, but it plausibly could happen, so they should train on it.
They give other examples too, like a reckless driver veering off the road in a certain way, or an elephant crossing the street.
So a world model can be a helpful counterpart for an agent in the same domain, simulating new experiences and providing coverage that the environment so far has not produced.
One other concept I’d like to bring in that isn’t in the paper but kind of lurks in the background is reward models.
A reward model is a model that numerically scores whatever you show it. So for example, you might train a reward model on safe vs unsafe prompts, with one for “safe” and zero for “unsafe”. Or you could feed it a partially complete math problem and score potential next steps, with one for “likely correct” and negative one for “likely incorrect” and zero for “no impact”.
Reinforcement learning with human feedback (RLHF) is probably the most prominent use for reward models. In RLHF, you start with a prompt and feed it to the model you want to train, which we’ll call the “generator”. You have it produce two responses, typically at two different temperatures, and then show the pair of responses to a human. The human then ranks the two responses, usually on a 1-7 scale, with 1 meaning “response A is much better” and 7 meaning “response B is much better”. You then train a reward model on these preference ranks to learn human preferences.
With your well trained reward model, you score responses from the generator on a bunch of new prompts. If the reward model is any good, then it can basically interpolate or simulate human preferences and thus train your generator way more scalably and granularly than a reasonable amount of human effort could.
So there’s a clear parallel: generators are to reward models what agents are to world models - at least when you use the world model to simulate an environment, rather than when you use the world model directly as the generator or agent etc.
Keep this parallel in mind for the takeaways at the end of the talk.
The Paper
So high-level, Qwen-AgentWorld is a language world model (LWM): working only in the medium of language, it models various worlds - search engine, mobile phone OS, terminal, and so on.
I think of it as the converse of an agent. So like an agent observes the environment and acts on the environment. The converse of that would observe the agent and produce the actions - or maybe the reactions - from the environment.
Sometimes I picture the LWM as a dungeon master from Dungeons & Dragons. Like in D&D, the player takes actions, and then the DM decides what the in-game consequences are. Except in this case the “game” is, like, surfing the web or using the command line.
The LWM itself might even use tools, like how a DM uses dice, but mostly it’s about following the logic of a system mentally and inventing aspects as needed.
Here is what that looks like in practice.
The first example is for software engineering, where the input is a tool call for running a terminal command and a description of what the command is trying to accomplish. Now it’s the model’s job to output the results of that command, just by thinking about it - no tool calling allowed. The result is an error and a full stack trace, just like you would get if you ran this command in the given context.
The second example is for Android, just tapping on the “Buy Now” button in this fake app. Now since Qwen-AgentWorld is a language world model, it can’t directly produce the pixels for the resulting screen; instead, it writes the HTML that then renders into the resulting screen.
I dwell on this now because it takes a change in mindset to reverse the inputs and outputs like this. We’re so used to agents acting in the world, it’s weird to see the model receiving those commands instead of giving them.
Now as you may have noticed, a lot of context was missing from the examples on the last slide. Like, how would a model know whether some script will crash or not?
Well that context is available to the LWM, but it’s in the system prompt, not in some outside tools it can call. Here’s an example for the command line, aka the terminal, which says not only what the model is for but also where it’s supposed to be, what its environment is like. Calling back to our D&D analogy, the system prompt is like the dungeon master’s guide for the campaign.
Note the text on the right side in italics: some sections are static, others are dynamic, meaning they change depending on the task. I think the division is pretty intuitive though, like the rules of the terminal “world” are always the same, but the conditions vary. One wrinkle however is that for the MCP and SWE domains, the action space actually does change per trajectory, because different MCPs and different software repos will have different tools available. Like obviously the MCPs for Notion and Salesforce will be different, and for software repos you at least have to deal with different programming languages and packages.
Now in terms of the data, they have three distinct phases: continual pretraining (CPT), supervised fine-tuning (SFT), and reinforcement learning (RL).
Continual pretraining is basically what it says: it’s pretraining, so basically reading a bunch of text and trying to predict the next token every time, and it continues the existing pretraining. CPT happens on top of a base model, before post-training. The data in this case comes in two flavors:
World knowledge, which will give the world model more detailed information about relevant domains than what was in the original pretraining
Trajectories, which show how environments from the relevant domains respond to agents
The trajectories are the novel part here. They spin up a bunch on their own of course, synthesizing tasks for the relevant domains and letting agents run wild on them in various sandboxes. Totally normal for pretraining data, which is more about quantity than quality. But they do also harvest naturally occurring trajectories from public sources like execution traces in code repos, as well as from their own past model development.
There’s a lot of cleanup and wrangling to get it all into the same format, which is important and underappreciated for quality but isn’t that interesting frankly. The do mention having over 10M trajectories to use in CPT, but otherwise no info about their data.
For SFT and RL, they do give numbers, which we’ll see on the next slide. But I did want to pull out a couple fun details first.
For SFT, they add in reasoning, to teach the world model to work through the logic of the given world. They also vary the system prompt to improve generalization.
For RL, they use rubrics, which we’ll discuss later when we talk about the benchmark they made for this paper, and they actually cited a Scale paper on rubrics best practices. They do have rule-based verifiers in some cases too, checking for objective correctness. They mix the rubric and rule scores at a 9:1 ratio, which is an approach I’ve never seen before and doesn’t get any further explanation sadly.
Also, during RL itself, they observe one fun bit of reward hacking that I have seen reported elsewhere. Basically, when you use an LLM judge, the model you’re training can trick the judge into awarding higher scores by peppering its responses with self-affirmations. One example they give is “operation completed successfully with all fields correctly populated” - the LLM judge is just too credulous and goes off that statement. Personally, I’ve seen Claude do a lot of this faulty self-affirmation, so I’m sure it’s not just a Qwen problem.
For the SFT and RL phases, here’s the amount of data for each of the seven domains.
I’ll note two things. One is the substantial difference in SFT numbers between MCP and SWE vs all the other domains. I initially thought maybe it was because they were already good at those domains, but Terminal has one of the highest counts, so that can’t be it. MCP and SWE are the only two domains where the action space is different for every task though, so perhaps it was just harder to generate data that cleared their automated quality checks. They do note later that MCP and SWE have far more turns per trajectory than the other domains, which again hints that they were harder to produce.
The other thing is the ratio of RL to SFT data. I expected these ratios to be roughly similar, and I guess they kinda are, but it’s still more varied than I thought it would be. The only pattern I see is lower ratios for the GUI domains, which again I can’t definitely explain. Could also be a quality issue. Keep in mind that the SFT data comes from a different model than the RL data, and they say later on that their model generally underperforms on GUI tasks because it’s relatively weak on vision, so my assumption is quality limited them.
Still, at least they disclosed the numbers. That’s become increasingly rare for the model builders to do.
Now in addition to training data, they also produce eval data - their new benchmark, AgentWorldBench. This is the ruler they will judge their models by, and we’ll see the results on the next slide.
It’s somewhat misleading to say they produced the data though, because as you can see below the pie chart, the prompts are all from existing benchmarks. And since this is a test of the world model’s ability to respond to agent actions, the examples also need trajectories showing an agent interacting with an environment. So concretely, this benchmark comprises prompts from other benchmarks, plus one complete and successful trajectory per prompt, containing agent turns from one of five possible models and environment turns from the benchmark’s environment.
The job of the world model, then, is to produce the correct environment response given the prompt plus the agent and environment turns so far. They pick several different spots on each trajectory to test the world model on, ensuring some minimum difficulty and some positional variety. So for example, on text domains they always pick the first and last turns at least.
They then rate on five dimensions, using an LLM judge to compare the LWM’s response against the ground truth response from the actual environment.
I have some quibbles about how they define and weight their criteria, but ultimately I think it’s reasonable enough. You just have to keep in mind that the scores all have error bars around them.
Here are the results on that benchmark.
Before we look at any particular result, let me contextualize the models on this list. Of course at the top we have the big three: Claude, GPT, and Gemini. It’s a little odd to list both Opus 4.8 and Opus 4.6, but otherwise these are fine. Nice that they included a smaller model in the form of Sonnet.
The next group down is the top of the open-weights pile, minus Qwen of course. These guys are roughly the same size, except for MiniMax-M2.7, which is significantly smaller.
After that we have Qwen, from what was the latest version at the time, namely Qwen3.6. We don’t know how big Plus and Max are, but my guess is Max is around the same size as the bigger Qwen3.5.
Finally, at the bottom we have the baseline and LWM versions of Qwen3.5 in two different sizes. These are mixture-of-experts models, so the first number is the total size and the second number is the count of active parameters.
Now looking at the results, I think you have to start by looking at the relative difference of the baseline vs the LWM version for both sizes, rather than the absolute performance of the LWM. If you compare the baselines to the other models above, you’ll see that the baselines are weirdly strong. Like for the smaller model, 3.5 is significantly better than 3.6, and is slightly better than MiniMax-M2.7, which is roughly ten times the size. And the bigger baseline model is apparently on par with Gemini, which is undoubtedly an order of magnitude bigger.
So yes, it’s nice they got their bigger LWM to beat all the closed models at simulating these domains, but some of that seems like variance and the right choice of baseline. And as I mentioned on the previous slide, reasonable people can disagree about the rubrics, so I think providing two decimals of precision is misleading and that any scores within a few points of each other are basically equivalent.
Finally, given the existing interest in world modeling and the high scores, it’s possible the closed models already get this type of training. Hard to know if we’re comparing apples to apples here.
Of course this benchmark is brand new for this paper, and also the training data domains matched the benchmark domains. What about some independent confirmation that Qwen-AgentWorld is a good all-around simulator?
One quick check you can run is to train for new benchmarks. So they take two generalist agent benchmarks, which are not directly in the target domains, and train the same model on them with two different simulators: Qwen3.6-Plus, and Qwen-AgentWorld.
As the table shows, Qwen3.6-Plus right off the shelf is a poor simulator of at least a generalist agent environment, with virtually no change on either benchmark. Qwen-AgentWorld, on the other hand, shows real improvement on both.
Thinking back to the AgentWorldBench scores, I do think it’s unfair to use Qwen3.6-Plus as a point of comparison here, since it scores worse than the stock Qwen3.5-397B. It’s unclear why they introduced another variable here by changing the baseline model.
Now this part still uses Qwen-AgentWorld as a simulator, but it focuses on how controllable the simulator is. Thinking back to our Waymo example from the background slides, one of the key advantages of simulation is you can produce conditions that are rare or not present in your corpus of natural training data. But just because a simulator can produce rare data doesn’t mean it’s easy to get the simulator to do it. So you need to test control empirically. Concretely, “control” means putting instructions in the system prompt about how to respond or what is in the hidden state, not just letting the simulator pick what seems most probable.
And when you do give those specific instructions, you get a more effective simulator as the table shows, at least some of the time anyway. It’s at least never worse.
Beyond just giving more specific directions, the authors design two sorts of control designed to improve robustness:
Environment Adaptation, where the simulator makes select changes in an otherwise standard environment. For example, one of the APIs in the system prompt might come back with a transient error instead of the expected response.
Fictional-World Construction, where a structurally realistic environment gets completely fictional facts. The example they give is a Search environment where a small colony exists on Mars, and there are news articles across the whole arc of colonization.
There’s some good detail about the fictional-world one in the paper if synthetic data is your jam.
Another view on the impact of controllable simulation is at the behavior level, like one level below the top-line results.
So on this web search benchmark for example, using real data sometimes teaches the model to be lazy, because in real search results you often don’t need to look at any of the resulting web pages - the search preview is enough. If that’s true too often, your model may learn to rely only on the search results, or maybe to click into just one link, before returning an answer.
However, if you control the simulation so that the known final answer is rarely in the search previews, then you can get the model to try harder and look at more pages. That’s what the graph on the right shows; for the same number of searches, the model learning from the controlled simulation hits more web pages because of the simulator, which is going to generalize better.
It’s instructive to see how the simulations got more realistic too. So for search, over the course of RL a couple telling details really improved.
For one, the url slugs got more realistic. After 100 RL steps, the ID for the Big Eyes movie page on IMDB was something pretty unlikely, this number composed of repeated and increasing digits. But after 200 RL steps, you get a more plausible ID.
Or take the list of simulated search hits. After 100 steps, you get a plausible but simplistic list, like a hit from NYT but with a generic title. After 200 steps, you get a title with some flair and also a top hit for Wikipedia, which in retrospect seems like an obvious omission from the earlier list but maybe wasn’t obvious at the time. And as the ground truth search results show, Wikipedia really is the top hit.
So the benchmark and the other results we just covered are for LWM as simulator. Now we can talk about LWM as agent, like Code World Model and DreamZero from the background slides.
They’re going to measure across several agentic benchmarks - some coding, a little searching, a couple generalist agent, and several variants of tool use. However, the training data is not agentic; it is single-turn, with no tool use or interaction at all!
So taking this regular old Qwen model, which has not received any world model training in pretraining or in supervised fine-tuning, and then doing LWM RL on it can improve agent performance across the board.
To me that really shows the power of instilling a mental model into a language model, and how walking through steps makes problems more clear. It also reminds me of rubber duck debugging, where just explaining your code out loud to nobody in particular or to an inanimate object clarifies your thinking on it.
Here’s a look at some more explicit world modeling. There’s a tricky task in this email tool called Mailman where the baseline model fails. It’s a bit jargon-heavy, but the baseline model does the equivalent of reading the docs and trying stuff, all very first-order thinking.
By contrast, after some RL, the LWM is able to think through the “world” or logic of Mailman, with second-order effects. It’s not totally explicit, like it’s not simulating exactly what Mailman would do, but it walks through a summary of it in natural language. That’s just what a human would do, except perhaps in the most challenging circumstances when the abstraction and imprecision of natural language are liabilities.
My Takeaways
World modeling should be part of LLM training
Maybe it already is at the closed labs?
There is some theoretical evidence that sufficiently general agents must contain world models
World modeling is still early
The paper cites a lot of other recent research, but there are no gold standards that I’ve seen yet
Generator : reward model :: agent : world model
Training a world model could become the main way to improve the agent, at least for a time
Maybe there will be human data for world model training
Could you use a world model as a faster approximation if the real environment is slow/expensive/one-way?
Agent + world model = RSI?
If the agent can improve the world model, and the world model can improve the agent (as we just saw), the cycle is complete