AI in software modernization: how Gen AI and symbolic AI actually rebuild legacy systems

← All posts

The short version

There are two different things people mean when they say AI is modernizing legacy code, and confusing them is why projects fail. Gen AI (large language models) reads code, explains it, drafts documentation, and proposes changes. It’s fast and broadly capable, and it’s probabilistic, so it can’t promise the new code behaves like the old code.

Symbolic AI paired with enhanced compiler technology converts code deterministically: the same input always yields the same output, and that output is built to be functionally equivalent to the original. This is the part that holds up on a 5,000,000-line system in a regulated industry.

The strongest 2026 pipelines use both. Symbolic AI and enhanced compiler technology do the conversion, and Gen AI augments the work around it: discovery, business rule extraction, documentation, test generation, and review. That’s the model behind DMS, the toolkit Modernize Software is built on.

Why legacy modernization is the hard problem in enterprise software

Most of the world’s critical transaction processing still runs on code written before the people maintaining it were born. Industry estimates put the volume of COBOL alone in the tens of billions of lines, with some counts reaching into the hundreds of billions, and that’s before you add PL/I, Assembler, JOVIAL, Natural, RPG, and the early C and C++ that now qualifies as legacy too. The systems work. That’s the point. They’ve been patched and tuned for decades, and they encode business rules nobody fully wrote down.

Three pressures are forcing the issue. The people who understand these systems are retiring faster than they can be replaced. The platforms underneath are getting more expensive to run and harder to staff. And the accumulated technical debt slows down every new feature the business wants to ship. Modernization isn’t optional anymore, but the failure rate has always been high, because rewriting a working system by hand is slow, expensive, and risky.

This is the gap that drew the industry to the promise of Gen AI. Is the promise real? McKinsey has reported that applying Gen AI to application modernization can shorten timelines by roughly 40 to 50 percent and cut technical-debt-related costs by about 40 percent. The promised 40% reduction in timeline when compared to rewriting the system from scratch?

IBM’s Institute for Business Value expects AI-enabled workloads, many of them agentic, to climb from around 3 percent in 2024 to roughly 25 percent in 2026. The momentum is genuine. The question this guide answers is which approach delivers that value, and where the easy version of the promise quietly breaks.

Two kinds of AI, and why the difference decides your project

“AI” is doing a lot of work in most modernization pitches. It usually points at two technologies that behave nothing alike.

Gen AI: probabilistic, generative, broadly capable

Large language models predict the most likely next token given everything they’ve seen. Trained on enormous code and text corpora, they pick up syntax, common idioms, and a lot of practical patterns. Ask one to explain a COBOL paragraph or draft a Java equivalent and it’ll produce something fluent and usually plausible. The strength is breadth and language fluency. The defining property is that the output is a probability distribution, not a derivation. Run the same prompt twice and you can get two different answers, and neither one comes with a guarantee that it matches the source program’s behavior.

Symbolic AI: rule-based, deterministic, formally grounded

Symbolic AI is the older branch of the field: explicit representations of knowledge and explicit rules that operate on them. In program transformation, that means parsing source code into a formal structure, reasoning over it with analyses that have provable properties, applying transformation rules defined against the grammar of the language, and regenerating valid source. The same input always produces the same output. Because the rules are explicit and the analyses are sound, you can reason about correctness instead of hoping for it. The cost is that someone has to build the language definitions and the rules. The payoff is determinism and accuracy at scale.

The one-line model worth memorizing: symbolic AI and enhanced compiler technology convert your code deterministically, and Gen AI augments that work. Determinism and accuracy come from the compiler-technology side. Breadth, language, and discovery come from Gen AI. The two are complements, not substitutes.

What Gen AI genuinely does well in modernization

It’s worth being precise about this, because the limits later in this guide only make sense once you see where Gen AI earns its place. These are the jobs where its probabilistic, language-first nature is a strength rather than a liability.

