Software World Model: Behavioral Simulations

• Software world models are frameworks—implicit within LLMs or explicit as simulators—that enable agents to predict and reason about software behavior.
• They integrate methodologies from code understanding, simulation, formal modeling, and human-computer interaction to address complex system dynamics.
• Recent research highlights both limitations in predictive accuracy and advances using executable simulations to improve testing, CI, and runtime evaluations.

A software world model is an internal or external model that allows an agent to reason about how software systems behave when executed and operated, not merely how source code is written (Bogomolov et al., 25 Jun 2026). In current usage, the term covers both implicit behavioral knowledge inside coding LLMs and explicit software artifacts—programs, simulators, typed semantic worlds, surrogate environments, and web-native state machines—that support prediction, planning, evaluation, or coordination over software-system behavior (Bogomolov et al., 25 Jun 2026, Feng et al., 29 Dec 2025, Mantsivoda et al., 1 Apr 2026). The concept therefore sits between code understanding, model-based control, software engineering, human-computer interaction, and formal systems modeling.

1. Conceptual scope and intellectual background

The recent technical definition most directly associated with the term treats a software world model as the internal model—implicit or explicit—that supports reasoning about software-system behavior: whether tests pass, which exception occurs, how much time and memory execution consumes, what methods or lines become hotspots, how build or CI pipelines behave, and how a change interacts with the surrounding repository (Bogomolov et al., 25 Jun 2026). On this view, standard code-execution benchmarks cover mainly one narrow slice of the problem, especially control-flow reasoning, whereas practical software engineering depends on a broader predictive grasp of execution and environment.

Within that framing, an implicit software world model is the capability a coding LLM acquires incidentally from broad code pretraining, while an explicit world model is trained or constructed specifically for behavioral prediction (Bogomolov et al., 25 Jun 2026). This distinction is now central to the literature: some work asks how much behavioral knowledge frontier coding models already possess, while other work builds explicit simulators, structured semantic substrates, or surrogate execution environments.

A broader conceptual current defines a world model less by representational form than by function. “Critiques of World Models” argues that the primary goal of a world model is “simulating all actionable possibilities of the real world for purposeful reasoning and acting” (Xing et al., 7 Jul 2025). Applied to software, this suggests—by plausible implication rather than explicit statement—that a software world model should support counterfactual reasoning about edits, commands, workflows, and deployment decisions, rather than only next-token or next-output prediction.

Older antecedents did not use the current AI terminology but articulated related ideas. Kruchten’s “frog and octopus” model describes software development through Intent, Product, People, Work, Time, Quality, Risk, Cost, Value and treats software projects as a unified conceptual world rather than a single process doctrine (Kruchten, 2012). “Software is a directed multigraph” models software and software process together as a typed directed multigraph over artifacts and dependencies, emphasizing traceability and architectural knowledge integration (Dabrowski et al., 2011). Hehl’s “Poïesis” extends software beyond digital code toward organized, instruction-driven process more generally (Hehl, 2016). These works are not technical software world models in the contemporary model-based sense, but they provide conceptual background for treating software as a structured domain with its own state, dynamics, and causal organization.

2. Main representational forms

Current research uses several distinct representational choices for software world models. The most important difference is whether the model remains implicit inside a general-purpose learner or is made explicit as code, a simulator, a semantic store, or a typed software environment.

Form	Example	Characteristic
Implicit behavioral model	Coding LLM evaluation (Bogomolov et al., 25 Jun 2026)	Capability acquired incidentally from broad code pretraining
Executable program world model	WorldCoder (Tang et al., 2024)	Transition and reward encoded as editable Python
Surrogate execution environment	SWE-World (Sun et al., 3 Feb 2026)	Learned execution and reward models replace Docker-dependent feedback
GUI or desktop transition model	CUWM and Code2World (Guan et al., 19 Feb 2026, Zheng et al., 10 Feb 2026)	Predicts next UI state from screenshot and action
Software-native persistent world	Web World Models (Feng et al., 29 Dec 2025)	Code-defined state and “physics” with LLM-generated semantic layer
Shared semantic world	WMAS / Ontobox (Mantsivoda et al., 1 Apr 2026)	Explicit ontology, state, actions, transitions, and constraints
Explicit discrete-event simulator	DEVS generation (Chen et al., 4 Mar 2026)	Natural-language specification compiled into executable DEVS models

