Article written by St\u00e9phane Cagnon, July 9, 2026<\/p>\n<\/div><\/div><\/div>
Generative AI is changing the game on IBM i: analyzing a thirty-year-old RPG program, explaining its logic, suggesting a refactor… All of this can now be done in minutes. It’s a historic opportunity for a legacy estate that often carries the heart of the business: billing, payroll, inventory…<\/span><\/p>\n But one question keeps coming up in the boardroom: “Does the modernized application do exactly what it did before?” Not roughly. Exactly. Because on these systems, a difference in behavior means an incorrect invoice or a payroll error.<\/p>\n Our conviction: the safest modernization is hybrid: AI to understand, determinism to transform, regression testing to prove it.<\/strong><\/p>\n<\/div><\/div><\/div> Key takeaways<\/span><\/p>\n<\/div> AI understands but it doesn’t guarantee, <\/b>that guarantee comes from deterministic engines.<\/p>\n<\/div><\/li> Regression testing proves<\/b> that a modernization reproduces business behavior exactly.<\/p>\n<\/div><\/li> The hybrid approach is cost-effective<\/b>: targeted AI + MCP = controlled token consumption.<\/p>\n<\/div><\/li><\/ul><\/div><\/div><\/div><\/div> Let’s be clear: generative AI brings real, immediate value on IBM i:<\/p>\n<\/div> Understand:<\/strong> explain undocumented code, reconstruct buried business rules.<\/p>\n<\/div><\/li> Document:<\/strong> produce the documentation no one had time to write.<\/p>\n<\/div><\/li> Assist:<\/strong> suggest refactorings, guide a junior developer through unfamiliar code.<\/p>\n<\/div><\/li> Accelerate:<\/strong> revive backlogged projects held back by limited resources and expertise.<\/p>\n<\/div><\/li><\/ul> But a language model is probabilistic by design: it produces the most likely output, not a guaranteed one. Ask it to convert the same program twice, and nothing guarantees you’ll get identical results. And across an application portfolio, whether it’s a few hundred programs or several thousand, nothing guarantees that the same conversion rule will be applied consistently everywhere.<\/p>\n This isn’t a flaw in AI. It’s its nature. And that’s precisely why AI alone can’t be responsible for modernizing a mission-critical system.<\/p>\n In these systems, everything comes down to the details: a rounding rule in accounting, a sort order, a numeric truncation context, a legacy date format. Invisible in a code review. Very visible in production.<\/p>\n<\/div><\/div><\/div> Faced with this, many organizations conclude: “then everything needs to be reviewed by humans.” That overlooks a third path, proven long before the AI wave: code transformation through deterministic engines, based on syntactic and semantic analysis of the language<\/b>, not on probabilities.<\/p>\n A deterministic process offers three properties that no generative model can guarantee:<\/p>\n On IBM i, two major modernization projects can be carried out this way:<\/b><\/p>\n<\/div> The first obstacle isn’t technical, it’s human: fixed-format RPG is unreadable to newer generations of developers, while Free Form offers a modern syntax closer to Java.<\/p>\n That’s exactly what ARCAD Transformer RPG<\/a> does: a fully automated conversion from RPGLE to RPG Free Form, with a conversion rate close to 100% (C, H, F, D, P specs and GOTO instructions), whether run one program at a time or in bulk. The engine detects truncation contexts in particular and corrects the code to prevent runtime issues; and every conversion can be checked through a visual comparison between the original and converted code. It’s also the only Free Form converter with its own IBM product number (5733-AC1).<\/p>\n For a CIO, that’s the essential point: this engine applies the same conversion rules from the first program to the last, no matter the size of the application portfolio, a guarantee no LLM can offer.<\/p>\n<\/div><\/div><\/div> The second project involves extracting business rules from the RPG monolith to expose them as RESTful web services, consumable by web portals, mobile apps, or partners.<\/p>\n ARCAD Transformer Microservices<\/a> supports this refactoring end to end, with a systematic method rather than a manual one: assistance in selecting candidate code blocks, automatic coupling checks to ensure the extracted modules are consistent, conversion of variables into parameters, automated module extraction, replacement of the original block with a call to the new procedure, and detection of duplicated logic to consolidate it into a single procedure. The observed gain: up to 70% more productivity than a manual effort, without sacrificing the reliability, security, or performance of the existing IBM i back end.<\/p>\n<\/div><\/div><\/div><\/div><\/div><\/div><\/div> Deterministic transformation or not, one governance rule remains: every modernization must be proven. And that proof follows a very precise logic, one that is also deterministic:<\/p>\n<\/div> replay the same business scenarios before and after the transformation;<\/p>\n<\/div><\/li> factually compare the results: screens, DB2 data, spooled output;<\/p>\n<\/div><\/li> turn every discrepancy into a measurable, analyzable, fixable fact.<\/p>\n<\/div><\/li><\/ul> That’s the role of ARCAD Verifier<\/a>. And one point deserves particular attention from QA managers: thanks to the link maintained between application code and test cases, Verifier identifies only the tests affected by a given change. In practice, after converting a batch of programs, you don’t blindly replay 3,000 scenarios: you replay the ones that touch the transformed code. Verification becomes targeted, fast, and therefore genuinely practical at every iteration, not just at the end of the project.<\/p>\n Same input + same scenario = same result. Otherwise, it’s a regression. Trust isn’t declared: it’s demonstrated, screen by screen, record by record, report by report.<\/p>\n<\/div><\/div><\/div> Secure your application changes<\/p>\n<\/div><\/div><\/div> Putting the three pieces together, the secure modernization chain looks like this:<\/p>\n<\/div> AI (understand) \u2192 Deterministic engines (transform) \u2192 Regression testing (prove) \u2192 Trust (deploy)<\/strong><\/p>\n<\/div> One question remains: how do the AI agent and the deterministic engines communicate?<\/p>\n That’s the role of the ARCAD MCP Server<\/a>. Through the standard MCP protocol, it exposes the ARCAD repository (34 years of deterministic analysis of the application estate: components, fields, procedures, dependencies) as more than 70 tools (resources, actions, methodological prompts). The AI agent (Copilot, Claude, an on-premise LLM…) queries these tools in natural language, chains calls together, and can trigger the underlying tooled processes (launching a Free Form conversion through Transformer RPG, for example), all while relying on a certified context derived from deterministic algorithms, not inference<\/strong>.<\/p>\n Three direct consequences for a CIO:<\/p>\n<\/div> AI no longer guesses, it knows:<\/strong> a factual context eliminates hallucinations about the application architecture.<\/p>\n<\/div><\/li> Your code stays with you:<\/strong> only the necessary information is sent to the agent, never the full codebase.<\/p>\n<\/div><\/li> The developer stays in the loop:<\/strong> AI accelerates, structures, and documents; the human expert validates and decides.<\/p>\n<\/div><\/li><\/ul> In other words, the hybrid approach described in this article isn’t a concept: it’s an operational architecture, where the AI agent orchestrates and the deterministic engines execute.<\/p>\n<\/div> This division of labor has an economic consequence that few organizations have measured yet: <\/span>token consumption<\/strong>.<\/span><\/p>\n Having an LLM convert millions of lines of RPG means sending millions of lines in and receiving just as many back out, then starting over with every correction. That means direct cost, latency, energy footprint, and, depending on the architecture, exposure of source code to external services. In the hybrid approach, by contrast, bulk transformation consumes no tokens at all<\/strong>: it’s carried out by syntactic analysis engines. AI is deployed surgically, on high-value tasks: understanding, explaining, documenting, and adjudicating complex cases.<\/p>\n The result: predictable, minimal AI costs, tight control over code confidentiality, and a budget that funds the transformation itself rather than rounds of inference. The MCP protocol amplifies this effect even further: because context makes up for raw model power, even a small local SLM hosted on-premises produces relevant results: sovereignty without the added cost.<\/p>\n<\/div><\/div><\/div> Connect your AI agents to your IBM i estate<\/p>\n<\/div><\/div><\/div> Rather than a pitch, here are three situations that CIOs and CISOs will recognize.<\/p>\n<\/div> Context<\/strong>: a manufacturer with an in-house RPG ERP, 2.5 million lines of code, and the last long-standing developer retiring in 18 months.<\/p>\n The risk isn’t a system failure, it’s losing the ability to evolve the system at all.<\/p>\n The hybrid response<\/strong>:<\/p>\n1. AI to understand<\/h2><\/div>
2. Determinism to transform<\/h2><\/div>
\n
<\/i><\/i><\/span>Automatically converting fixed-format RPG to RPG Free Form<\/span><\/a><\/h3><\/div>
<\/i><\/i><\/span>Methodically refactoring the monolith into modules and web services<\/span><\/a><\/h3><\/div>
3. Regression testing to prove it<\/h2><\/div>
4. A token-efficient hybrid architecture<\/h2><\/div>
The orchestration link: the MCP protocol<\/h3><\/div>
A token-saving economy<\/h3><\/div>
5. Three real-world situations<\/h2><\/div>
<\/i><\/i><\/span>The last expert's retirement<\/span><\/a><\/h3><\/div>
\n