• Code understanding and explanation. Point a model at a 40-year-old paragraph of COBOL and it’ll summarize what the code appears to do in plain language. For systems whose original authors are gone and whose documentation never existed, this collapses weeks of archaeology into hours. IBM’s watsonx Code Assistant for Z and its Project Bob preview both lead with this, and it’s the feature teams adopt first.
• Business rule extraction. Underneath the syntax, legacy programs encode decisions: how interest accrues, when a claim is flagged, which customers get which rate. Gen AI is good at surfacing candidate rules from procedural code so analysts can confirm them. Vendors like Fresche extract the business rules from RPG or Synon first, then generate new code from the rules rather than translating line by line, precisely because the rules are the asset worth preserving.
• Documentation generation. Research on legacy modernization keeps landing on documentation as one of the clearest wins for Gen AI, including for genuinely obscure languages like MUMPS and IBM assembler where almost no modern reference exists. Generated documentation needs review, and it still beats starting from nothing.
• Test generation and scaffolding. Gen AI can draft unit tests, characterization tests, and test data that capture current behavior so you have a safety net before you change anything. The tests need checking, and they make the rest of the pipeline safer.
• Code review and second opinions. A model reviewing transformed code catches a useful fraction of issues a human reviewer might miss, especially obvious ones at volume. Pairing one model’s output with another model’s review has become a common quality gate going into 2026.
• Agentic orchestration. The 2025 to 2026 shift is from single prompts to multi-agent workflows. IBM’s watsonx Code Assistant for Z now coordinates specialized agents: an orchestrator that runs the workflow, an architect agent that retrieves program metadata and runs impact analysis, and a code agent that does the generation, with the Model Context Protocol connecting the system to external tools and data. This is real engineering progress, and it makes Gen AI far more useful for end-to-end modernization than a chat box ever was.

Where Gen AI hits a wall: the correctness problem

Everything above is about understanding, drafting, and assisting. The moment the task becomes “produce the replacement system and prove it behaves like the original,” the probabilistic nature of Gen AI stops being a feature. Five limits show up in the research and in practice, and they compound.

1. Non-determinism

Give a model the same program twice and you can get two different translations. For a one-off snippet that’s a curiosity. Across a system of tens of thousands of files, it means the same COBOL construct gets handled inconsistently in different places, which is a maintenance problem you’ve now baked into the new codebase. Deterministic transformation produces the same output every time, which is what makes large migrations auditable.

2. Hallucination in code

Models generate fluent output that’s confidently wrong: a method that doesn’t exist, a library that was never published, an edge case silently dropped. A 2025 USENIX Security study documented package hallucinations across code-generating models, and the Collu-Bench benchmark showed that even predicting where a model has hallucinated in code is hard, with detection accuracy in the 22 to 33 percent range. In modernization the danger is subtle, because a hallucinated change can compile, pass a shallow test, and still be wrong.

3. The semantic understanding gap

This is the finding that should give any modernization lead pause. A 2026 benchmark study in the International Journal on Software Tools for Technology Transfer tested whether models can tell when two pieces of code are semantically equivalent. They misclassified about 41 percent of equivalent cases with no surrounding context, and about 29 percent even with context. Prompting helped a little and didn’t fix the underlying limitation. If a model struggles to recognize when two programs do the same thing, you can’t assume it reliably preserves what a program does when it rewrites it.

4. The verification problem

The most telling evidence comes from the teams building Gen AI translators. IBM Research published work stating plainly that LLM-based translation of COBOL to Java, while promising, can’t be trusted to be correct without validation, and that manual validation is slow and labor-intensive. Their answer was to build a separate checker that uses symbolic execution to generate equivalent tests for the source and the translated code and compare behavior. Sit with that. The correctness guarantee for the Gen AI output comes from a symbolic, deterministic method bolted on afterward. The probabilistic step produces the candidate, and a symbolic step decides whether to trust it.

5. JOBOL: technically valid, practically unmaintainable

Naive translation produces what the industry now calls JOBOL: Java that’s syntactically valid but still thinks in COBOL. It keeps the old control flow, the old data layouts, and the old architecture, so developers have to keep treating the Java as if it were COBOL. You’ve changed the language and kept every reason you wanted to leave it. The goal is idiomatic modern code that reconstructs the business logic, and getting there by Gen AI alone is exactly where most programs stall, because it requires structural understanding the model doesn’t reliably have.

Why these compound: non-determinism multiplies inconsistency across files, hallucination injects errors that pass shallow checks, the semantic gap means the model can’t reliably tell its own correct output from its incorrect output, verification has to come from somewhere else, and JOBOL means even “working” output may not be maintainable. None of this makes Gen AI useless. It makes Gen AI the wrong thing to put in charge of the conversion itself.

The deterministic alternative: symbolic AI and enhanced compiler technology

If Gen AI can’t own the conversion, what can? The answer the field keeps returning to is automated program transformation: the fusion of symbolic AI and enhanced compiler technology that converts code deterministically. This is what DMS, the engine behind Modernize Software, is built on, and it’s worth understanding how it actually works, because the mechanics are the whole argument.