These forms are not mutually exclusive. A system may combine deterministic code-defined state transitions with stochastic semantic generation, as in Web World Models, or pair explicit simulators with learned policies, as in world-centered architectures and discrete-event synthesis (Feng et al., 29 Dec 2025, Mantsivoda et al., 1 Apr 2026, Chen et al., 4 Mar 2026). A recurrent design pattern is to separate hard constraints and state transitions from semantic elaboration, so that the world remains controllable, inspectable, and reproducible while still supporting open-ended generation.

3. Behavioral prediction in coding and software engineering

The most direct empirical study of implicit software world models in coding LLMs is “Towards Evaluation of Implicit Software World Models in Coding LLMs” (Bogomolov et al., 25 Jun 2026). That benchmark is built from SWE-bench Verified, a curated benchmark of 500 real GitHub issues with verified gold patches across 12 Python repositories, then filtered and downsampled to 435 examples with context under 500K characters (Bogomolov et al., 25 Jun 2026). Instead of asking only for functional correctness, it evaluates prediction of test outcome, exception class, wall-clock time, peak memory, and four top-20 profiler rankings: method-level time, method-level memory, line-level time, and line-level memory (Bogomolov et al., 25 Jun 2026).

The reported results are notably weak. For test failure prediction, the best model is gpt-5.5 with precision 0.987, recall 0.735, F1 0.842, and the dominant pattern is high precision but low recall, indicating a bias toward predicting that tests pass (Bogomolov et al., 25 Jun 2026). For scalar resource prediction, all models show slope compression and usually positive bias on the $\log_{10}$ scale. The best peak-memory result is gpt-5.4 with slope 0.738, bias $+1.176$, MAE 0.567, and the best wall-clock result is again gpt-5.4 with slope 0.800, bias $+0.500$, MAE 0.578 (Bogomolov et al., 25 Jun 2026). For hotspot localization, performance is much weaker: the authors emphasize that best Recall@5 never reaches 0.2, and even better models often have execution rates around 0.2–0.3 for method-level predictions (Bogomolov et al., 25 Jun 2026). The central conclusion is that current coding LLMs possess, at best, weak and brittle implicit software world models.

A different line of work externalizes the world model as a learned environment for software engineering agents. SWE-World is a Docker-free surrogate execution environment that keeps deterministic navigation and editing actions real in a lightweight sandbox while replacing runtime-sensitive execution with SWT and final test evaluation with SWR (Sun et al., 3 Feb 2026). On SWE-bench Verified, this raises Qwen2.5-Coder-32B from 6.2% to 52.0% via Docker-free SFT, 55.0% with Docker-free RL, and 68.2% with TTS@8 (Sun et al., 3 Feb 2026). The same paper reports that Docker trajectories (5.7K) yield 51.4%, SWE-World trajectories (5.7K) yield 52.2%, and SWE-World + Docker (9.3K) yields 53.8%, suggesting that learned-environment data can be usable for policy training at scale (Sun et al., 3 Feb 2026). The paper also notes a major limitation: SWT and SWR consume the gold patch as an internal reference, hidden from the agent but still available to the simulator, so the environment is partly oracle-informed rather than a pure execution emulator (Sun et al., 3 Feb 2026).

WorldCoder represents the opposite extreme: the world model is itself executable software (Tang et al., 2024). It formulates a deterministic, fully observed, episodic, low-dimensional CMDP and learns a pair of Python functions $(\hat{T}, \hat{R})$, where $\hat{T}: S \times A \rightarrow S$ and $$\hat{R}:C\to (S \times A\times S \rightarrow \mathbb{R}\times\{0,1\})$$ (Tang et al., 2024). The key learning constraints are data consistency and optimism under uncertainty, expressed as logical conditions $\phi_1$ and $\phi_2$ over replay data and the learned program (Tang et al., 2024). This makes the world model editable, inspectable, and transferable by localized code revision. In the paper’s own interpretation, the agent learns a world model by writing software, debugging that software against counterexamples, and then planning by executing it (Tang et al., 2024).

