Move your estate frame by frame. You do not need a big-bang rewrite or an all-or-nothing cutover.
The reasons to leave increase. The reasons that stop the exit stay the same.
The systems continue to operate. But fewer people can change them, and less budget is available.
When COBOL and IMS specialists retire, their knowledge goes with them.
Release cycles and license fees use budget that you need for new work.
APIs, analytics and AI agents cannot easily access mainframe logic and records.
The code has operated for decades. The people who knew it have left.
The documentation is missing or old. Only the source code is accurate.
There is no test environment and no production data to compare the old and new systems.
A full rewrite puts the full estate at risk in one cutover.
Logistics for more than 30 plants on IBM z/OS. CHAI used only the source code. There was no documentation and no test environment.
CHAI moved 1,076 programs module by module. The result uses no COBOL runtime, wrapper or emulation.
CHAI split more than 2,160 programs into 9 bounded contexts. Waves 1 and 2 are now in Java.
It maps the full estate from the code that your team has now.
It checks its results again before any code moves.
The mainframe continues to run the other domains. Rollback is ready.
CHAI scans the full estate from the source code. It finds dependencies, data access and integrations, also in code that is not in English.
Estate map of programs, data and integrations
CHAI puts programs into domains. The measured coupling between domains sets the migration order.
Domain map with coupling counts and a migration order
CHAI checks its first pass again. This lets you find errors in the plan, not in production.
Corrected plan that shows the missed dependencies
CHAI moves each domain to cloud-native, event-driven services. The mainframe continues to run the other domains.
Phased roadmap with gates and rollback
The IBM z/OS estate of a global automotive group, layer by layer. Select a layer to see what CHAI changed it into.
Business logic becomes Java that is easy to read and maintain. The Java is grouped by domain, not by program.
These targets are from the automotive engagement. Each engagement sets its own targets with CHAI Recipes.
Read the full case studyYou get four results that your team can use. Open each result to see an example.
Each domain runs in parallel with the mainframe. When the domain passes its gate, it replaces the mainframe for that domain.
Old and new run in parallel. The mainframe runs the rest.
Outputs are compared with the mainframe byte for byte.
Each phase passes its gates. Rollback is ready.
Your timeline comes from your domain map, not a template.
Illustrative. Your phases and timeline come from your own estate map.
Engineers approve the success criteria before migration. They validate the output after migration.
Use your own LLM, on the cloud or platform you choose.
Each task traces back to the source. Reviewers can check the work.
Yes. In the automotive engagement, CHAI used only the source code. There was no documentation, no dependency map and no test environment. CHAI analyzed all 11,238 artifacts in seven days, including COBOL code in German.
No. CHAI finds where the estate splits into independent domains. Then it migrates one slice at a time. We recommend a phased Strangler Fig migration. In this method, the old and new systems run in parallel, and each phase must pass validation gates.
In the automotive proof of concept, eight COBOL programs became one Java 21 Spring Boot service on a Kubernetes target. Four IMS databases became one PostgreSQL schema. REST APIs and Kafka events replaced the 3270 screens.
Each slice comes with automated tests. The automotive slice had no tests before and 151 tests after. Engineers do checks before and after migration, and each task in the plan traces back to the source. When environment access is available, we compare the outputs with the mainframe byte for byte.
No. CHAI lets you use your own LLM, on the cloud or platform you choose. The analysis runs on a model in your own cloud account.
See CHAI map your estate and modernize it.
# Mainframe Modernization with CHAI CHAI reads a COBOL mainframe estate from the source code. It finds where the estate splits into independent domains and checks its own results. Then it migrates one slice at a time to a tested Java service. No big-bang rewrite is necessary. **For:** CIOs, VPs of Engineering and modernization leads at enterprises that run COBOL, IMS and 3270 workloads on IBM z/OS. --- ## Why exit now - **Skilled people retire** — when COBOL, IMS and 3270 specialists retire, their knowledge goes with them - **Changes are slow and expensive** — release cycles, license fees and specialist support use budget that you need for new work - **Core data is difficult to access** — APIs, events, analytics and AI agents cannot easily use mainframe logic and records - **Renewals set the deadline** — without an estate map, you have two options: renew the contract again, or rewrite with too little time ## Why mainframe exits stop - **No reliable map** — the documentation and dependency maps are missing or old; only the source code is accurate - **Nothing to compare against** — there is no test environment and no production data to compare the old and new systems - **Big-bang risk** — a full rewrite puts the full estate at risk in one cutover ## How CHAI does it (four stages) - **Discover** — CHAI scans the full estate from the source code. It finds dependencies, data access and integrations, also in code that is not in English - **Split** — CHAI puts programs into domains. The measured coupling between domains sets the migration order - **Verify** — CHAI checks its first pass again and corrects the plan before any code moves - **Modernize** — CHAI moves each domain to cloud-native, event-driven services. The mainframe continues to run the other domains ## What the estate becomes (default targets; CHAI Recipes set the targets for each engagement) - COBOL programs → Java 21 services (Spring Boot) - IMS databases and DL/I calls → a relational schema (PostgreSQL) - 3270 screens → REST APIs; program-to-program calls → Kafka events - No automated tests → unit tests with every slice - One platform for everything → Kubernetes, one domain at a time ## What you get - An estate map: programs, data, screens and integrations, with their dependencies - A domain split and a migration order - A unit-tested service: one real slice, migrated from start to finish - A developer-ready plan: tasks with estimates. Each task traces to the source and has criteria to verify it ## Ways to engage - **Discovery assessment** — estate map, domain split and migration order - **Proof-of-concept slice** — one real slice, migrated and tested, plus a task-level plan - **Phased migration** — Strangler Fig method, with validation gates and rollback at each phase ## People stay in control, and the code stays in your tenant - Engineers approve the success criteria before migration. They validate the output after migration - Use your own LLM, on the cloud or platform you choose. The source code stays in your tenant - Each task traces back to the source ## Proof: global automotive group, IBM z/OS - 11,238 artifacts (1,097 COBOL programs, IMS/DB2, 3270 terminals, 33 external integrations) analyzed in 7 days. A manual analysis takes 6–8 weeks - 4 independent domains, 18 cross-domain calls, 0 circular dependencies - First slice: ~18,000 COBOL lines → ~1,400 Java 21 lines (13:1), 4 IMS DBs → 1 PostgreSQL schema, 3270 screens → 14 REST APIs + Kafka events, 0 → 151 automated tests - Case study: /success-stories/automotive-mainframe-modernization/ ## Proof: reinsurance accounting platform, COBOL on UNIX - 35-year-old system: 1,076 COBOL programs, 700+ copybooks, Oracle Pro*C data access, C terminal UI - 29,847 COBOL lines migrated to 7,652 lines of native Java 17 (3.9:1), 313/313 tests passing, 0 COBOL runtime dependencies - First module from start to tested Java in about 4 days - Case study: /success-stories/reinsurance-cobol-to-java/ ## Proof: European accounting software provider, z/OS billing and a C++ engine - Billing: 2,160+ COBOL and Assembler programs on CICS, DB2 and VSAM; 9 bounded contexts and a 4-wave plan; waves 1–2 migrated to Java (DB2 → PostgreSQL, MQ → Kafka, 3270 → REST) - Effort: billing 56 → 25.5 engineer-weeks (2.2×), C++ engine 40 → 24 weeks (1.65×), integration adapters 16 → 2 engineer-weeks (8×) - Case study: /success-stories/accounting-software-mainframe-modernization/ ## Products - CHAI DART — discovery and assessment: /products/dart/ - CHAI Flow — modernization as a pipeline: /products/flow/ - CHAI Universe — agentic workspace: /products/universe/ ## Contact Book a demo: /contact/ Email: hello@cloudhedge.io