Pith. sign in

REVIEW 3 major objections 5 minor 53 references

Reasoning from Traces: Divergence-Guided Agentic Repair of WebAssembly Discrepancies

T0 review · 3 major / 5 minor · reviewed 2026-08-08 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read WasmMend's central claim is that localizing the first mismatched function between native and Wasm executions, rather than adding more LLM-driven instrumentation, is what lets agents repair cross-platform discrepancies.

desk verdict A genuinely new and well-evaluated repair pipeline for Native-Wasm discrepancies, but the main attribution claim needs one more ablation before it fully lands. read the letter →

arxiv 2608.05521 v1 pith:GEPWRK7N submitted 2026-08-06 cs.SE

Liyan Huang , Kaicheng Wang , Weihang Wang This is my paper · ORCID
classification cs.SE
keywords WebAssemblyprogramrepairLLMagentsdifferentialtraceanalysisdivergencelocalizationcross-platformcompilationEmscriptenfunctionaldiscrepancy
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper aims to make a hard class of bug automatically repairable: the same C/C++ program runs correctly as a native binary but crashes or produces different output after being compiled to WebAssembly, with the cause buried in the platform runtime rather than in source logic. Its proposal, WasmMend, converts that undirected debugging problem into a focused one by first finding the function where native and Wasm executions stop agreeing, then handing that evidence to LLM agents that analyze, patch, and re-validate. On a benchmark of 34 real-world discrepancies, WasmMend fixes 70.0% of cases when trace evidence is generated with the strongest model, and 66.7% on average across models and repeats, versus 50.2% for an undirected agentic baseline and 54.5% for agents allowed to write their own runtime instrumentation. The paper takes this gap as evidence that the gain comes from divergence-guided reasoning, not from instrumentation or model capability alone. If the result holds, cross-platform repair becomes a localization problem first and a patch-generation problem second.

What carries the argument

The load-bearing mechanism is a cross-execution match over serialized function entry and exit events. WasmMend instruments every function reachable from the failing test, printing each function's input state at entry and output state at every exit, then runs both the native and Wasm builds and aligns the two event streams. Matching allows events to occur in different positions because C argument evaluation order is unspecified, requires identical function names and equivalent states, and normalizes memory addresses and file descriptors before comparison. An unmatched native entry event blames the caller currently at the top of the reconstructed call stack; an unmatched exit event blames the current function. A Suspects list with a witness mechanism preserves the diagnostic even when some instrumentation was conceded or omitted. The final report—the mismatch, the stack, the suspects, and the available I/O states—is the evidence that seeds the two agents: an ANALYZE agent for investigation and a PATCH agent for editing and verification.

What would settle it

Construct a discrepancy in which native and Wasm executions pass through the same functions with identical printed entry/exit states but produce different final output because of an internal branch driven by a value that is not serialized; WasmMend's cross-execution match would find no mismatch and would fail to name the true root-cause function, or would blame a different function. A reader could also compare the function named by the first mismatch against the manually annotated root cause for every case, which the paper already does, and check whether cases with full call-stack recovery always fix at higher rates.

Watch

Extended reading notes

Core claim

WasmMend is presented as the first system to automatically repair Native-Wasm functional discrepancies. Its core discovery is that the initial divergence point between the two executions is a sufficient causal signal for repair: once the first unmatched function event is identified, an LLM agent can reason about the platform-level cause and produce a patch that makes the Wasm build match native behavior without changing native semantics. The repair loop recompiles both builds after each patch and accepts the patch only when both outputs agree. In the evaluation, WasmMend reaches a 70.0% fix rate with Gemini-assisted trace analysis and 66.7% on average, compared to 50.2% for undirected agentic repair and 54.5% when agents are allowed to instrument code on their own during repair. Section 4.2 of the paper states this observation substantiates the central design claim that the gains are primarily driven by differential trace analysis.

Load-bearing premise

The load-bearing assumption is that the first moment where the native and WebAssembly runs stop matching also identifies the buggy function; this breaks if the true divergence hides inside a function without altering the states printed at function entry and exit, or if instrumenting the code changes the execution it is measuring.

Editorial extensions

