Qwen AgentWorld-35B: Run an Agent Environment Simulator on Your Own Machine (vLLM, SGLang, Apache-2.0)
Let’s be upfront about what this is, because the name “world model” can be confusing and easy to misread.
Qwen released Qwen-AgentWorld-35B-A3B on June 24. It’s not a coding agent you point at your repo. It’s a simulator: you pass it an action (for example, “execute ls -la /home/user/project/”) plus the interaction history, and it predicts the next state of the environment—what the terminal would return to you—. That’s the whole game. It learned to model how environments respond to actions, and it does this across seven domains at once.
Seven domains in a single model: MCP (tool calling), Search, Terminal, SWE, Android, Web, and OS —covering both text and GUI interaction—. Qwen presents it as the first language world model spanning all seven in a single set of weights.
So who is this for? Not for your daily git commit workflow. It’s for those training or evaluating agents —and that’s where the practical payoff is, which we’ll get to.
The specs that matter
- MoE, 35B total / ~3B active per token —so it performs above what a 3B active footprint would suggest.
- Context window of 262,144 tokens (by default). The model card warns: if you hit OOM, reduce the window, but keep it at 128K minimum, because multi-turn environment simulation eats up context.
- Apache-2.0 —commercial use allowed, no asterisks.
- Compatible with Transformers, vLLM, and SGLang.
- Comes with AgentWorldBench (the evaluation benchmark) and per-domain system prompts in the repo.
There’s also a bigger sibling, 397B-A17B, which is the performance star of the paper but not part of the open release. The 35B is what you can actually download and run, and that’s why it’s what we’re interested in.
Serving it (the hands-on part)
Both commands come from Qwen’s own documentation. SGLang:
python -m sglang.launch_server \
--model-path Qwen/Qwen-AgentWorld-35B-A3B \
--port 8000 \
--tensor-parallel-size 4 \
--context-length 262144 \
--reasoning-parser qwen3
vLLM:
vllm serve Qwen/Qwen-AgentWorld-35B-A3B --port 8000
Notice the --reasoning-parser qwen3 in SGLang: AgentWorld reasons with a long chain-of-thought before emitting the next predicted state, so the server needs to parse the thinking block. If you can’t reach Hugging Face, the repo documents ModelScope as a fallback (SGLANG_USE_MODELSCOPE=true or VLLM_USE_MODELSCOPE=true).
Once it’s running, you call it like any OpenAI-compatible chat endpoint. The pattern from the model card: a system prompt that frames the domain (“predict the terminal output”), then a user turn with the action—for example, Action: execute_bash / Command: ls -la /home/user/project/—and the model returns what that environment would plausibly produce.
Practical use cases: where the disk space pays for itself
This is the part that matters, and why I’d file this under “tool worth knowing” rather than “model of the week”.
1. Train agents without spinning up real infrastructure. Normally, doing RL on an agent means a live environment: a real terminal, a real Android emulator, a real browser, all wired up and reset between episodes. That’s slow, fragile, and expensive. AgentWorld lets you use the simulator as the environment. Qwen validated it on Tool Decathlon, MCPMark, and WideSearch, reporting that controllable simulation outperformed both uncontrolled simulation and real environment training.
2. Evaluate agents cheaply and repeatably. A simulated environment is controllable and nearly deterministic—you can reproduce the same scenario, inject perturbations, and even build fictional environments to stress edge cases that are a pain to reproduce live. (As a fun note: the model generalizes zero-shot to out-of-domain environments, OpenClaw among them—something we’ve already discussed.)
3. Catch the failures that task-completion benchmarks miss. Here’s the sharp insight. Most coding benchmarks only ask “did the PR pass?”. AgentWorldBench scores the interaction layer across five dimensions: format, factuality, consistency, realism, and quality. Agents fail in messy ways: a plausible terminal output with the wrong filename, a web page state that drifts across turns, a fabricated tool result that breaks the schema. Those are exactly the kinds of failures a state-prediction model is built to surface.
One honest caveat from Qwen’s own analysis: factuality is the hardest dimension —it showed the most improvement during training, but remained the lowest-scoring throughout—. Translation: the simulator is good at generating plausible states, less reliable at factually exact ones. Keep that in mind before blindly trusting a simulated result.
Does it deserve your attention?
If you’re shipping agents—MCP tools, terminal agents, browser or Android automation—this is a way to cheapen and make more controllable your training and evaluation loop, with Apache-2.0 weights you host yourself. If what you want is something to write code, this isn’t it, and that’s fine. It’s a specialist tool, and a good one.
Are you already training or evaluating agents with simulators, or are you still stuck with real infrastructure? Tell us how you’re solving it.