4. GUI, desktop, and web software worlds

In computer-use settings, the software world model becomes a predictor of interface transitions. CUWM, the Computer-Using World Model, models desktop software in Microsoft Word, Microsoft Excel, and Microsoft PowerPoint by factorizing the next-state problem into a textual transition description $\Delta_t = f_{\text{text}}(s_t, a_t)$ and a visual realization $\hat{s}_{t+1} = f_{\text{image}}(s_t, \Delta_t)$ (Guan et al., 19 Feb 2026). It is trained on offline UI transitions from GUI-360 and used at test time for one-step action search over five diverse candidate actions (Guan et al., 19 Feb 2026). The full model reaches PSNR 14.91, SSIM 0.67, LPIPS 0.21, FID 20.48, and TRS 0.716 (Guan et al., 19 Feb 2026). In downstream agent selection, GPT-4o improves from 0.4558 without a world model to 0.4720 with CUWM Image, while Qwen3-VL-8B improves from 0.3895 to 0.4189 (Guan et al., 19 Feb 2026). A notable negative result is that combining text and image predictions often hurts performance, which the authors attribute to cross-modal conflict and error accumulation (Guan et al., 19 Feb 2026).

Code2World addresses the same next-UI prediction problem through renderable code generation rather than image editing (Zheng et al., 10 Feb 2026). It defines $+1.176$0 and $+1.176$1, where the predicted state is full HTML and the observable next state is the browser-rendered image (Zheng et al., 10 Feb 2026). To support this, the paper constructs AndroidCode, a corpus of over 80K high-quality screen-action pairs, by translating GUI trajectories into HTML with GPT-5 and refining the code through visual-feedback revision until SigLIP similarity exceeds 0.9 or revision budget is exhausted (Zheng et al., 10 Feb 2026). Code2World-8B reaches $+1.176$2, $+1.176$3, $+1.176$4, and $+1.176$5 on Android Control, and it boosts Gemini-2.5-Flash on AndroidWorld navigation from 41.4% to 50.9%, i.e. +9.5% (Zheng et al., 10 Feb 2026). The core idea is that renderable code is more structurally controllable than raw pixel prediction while remaining directly visualizable.

Web World Models generalize the same logic beyond a single application class by making the world itself a web application (Feng et al., 29 Dec 2025). The paper explicitly splits state into deterministic code-defined state and model-generated semantic state, writing $+1.176$6, with $+1.176$7 and $+1.176$8 (Feng et al., 29 Dec 2025). In this design, inventories, coordinates, resource caps, legal actions, retrieval pipelines, rendering, schema validation, and stable identifiers are implemented in ordinary web software, while the LLM supplies guides, dialogue, missions, articles, or long-form fiction (Feng et al., 29 Dec 2025). This produces a software-native world model whose “physics” is executable code and whose semantic surface is generated on demand.

5. Platforms, formal semantics, and explicit world-centered systems

A separate branch of work treats software world models as explicit research infrastructure or formal semantic substrates. The stable-worldmodel platform is a software ecosystem for world-model research rather than a single model (Maes et al., 20 May 2026). It standardizes data collection, environment interaction, planning, and evaluation through abstractions such as World, Policy, and Solver, and adds controllable Factors of Variation (FoV) for visual, geometric, and physical perturbations (Maes et al., 20 May 2026). The paper’s strongest concrete software claim is its data layer: on Push-T, throughput is reported as HDF5 local: 1416, HDF5 S3: 9 without caching, 757 with caching, Lance local: 4815, Lance S3: 3184, and Video local: 1331 samples/sec (Maes et al., 20 May 2026). The platform therefore operationalizes world-model experimentation as a reproducible software stack with shared evaluation APIs and versioned datasets.

