There is a lot of excitement right now about AI enabling mainframe application modernization. Boards are paying attention. CIOs are asked for a plan. AI is a real accelerator for modernizing COBOL but to get results, AI needs more context than source code alone can provide. Here's what we've learned from working with 400+ enterprise customers: mainframe modernization has two very different parts. The first part is reverse engineering, understanding what your existing systems actually do. The second part is front-end engineering, building new applications.
The first part is where mainframe projects live or die. However, coding assistants are only really good in the second part. Give them a clear, proven definition and they will build modern applications quickly.
We've learned that delivering modern COBOL success requires a solution that can decouple the engineer, generate verifiable and trackable specs, and help those specs flow to any AI-powered front-end engineering code assistant. Effective development requires both reverse engineering and forward engineering.
What is needed is a modernization of the main frame
Context, perfect
Mainframe applications are large. It's really big. A single program can run tens of thousands of lines, pulls shared data definitions from across the system, calls other programs, and is programmed with ubiquitous JCL. Today, AI can only process a limited amount of code at a time. Feed it through a single program and cannot see duplicates, called subroutines, shared files, or JCL that includes everything. It will produce output that looks reasonable with the code I can see but misses dependencies that were never shown. In dealing with customers, we solve this by removing all obvious dependencies first, then feed the bound AI, complete units and everything you need is solved. That way AI focuses on what it's good at (understanding business logic, generating insights) instead of guessing at connections it can't see.
Context of field awareness
Here's something that surprises people: the same COBOL source code behaves differently depending on the compiler and runtime. How numbers are summed, how data resides in memory, how programs talk to middleware. This is not in the source code. They are determined by the specific combination and runtime environment the code is built for. Decades of hardware-software integration cannot be replicated by moving code. We've found that AI does its best work when platform-specific behavior is already resolved. The AI feed is clean, platform-aware input, and it delivers. Feed it raw source code, and it will produce output that looks correct but behaves differently than the original. In financial systems, the difference in coverage is not a matter of cosmetics. It is a material error.
A traceable basis
If you're in a bank, insurance, or government, your regulators will ask one question: can you prove you didn't miss anything? AI alone is not enough to extract business logic and produce documents that will be acceptable to regulators. Compliance requires that all outputs have a valid, legible link back to the original system. We learned early on that traceability does not come from learning AI source code. It comes from organizing code into precise, responsible units so that we know exactly what goes into AI and can trace everything that comes out back to its source. For clients in regulated industries, this often differs between a project going forward and a project standing still.
How we set up AI to succeed in AWS Transform
We built AWS Transform to modernize mainframe applications at scale. The idea is straightforward: give AI the right foundation, and customers get traceable, accurate, and complete results that they can take to production. AWS Transform starts by building a complete, deterministic model of the application. Special agents abstract code structure, runtime behavior, and data relationships across a system — not one system at a time, but everywhere. This produces a dependency graph aligned with the semantics of the actual compiler, capturing cross-program dependencies, middleware interactions, and platform-specific behavior before AI gets involved. From there, large programs are decomposed into integrated, processable units. Field-specific behavior is resolved deterministically. Units are limited for the AI to process effectively. Then the AI outputs the business logic in natural language, and everything it outputs is validated against the predetermined evidence that has already been generated. The mapping details return to the original code. When the administrator asks “did you miss something?”, there is an affirmative answer. What sets this apart is that AI never works in the dark. Every processing unit has known inputs and expected outputs, so we can verify the return. There is no other method on the market that closes that loop. The output is a set of proven, trackable technical specifications that connect to any modern development environment. The difficult part of modernity is understanding what exists today. Once you capture that with accurate specs, AI-powered IDEs can build a new system with confidence.
An end-to-end business transformation platform
No one makes a single app modern. Our clients are looking at large portfolios or thousands of interconnected applications, and they need more than analytical help. AWS Transform automates the entire lifecycle: analysis, planning, testing, refactoring, reimagining. Everything. And within that, different applications require different approaches. Others were rethought from scratch. Others just need a clean, deterministic conversion to Java. Others need to move out of the data center first and modernize later. Some will live on the mainframe. We've learned the hard way that treating them the same way is how projects explode. The portfolio decision (which application, which method, which order) is as important as the technology. In our experience, this is the only way business development ends. All measurement methods are why these projects fail. Another thing that is often overlooked: test data. You cannot prove that a modern application works without real production data and real conditions. We've watched teams get all the way through code conversions and then stop because no one planned to capture the data. Therefore, we built test planning and data capture into the on-prem platform from day one. Not a cleanup job at the end. This is what this actually looks like when it works. End-to-end automation, the right approach for each application, authentication included.
How do you get this right
The question is not “should we use AI to modernize COBOL?” Yes you should. The question is how do you set up AI to deliver: traceability of controls, platform-specific behavior that is handled efficiently, consistency across your application portfolio, and the ability to scale across hundreds of interconnected systems. That's what we considered when building AWS Transform. Prescriptive analysis as a basis. AI as an accelerator. An AWS service that includes a full range of modernization patterns.
And it works.
The BMW Group reduced inspection time by 75% and increased inspection coverage by 60%, significantly reducing risk while accelerating modernization timelines.
Fiserv completed a mainframe fabrication project that would have taken 29+ months in just 17 months.
Itau has cut application discovery and testing time by over 90%, allowing teams to modernize applications 75% faster than previous manual efforts.
About the writers