If this is right

  • Cross-platform repair should be staged as locate-then-repair: undirected exploration or even repair-time instrumentation without localization yields far smaller gains.
  • The quality of the localization evidence directly controls the fix rate: static-only trace evidence dropped the average to 58.8%, while higher-quality LLM-assisted trace evidence raised it to 70.0%.
  • Weaker LLM backends benefit most from divergence evidence, so the approach may reduce the gap between strong and weak repair models.
  • The benchmark result, if it generalizes, makes Native-Wasm discrepancies a tractable target for automated patch generation rather than a manual debugging burden.
  • Failure cases still cluster in two modes—too many plausible patch locations and deep platform semantics—so future work should narrow patch candidate sets and encode Wasm runtime behavior.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Editorial inference: if the localization mechanism is language-agnostic as the paper argues, the same two-stage design should transfer to Rust-to-Wasm and Go-to-Wasm, with only the instrumentation layer needing rework.
  • Editorial inference: a direct test of whether the evidence or the agent loop matters would be to feed the same differential-trace report to a single one-shot repair prompt; if the fix rate stays near 70%, the trace evidence is the dominant factor.
  • Editorial inference: the paper leaves unquantified whether injected instrumentation can itself perturb execution; comparing localization against ground-truth root-cause annotations on a held-out set would reveal how often the first mismatch points at the true function.
  • Editorial inference: if small models gain the most from trace evidence, a cheap production recipe may be a small model plus high-quality divergence localization rather than a frontier model plus free exploration.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 5 minor

Summary. WasmMend targets functional discrepancies between native C/C++ binaries and their WebAssembly (Wasm) counterparts. It first instruments all call-graph-reachable functions, serializes user-defined types, and compares native and Wasm event streams using a stack-based cross-execution match (Algorithms 1-3) to produce a report localizing the first divergent function. A two-agent LLM framework (ANALYZE/PATCH) then reasons from this report and the surrounding context, with patch-execute feedback, to synthesize and validate source patches that restore behavioral equivalence. Evaluated on 34 discrepancies from the WasmChecker benchmark with three LLM backends, WasmMend reports a 66.7% average fix rate over five repeats (70.0% when given Gemini-assisted traces), versus 50.2% for the undirected baseline and 54.5% for repair-time LLM instrumentation, together with token-cost comparisons.

Significance. If the claimed causal mechanism holds, WasmMend is a valuable contribution: it converts a hard, undirected exploration problem into a focused evidence-based repair task, and the reported cost data show that the gains are not purchased at large token expense. The evaluation is more thorough than is typical for this area: it covers three model families, ablates trace quality (static-only versus Gemini-assisted), reports standard errors over five repeats, and uses manually annotated root causes to measure localization quality rather than inferring it from repair outcomes. The main weakness is that the headline comparison does not isolate the differential localization step from the exhaustive automatic instrumentation, so the central design claim is not yet fully supported.

major comments (3)
  1. [§4.2, Table 1; §3.2.1] The central claim that WasmMend's gains are 'primarily driven by differential trace analysis' is not supported by the reported comparison, because WasmMend differs from Repair-Time Instr. in two ways: it automatically instruments every call-graph-reachable function (Section 3.2.1), and it supplies the cross-execution divergence report. The 66.7% versus 54.5% gap could therefore be due to exhaustive automatic instrumentation alone. Table 5 ablates trace quality, but every variant still includes the differential match; no configuration supplies the full instrumented native and Wasm event streams without the first-divergence report and suspects list. Please add a control that removes only the differential localization (for example, a RawTrace configuration that gives the agents the complete unaligned event streams or per-function entry/exit state dumps, without the stack reconstruction, suspects, or divergence report), or otherwise explicitly bound the contribution of the localization step.
  2. [Abstract; §4.4, Table 5] The abstract states that WasmMend 'achieves a fix rate of 70.0%, compared to 50.2% for the agentic baseline and 54.5% for the approach augmented with repair-time LLM-based instrumentation,' but Table 1's main WasmMend average is 66.7%; the 70.0% figure is the WasmMendG variant in Table 5, which uses Gemini-assisted trace analysis. This overstates the headline result. Either revise the abstract to report 66.7% as the primary configuration or clearly attribute 70.0% to the variant with higher-quality traces.
  3. [§3.2.2, Algorithms 1-2, Appendix D.2] The differential trace analysis assumes that the first unmatched native event, after matching entry/exit states with normalized memory addresses and file descriptors, identifies the divergence-origin function. This assumption can fail when the divergence is caused by internal control flow or internal state that is not visible in the serialized entry/exit states, and the paper does not provide a controlled evaluation of this failure mode. Table 4 measures localization on the 34 WasmChecker cases, but it does not bound false-positive or false-negative localization on cases where entry/exit states are equal yet behavior diverges. Please either add synthetic mutation experiments that change internal behavior while keeping serialized entry/exit states identical, or explicitly state this as a limitation with a discussion of its impact on the reported fix rates.