Step one: turn code into a formal structure

A transformation engine starts by parsing source into abstract syntax trees, the same kind of structure a compiler builds. DMS uses GLR parsing with semantic predicates, which lets it handle the awkward real-world grammars that defeat simpler parsers, including languages like Fortran whose syntax isn’t cleanly context-free. The trees capture full detail: source position, comments, the radix and format of numbers, the things that make regenerated code recognizable to the engineer who wrote the original. This matters because the unit of reasoning is now the structure of the program, not a stream of text.

Step two: analyze with methods that have provable properties

On top of the trees sit analyses drawn from decades of compiler and program-analysis research: control-flow analysis, data-flow analysis, points-to analysis, symbol tables with language-correct scoping. These aren’t heuristics that usually work. They’re algorithms with defined behavior, which is what lets the engine make changes that are safe by construction rather than safe by inspection. Symbolic execution, where a program runs on symbolic inputs and the engine tracks path constraints, gives deterministic insight into how the code behaves across whole classes of inputs at once.

Step three: transform with explicit, grammarbound rules

Transformations are written as rules against the language, often in surface-syntax form that looks like the code itself, so a rule says “rewrite this pattern into that pattern” in terms a language engineer can read and verify. Because the rules operate on the formal structure and are applied by the engine the same way every time, the conversion is deterministic and consistent across every file in the system. The same construct is handled the same way on line 12 of one program and line 4,000,000 of another.

Step four: regenerate real source, and do it at scale

Prettyprinters convert the transformed trees back into compilable source, preserving the detail captured during parsing. DMS runs this on symmetric multiprocessing hardware through PARLANSE, Semantic Designs’ parallel language for symbolic execution, which is what lets it process tens of thousands of files and millions of lines as one coherent job rather than a stack of disconnected snippets. It handles the character encodings legacy systems actually use, including EBCDIC, Shift-JIS, and the full range of Unicode, not just ASCII. Whole-system scope is the difference between migrating an application and migrating a pile of files that used to be an application.

The guarantee that follows. Because every step is deterministic and grounded in sound analysis, the output is built to be functionally equivalent to the input, the same result for the same input, every run, across the entire codebase. That’s the property regulated industries, safety-critical systems, and large financial platforms need, and it’s the property Gen AI alone can’t provide. Semantic Designs has applied this approach to large reengineering programs over many years, including the kind of C++ component reengineering documented in the peer-reviewed literature and language conversions in defense and aerospace where being approximately right is not an option.

The convergence: neuro-symbolic modernization is where the field is going

Here’s the part that resolves the apparent tug-of-war. The research consensus heading into 2026 is that the future of code modernization is neuro-symbolic: Gen AI and symbolic methods working together, each covering the other’s weakness. The phrase researchers keep using is “best of both worlds,” and the architecture is consistent across independent groups.

CodeMetal’s LLMLift, building on the Tenspiler work with Professor Alvin Cheung’s group at UC Berkeley, uses a model to propose a translation and then a formal verification step to prove the translation is correct, describing itself as a neuro-symbolic system for code migration. IBM’s COBOL-to-Java validation work, described earlier, is the same shape: Gen AI proposes, symbolic execution verifies. A broader pattern has emerged across enterprise pipelines, which now pair language models with symbolic validators so the fluent output is checked by a method that’s deterministic and reliable. The recurring design splits the work by what each side is good at: the model supplies language and breadth, the symbolic engine supplies the correctness guarantee, and nothing ships unless it passes the deterministic check.

How Modernize Software applies the convergence

DMS uses symbolic AI and enhanced compiler technology to convert your code deterministically. Gen AI augments that work around the edges where its strengths apply: understanding the legacy system, extracting business rules, drafting documentation, generating tests, and reviewing output. The conversion itself, the part that has to be correct, stays with the deterministic engine. The augmentation, the part that benefits from breadth and language, draws on Gen AI. You get the speed of modern models and a result you can actually certify.

A decision framework: when to use which

Matching the method to the task is most of the skill. The split below reflects what the research and the field practice both point to.

