AISM 2026 – Preliminary Table of Contents

2nd International Workshop on AI for Software Modernization (AISM 2026)

Frontmatter

Papers

Pattern-Guided Static Analysis for APIfication of COBOL Monoliths
Vini Kanvar, Ashwin Dhinesh Kumar, and Keerthi Narayan Raghunath
(IBM Research, India; IBM Research, USA; IBM, India)
Legacy COBOL mainframes resist APIfication due to monolithic structure and scattered logic. We present a novel pipeline that takes code blocks selected and validated by the user, potentially with AI-assisted boundary suggestions, and generates compilable API modules with request/response copybooks.
Key innovations include: (1) five COBOL patterns (P1–P5) guiding analysis selection, (2) WoCC—a pattern-based call-chain approximation avoiding recursive traversal for organized monoliths, and (3) end-to-end code synthesis handling REDEFINES aliasing and inter-program calls.
Unlike prior slicing (variable sets only) or ADDI (read/write reporting), we deliver deployable APIs. On GENAPP/CBSA/industry systems, signature inference drops from weeks to minutes; refactoring effort reduces by 15–50%. Practitioners validated precision; modules deployed via z/OS Connect pass functional tests.
Article Search Article: asews26aismmain-p1-p (type: Full Paper) doi:10.1145/3843775.3844542

Spec2COBOLRot: An Agentic-AI Degradation Loop for Realistic COBOL Corpus Generation
Jean-Baptiste Espinasse, Djamel Eddine Khelladi, and Mathieu Acher
(Inria, France; Sopra Steria, France; CNRS, France; University of Rennes, France; INSA, France)
COBOL remains widely deployed, yet representative corpora reflecting real production code are rarely available, limiting rigorous benchmarking of modernization approaches. We propose a systematic agentic AI pipeline for generating realistic COBOL programs, combining specification-driven generation with iterative degradation guided by patterns and complexity targets extracted from real production code. Here, realism is understood as structural fidelity to production code as captured by our metrics. We evaluate whether degradation reaches target complexity levels while preserving business behavior, and examine the limits of the approach, across three programs from distinct business domains. Results show the pipeline reliably produces syntactically valid programs and moves them toward realistic structural complexity. However, preserving business behavior is not always achieved by construction, and targeting structural metrics independently of business logic risks producing programs whose complexity does not reflect a plausible maintenance history. We discuss these limitations and outline a more realistic alternative as a direction for future work, generating legacy programs from scratch along a simulated development history.
Article Search Article: asews26aismmain-p2-p (type: Full Paper) doi:10.1145/3843775.3844543

From C to Idiomatic Rust: A Ship-of-Theseus Agentic Translation
Vasily A. Sartakov
(Huawei Technologies Research & Development, UK)
C underpins operating systems, embedded platforms, and network infrastructure as its abstractions map directly to machine behaviour. Its explicit memory model, predictable data representations, and minimal runtime allow compilers to generate fast, deterministic code. These properties also leave correctness and memory safety entirely to the programmer, making undefined behaviour, pointer misuse, and lifetime errors persistent sources of defects and security vulnerabilities in long-lived C codebases. Rust eliminates most failure modes through a static ownership and borrowing model that enforces memory safety and aliasing constraints at compile time. However, mature C systems cannot be translated directly: implicit layout assumptions, aliasing patterns, and undefined behaviour must be reconstructed before safe Rust can be produced.
This paper presents a migration methodology that first generates a semantics-preserving, non-idiomatic Rust baseline and then incrementally rewrites it into idiomatic Rust using agentic AI, validating each step through compilation and behavioural testing. Applied to iodine, a real-world DNS tunnel, the approach demonstrates that reliable C-to-Rust migration is a structured transformation workflow rather than a single translation step.
Article Search Article: asews26aismmain-p3-p (type: Full Paper) doi:10.1145/3843775.3844544

Traceable RAG for Legacy COBOL Comprehension: Integrating Architectural and Semantic Analysis
Hamza Abdul Kader, Ermin Lilaj, Marco Calamo, Alberto Coluzzi, Flavia Monti, Gabriella Palumbo, Guido Carotenuto, and Massimo Mecella
(Sapienza University of Rome, Italy; Camera dei Deputati, Italy)
Understanding undocumented COBOL applications is a major challenge in legacy system modernization. We present a locally deployed open-source RAG pipeline that combines architectural and semantic program analysis to support traceable LLM-based question answering about the full legacy codebase. The extracted information is organized into structured artifacts covering program metadata, source code, business rules, and dataflow, while preserving links to the underlying analysis results. Relevant evidence is retrieved through a hybrid strategy and provided to a local LLM, which generates answers accompanied by inspectable supporting artifacts. A preliminary expert evaluation classified 31 of 42 question formulations as satisfactory. At the information need level, the system obtained satisfactory results for 11 of 14 needs, while eight were answered satisfactorily across all three paraphrased formulations.
Article Search Article: asews26aismmain-p6-p (type: Short Paper (4 pages)) doi:10.1145/3843775.3844545