minor comments (5)
  1. [Abstract] The abstract contains a LaTeX artifact: '54.5\%' should read '54.5%'.
  2. [§4.5] The failure categories 'strategy overload' (55.7%) and 'platform complexity' (33.5%) sum to 89.2%; please clarify what the remaining 10.8% of failures are.
  3. [Appendix E.2, Table 6] The standard errors are over five repeats per configuration; because the benchmark contains only 34 discrepancies, the repeats are not independent samples of the benchmark distribution. Please report per-discrepancy confidence intervals or a non-parametric comparison for the key configuration contrasts.
  4. [Appendix B] The appendix states that the codebase 'will be released' at a URL; for reproducibility, the artifact with pinned toolchain and model versions should be made available at review time.
  5. [Figure 3] The figure legend and text refer to line colors; adding distinct markers or line styles would make the results readable in monochrome print.

Circularity Check

0 steps flagged · score 2.0 of 10

No significant circularity; only minor non-load-bearing self-citation of the WasmChecker benchmark.

full rationale

WasmMend's central claim, that differential trace analysis drives its repair gains, is an empirical comparison (Table 1, Section 4.2) measured against actual execution outcomes: a run succeeds only if a patch makes native and Wasm executions consistent (Section 3.1). That success metric is not defined in terms of the trace-analysis output, so the fix rate is an independent measurement. The differential trace analysis itself (Algorithms 1-3) is a concrete matching procedure over instrumented entry/exit events; its quality is then checked against manually annotated root causes (Section 4.4), which are used only as evaluation ground truth and not as fitting inputs to the algorithm. The paper's localization rates (Table 4) and fix-rate improvements (Tables 1 and 5) are therefore not equivalent by construction to the method's inputs. The only self-citation of note is the evaluation benchmark, WasmChecker [2], which shares two of the present authors; however, the benchmark is an external corpus of real-world discrepancies and the paper's results are judged by runnable native/Wasm execution outcomes, so this citation is not load-bearing circularity. A missing RawTrace control is a legitimate internal-validity concern about whether exhaustive instrumentation rather than the divergence report causes the gain, but that is a confound, not a circular derivation: no equation in the paper defines the repair outcome as the trace-localization output.

Assumptions & free parameters 1 free parameters · 5 assumptions · 0 invented entities

The system introduces no new physical or semantic entities. The load-bearing assumptions are engineering and evaluation assumptions: that instrumentation preserves behavior, that the first unmatched event pinpoints the cause, that single-input validation implies repair, and that the 34-case benchmark generalizes. The only free parameter is the iteration budget, which is a hand-chosen experimental cap.

free parameters (1)
  • Maximum agent repair iterations per run = 50
    Chosen after pilot experiments (Appendix E.1). It bounds the number of ANALYZE plus PATCH iterations and directly shapes the fix-rate and cost results reported in Tables 1 and 2.
assumptions (5)
  • domain assumption Native x86/GCC execution is the ground-truth semantic reference for each discrepancy.
    Section 3.1 defines the repair objective as preserving exec(Cn(S),I) while aligning Wasm to it. If GCC native behavior is not the right reference, the whole repair target changes.
  • domain assumption Instrumented source code with added print statements does not alter the execution behavior relevant to the divergence.
    Section 3.2.1 verifies instrumentation consistency with unit tests when available, but this is not guaranteed for all cases, and the LLM-assisted instrumentation explicitly allows concessions that omit state or restore original functions.
  • ad hoc to paper The first unmatched native event after cross-execution matching identifies the divergence-origin function.
    Algorithm 1 halts at the first unmatched native event and reports the function at the top of the reconstructed stack. This presumes that entry/exit state serialization captures every cause and that the equivalence rules in Algorithm 2 are correct.
  • domain assumption A patch accepted on the single test input I preserves general program semantics.
    The validation in Section 3.3 checks consistency on the discrepancy input only: exec(Cn(S),I) ≡ exec(Cn(S⊕P),I) ≡ exec(Cw(S⊕P),I). No full regression suite beyond the failing unit test is reported.
  • domain assumption The 34 WasmChecker discrepancies are representative of Native-Wasm functional discrepancies.
    The paper relies on WasmChecker as the most comprehensive existing benchmark, while Appendix A acknowledges the modest absolute number. Generalizing beyond these cases is untested.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Reasoning from Traces: Divergence-Guided Agentic Repair of WebAssembly Discrepancies." pith.science (2026). https://pith.science/paper/GEPWRK7N