• Understanding undocumented legacy code — Lead with Gen AI. Breadth and language fluency turn weeks of archaeology into hours; output is a draft for humans to confirm.
• Business rule extraction — Lead with Gen AI, human-confirmed. Surfaces candidate rules from procedural code; the rules become the spec the new system is built against.
• Documentation — Lead with Gen AI. A clear, low-risk win even for obscure languages; review before publishing.
• Test and characterization scaffolding — Lead with Gen AI plus symbolic test gen. Models draft tests fast; symbolic execution generates equivalence tests that actually prove behavior.
• The conversion itself, at scale — Lead with symbolic AI and enhanced compiler technology. Deterministic, consistent across millions of lines, built for functional equivalence.
• Mission-critical and regulated systems — Lead with symbolic AI and enhanced compiler technology. Correctness has to be provable and auditable, not probable.
• Final equivalence validation — Lead with symbolic methods. Deterministic checks decide what ships; Gen AI review is a useful second pass, not the gate.
• Isolated, low-risk, small-scope changes — Lead with Gen AI, with tests. Where a wrong answer is cheap to catch and fix, speed wins.

A practical pipeline that combines both

Putting it together, a modernization program that holds up looks like a sequence where each stage uses the method suited to it. The conversion sits on the deterministic engine, and Gen AI does the work that surrounds it.

1. Assess and inventory. Catalog the codebase: languages, dialects, dependencies, dead code, and the troublesome constructs that will need special handling. Removing redundant code before conversion lowers the total cost of everything downstream. Automated assessment beats manual sampling here, because the long tail of edge cases is where projects overrun.
2. Understand and extract. Use Gen AI to explain programs and surface candidate business rules, then have analysts confirm them. This produces the specification the modernized system will be measured against, and it’s where Gen AI’s breadth pays off most.
3. Establish the safety net. Generate characterization tests that capture current behavior. Use Gen AI to draft them quickly and symbolic test generation to produce tests that actually check equivalence, so you can detect any behavioral drift the moment it appears.
4. Transform deterministically. Run the conversion through the symbolic AI and enhanced compiler technology engine, applying grammar-bound rules consistently across the whole system. This is the step that produces the new source, and it produces the same result every time.
5. Validate for functional equivalence. Compare the behavior of the original and the converted system using deterministic, symbolic-execution-based checks. This is the gate. Add a Gen AI review pass as a second opinion, not as the decision-maker.
6. Refine toward idiomatic code. Apply further transformation rules to restructure the output into modern, maintainable form rather than leaving JOBOL behind, and use Gen AI to suggest naming, comments, and local cleanups that humans approve.

Pitfalls that sink modernization programs, and how to avoid them

• Trusting unverified Gen AI output. The single most expensive mistake. If a deterministic check isn’t deciding what ships, you’re shipping on probability. Make symbolic equivalence validation the gate.
• Letting JOBOL through. Valid-but-unidiomatic output passes compilation and fails the team six months later. Treat “compiles and passes a few tests” as the start of quality work, not the end of it, and use transformation rules to restructure toward idiomatic code.
• Ignoring the long tail. The first 80 percent of constructs convert easily, and the last 20 percent, the rare dialect quirks and the clever 1985 optimizations, are where the schedule dies. Inventory them up front so they’re planned work, not surprises.
• Skipping equivalence testing. Without tests that prove the new system behaves like the old one, you’ve replaced a known system with an unknown one. Build the safety net before you change anything.
• Confusing translation with re-architecture. Some systems need a faithful conversion that preserves behavior exactly. Others need genuine restructuring. Decide which one you’re doing before you start, because the methods and the success criteria differ.

The road ahead for 2026 and beyond

A few directions are already clear. Agentic pipelines will keep maturing, with specialized agents handling discovery, transformation, and validation under an orchestrator, connected to tools and data through open protocols like MCP. On-premises and sovereign deployment of the models is becoming standard for regulated industries that can’t send source code to a public endpoint, and vendors are already shipping on-prem options. And the neuro-symbolic design will move from research framing to default architecture, because the correctness problem doesn’t go away as models improve. Better models produce better candidates. They don’t turn probability into proof.

That last point is the durable one. As Gen AI gets stronger, the value of a deterministic core that can certify its output goes up, not down, because the appetite to deploy AI-generated changes into critical systems grows and the need to prove those changes correct grows with it. The teams that win the next phase of modernization are the ones who put symbolic AI and enhanced compiler technology at the center and let Gen AI do what it’s genuinely good at around it.

Where Modernize Software fits