AI Meets Program Analysis: Lessons from a Decade of Enterprise Software Modernization at IBM
Vini Kanvar
(IBM Research, India)
Generative AI has rapidly transformed software engineering through code generation, explanation, translation, documentation, and agentic development workflows. This transformation raises a fundamental question: what is the role of program analysis in the era of AI? Drawing on a decade of enterprise software modernization research at IBM, this paper argues that AI and program analysis are not competing technologies but complementary capabilities. Program analysis provides semantic evidence, dependency reasoning, correctness guarantees, and architectural constraints, while AI leverages this evidence to generate code, produce documentation, derive specifications, assist architectural design, and improve developer productivity. We illustrate this synergy through IBM's modernization research spanning legacy software understanding, business function extraction, service refactoring, APIfication, code generation, COBOL-to-Java translation, and automated testing. Across these workflows, a consistent lesson emerges: the most reliable and trustworthy AI-assisted modernization is achieved when AI is grounded in semantic artifacts extracted and validated through program analysis. Looking ahead, we envision enterprise software engineering as a collaboration in which program analysis provides evidence, AI provides intelligence, and human engineers contribute the judgment and wisdom required to build trustworthy software systems.
Article Search Article: asews26aismmain-p7-p (type: Full Paper) doi:10.1145/3843775.3844546

Towards Fully Automated COBOL-to-Java Translation
Joanna Abraham and Justyna Petke
(University College London, UK)
COBOL remains one of the most widely deployed programming languages in mission-critical business systems, yet the pool of developers who can maintain it is shrinking. Automated translation to modern languages like Java is an increasingly attractive modernisation strategy, but systematic evaluation of available approaches remains limited. Here, we evaluate state-of-the-art open source COBOL-to-Java translation approaches, across a benchmark of 326 small open source programs, and investigate LLM-based strategies for repair and maintainability improvement of resultant translations.
The evaluated tools present a clear correctness-maintainability trade-off: COBOL4J, a rule-based COBOL-to-Java translator, achieves the highest functional correctness, based on test-pass rates, at 86.4%, but generates verbose, unmaintainable output. XMAiNframe-7B, a COBOL fine-tuned LLM, strikes the best balance across both dimensions with 55.2% functional accuracy; and Qwen2.5-Coder-7B, a general-purpose model, performs weakest on functional correctness at 22.4%. We find that the post-hoc repair pipeline, with the best-performing iterative prompting strategies, eliminates most compilation errors across all three tools on the tested dataset. Post-hoc refactoring reduces COBOL4J’s verbose output from an average of 15 functions per file, to only 1.2, however, half the time at the cost of correctness.
Our findings show that production-grade COBOL modernisation is best approached as a hybrid pipeline: using rule-based translation to ensure baseline functional correctness, followed by domain-specialised LLM refinement to improve structure and maintainability. The derived bug taxonomy analysis can be used to guide targeted prompt design and improve future COBOL-to-JAVA translator development.
Article Search Article: asews26aismmain-p12-p (type: Full Paper) doi:10.1145/3843775.3844547

LLM-Based Legacy Application Re-engineering Platform: An Experience Report of Migrating a Web Application
Sandra Greiner, Andrés Torrejón González, Helge Dralle, and Christian Michel
(University of Southern Denmark, Denmark; insinno, Spain; insinno, Germany)
Re-engineering software (web) applications is a frequent modernization task, with little to no automation, rendering it tedious, time-consuming, and prone to errors. Specifically for web applications, the front-end is typically fully replaced with a novel technology stack while still requiring full interoperability with the back-end, still offering the same functionalities, and still satisfying the same business needs. Recent advances have shown successful use of Generative AI, and specifically LLMs, in software re-engineering tasks. Still, the studied software systems are either small, demonstrating migrations at the scale of methods, single attributes, or only of their types, or they require LLMs with large context windows to be aware of, for instance, entire classes or the full software project. In this paper, we introduce a legacy application re-engineering platform that uses business context data and the source code of a full-stack software system to inform five LLM-based agents. The agents, draft a full migration plan of transforming the legacy software system into the desired target technology stack while respecting latest coding best practices and fixing technical debts. We provide an experience report of a case study, where we migrate a legacy web application implemented in Angular 5, and in Java using the Play Framework, into a modern website using Angular 21 for the front-end and recent Java Spring Boot technology for the back-end. By only requesting the desired target technology stack, our LLM-based platform creates and executes the migration plan fully autonomously. Through senior developers' audits, we identify 5 critical issues that mainly relate to the configuration of the back-end and a few missing end-point implementations, and 4 issues of medium severity relating to the front-end while the full application is executable upon creation. Lastly, we discuss the insights gained from building and running our platform.
Article Search Article: asews26aismmain-p16-p (type: Full Paper) doi:10.1145/3843775.3844548