@misc{pith2026260805521,
  author       = {Pith},
  title        = {Pith review of: Reasoning from Traces: Divergence-Guided Agentic Repair of WebAssembly Discrepancies},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/GEPWRK7N}},
  note         = {Machine review of arXiv:2608.05521}
}
read the original abstract

WebAssembly (Wasm) promises seamless reuse of C/C++ codebases as portable, fast, sandboxed binaries. In practice, however, this promise often falls short: recent studies show that cross-compiling the same C/C++ source to Wasm and native binaries frequently leads to runtime discrepancies, owing to library implementation differences or compiler bugs. Since the root causes lie in the platform-level runtime and are hidden beneath the source code, even state-of-the-art LLM-based repair agents often fail to fix these discrepancies. In this paper, we present WasmMend, the first system to automatically repair Native-Wasm functional discrepancies. WasmMend converts the undirected exploration to a focused reasoning task in two stages: First, a novel differential trace analysis approach localizes the function where Wasm and native executions initially diverge; guided by this localization, LLM agents then reason about the root causes and generate patches that eliminate the divergent behavior. Experiments on real-world C/C++ projects show that WasmMend achieves a fix rate of 70.0%, compared to 50.2% for the agentic baseline and 54.5\% for the approach augmented with repair-time LLM-based instrumentation, demonstrating the value of divergence-guided reasoning for cross-platform repair.

Figures

Figures reproduced from arXiv: 2608.05521 by the authors.

