WorksComputer Science
Software Engineering for AI-Driven Science
Abstract
AI has made significant contributions to scientific discovery. Autonomous agents can now independently analyse complex problems, design experiments, write and execute code, analyse findings, and derive scientific conclusions. Nevertheless, errors in AI-generated code, experimental procedures, or evidence interpretation can lead to invalid research conclusions, undermining the reliability and reproducibility of automated scientific discovery. In this vision paper, we propose Software Engineering for AI-Driven Science (SE4AI4Sci) as an emerging research area for addressing this challenge. As an organising framework, we introduce the Scientific Assurance Chain, connecting intent, experimental design, implementation, execution, evidence, and claim. Through six documented failures in recent AI-for-science systems, we show where this chain can break, where existing assurance mechanisms fall short, and what new research challenges follow. We also outline a research agenda for adapting and extending software engineering techniques across the chain.
Introduction
AI has already made significant contributions to science [26], but autonomous agents are beginning to change not only the tools scientists use, but the way science itself is conducted. Recent agentic systems can generate hypotheses, search the literature, write and execute experimental code, analyse results, and produce scientific reports with limited human intervention. The AI Scientist demonstrates an end-to-end pipeline from research ideation to paper writing [3], while systems such as Robin connect automated hypothesis generation and data analysis to experimental biology [1]. In many of these systems, code is the mechanism through which scientific decisions become actions: agents use it to manipulate data, invoke tools, run experiments, and analyse results.
AI-driven science therefore changes the role of software. Rather than only implementing a scientific procedure defined by a human, autonomous agents can help choose methods, generate hypotheses, modify workflows, and interpret the evidence they produce [11]. Scientific AI agents are consequently not only AI systems but software systems in their own right: their decisions are realised in code and workflows that can be specified, tested, monitored, and traced. As they participate in more of the scientific process, assurance must also cover the scientific decisions made through that software.
Early results show why this matters. AutoMat [2] shows that coding agents can reproduce plausible numerical results despite methodological deviations from the intended scientific procedure, while other work has already begun to introduce explicit safeguards for autonomous scientific agents [17]. These are not simply failures of scientific reasoning. They expose problems of requirements engineering, software testing, runtime assurance, provenance, and traceability that are familiar to software engineering, but arise in a new setting where autonomous software can itself change the scientific process.
The vital intersection of software engineering and AI-driven science is also reflected in Terminal-Bench [30, 29] and Terminal-Bench-Science [27]. They are widely prioritised by frontier LLM labs [31, 32, 33, 34, 35] and tracked by major evaluation platforms like Artificial Analysis [28].
The underlying problem is straightforward: errors in AI-generated code, experimental procedures, or evidence interpretation can lead to invalid research conclusions. Moreover, the stakes extend beyond any one workflow. Scientific results become evidence in papers, inputs to later models and experiments, and sometimes the basis for decisions in medicine, engineering, policy, and practice. A silent error can therefore propagate well beyond the workflow in which it first occurred.
Software engineering provides established techniques for addressing this problem, including requirements and specification [13, 16], testing and verification [15], static program analysis [36, 37], fault localisation and automated program repair (APR) [38, 39]. These techniques provide strong foundations for scientific reliability, but cannot simply be applied unchanged. The central challenge lies in adapting and extending software engineering techniques to cover the adaptive, self-directed AI-driven discovery process.
In this vision paper, we propose Software Engineering for AI-Driven Science (SE4AI4Sci) as a new research area for the software engineering community. Our vision is:
Figure 1. The Scientific Assurance Chain and supporting software-engineering mechanisms.
In particular:
We introduce the Scientific Assurance Chain—spanning intent, experimental design, implementation, execution, evidence, and claim—as a principled framework for identifying assurance requirements and transition obligations, and mapping them to software-engineering techniques (Figure 1).
We ground the proposed research area in six documented failures across the chain, showing where existing assurance mechanisms can fall short and deriving stage-specific research challenges.
We present a research agenda for adapting and extending software-engineering techniques to preserve scientific intent and method constraints, test unknown answers, assure autonomous decisions, trace evidence to claims, and evaluate progress across the chain.
Existing Foundations
The SE community has long studied scientific software, including development practices and evolving requirements [5], testing challenges such as the oracle problem [6], and metamorphic testing [15]. Recent work applies metamorphic and differential testing to bioinformatics tools [24] and uses model checking and domain expertise to refine metamorphic relations for scientific software [25]. The Software Engineering for Science (SE4Science) workshop series provides a dedicated forum for this work [4]. SE4AI4Sci builds on these foundations, and offers more opportunities for software engineering to contribute to science discovery.
The Scientific Assurance Chain
To structure assurance in AI-driven science, we model the path from a scientific question to a scientific claim as a sequence of transformations. This is not intended as another software lifecycle model, but as a view of how scientific intent is transformed through software into executable artefacts, evidence, and ultimately claims, making the full path an SE assurance problem. Intent is operationalised into an experimental design; its computational components are realised in software; the experiment is carried out in a concrete setting; execution produces evidence; and that evidence is interpreted as a scientific claim. These transformations motivate the six assurance stages shown in Figure 1.
Intent captures the scientific question and assumptions; experimental design specifies methods, baselines, subjects or datasets, controls, metrics, and analysis procedures, including any computational workflow; implementation realises the computational components of that design in software; execution carries out the experiment, potentially combining computation, physical experiments, and human-participant studies; evidence captures the resulting observations; and claim interprets those observations scientifically. Software may coordinate execution without automating every step. The abstraction is intentionally domain-general, but the stages are distinct because each represents a different artefact or decision boundary with different properties to assure.
The links between stages are equally important. Each transition creates an assurance obligation: relevant intent, assumptions, constraints, and provenance should be preserved as one representation of the science is transformed into the next. For example, an IntentExperimental Design obligation might require a stated control to remain present in the resulting procedure. Local correctness at one stage therefore does not imply correctness of the scientific process as a whole.
Figure 1 illustrates complementary SE mechanisms: requirements engineering captures intent and method constraints; testing and verification check implementations and executions; traceability and computational reproducibility connect results and claims to recorded artefacts. These mechanisms span stages and transitions as agents revise methods and code; connections indicate primary application areas. Failed checks motivate fault localisation; APR proposes candidate code fixes requiring re-testing and revalidation before reintegration.
Traceability and computational reproducibility can record and reproduce how scientific artefacts are connected, but do not by themselves establish whether scientific validity is preserved across those transformations.
Where the Assurance Chain Breaks
The assurance problems captured by the Scientific Assurance Chain are not hypothetical. Existing software-engineering techniques provide important starting points, but often assume relatively stable requirements, implementations, or execution boundaries. AI-driven science changes these assumptions: autonomous agents can choose methods, modify workflows and code, act on intermediate results, and interpret the evidence they produce. Assurance must therefore extend beyond checking individual artefacts to preserving scientific intent and constraints across decisions and transformations.
Recent systems provide documented failures at every stage. Some are loud, such as crashes or uncontrolled execution; others are silent, where the workflow completes successfully while the procedure, evidence, or claim is wrong. Rather than attempt a broad analysis across an ill-defined population of AI-driven scientific systems, we focus on six illustrative cases spanning the chain. Our aim is not to estimate prevalence, but to ground SE4AI4Sci in observed failures: each case shows where existing checks can fall short and motivates a distinct assurance challenge for AI-driven science.
Intent – Answering the Wrong Scientific Question
Google’s AI co-scientist generated hypotheses that were scientifically plausible but did not always address the question originally posed [11]. The failure is one of intent preservation: evaluating hypothesis quality is not enough if the agent has drifted from the original scientific objective. Requirements engineering and requirements-to-artefact traceability must therefore capture not only what the system should do, but which scientific questions, assumptions, and scope should remain stable as the agent explores.
Open question (Intent): How can requirements engineering represent scientific questions, assumptions, and scope so that later decisions remain aligned with the original intent?
Experimental Design – The Right Number from the Wrong Procedure
AutoMat reproduced a target accuracy of approximately , but used a different evaluation subset and methodological procedure from the intended experiment [2]. The output looked correct, so result-based checking could not expose that the experimental design itself had drifted. The assurance challenge is therefore method conformance: specifications, contracts, and provenance must make procedural deviations detectable even when the final result appears plausible. SE techniques must encode dataset selection and experimental controls as checkable constraints, rather than validate only the final output.
Open question (Experimental Design): How can experimental designs be specified and checked so that an agent cannot reproduce the right result using the wrong procedure?
Implementation – Reconstructing the Wrong Experiment
EXP-Bench reports reconstructed experiments that preserve the broad scientific goal but introduce invalid operations into the implementation [10]. Here the experimental design may be appropriate, yet its software realisation is not faithful. Code plausibility or local correctness is therefore insufficient unless testing and verification remain connected to the scientific method the code is intended to realise. Fault localisation and APR must then use these scientific constraints to guide diagnosis and revalidation of code fixes.
Open question (Implementation): How can we verify that generated scientific software faithfully implements the intended experimental method?
Execution – Escaping the Experimental Boundary
The AI Scientist reports agents relaunching scripts, modifying timeout controls, and consuming excessive storage [7]. The failure lies at the boundary between experimental autonomy and control over the environment in which the experiment runs. Checks inside the workflow are insufficient when the agent can modify the constraints themselves, motivating external enforcement through sandboxing, capability restrictions, resource policies, and runtime monitoring. This calls for runtime verification of agent actions against constraints enforced outside the agent’s control.
Open question (Execution): How should scientific software environments support computational, physical, and human-participant experiments while constraining agents?
Evidence – Extracting the Wrong Data
Dilan-Pantojas et al. show substantial errors when multimodal systems extract quantitative evidence from scientific figures [8]. Once an incorrect value becomes structured data, downstream software may process it and conventional execution checks see nothing wrong. Assurance must therefore preserve provenance, uncertainty, and validation as evidence is extracted and transformed, rather than treating every machine-readable value as equally trustworthy. Data-pipeline testing and contracts can check units, ranges, and transformation properties, while traceability links extracted values to their sources.
Open question (Evidence): How can provenance, uncertainty, and validation be preserved as scientific evidence is extracted, transformed, and reused?
Claim – When the Explanation Contradicts the Evidence
A recent particle-physics study found agents giving explanations that contradicted their own numerical results despite obtaining plausible experimental outputs [9]. Nothing need be wrong with the execution or evidence; the failure occurs when that evidence is turned into a scientific claim. Conventional code tests do not directly check this relation; SE traceability and consistency checking must extend to generated reports, linking claims to supporting results and flagging contradictions or unsupported generalisations.
Open question (Claim): How can scientific claims be traced back to the evidence that supports them, and automatically checked for contradiction or unsupported generalisation?
A Research Agenda for Software Engineering
The failures above point to assurance problems that become more difficult when autonomous agents participate in the scientific process. Existing software-engineering techniques provide strong foundations, but they were not designed for systems that can choose methods, modify workflows, act on intermediate results, and interpret their own evidence. The six stage-specific questions therefore motivate five broader research directions. Intent and Experimental Design together motivate preserving scientific intent and method constraints; Implementation motivates testing science when the correct answer is unknown; Execution motivates assuring autonomous scientific decisions; and Evidence and Claim together motivate tracing evidence into claims. A fifth, cross-cutting direction—benchmarking scientific assurance—provides a common basis for evaluating progress across all six stages.
Preserving Scientific Intent
Autonomous agents can change hypotheses, methods, datasets, and intermediate decisions as a study evolves, making scientific requirements less fixed than conventional software requirements. Requirements engineering, contracts, and traceability therefore need to capture which scientific assumptions and methodological constraints must remain invariant, while still allowing legitimate exploration. Work on hypothesis formalisation provides an initial foundation [18]. Progress should be measured by whether agents can adapt workflows without silently drifting from the scientific question or violating methodological constraints.
Testing Unknown Answers
Scientific discovery presents a fundamental oracle problem: the correct result is often precisely what the experiment is trying to discover. Property-based and metamorphic testing provide promising starting points [19], but applying them to scientific software can require substantial domain knowledge and make it difficult to distinguish software faults from problems in the data or method [24]. Recent work has begun to adapt SE techniques to help derive scientifically meaningful metamorphic relations [25]. The challenge is to make such properties explicit and checkable as autonomous workflows evolve. Progress can be assessed by whether they detect invalid procedures without requiring the final scientific answer in advance.
Assuring Autonomous Decisions
AI-driven science gives software a new role: agents may choose tools, revise workflows, modify code, and react to experimental results without a human approving every step. This makes assurance a runtime problem as well as a design-time one. Scientific infrastructure should therefore expose machine-readable constraints, observable actions, structured errors, resource policies, and provenance-aware interfaces, building on emerging agent interfaces and safeguards [17, 21]. It must also enable experiments beyond scripts through interfaces to laboratory instruments and human-participant protocols, with support for consent, protocol enforcement, and human oversight. Progress should be measured by whether agents retain useful autonomy while unsafe, irreproducible, or scientifically invalid actions are prevented or surfaced.
Tracing Evidence to Claims
When autonomous agents also interpret results, provenance must extend beyond data and execution to the scientific claims produced from them. Existing provenance and traceability techniques provide important foundations [20, 14], but do not yet provide end-to-end links between assumptions, transformations, evidence, and conclusions. New mechanisms should make claims inspectably dependent on the evidence that supports them, so contradictions, uncertainty, or later changes can propagate through the chain. Progress can be assessed by whether unsupported or inconsistent claims can be detected and traced back to the decisions that produced them.
Benchmarking Scientific Assurance
These challenges require evaluation beyond successful execution or correct final answers, both of which can hide failures elsewhere in the chain. Recent benchmarks are beginning to evaluate scientific verification and integrity directly [22, 23]. A cross-cutting benchmark should instead localise where assurance fails, including cases where an agent reaches the right answer through an invalid process. Such benchmarks would provide common targets for measuring progress and comparing new assurance techniques across the Scientific Assurance Chain.
Future Plans
A first priority for SE4AI4Sci is to build a deeper empirical understanding of how AI-driven scientific workflows fail when autonomous agents participate in scientific decision-making. We plan to broaden the analysis beyond the illustrative cases in this paper, covering different scientific disciplines and working with domain researchers to distinguish generic software-engineering failures from those that depend on scientific knowledge. The resulting failure taxonomy will localise failures by stage or transition, distinguish loud from silent failures, and capture how difficult they are to detect.
This taxonomy will provide the basis for a benchmark of scientific assurance failures: reproducible cases in which different parts of the Scientific Assurance Chain can break. Rather than measuring only whether an agent reaches the expected answer, the benchmark will expose where assurance failed and whether that failure can be detected. The result will be shared infrastructure for comparing systems and assurance techniques across scientific domains.
Using this benchmark, we will develop and evaluate techniques for preserving scientific intent and method constraints, testing unknown answers, assuring autonomous decisions, and tracing evidence to claims. We will measure whether these mechanisms prevent failures, detect them, or surface them earlier for human review. Together, the taxonomy, benchmark, and evaluated techniques will provide an empirical foundation on which others can develop and compare new SE4AI4Sci approaches. This programme should be developed with scientists: software engineering can provide the assurance mechanisms, while domain experts define the scientific properties they must preserve. We will also explore agent-assisted replication by reusing validated study artefacts and applying SE traceability and conformance checking to controlled variations in subjects and settings that assess generalisation.
Building the SE4AI4Sci Community
We have created and commit to maintaining awesome-se4ai4sci,1 a curated repository of work relevant to SE4AI4Sci. We seeded it from this paper’s references, database searches, snowballing [12], and existing curated lists, screening candidates against documented inclusion criteria. Organised around the six stages of the Scientific Assurance Chain, the repository separates documented failures from SE4AI4Sci work and includes related agents, benchmarks, and foundations. We intend it to lower the barrier to entering the area, expose gaps, and support a future systematic survey and taxonomy.
Conclusion
We introduced SE4AI4Sci as a research area for assuring scientific processes in which autonomous software participates in scientific decision-making, and the Scientific Assurance Chain as a framework for structuring where that assurance can fail. Through six documented cases, we grounded the problem in observed failures and identified directions for adapting and extending software-engineering techniques across the chain. We invite the software-engineering community to help develop SE4AI4Sci through new methods, benchmarks, and empirical studies. AI-driven science expands the software-engineering assurance boundary: when software helps produce scientific knowledge, correct execution is necessary, but trustworthy claims require much more.
References
- [1]Ghareeb, A. E., Chang, B., Mitchener, L., et al. (2026). A Multi-Agent System for Automating Scientific Discovery. Nature, 655(8122), 497–505. https://doi.org/10.1038/s41586-026-10652-y
- [2]Huang, Z., Cao, Y., Shargh, A. K., et al. (2026). Can Coding Agents Reproduce Findings in Computational Materials Science?. Conference on Language Modeling (COLM).
- [3]Lu, C., Lu, C., Lange, R. T., Yamada, Y., Hu, S., Foerster, J., Ha, D., & Clune, J. (2026). Towards End-to-End Automation of AI Research. Nature, 651(8107), 914–919. https://doi.org/10.1038/s41586-026-10265-5
- [4]SE4Science. (n.d.). Software Engineering for Science Workshop Series. In https://se4science.org/workshops/. Retrieved https://se4science.org/workshops/se4science.org/workshops
- [5]Segal, J. (2005). When Software Engineers Met Research Scientists: A Case Study. Empirical Software Engineering, 10(4), 517–536. https://doi.org/10.1007/s10664-005-3865-y
- [6]Kanewala, U., & Bieman, J. M. (2014). Testing Scientific Software: A Systematic Literature Review. Information and Software Technology, 56(10), 1219–1232. https://doi.org/10.1016/j.infsof.2014.05.006
- [7]Sakana AI. (2024). The AI Scientist: Towards Fully Automated Open-Ended Scientific Discovery. In https://sakana.ai/ai-scientist/. https://sakana.ai/ai-scientist/sakana.ai/ai-scientist
- [8]Dilan-Pantojas, I. O., Duong, P. T., Lopes, K., & Boyce, R. D. (2026). Assessing Multimodal AI for Visual Information Extraction of Pharmacology. AMIA Joint Summits on Translational Science proceedings. AMIA Joint Summits on Translational Science, 2026, 353–362.
- [9]Eulig, S. Y. (2026). Position: Correct Answer, Wrong Mechanism --- When AI Scientists Defend General Claims Their Own Data Contradicts. ICML 2026 Workshop on AI Scientists: Tools, Co-Authors, or Founders?.
- [10]Kon, P. T. J., Ding, Q., Liu, J., et al. (2026). EXP-Bench: Can AI Conduct AI Research Experiments?. International Conference on Learning Representations.
- [11]Penadés, J. R., Gottweis, J., He, L., et al. (2025). AI Mirrors Experimental Science to Uncover a Mechanism of Gene Transfer Crucial to Bacterial Evolution. Cell, 188(23), 6654–6665.e2. https://doi.org/10.1016/j.cell.2025.08.018
- [12]Wohlin, C. (2014). Guidelines for Snowballing in Systematic Literature Studies and a Replication in Software Engineering. Proceedings of the 18th International Conference on Evaluation and Assessment in Software Engineering. https://doi.org/10.1145/2601248.2601268
- [13]Bajraktari, A., Binder, M., & Vogelsang, A. (2024). Requirements Engineering for Research Software: A Vision. 2024 IEEE 32nd International Requirements Engineering Conference (RE), 423–431. https://doi.org/10.1109/RE59067.2024.00050
- [14]Baumgärtner, T., & Gurevych, I. (2026). SciCoQA: Quality Assurance for Scientific Paper--Code Alignment. Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 38740–38770. https://doi.org/10.18653/v1/2026.acl-long.1795
- [15]Kanewala, U., & Chen, T. Y. (2019). Metamorphic Testing: A Simple Yet Effective Approach for Testing Scientific Software. Computing in Science & Engineering, 21(1), 66–72. https://doi.org/10.1109/MCSE.2018.2875368
- [16]Vu, A. D., & Kehrer, T. (2024). Towards Generating Contracts for Scientific Data Analysis Workflows. 2024 IEEE International Conference on High Performance Computing, Data, and Analytics Workshops (SC Workshops), 2048–2055. https://doi.org/10.1109/SCW63240.2024.00256
- [17]Zhu, K., Zhang, J., Qi, Z., Shang, N., Liu, Z., Han, P., Su, Y., Yu, H., & You, J. (2025). SafeScientist: Enhancing AI Scientist Safety for Risk-Aware Scientific Discovery. Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, 2289–2317. https://doi.org/10.18653/v1/2025.emnlp-main.116
- [18]Jun, E., Birchfield, M., de Moura, N., Heer, J., & Just, R. (2022). Hypothesis Formalization: Empirical Findings, Software Limitations, and Design Implications. ACM Transactions on Computer-Human Interaction, 29(1), 1–28. https://doi.org/10.1145/3476980
- [19]Jing, L., Wang, X., Zhang, L., & Du, S. S. (2026). PBT-Bench: Benchmarking AI Agents on Property-Based Testing. Advances in Neural Information Processing Systems. https://arxiv.org/abs/2605.15229
- [20]Souza, R., Gueroudji, A., DeWitt, S., Rosendo, D., Ghosal, T., Ross, R., Balaprakash, P., & Da Silva, R. F. (2025). PROV-AGENT: Unified Provenance for Tracking AI Agent Interactions in Agentic Workflows. 2025 IEEE International Conference on eScience (eScience), 467–473. https://doi.org/10.1109/eScience65000.2025.00093
- [21]Hu, Q., Zhu, Q., Zhang, H., Liu, T., & Liu, S. (2026). Coala: A Standard-Based Framework for Converting CWL-Described Command-Line Tools into Agentic Toolsets. Bioinformatics, 42(9), btag641. https://doi.org/10.1093/bioinformatics/btag641
- [22]Son, G., Hong, J., Fan, H., Nam, H., Ko, H., Lim, S., Song, J., Choi, J., Paulo, G., Yu, Y., & Biderman, S. (2025). When AI Co-Scientists Fail: SPOT---A Benchmark for Automated Verification of Scientific Research. https://arxiv.org/abs/2505.11855
- [23]Yang, Z., Liu, X., & Xu, X. (2026). SciIntegrity-Bench: A Benchmark for Evaluating Academic Integrity in AI Scientist Systems. https://arxiv.org/abs/2605.10246
- [24]Marsh, A., Cohen, M. B., & Cottingham, R. W. (2025). A Tale from the Trenches: Applying Metamorphic and Differential Testing to Bioinformatics Software. 2025 IEEE Conference on Software Testing, Verification and Validation (ICST), 553–564. https://doi.org/10.1109/ICST62969.2025.10988959
- [25]Stevens, C., Kjeer, K., Richard, R., Valeev, E., & Cohen, M. B. (2025). Model Assisted Refinement of Metamorphic Relations for Scientific Software. 2025 IEEE/ACM 47th International Conference on Software Engineering: New Ideas and Emerging Results (ICSE-NIER), 31–35. https://doi.org/10.1109/ICSE-NIER66352.2025.00012
- [26]Jumper, J., Evans, R., Pritzel, A., et al. (2021). Highly Accurate Protein Structure Prediction with AlphaFold. Nature, 596(7873), 583–589. https://doi.org/10.1038/s41586-021-03819-2
- [27]Terminal-Bench-Science Team. (2026). Terminal-Bench-Science: Evaluating AI Agents on Research Workflows Across Scientific Domains. In https://github.com/harbor-framework/terminal-bench-science. https://doi.org/10.5281/zenodo.22110253
- [28]Artificial Analysis. (2026). Coding Agent Index v1.5 Methodology. In https://artificialanalysis.ai/methodology/coding-agents-benchmarking. https://artificialanalysis.ai/methodology/coding-agents-benchmarkingartificialanalysis.ai/methodology/coding-agents-benchmarking
- [29]Marten, R. (2026). Terminal-Bench 4.0. In https://www.tbench.ai/news/terminal-bench-4-0. https://www.tbench.ai/news/terminal-bench-4-0tbench.ai/news/terminal-bench-4-0
- [30]Merrill, M. A., Shaw, A. G., Carlini, N., Li, B., Raj, H., Bercovich, I., Shi, L., Shin, J. Y., Walshe, T., et al. (2026). Terminal-Bench: Benchmarking Agents on Hard, Realistic Tasks in Command Line Interfaces. https://arxiv.org/abs/2601.11868
- [31]Mistral AI. (2026). Introducing Mistral Large 4: Frontier Multimodal Intelligence and Agentic Execution. In https://mistral.ai/news/mistral-large-4/. https://mistral.ai/news/mistral-large-4/mistral.ai/news/mistral-large-4
- [32]Anthropic. (2026). Claude Opus 5.5 System Card and Agentic Coding Report. In Anthropic. https://www.anthropic.com/research/claude-opus-5-5anthropic.com/research/claude-opus-5-5
- [33]OpenAI. (2026). GPT-6 Astra System Card: Autonomous Coding and Multimodal Computer Use. In OpenAI. https://openai.com/index/gpt-6-astra-system-card/openai.com/index/gpt-6-astra-system-card
- [34]Moonshot AI Team. (2026). Kimi K3: Open Frontier Intelligence. https://arxiv.org/abs/2607.24653
- [35]Z.AI Team, & Zhipu AI. (2026). GLM-5.3: Frontier Architecture and Post-Training for Agentic and Terminal Workflows. In https://huggingface.co/zai-org/GLM-5.3. https://huggingface.co/zai-org/GLM-5.3huggingface.co/zai-org/GLM-5.3
- [36]Bessey, A., Block, K., Chelf, B., et al. (2010). A Few Billion Lines of Code Later: Using Static Analysis to Find Bugs in the Real World. Communications of the ACM, 53(2), 66–75.
- [37]Cousot, P., & Cousot, R. (1977). Abstract Interpretation: A Unified Lattice Model for Static Analysis of Programs by Construction or Approximation of Fixpoints. Proceedings of the 4th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages (POPL), 238–252.
- [38]Wong, W. E., Gao, R., Li, Y., Abreu, R., & Wotawa, F. (2016). A Survey on Software Fault Localization. IEEE Transactions on Software Engineering, 42(8), 707–740.
- [39]Le Goues, C., Nguyen, T., Forrest, S., & Weimer, W. (2012). GenProg: A Generic Program Repair Method for Automating Software Fixes. IEEE Transactions on Software Engineering, 38(1), 54–72.