World-centered architectures push explicitness further by making the shared world representation primary. “Semantic Modeling for World-Centered Architectures” defines a world as $+1.176$9, where $+0.500$0 is a set of entities, $+0.500$1 a set of relations, $+0.500$2 a state space, $+0.500$3 admissible actions, $+0.500$4 a transition function or relation, and $+0.500$5 constraints or norms (Mantsivoda et al., 1 Apr 2026). In WMAS, agents do not primarily reason over private local models; they act over a shared semantic world that supports explicit ontology, state accessibility, normativity, and verifiable transitions (Mantsivoda et al., 1 Apr 2026). The Ontobox platform is presented as an implementation of this architecture for structured domains such as enterprises, finance, healthcare, and regulatory systems (Mantsivoda et al., 1 Apr 2026).

Specification-driven DEVS generation represents another explicit route. The paper formalizes a discrete-event world as $+0.500$6 and synthesizes executable Parallel DEVS models from natural-language specifications through staged structural and behavioral generation (Chen et al., 4 Mar 2026). Instead of comparing generated simulators against a single gold implementation, it validates emitted event traces against specification-derived constraints and reports Operational success score (OSS) and Behavioral conformance score (BCS) (Chen et al., 4 Mar 2026). This is especially relevant for software systems dominated by queues, protocols, message passing, and timed workflows, where discrete-event semantics provide explicit causality and long-horizon consistency.

A verification-oriented variant appears in software-defined networking. MOCS models an SDN as $+0.500$7 with explicit controller state, switch flow tables, packet queues, control queues, forwarding queues, PacketIn and BarrierRes behavior, and property checking in $+0.500$8 (Klimis et al., 2020). This is a software world model in a narrower but rigorous sense: a finite, exhaustive, property-aware transition model of a closed-loop software-controlled environment.

6. Limitations, misconceptions, and open directions

A recurring misconception is to equate world models with visual generation or one-step prediction. “Critiques of World Models” argues that video generation systems often “fall outside the definition of world models for reasoning and planning” because they generate fixed trajectories without explicit action-conditioned branching (Xing et al., 7 Jul 2025). The same caution applies in software: screenshot realism, plausible code completion, or fluent explanation is not sufficient if the model cannot support counterfactual reasoning about what different actions would do.

Current systems remain narrow in scope. The coding benchmark in (Bogomolov et al., 25 Jun 2026) is limited to Python, to contexts under 500K characters, and to 435 final examples derived from SWE-bench Verified; it also uses an oracle-based context collection strategy that includes all executed code, which the authors explicitly describe as an upper bound (Bogomolov et al., 25 Jun 2026). CUWM is limited to Microsoft Office, uses only one-step lookahead, and still requires the downstream agent to ignore diffusion artifacts (Guan et al., 19 Feb 2026). Code2World models the visible GUI state rather than full hidden application state and shows notable degradation on GUI Odyssey relative to in-domain evaluation (Zheng et al., 10 Feb 2026). Web World Models demonstrate breadth but provide little in the way of substantial quantitative metrics or ablation tables (Feng et al., 29 Dec 2025).

Explicit systems have their own costs. World-centered architectures require up-front ontology engineering and are most appropriate when the world admits explicit ontology, structural stability, normativity, and state accessibility (Mantsivoda et al., 1 Apr 2026). DEVS-based synthesis depends on specification quality and still uses manually implemented verification oracles for each benchmark scenario (Chen et al., 4 Mar 2026). SWE-World reduces Docker dependence but introduces simulator mismatch, reward-model error, and benchmark-specific oracle information through hidden gold patches (Sun et al., 3 Feb 2026).

The main open direction, stated most clearly in (Bogomolov et al., 25 Jun 2026), is to move beyond control-flow-centric evaluation toward broader software behavior: build resolution, CI behavior, deployment/runtime environment, concurrency, and repo-level agentic workflows. The same paper also identifies practical next steps: replacing oracle context with realistic retrieval, improving elicitation, and training or adapting models specifically for software world modeling rather than assuming broad coding competence transfers automatically (Bogomolov et al., 25 Jun 2026). A plausible architectural implication, suggested by the broader critique in (Xing et al., 7 Jul 2025), is that stronger software world models may require hierarchical, mixed discrete/continuous representations that connect symbolic software structure, runtime traces, and action-conditioned counterfactual simulation.