Modernize Software is built on DMS, which uses symbolic AI and enhanced compiler technology to convert legacy code deterministically, with Gen AI augmenting the discovery, documentation, and validation work around the conversion. It handles whole systems across many source languages and the encodings legacy mainframes actually use, and it’s been proven on large reengineering programs in industries where the new system has to behave exactly like the old one. If you’re weighing a modernization program and want the conversion to be something you can certify rather than hope for, that’s the conversation to have.

Talk to Modernize Software

Tell us about your codebase and what “done” has to mean for your business, and we’ll map the deterministic conversion path and where Gen AI helps along the way.

Frequently asked questions

Can Gen AI fully automate legacy code modernization?

Not the conversion itself, not for systems where correctness matters. Gen AI is strong at understanding, documentation, and drafting, and its output is probabilistic, so it can’t guarantee the new code behaves like the old code. The teams building Gen AI translators rely on separate, deterministic methods to verify the results. For the conversion, lead with symbolic AI and enhanced compiler technology, and use Gen AI to augment the work around it.

What is the difference between Gen AI and symbolic AI in this context?

Gen AI, meaning large language models, predicts likely output from patterns it learned in training. It’s broad and fluent and non-deterministic. Symbolic AI represents knowledge and rules explicitly and operates on the formal structure of a program, so it’s deterministic and you can reason about its correctness. In modernization, Gen AI is best for understanding and assistance, and symbolic AI paired with enhanced compiler technology is best for the conversion.

What is JOBOL and why does it matter?

JOBOL is the nickname for Java that’s syntactically valid but still structured like COBOL, the typical result of naive line-by-line translation. It compiles and runs, and it keeps the old architecture and data layouts, so developers have to keep thinking in COBOL. It defeats the purpose of modernizing. Avoiding it requires structural transformation that reconstructs the business logic into idiomatic modern code.

How do you verify that modernized code is correct?

The reliable approach is functional-equivalence testing using deterministic methods such as symbolic execution, which generates equivalent tests for the original and the converted code and compares behavior across whole classes of inputs. A Gen AI review pass is a useful second opinion. The deterministic check is what decides whether the new system ships.

Is symbolic AI old technology?

It predates today’s models, and that’s a feature here. The techniques are mature, well understood, and deterministic, which is exactly what large-scale, mission-critical conversion needs. The current direction in research combines these proven methods with Gen AI rather than replacing them, because the correctness guarantee comes from the symbolic side.

How does this approach handle very large codebases?

Deterministic transformation built on enhanced compiler technology parses the whole system into formal structures and applies rules consistently across every file, running on parallel hardware so it can process tens of thousands of files and millions of lines as one coherent job. Because it’s deterministic, the same construct is handled the same way everywhere, which keeps the result consistent and auditable at scale.

Sources and further reading

Selected references behind the claims in this guide.

• McKinsey, on Gen AI accelerating application modernization (timelines and tech-debt cost). https://www.effectivesoft.com/blog/ai-legacy-code-modernization-migration.html
• IBM, agentic AI for mainframe modernization with watsonx Code Assistant for Z, including the IBM IBV workload projection. https://www.ibm.com/new/announcements/agentic-ai-for-smarter-mainframe-modernization-with-ibm-watsonx-code-assistant-for-z
• Understanding code semantics: a benchmark study of LLMs (Int. Journal on Software Tools for Technology Transfer, 2026). https://link.springer.com/article/10.1007/s10009-026-00842-4
• IBM Research, Automated Validation of COBOL to Java Transformation (symbolic-execution-based equivalence checking). https://arxiv.org/pdf/2506.10999
• Collu-Bench: predicting language model hallucinations in code. https://arxiv.org/pdf/2410.09997
• TechTarget, on the JOBOL problem in COBOL-to-Java conversion. https://www.techtarget.com/searchsoftwarequality/news/252523671/COBOL-programming-skills-gap-thwarts-modernization-to-Java
• HCLTech, on avoiding JOBOL through two-step conversion. https://www.hcltech.com/blogs/cobol-to-java-modernization
• CodeMetal, combining AI with formal verification for legacy code migration (LLMLift, Tenspiler). https://www.codemetal.ai/research/combining-ai-with-formal-verification-for-efficient-migration-of-legacy-code
• DMS Software Reengineering Toolkit, technical overview (GLR parsing, ASTs, prettyprinters, PARLANSE, encodings). https://en.wikipedia.org/wiki/DMS_Software_Reengineering_Toolkit
• Semantic Designs, DMS Software Reengineering Toolkit product page. https://semanticdesigns.com/Products/DMS/DMSToolkit.html