Recovering Software Architecture Intent from Historical Work Items using Generative AI: A Mixed-Methods Industry Case Study
Dominik Storck, Tobias Eisenreich, and Stefan Wagner
(TU Munich, Germany)
Software architecture is often only partially captured in code, while much of the design intent lives in evolving project artifacts. In agile projects, work items, user stories, and related tracking documents preserve valuable traces of that intent, but they rarely support direct architectural analysis. This work investigates the recovery of C4 architecture diagrams from historical agile work items using an LLM-based pipeline. The semi-automatic five-step workflow employs a prompt chain, bidirectional traceability, and Chain-of-Thought reasoning to transform unstructured Azure DevOps work items into visual artifacts. Evaluated on two industry projects, we use a mixed-methods design combining qualitative expert interviews with a quantitative stability analysis. Practitioners perceive the generated architectural baselines as accurate and highly useful for system comprehension. Strictly bound by their input data, the artifacts mirror the documented intent, thereby surfacing discrepancies and architectural drift when compared to the implemented reality. Quantitatively, the workflow exhibits high stability for architectural entities but lower stability for their relationships, with relative variance compounding across generation steps. The proposed workflow demonstrates the practical viability of LLM-assisted architectural recovery based on development process artifacts.
Article Search Artifacts Available Article: asews26aismmain-p18-p (type: Full Paper) doi:10.1145/3843775.3844549

Architecture Generator (doi:10.5281/zenodo.22145614): The project implements an end-to-end pipeline that: 1. Extracts work items (Epics, Features, User Stories, Tasks) from Azure DevOps. 2. Converts them into a structured Markdown “project context”. 3. Employs a two-step LLM prompting workflow to generate: - a C4 System Context model (Level 1), and - a C4 Container model ...

Passing Parity Is Not Preserving Behaviour: Oracle Escape in Function-Level LLM Code Migration
Simarjot Khanna
(Independent, Canada)
Parity testing validates software modernization: the legacy system supplies every expected output, so the oracle is sound. One decision is delegated, increasingly to a language model and often the very model that translated the code: which inputs to try. How much divergence such suites let through is unmeasured, and whether a model validating its own translation misses more is unknown; we pre-registered that self-validation hypothesis. We measure both in Python-to-Java function migration with five models, each acting as both translator and validator, with expected values always from executing the legacy source and divergence established by differential execution on a large type-directed input set together with the generated suites. Of the parity suites that passed, 40.8% were on divergent translations, and 7.7% on translations that diverge on an input a reviewer would call unremarkable. We could not detect a self-validation penalty. Validator strength and translator subtlety dominate instead: misses are worst when a weak validator checks a strong translator's code, the configuration a cost-conscious pipeline prefers. A passing parity suite is evidence about where testing has looked, not a verdict of behavioural equivalence, and should be reported with its escape rate attached.
Article Search Article: asews26aismmain-p20-p (type: Full Paper) doi:10.1145/3843775.3844550

Agentic Software Porting: Lessons from the CHERI-PIT
Noam Benkler, Steven Johnston, David Lide, Allison Randal, Mark Valovage, Dan Thomsen, Jason Li, Robert Watson, and David Musliner
(Smart Information Flow Technologies, USA; Trusted Science and Technology, USA; Capabilities Limited, UK)
Porting C/C++ software to new hardware is an agent-shaped problem. The source changes stay small, but each one requires scarce expert diagnosis of compiler warnings and hardware faults. This experience paper reports eight lessons from six months of developing CHERI-PIT, a system still under active development. CHERI-PIT is an LLM-agent pipeline that ports C/C++ projects to the memory-safe pure-capability (purecap) ABI of CHERI hardware on Arm Morello. The pipeline has carried 29 upstream projects to reproducible port recipes. Verifier scripts measured zero CHERI faults over each ported project’s test baselines on Morello hardware. The corpus includes a working PostgreSQL server and a complete CRuby interpreter. The lessons fall into three themes: dividing the labor so one pipeline survives project scale, verifying progress mechanically so no claim of success rests on the agent’s own report, and retaining insight gained through porting so the tool grows more capable with each port. Each lesson unfolds as an evolution: what CHERI-PIT initially did, what we observed, and what we changed The lessons together trace a path toward a porting tool that emits reproducible and auditable port recipes.
Article Search Article: asews26aismmain-p21-p (type: Short Paper (4 pages)) doi:10.1145/3843775.3844551

proc time: 0.34