Towards Evaluation of Implicit Software World Models in Coding LLMs

# Towards Evaluation of Implicit Software World Models in Coding LLMs
Source: [https://arxiv.org/html/2606.27406](https://arxiv.org/html/2606.27406)
\{jbabstract\}

Software engineering, whether performed by humans or by AI agents, requires reasoning about how software behaves\. We call the internal model that supports such reasoning the*software world model*, and view current code\-execution benchmarks as covering one well\-studied slice of it—control flow\. In this paper, we take a step toward a broader evaluation by shifting the observable axis to execution resources: alongside test outcome and exception class, we predict peak memory, wall\-clock time, and ranked profiler outputs at method and line granularity\. We use SWE\-bench Verified as the source of data to hold the test close to real\-world software engineering tasks\. All tested models, frontier ones included, show modest performance and brittle behaviour, suggesting a notable lack of understanding of how software is*executed*, as opposed to how its source code is*written*\.

## 1Introduction

The most straightforward way of assessing coding LLMs is by how well they write code\. Function\-level benchmarks such as HumanEval\[[undefg](https://arxiv.org/html/2606.27406#bib.bibx8)\]and MBPP\[[undefd](https://arxiv.org/html/2606.27406#bib.bibx5)\]score whether a generated solution passes a held\-out test suite; repository\-level benchmarks such as SWE\-Bench\[[undefj](https://arxiv.org/html/2606.27406#bib.bibx11)\]and Aider\-Polyglot\[[undef](https://arxiv.org/html/2606.27406#bib.bibx1)\]score whether a generated patch fixes a real bug or implements a feature; and repository\-scale benchmarks such as Commit0\[[undefv](https://arxiv.org/html/2606.27406#bib.bibx23)\]ask a model to reproduce an entire Python repository from its specification and unit\-test suite\. These evaluations measure the capabilities of model in code generation\.

Another line of benchmarks evaluates coding LLMs on their understanding of program execution\. CRUXEval\[[undefi](https://arxiv.org/html/2606.27406#bib.bibx10)\]predicts function inputs given outputs \(and vice versa\) on 800 short Python functions\. REval\[[undeff](https://arxiv.org/html/2606.27406#bib.bibx7)\]decomposes function execution into predicting code coverage, program state along the path, the next executed statement, and the final output\. ThrowBench\[[undefs](https://arxiv.org/html/2606.27406#bib.bibx20)\]predicts the runtime exception type\. BigO\(Bench\)\[[undefe](https://arxiv.org/html/2606.27406#bib.bibx6)\]classifies asymptotic complexity\. CodeMind\[[undefl](https://arxiv.org/html/2606.27406#bib.bibx13)\]bundles three reasoning tasks on1,4501\{,\}450short programs\. RE2\-Bench\[[undefm](https://arxiv.org/html/2606.27406#bib.bibx14)\]evaluates reasoning code on repository\-scale\. The reasoning benchmarks mostly operate on isolated, often synthetically created, Python functions, classes, or short programs, and mostly focus on return value or a derivative\.

Reasoning about code execution in terms of the control flow is, however, only one slice of the broader skill software engineers exercise daily — predicting how a build will resolve dependencies, how a test suite will behave under a given change, how a service will respond at runtime, how concurrent code will interleave, how a patch will interact with the surrounding repository\. We use the term*software world model*for this broader internal model of software\-system behaviour, of which the control flow is the most studied facet\. Following the established usage, we distinguish*implicit world models*—the capability spontaneously acquired by coding LLMs trained on general code corpora—from*explicit world models*, models trained for this purpose specifically, such as the recent CWM\[[undefh](https://arxiv.org/html/2606.27406#bib.bibx9)\]\.

A complete evaluation of an implicit software world model would span build and dependency resolution, test and CI behaviour, runtime errors, deployment and runtime environments, concurrency, and the agentic, repo\-level workflows that connect them — work well beyond a single paper\. As a first step in this direction, we stay within the most\-studied facet, code execution, and push it toward more realistic software contexts\. We address two gaps in current code\-execution evaluation\. First, the function\-scoped snippets used in most reasoning benchmarks do not match the complexity of practical software, where behaviour depends on a surrounding library implementation\. Second, the return value is only one of many facets of how a piece of software actually executes\. To bridge these gaps, we \(1\) design a set of metrics that captures a wider slice of execution behaviour, \(2\) collect a dataset of library\-level cases derived from SWE\-bench Verified, and \(3\) present results for a broad set of recent code\-fluent LLMs, both proprietary and open\-weight\. We position this contribution as a template for further extensions of software world model evaluation, beyond code execution alone\. The data package is available on Hugging Face111[https://huggingface\.co/collections/JetBrains\-Research/dl4c26\-evaluation\-of\-software\-world\-model](https://huggingface.co/collections/JetBrains-Research/dl4c26-evaluation-of-software-world-model), and the code on GitHub222[https://github\.com/JetBrains\-Research/cwm\-execution\-tracer](https://github.com/JetBrains-Research/cwm-execution-tracer)\.

## 2Data

We build the dataset from SWE\-bench Verified\[[undefj](https://arxiv.org/html/2606.27406#bib.bibx11)\], a curated collection of 500 real GitHub issues and verified gold patches across 12 Python repositories\. We build samples from the pairs of tests that were failing and then got fixed with the gold patch\. To make the task solvable for most models, we only retain the examples that require less than 500K characters of context\. As SWE\-bench Verified is dominated by samples from Django, we then downsample the data to 435 examples, while preserving diversity at the repository level\. To collect the ground truth observables, for each instance we inject a customsys\.settrace/sys\.monitoring\-based tracer into the SWE\-bench Docker container, and run the designated tests\. We run the procedure before and after the patch, to catch different behaviours of the same test\. The tracer records a number of observables detailed further in this section\.

Test outcome\.The tracer records whether each test passed or failed\. We count a test as failed if it raises anAssertionErroror another exception\. For tests that failed, we additionally record the exception class name\.

Wall\-clock time\.We record the wall\-clock time as the elapsed time between the start and finish of the function execution\. To alleviate the noise from other measurements, we do this on a clean run without any additional tracing\.

Peak memory\.Memory required for the test to run\. We record it as a maximum of memory consumption recorded during the test execution, measured at the line level\.

Profiler\.For each run, we record four profiling types, formed by the Cartesian product of two profiling scopes \(method\-level and line\-level\) and two profiling metrics \(time and memory\)\. We record wall\-clock time in milliseconds and memory in kilobytes\. For the method profiler, we record fully qualified function names, and for the line profiler, we record lines in the format<file\>:<line\>\. In all cases, we record the top 20 rows, ordered by the respective metric, and limit the scope of profiling to the repository\.

## 3Metrics

We target three qualitatively different prediction tasks and use a distinct metric family for each\. Outcome prediction is evaluated by classification accuracy; resource prediction by linear calibration on a log scale, since wall time and memory span several orders of magnitude; and profiling as a ranking task\. All metrics are computed per instance and aggregated over the dataset\.

Test failure\.We treat test failure prediction as a binary classification and report precision, recall, and F1\.

Linear calibration for wall time and peak memory\.Both quantities span several orders of magnitude, so we evaluate on thelog10\\log\_\{10\}scale\. We fit a linear modely^=a​y∗\+b\\hat\{y\}=a\\,y^\{\*\}\+bwherey^=log10⁡\(predicted\)\\hat\{y\}=\\log\_\{10\}\(\\text\{predicted\}\)andy∗=log10⁡\(actual\)y^\{\*\}=\\log\_\{10\}\(\\text\{actual\}\), and report slopeaa\(calibration\), interceptbb\(systematic bias\), and Mean Absolute Error\. We additionally replace zero predictions of models with 0\.01 ms for time and 10KB for peak memory\. These values are smaller than all the groundtruth numbers in our dataset, yet they allow us to compute log\-scale metrics\.

Profiler ranking\.For each of the four ranked lists \(functions×\\times\{time, memory\} and lines×\\times\{time, memory\}\) we report two ranking metrics: recall and NDCG\.Recall​@​k\\mathrm\{Recall\}@kyields11for a sample if the actual top\-method/\-line is within topkkpredicted methods/lines and0otherwise\.DCG​@​k\\mathrm\{DCG\}@kis defined as∑i=1kri/log2⁡\(i\+1\)\\sum\_\{i=1\}^\{k\}r\_\{i\}/\\log\_\{2\}\(i\+1\), whererir\_\{i\}is the measured time/memory attributed to the function or line predicted at rankii\. We reportNDCG​@​5\\mathrm\{NDCG\}@5—DCG​@​5\\mathrm\{DCG\}@5normalized by the optimalDCG​@​5\\mathrm\{DCG\}@5—andRecall​@​5\\mathrm\{Recall\}@5\. To gauge the model’s ability to estimate the execution scope we additionally measure execution rate, which defines a portion of predicted methods or lines that were actually executed during the run\.

## 4Experiment Setup

Models\.We evaluate three Anthropic models via the Anthropic API:claude\-haiku\-4\-5\[[undefa](https://arxiv.org/html/2606.27406#bib.bibx2)\],claude\-sonnet\-4\-6\[[undefc](https://arxiv.org/html/2606.27406#bib.bibx4)\], andclaude\-opus\-4\-7\[[undefb](https://arxiv.org/html/2606.27406#bib.bibx3)\]\. Via the OpenAI API we evaluategpt\-5\-mini\[[undefn](https://arxiv.org/html/2606.27406#bib.bibx15)\],gpt\-5\.2\[[undefp](https://arxiv.org/html/2606.27406#bib.bibx17)\],gpt\-5\.4\[[undefq](https://arxiv.org/html/2606.27406#bib.bibx18)\], andgpt\-5\.5\[[undefr](https://arxiv.org/html/2606.27406#bib.bibx19)\]\. We run five open\-weight models locally:gpt\-oss\-120b\[[undefo](https://arxiv.org/html/2606.27406#bib.bibx16)\]from OpenAI;Qwen3\.5\-397B\-A17B\[[undefu](https://arxiv.org/html/2606.27406#bib.bibx22)\],Qwen3\-235B\-A22B\-Instruct, andQwen3\-30B\-A3B\-Instruct\[[undeft](https://arxiv.org/html/2606.27406#bib.bibx21)\]from Alibaba; andCWM\[[undefh](https://arxiv.org/html/2606.27406#bib.bibx9)\]by FAIR\.

Context\.The user message consists of two blocks\. Thefirst blockis a slice of the library containing all executed code\. For each file, where at least one line was executed, we include module preambles \(all content before the first class or function definition\), followed by every function \(or method body enclosed in class scaffolding\) in which at least one line was executed\. For classes with executed lines we also keep everything outside methods such as class definition and its fields\. The remaining budget \(if any\) up to 500 K characters is then filled with non\-executed functions and methods\. Thesecond blockis the test file, windowed to at most 60 K characters centered on the target test function\. The prompt template is shared in[Appendix˜A](https://arxiv.org/html/2606.27406#A1)\.

Task\.The model is instructed to return a single JSON object with ten fields:reasoning\(a 2–4 sentence explanation\),outcome\(passed,failed, orerror\),failure\_lineandexception\_type\(null when outcome is passed\),peak\_bytesandwall\_ms\(integer and float respectively\), and four ranked lists of up to 20 entries each:hot\_methods\_time,hot\_methods\_alloc,hot\_lines\_time, andhot\_lines\_alloc\. These fields correspond directly to the observables described in Section[2](https://arxiv.org/html/2606.27406#S2)and are scored by the metrics in Section[3](https://arxiv.org/html/2606.27406#S3)\.

## 5Results Discussion

Table 1:Test failure prediction, sorted by F1↓\\downarrow\.Table 2:Peak memory consumption prediction calibration \(log10\\log\_\{10\}scale\)\. Ideal: slope=1=1, bias=0=0\. Sorted by MAE↓\\downarrow\.Table 3:Wall\-time prediction calibration \(log10\\log\_\{10\}scale\)\. Ideal: slope=1=1, bias=0=0\. Sorted by MAE↓\\downarrow\.Table 4:Memory\-profiler ranking quality\.*exec*: fraction of predicted names present in the execution trace\. NDCG@5 and recall@5 assess ranking quality against ground\-truth allocation profiles\. Sorted by Method NDCG@5↓\\downarrow\.Table 5:Time\-profiler ranking quality\.*exec*: fraction of predicted names present in the execution trace\. NDCG@5 and recall@5 assess ranking quality against ground\-truth time profiles\. Sorted by Method NDCG@5↓\\downarrow\.[Table˜1](https://arxiv.org/html/2606.27406#S5.T1)reports test\-outcome classification;[Tables˜2](https://arxiv.org/html/2606.27406#S5.T2)and[3](https://arxiv.org/html/2606.27406#S5.T3)report resource\-prediction calibration;[Tables˜4](https://arxiv.org/html/2606.27406#S5.T4)and[5](https://arxiv.org/html/2606.27406#S5.T5)report profiler\-ranking quality\. We note that all the models, including the frontier models available by API aren’t scoring high on the proposed tasks\. For test outcome prediction, most models have F1 scores consistently low, largely due to very low recall\. For both peak memory and wall\-time, model predictions are systematically biased, with every model having slope and bias significantly different from optimal\(1,0\)\(1,0\)values\. For all types of profiling, the bestr​e​c​a​l​l​@​5recall@5never reaches0\.20\.2, indicating that models rarely identify the most consuming entity\.

For the test outcome prediction, we note that most models have low recall, indicating a strong bias towards tests passing\. We attribute this to LLMs’ tendency to follow the natural\-language semantics of code rather than its structure, as shown by\[[undefk](https://arxiv.org/html/2606.27406#bib.bibx12)\]\. Optimizing tests to elicit unbiased predictions from LLMs may be a promising research direction for Software Engineering\.

For the peak memory consumption and time, in addition to the presence and strength of systematic errors, we note that the bias itself is universal\. We observe unanimous slope compression \(models giving predictions closer to the average\) and bias towards overestimation \(for most of the models the difference is at least an order of magnitude\)\. The unique case of CWM can be explained by 247 cases where it predicts 0 ms execution time, motivating it in reasoning by inability to calculate it precisely\. This conservative estimations make models less useful in giving predictions when it comes to load brought by particular tasks333On an anecdotal observation, while we were running experiments for this paper, the runs were supervised by Sonnet 4\.6, which systematically mispredicted the time needed to complete a run by always predicting a value around 20 minutes, whether in reality it took 2 hours or 7 minutes\.\.

Most often, the predictions for the profiling tasks are dominated by the line numbers and methods that weren’t actually executed\. We additionally measured NDCG@5 of a set obtained by correct ordering of model predictions and noticed a significant boost \(On average×1\.5\\times 1\.5for method profiling and×2\\times 2for line profiling\), which indicates that hallucinating execution scope is not the sole problem — correct ranking is challenging for models\.

In general, we note that smaller and especially open\-weight models have a tendency to predict "round" numbers, with particularly peculiar numbers like "12345 ms" dominating the output of Qwen3\-30B\. This is especially well notable on the scatter plots of predicted and measured values shown in[Appendix˜B](https://arxiv.org/html/2606.27406#A2)\. Surprisingly, CWM’s performance on code generation and reasoning, is not transferring to reasoning about software—while it produces coherent reasoning traces and outputs, it falls behind the Qwen3\-30B \(a model of the similar size\) in most experiments\. These findings reinforce our point about the need for a wider understanding of Software World Models beyond Code World Models\.

## 6Limitations

We see three points where further work can make the results more diverse: data, context, and answer elicitation techniques\. The dataset is derived from SWE\-bench Verified and further limits its scope by filtering the tests and libraries where the context doesn’t fit in 500k characters\. We leave generalisation to other languages, less\-curated codebases, or broader test populations to future work\. This paper only evaluates a single oracle\-based context\-collection strategy, thus establishing the upper boundary of the context collection performance\. Future work should explore more realistic scaffolding\. Finally, this paper does not explore broader ways to elicit better answers from LLMs, leaving such strategies as advanced prompting, multi\-shot voting, or probing the latent space open for further exploration\.

## 7Conclusion

Code execution is one facet of the broader*software world modeling*; this paper is intended as a first probe into the rest of that space\. We extend execution evaluation to library\-level cases from SWE\-bench Verified and to four tasks beyond the return value: test outcome, peak memory consumption, wall time, and ranked profiler outputs at method and line granularity\. Across twelve models, including the trace\-trainedCWMand frontier models, performance is modest\. We envision further extensions to the area of software world modeling in such tasks as build resolution, CI, deployment, concurrency, and agentic workflows; we release the data, prompts, and tracing harness to contribute to help advance the research in this area\.

## References

- \[undef\]undef Aider\-AI“aider: AI pair programming in your terminal”[https://github\.com/Aider\-AI/aider](https://github.com/Aider-AI/aider), GitHub repository, 2026
- \[undefa\]undef Anthropic“Claude Haiku 4\.5 System Card” Accessed 2026\-05,[https://www\.anthropic\.com/claude\-haiku\-4\-5\-system\-card](https://www.anthropic.com/claude-haiku-4-5-system-card), 2025
- \[undefb\]undef Anthropic“Claude Opus 4\.7 System Card” Accessed 2026\-05,[https://www\.anthropic\.com/claude\-opus\-4\-7\-system\-card](https://www.anthropic.com/claude-opus-4-7-system-card), 2026
- \[undefc\]undef Anthropic“Claude Sonnet 4\.6 System Card” Accessed 2026\-05,[https://www\.anthropic\.com/claude\-sonnet\-4\-6\-system\-card](https://www.anthropic.com/claude-sonnet-4-6-system-card), 2026
- \[undefd\]Jacob Austin et al\.“Program Synthesis with Large Language Models”, 2021arXiv:[https://arxiv\.org/abs/2108\.07732](https://arxiv.org/abs/2108.07732)
- \[undefe\]Pierre Chambon, Baptiste Roziere, Benoit Sagot and Gabriel Synnaeve“BigO\(Bench\) – Can LLMs Generate Code with Controlled Time and Space Complexity?”, 2025arXiv:[https://arxiv\.org/abs/2503\.15242](https://arxiv.org/abs/2503.15242)
- \[undeff\]Junkai Chen et al\.“Reasoning Runtime Behavior of a Program with LLM: How Far Are We?”In*Proceedings of the IEEE/ACM 47th International Conference on Software Engineering*IEEE Press, 2025, pp\. 1869–1881URL:[https://doi\.org/10\.1109/ICSE55347\.2025\.00012](https://doi.org/10.1109/ICSE55347.2025.00012)
- \[undefg\]Mark Chen et al\.“Evaluating Large Language Models Trained on Code”, 2021arXiv:[https://arxiv\.org/abs/2107\.03374](https://arxiv.org/abs/2107.03374)
- \[undefh\]undef FAIR et al\.“CWM: An Open\-Weights LLM for Research on Code Generation with World Models”, 2025arXiv:[https://arxiv\.org/abs/2510\.02387](https://arxiv.org/abs/2510.02387)
- \[undefi\]Alex Gu et al\.“CRUXEval: A Benchmark for Code Reasoning, Understanding and Execution”In*Proceedings of the 41st International Conference on Machine Learning*235, Proceedings of Machine Learning ResearchPMLR, 2024, pp\. 16568–16621URL:[https://proceedings\.mlr\.press/v235/gu24c\.html](https://proceedings.mlr.press/v235/gu24c.html)
- \[undefj\]Carlos E Jimenez et al\.“SWE\-bench: Can Language Models Resolve Real\-world Github Issues?”In*The Twelfth International Conference on Learning Representations*, 2024URL:[https://openreview\.net/forum?id=VTF8yNQM66](https://openreview.net/forum?id=VTF8yNQM66)
- \[undefk\]Man Ho Lam, Chaozheng Wang, Jen\-tse Huang and Michael R\. Lyu“CodeCrash: Exposing LLM Fragility to Misleading Natural Language in Code Reasoning” arXiv:2504\.14119arXiv, 2025DOI:[10\.48550/arXiv\.2504\.14119](https://dx.doi.org/10.48550/arXiv.2504.14119)
- \[undefl\]Changshu Liu, Yang Chen and Reyhaneh Jabbarvand“CodeMind: Evaluating Large Language Models for Code Reasoning”, 2025arXiv:[https://arxiv\.org/abs/2402\.09664](https://arxiv.org/abs/2402.09664)
- \[undefm\]Changshu Liu, Alireza Ghazanfari, Yang Chen and Reyhaneh Jabbarvand“Evaluating Code Reasoning Abilities of Large Language Models Under Real\-World Settings”In*arXiv preprint arXiv:2512\.14917*, 2025
- \[undefn\]undef OpenAI“GPT\-5 System Card” Accessed 2026\-04,[https://openai\.com/index/gpt\-5\-system\-card/](https://openai.com/index/gpt-5-system-card/), 2025
- \[undefo\]undef OpenAI“gpt\-oss\-120b & gpt\-oss\-20b Model Card” Accessed 2026\-05,[https://openai\.com/index/gpt\-oss\-model\-card/](https://openai.com/index/gpt-oss-model-card/), 2025
- \[undefp\]undef OpenAI“Update to GPT\-5 System Card: GPT\-5\.2” Accessed 2026\-05,[https://openai\.com/index/gpt\-5\-system\-card\-update\-gpt\-5\-2/](https://openai.com/index/gpt-5-system-card-update-gpt-5-2/), 2025
- \[undefq\]undef OpenAI“GPT\-5\.4 Thinking System Card” Accessed 2026\-05,[https://openai\.com/index/gpt\-5\-4\-thinking\-system\-card/](https://openai.com/index/gpt-5-4-thinking-system-card/), 2026
- \[undefr\]undef OpenAI“GPT\-5\.5 System Card” Accessed 2026\-05,[https://openai\.com/index/gpt\-5\-5\-system\-card/](https://openai.com/index/gpt-5-5-system-card/), 2026
- \[undefs\]Julian Aron Prenner and Romain Robbes“ThrowBench: Benchmarking LLMs by Predicting Runtime Exceptions”, 2025arXiv:[https://arxiv\.org/abs/2503\.04241](https://arxiv.org/abs/2503.04241)
- \[undeft\]undef Qwen Team“Qwen3: Think Deeper, Act Smarter” Accessed 2026\-05,[https://qwenlm\.github\.io/blog/qwen3/](https://qwenlm.github.io/blog/qwen3/), 2025
- \[undefu\]undef Qwen Team“Qwen3\.5: Towards Native Multimodal Agents” Accessed 2026\-05,[https://www\.alibabacloud\.com/blog/602894](https://www.alibabacloud.com/blog/602894), 2026
- \[undefv\]Wenting Zhao et al\.“Commit0: Library Generation from Scratch”, 2024arXiv:[https://arxiv\.org/abs/2412\.01769](https://arxiv.org/abs/2412.01769)

## Appendix APrompt Template

Each sample is sent to the model as a two\-message conversation\. The system message is identical for all samples; the user message is constructed per sample as described in[Section˜4](https://arxiv.org/html/2606.27406#S4)\. Variable parts are shown in ⟨angle brackets⟩\.

### System message

``

`User message Appendix B Calibration Scatter Plots Figures 1 and 2 show per\-model scatter plots of predicted versus ground\-truth values for peak heap allocation and wall\-clock time, respectively\. Each panel reports the log\-log linear fit \(y^=s⋅x\+b\\hat\{y\}=s\\cdot x\+b, slope ss and bias bb\) together with the mean absolute log10 error \(MAE\)\. The dashed diagonal marks perfect calibration \(y=xy\{=\}x\); the solid blue line is the fitted regression\. Points are coloured by ground\-truth test outcome \(pass / fail\)\. All models consistently overestimate both quantities \(positive bias\), with slope below 1 indicating compression of the dynamic range\. Figure 1: Peak heap allocation: predicted vs\. ground\-truth log10⁡\(bytes\)\\log\_\{10\}\(\\text\{bytes\}\) for all twelve models\. Each panel’s legend reports MAE, fitted slope ss, and bias bb; dashed diagonal is y=xy\{=\}x \(perfect calibration\)\. Points are coloured by test outcome \(green = pass, red = fail\)\. Figure 2: Wall\-clock time: predicted vs\. ground\-truth log10⁡\(ms\)\\log\_\{10\}\(\\text\{ms\}\) for all twelve models\. Layout and colour coding identical to Figure 1\. CWM is the only model whose bias is negative \(b=−0\.64b\{=\}\{\-\}0\.64\), reflecting systematic under\-prediction of execution time\.`