Figure 1
Figure 1. Example Native-Wasm discrepancy: Calling [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Architecture of WasmMend behavioral discrepancies. Notably, Baradaran et al. [2] provides a comprehensive study on real-world repositories at scale, exposing the severity of these divergences. Yet, these works stop at detection and characterization. To our knowledge, WasmMend is the first system to automatically patch discrepancies between Wasm and native executions. LLM-based Program Repair. LLMs serve as effective… view at source ↗
Figure 3
Figure 3. Fix rate with respect to inference budget (USD). Across all evaluated LLMs, WasmMend [PITH_FULL_IMAGE:figures/full_fig_p008_3.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Example patch for Figure 1: a ternary guard for the [PITH_FULL_IMAGE:figures/full_fig_p014_4.png]
Figure 5
Figure 5. Figure 5: Example of unspecified behavior: the order of evaluation of function arguments is [PITH_FULL_IMAGE:figures/full_fig_p015_5.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

53 extracted references · 33 canonical work pages

  1. [1]

    Juan Altmayer Pizzorno and Emery D. Berger. Coverup: Effective high coverage test generation for python.Proc. ACM Softw. Eng., 2(FSE), June 2025. doi: 10.1145/3729398. URL https: //doi.org/10.1145/3729398

    doi:10.1145/3729398 2025

  2. [2]

    Reusing legacy code in wasm: Key challenges of compilation and code semantics preservation

    Sara Baradaran, Liyan Huang, Mukund Raghothaman, and Weihang Wang. Reusing legacy code in wasm: Key challenges of compilation and code semantics preservation. In2026 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), pages 181–192, 2026. doi: 10.1109/SANER67736.2026.00029

    work page arXiv 2026

  3. [3]

    Juliet 1.3 test suite: Changes from 1.2, 2018-06-14 2018

    Paul Black. Juliet 1.3 test suite: Changes from 1.2, 2018-06-14 2018. URL https://doi. org/10.6028/NIST.TN.1995

    work page doi:10.6028/nist.tn.1995 2018

  4. [4]

    Repairagent: An autonomous, llm- based agent for program repair

    Islem Bouzenia, Premkumar Devanbu, and Michael Pradel. Repairagent: An autonomous, llm- based agent for program repair. InProceedings of the IEEE/ACM 47th International Conference on Software Engineering, ICSE ’25, page 2188–2200. IEEE Press, 2025. ISBN 9798331505691. doi: 10.1109/ICSE55347.2025.00157. URL https://doi.org/10.1109/ICSE55347.2025. 00157

    arXiv 2025

  5. [5]

    Teaching large language models to self-debug, 2023

    Xinyun Chen, Maxwell Lin, Nathanael Schärli, and Denny Zhou. Teaching large language models to self-debug, 2023. URLhttps://arxiv.org/abs/2304.05128

    arXiv 2023

  6. [6]

    TRIGFUZZ: Triggering Conditions Guided Directed Fuzzing

    Yiyang Chen, Nuoqi Gui, Long Wang, Longfei Chen, Xuanqing Shi, Xi Cao, and Chao Zhang. TRIGFUZZ: Triggering Conditions Guided Directed Fuzzing . In2026 IEEE Symposium on Security and Privacy (SP), pages 4128–4146, Los Alamitos, CA, USA, May 2026. IEEE Computer Society. doi: 10.1109/SP63933.2026.00156. URL https: //doi.ieeecomputersociety.org/10.1109/SP639...

    arXiv 2026

  7. [7]

    Deepseek-v4: Towards highly efficient million-token context intelligence,

    DeepSeek-AI. Deepseek-v4: Towards highly efficient million-token context intelligence,

  8. [8]

    fmt: A modern formatting library, 2025

    fmt Team. fmt: A modern formatting library, 2025. URLhttps://github.com/fmtlib/fmt

    work page 2025

Show all 53 references
  1. [9]

    Gemini 3 flash model card

    Google DeepMind. Gemini 3 flash model card. https://storage.googleapis.com/ deepmind-media/Model-Cards/Gemini-3-Flash-Model-Card.pdf, December 2025

    2025

  2. [10]

    Schuff, Ben L

    Andreas Haas, Andreas Rossberg, Derek L. Schuff, Ben L. Titzer, Michael Holman, Dan Gohman, Luke Wagner, Alon Zakai, and JF Bastien. Bringing the web up to speed with webassembly.SIGPLAN Not., 52(6):185–200, June 2017. ISSN 0362-1340. doi: 10.1145/ 3140587.3062363. URLhttps://...

    2017

  3. [11]

    An empirical study of real-world webassembly binaries: Security, languages, use cases

    Aaron Hilbig, Daniel Lehmann, and Michael Pradel. An empirical study of real-world webassembly binaries: Security, languages, use cases. InProceedings of the Web Con- ference 2021, WWW ’21, page 2696–2708, New York, NY , USA, 2021. Association for Computing Machinery. ISBN 978...

    2021

  4. [12]

    TypeError: Cannot read properties of null (reading ’length’)

    hly2019. “TypeError: Cannot read properties of null (reading ’length’)” with pipe + dup&dup2. GitHub issue #22030, emscripten-core/emscripten, 2024. URL https://github.com/ emscripten-core/emscripten/issues/22030

    2024

  5. [13]

    Mohammed Nurul Hoque and Khaled A. Harras. Webassembly for edge computing: Potential and challenges.IEEE Communications Standards Magazine, 6(4):68–73, 2022. doi: 10.1109/ MCOMSTD.0001.2000068

    2022

  6. [14]

    Tracecoder: A trace-driven multi-agent framework for automated debugging of llm-generated code.arXiv preprint arXiv:2602.06875, 2026

    Jiangping Huang, Wenguang Ye, Weisong Sun, Jian Zhang, Mingyue Zhang, and Yang Liu. Tracecoder: A trace-driven multi-agent framework for automated debugging of llm-generated code.arXiv preprint arXiv:2602.06875, 2026. URL https://arxiv.org/abs/2602.06875

    2026

  7. [15]

    Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan

    Carlos E. Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan. Swe-bench: Can language models resolve real-world github issues?, 2024. URLhttps://arxiv.org/abs/2310.06770. 10

    2024 arXiv

  8. [16]

    René Just, Darioush Jalali, and Michael D. Ernst. Defects4j: a database of existing faults to enable controlled testing studies for java programs. InProceedings of the 2014 International Symposium on Software Testing and Analysis, ISSTA 2014, page 437–440, New York, NY , USA,

    2014

  9. [18]

    Kalign: An accurate and fast multiple sequence alignment algorithm.BMC bioinformatics, 6:298, 02 2005

    Timo Lassmann and Erik Sonnhammer. Kalign: An accurate and fast multiple sequence alignment algorithm.BMC bioinformatics, 6:298, 02 2005. doi: 10.1186/1471-2105-6-298

    2005 doi

  10. [19]

    Cheerp: A C/C++ compiler for WebAssembly and JavaScript

    Leaning Technologies. Cheerp: A C/C++ compiler for WebAssembly and JavaScript. https: //cheerp.io/, 2026

    2026

  11. [20]

    Lahiri, and Siddhartha Sen

    Caroline Lemieux, Jeevana Priya Inala, Shuvendu K. Lahiri, and Siddhartha Sen. Codamosa: Escaping coverage plateaus in test generation with pre-trained large language models. In2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE), pages 919–931,

  12. [21]

    Bringing webassembly to resource- constrained iot devices for seamless device-cloud integration

    Borui Li, Hongchang Fan, Yi Gao, and Wei Dong. Bringing webassembly to resource- constrained iot devices for seamless device-cloud integration. InProceedings of the 20th Annual International Conference on Mobile Systems, Applications and Services, MobiSys ’22, page 261–272, Ne...

    2022

  13. [22]

    Hybrid automated program repair by combining large language models and program analysis.ACM Trans

    Fengjie Li, Jiajun Jiang, Jiajun Sun, and Hongyu Zhang. Hybrid automated program repair by combining large language models and program analysis.ACM Trans. Softw. Eng. Methodol., 34(7), August 2025. ISSN 1049-331X. doi: 10.1145/3715004. URL https://doi.org/10. 1145/3715004

    2025 doi

  14. [23]

    Quixbugs: a multi- lingual program repair benchmark set based on the quixey challenge

    Derrick Lin, James Koppel, Angela Chen, and Armando Solar-Lezama. Quixbugs: a multi- lingual program repair benchmark set based on the quixey challenge. InProceedings Companion of the 2017 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Application...

    2017

  15. [24]

    Is your code generated by chatgpt really correct? rigorous evaluation of large language models for code generation, 2023

    Jiawei Liu, Chunqiu Steven Xia, Yuyao Wang, and Lingming Zhang. Is your code generated by chatgpt really correct? rigorous evaluation of large language models for code generation, 2023. URLhttps://arxiv.org/abs/2305.01210

    2023 arXiv

  16. [25]

    Chandra Maddila, Adam Tait, Claire Chang, Daniel Cheng, Nauman Ahmad, Vijayaraghavan Murali, Marshall Roch, Arnaud Avondet, Aaron Meltzer, Victor Montalvao, Michael Hopko, Chris Waterson, Parth Thakkar, Renuka Fernandez, Kristian Kristensen, Sivan Barzily, Sherry Chen, Rui Abr...

    2025 arXiv

  17. [26]

    Evaluating webassembly enabled serverless approach for edge computing

    Pankaj Mendki. Evaluating webassembly enabled serverless approach for edge computing. In 2020 IEEE Cloud Summit, pages 161–166, 2020. doi: 10.1109/IEEECloudSummit48914.2020. 00031

    2020

  18. [27]

    Nguyen, Phong X

    Huy Nhat Phan, Tien N. Nguyen, Phong X. Nguyen, and Nghi D. Q. Bui. Hyperagent: Generalist software engineering agents to solve coding tasks at scale, 2025. URL https: //arxiv.org/abs/2409.16299. 11

    2025 arXiv

  19. [28]

    Qwen3.5: Towards native multimodal agents, February 2026

    QwenTeam. Qwen3.5: Towards native multimodal agents, February 2026. URL https: //qwen.ai/blog?id=qwen3.5

    2026

  20. [29]

    An overview of webassembly for iot: Background, tools, state-of-the- art, challenges, and future directions.Future Internet, 15(8), 2023

    Partha Pratim Ray. An overview of webassembly for iot: Background, tools, state-of-the- art, challenges, and future directions.Future Internet, 15(8), 2023. ISSN 1999-5903. doi: 10.3390/fi15080275. URLhttps://www.mdpi.com/1999-5903/15/8/275

    2023 doi

  21. [31]

    An empirical evaluation of using large language models for automated unit test generation.IEEE Transactions on Software Engineering, 50(1):85–105, 2024

    Max Schäfer, Sarah Nadi, Aryaz Eghbali, and Frank Tip. An empirical evaluation of using large language models for automated unit test generation.IEEE Transactions on Software Engineering, 50(1):85–105, 2024. doi: 10.1109/TSE.2023.3334955

    2024

  22. [32]

    Security risks of porting c programs to webassembly

    Quentin Stiévenart, Coen De Roover, and Mohammad Ghafari. Security risks of porting c programs to webassembly. InProceedings of the 37th ACM/SIGAPP Symposium on Applied Computing, SAC ’22, page 1713–1722, New York, NY , USA, 2022. Association for Computing Machinery. ISBN 9781...

    2022

  23. [33]

    The security risk of lacking compiler protection in webassembly

    Quentin Stiévenart, Coen De Roover, and Mohammad Ghafari. The security risk of lacking compiler protection in webassembly. In2021 IEEE 21st International Conference on Software Quality, Reliability and Security (QRS), pages 132–139, 2021. doi: 10.1109/QRS54544.2021. 00024

    2021

  24. [34]

    Magis: Llm-based multi-agent framework for github issue resolution

    Wei Tao, Yucheng Zhou, Yanlin Wang, Wenqiang Zhang, Hongyu Zhang, and Yu Cheng. Magis: Llm-based multi-agent framework for github issue resolution. InProceedings of the 38th International Conference on Neural Information Processing Systems, NIPS ’24, Red Hook, NY , USA, 2024. ...

    2024

  25. [35]

    Emscripten: a complete open source LLVM-based compiler toolchain for WebAssembly, 2010

    Emscripten Team. Emscripten: a complete open source LLVM-based compiler toolchain for WebAssembly, 2010. URLhttps://emscripten.org

    2010

  26. [36]

    PEGTL: Parsing expression grammar template library

    PEGTL Team. PEGTL: Parsing expression grammar template library. https://github.com/ taocpp/PEGTL, 2024

    2024

  27. [37]

    Empowering web applications with webassembly: Are we there yet? In2021 36th IEEE/ACM International Conference on Automated Software Engineering (ASE), pages 1301–1305, 2021

    Weihang Wang. Empowering web applications with webassembly: Are we there yet? In2021 36th IEEE/ACM International Conference on Automated Software Engineering (ASE), pages 1301–1305, 2021. doi: 10.1109/ASE51524.2021.9678831

    2021

  28. [38]

    Introduction to WebAssembly

    WebAssembly Community Group. Introduction to WebAssembly. https://webassembly. github.io/spec/core/intro/introduction.html, 2026

    2026

  29. [39]

    Webassembly browser support

    WebAssembly Community Group. Webassembly browser support. https://webassembly. org/features/, 2026

    2026

  30. [40]

    Wasmachine: Bring iot up to speed with a webassembly os

    Elliott Wen and Gerald Weber. Wasmachine: Bring iot up to speed with a webassembly os. In 2020 IEEE International Conference on Pervasive Computing and Communications Workshops (PerCom Workshops), pages 1–4, 2020. doi: 10.1109/PerComWorkshops48775.2020.9156135

    2020

  31. [41]

    Runtime execution traces guided automated program repair with multi-agent debate, 2026

    Jiaqing Wu, Tong Wu, Manqing Zhang, Yunwei Dong, and Bo Shen. Runtime execution traces guided automated program repair with multi-agent debate, 2026. URL https://arxiv.org/ abs/2604.02647

    2026 arXiv

  32. [42]

    Debugrepair: Enhancing llm-based automated program repair via self-directed debugging, 2026

    Linhao Wu, Yifei Pei, Zhen Yang, Kainan Li, Zhonghang Lu, Hao Tan, Xiran Lyu, Jia Li, Yizhou Chen, Pengyu Xue, Kunwu Zheng, and Dan Hao. Debugrepair: Enhancing llm-based automated program repair via self-directed debugging, 2026. URLhttps://arxiv.org/abs/ 2604.19305

    2026 arXiv

  33. [43]

    Broken promise: Differential analysis of functional discrepancies between webassembly and native binaries

    Xiao Wu, Alan Romano, Liyan Huang, Qiwen Yan, Cai Fu, and Weihang Wang. Broken promise: Differential analysis of functional discrepancies between webassembly and native binaries. InProceedings of the ACM Web Conference 2026, WWW ’26, page 5144–5154, New York, NY , USA, 2026. A...

    2026

  34. [45]

    The plastic surgery hypothesis in the era of large language models

    Chunqiu Steven Xia, Yifeng Ding, and Lingming Zhang. The plastic surgery hypothesis in the era of large language models. In2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE), pages 522–534, 2023. doi: 10.1109/ASE56229.2023.00047

    2023

  35. [46]

    Fuzz4all: Universal fuzzing with large language models

    Chunqiu Steven Xia, Matteo Paltenghi, Jia Le Tian, Michael Pradel, and Lingming Zhang. Fuzz4all: Universal fuzzing with large language models. In2024 IEEE/ACM 46th International Conference on Software Engineering (ICSE), pages 1547–1559, 2024

    2024

  36. [47]

    Demystifying llm-based software engineering agents.Proc

    Chunqiu Steven Xia, Yinlin Deng, Soren Dunn, and Lingming Zhang. Demystifying llm-based software engineering agents.Proc. ACM Softw. Eng., 2(FSE), June 2025. doi: 10.1145/3715754. URLhttps://doi.org/10.1145/3715754

    2025 doi

  37. [48]

    Understanding the performance of webassembly applications

    Yutian Yan, Tengfei Tu, Lijian Zhao, Yuchen Zhou, and Weihang Wang. Understanding the performance of webassembly applications. InProceedings of the 21st ACM Internet Measurement Conference, IMC ’21, page 533–549, New York, NY , USA, 2021. Association for Computing Machinery. I...

    2021

  38. [49]

    Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press

    John Yang, Carlos E. Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press. Swe-agent: agent-computer interfaces enable automated software engineering. InProceedings of the 38th International Conference on Neural Information Processing System...

    2024

  39. [50]

    Yang, Chang Hu, Yanlin Wang, Tao Zhang, and Claire Le Goues

    He Ye, Aidan Z.H. Yang, Chang Hu, Yanlin Wang, Tao Zhang, and Claire Le Goues. Adverintent- agent: Adversarial reasoning for repair based on inferred program intent.Proc. ACM Softw. Eng., 2(ISSTA), June 2025. doi: 10.1145/3728939. URLhttps://doi.org/10.1145/3728939

    2025 doi

  40. [52]

    Low-Cost and comprehen- sive non-textual input fuzzing with LLM-Synthesized input generators

    Kunpeng Zhang, Zongjie Li, Daoyuan Wu, Shuai Wang, and Xin Xia. Low-Cost and comprehen- sive non-textual input fuzzing with LLM-Synthesized input generators. In34th USENIX Security Symposium (USENIX Security 25), pages 6999–7018, Seattle, WA, August 2025. USENIX Association. I...

    2025

  41. [53]

    A systematic literature review on large language models for automated program repair

    Quanjun Zhang, Chunrong Fang, Yang Xie, Yuxiang Ma, Weisong Sun, Yun Yang, and Zhenyu Chen. A systematic literature review on large language models for automated program repair. ACM Trans. Softw. Eng. Methodol., March 2026. ISSN 1049-331X. doi: 10.1145/3799693. URLhttps://doi....

    2026 doi

  42. [54]

    / e m p t y _ f i l e

    Yuntong Zhang, Haifeng Ruan, Zhiyu Fan, and Abhik Roychoudhury. Autocoderover: Autonomous program improvement. InProceedings of the 33rd ACM SIGSOFT Interna- tional Symposium on Software Testing and Analysis, ISSTA 2024, page 1592–1604, New York, NY , USA, 2024. Association fo...

    2024

  43. [2014]

    ISBN 9781450326452

    Association for Computing Machinery. ISBN 9781450326452. doi: 10.1145/2610384. 2628055. URLhttps://doi.org/10.1145/2610384.2628055

  44. [2023]

    doi: 10.1109/ICSE48619.2023.00085

    2023

  45. [2026]

    URL https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro/blob/main/ DeepSeek_V4.pdf

Pith tools

Reviewed August 8, 2026 · model on record in the stance chip above.