AWS re:Invent 2025 - Enterprise-scale App Modernization with Agentic AI through TSRI's JANUS Studio

🦄 Making great presentations more accessible.
This project enhances multilingual accessibility and discoverability while preserving the original content. Detailed transcriptions and keyframes capture the nuances and technical insights that convey the full value of each session.

Note: A comprehensive list of re:Invent 2025 transcribed articles is available in this Spreadsheet!

Overview

📖 AWS re:Invent 2025 - Enterprise-scale App Modernization with Agentic AI through TSRI's JANUS Studio

In this video, Scott Pickett presents TSRI's enterprise modernization solution combining Agentic AI with JANUS Tooling to address legacy code challenges like retiring SMEs, technical debt, and rising license fees. The 30-year-old company uses a deterministic AI engine called JANUS integrated with GenAI and knowledge graphs to automate code transformation from COBOL/FORTRAN to modern languages. Their new platform Juno enables single-click transformation, automated testing with functional equivalence validation, and AI-driven documentation. Case studies include US Air Force achieving 90% cost reduction and US Postal Service modernization. The solution delivers complete code transformation, database schema migration, screen modernization to React/Angular/Blazor, and REST API integration while maintaining business logic integrity.

; This article is entirely auto-generated while preserving the original presentation content as much as possible. Please note that there may be typos or inaccuracies.

Main Part

The Modernization Crisis: Why Enterprises Must Act Now

Well, good morning. Hopefully you're having a good show and starting the conference off right. I'm Scott Pickett, and I'll be speaking with you about enterprise scale modernization, leveraging Agentic AI and JANUS Tooling.

So what's the problem set? What are the challenges out there? Why do people need to modernize now? Number one, retiring SMEs. They don't teach COBOL in school anymore. There aren't COBOL experts. There aren't FORTRAN experts. There aren't experts in these legacy languages, but there's a lot of that code out there. A lot of institutions and companies still rely on it, and they cannot even get SMEs that have a detailed understanding of the application, let alone know how to fix it, run it, and operate it.

The other issue that enterprises are facing is growing technical debt. Basically these applications haven't been looked at for years and years and years. They're very fragile situations where they can't update regularly. Oftentimes these solutions are updated on an annualized basis at the most. That's a huge obvious issue, and it's growing and growing each year.

The other problem out there that people are facing is increasing license fees. Many of the vendors who shall not be named are now taking advantage of the situation and increasing their license costs by upwards of 300%. They know they've got you, and they're going to increase and increase and lock you in for another three years, and that's another major problem. Got a few people smiling out there.

And the other situation you're seeing is business innovation. Population changes, number of users changes. People want to start to leverage web services and add-on services. The legacy solutions aren't cutting it. They can't meet the business needs.

TSRI has been in the industry for 30 years. It was founded out of Boeing AI labs. We basically touch every single segment worldwide. Cut its teeth in Y2K, really in the defense and federal sector that was most of the business early on. We've since expanded into retail. We've done a number of different postal services recently, rolled out the United States Postal Service. We've done the Danish Postal Service.

Big new momentum happening right now is in insurance companies, modernizing several different insurance companies and just completed a nationwide rollout there. I'll talk a little bit about that. And then also the big one is the financial sector. Some of the largest legacy mainframe solutions right now are in the banking sector and they're modernizing now for the same reasons I just brought up.

TSRI's Hybrid Approach: Combining Deterministic AI JANUS with GenAI Solutions

We're recognized as being a leader in the industry. We're in the top magic quadrant in innovation and solution options. So how does this all work? We have a deterministic AI engine called JANUS. That's a rule-based engine that gives you a known output. You can still leverage experts to be able to write rules to operate on that code base, but you always know the emissions that you're getting. There's no probability in that. There's no guesswork.

We've integrated that in with a Gen AI solution. We have extracted out knowledge graphs that can drive that Gen AI, chunk that down into stuff that are usable chunks that it can operate on efficiently, because we are talking about millions and millions of lines of code. We're also giving a lot more domain expertise associated with that implementation. Those knowledge graphs are driven into a vector database that's allowing you to do a number of new things in your modernization efforts.

First one you've got to do is assess where you're at with your code base, what you don't know, what services you need, what services you don't need. That's all done by utilizing our next generation solution, Juno. That's an application agent that leverages our business documentation, our design documentation, the test documentation, and provides proposal feedback, POC feedback, and actually gets you started in your modernization journey.

The next step after that is actually doing the code transformation. This is all automated. It's all right now available for demonstration at our booth, but it's all automated. It's up on AWS. It'll generate transformed code using that deterministic IOM-based solution, providing you with code output, providing you with additional testing output, being able to give you information on database. We do the schema transformation and actually develop the ETL scripts for the data loading so you have a solution there.

And we also do the screen transformation, migrating people from your legacy green screen situations into a React, Angular, and Blazor type solution. In addition to that, if you're operating based on a solution that can be modernized, you begin to be able to leverage GenAI to do idiomatic refactorings of the Java or C#. And that gets you to a point where you now have a solution that's stable, that you know works, that the business logic is maintained, and you're able to start to reimagine your solution and leverage GenAI to move you forward. You're in a new, updated CI/CD pipeline. You've got unit tests, you have regression tests, and you're now able to build on something that you can move forward with. In addition, typically as a part of this process, we're injecting REST endpoints and API interfaces that allow you to integrate in with COTS solutions or be able to partition the solution out into different microservices.

Let's talk a little bit more about the details associated with the solution. Again, it's all based on a Deterministic AI solution as the foundation. This is JANUS. We're lexing and parsing in a traditional way to drive towards an intermediate object model that's basically a representation of the abstract syntax tree. You can go up and down that syntax tree, you can take out nested loops, you can drive in new REST interfaces, and you can containerize at that point. All the syntactical issues are resolved, the semantics like go-to statements are eliminated, and you're able to basically get a solid modernized solution that runs and is functionally equivalent. Then you're able to also apply rules and do rules-based refactoring and code quality refactoring.

We extract out a knowledge graph that'll allow you to start to leverage GenAI, and with the GenAI solution, you're basically developing a custom prompt engine for your solution that allows you to generate all the details that you need for business documentation, test case generation, and metadata that can allow you to actually run the tests. We can provide seed tests and then be able to expand on those seed tests to increase test case coverage, an often forgotten part of modernization. You end up needing the code, the source code, and we have all these artifacts delivered. It's kind of a new world with respect to being able to have a platform that you can take forward in the modern environment.

Juno in Action: Automated Assessment, Transformation, and Testing at Scale

This solution right now is operating today. Here are a couple of screenshots. They might be hard to see, but go and take a closer look. You'll do the project assessment and get the details of the project assessment, understanding the business logic and having an agent that you can query that solution and get insights into that solution. You can get complete proposals as far as what the costs are going to look like when you're in the AWS environment and what the savings are going to be. You'll have strategic recommendations on how to replace external services that you're dependent on, around those dirty little assembly programs and those proprietary sort programs. You'll have the details that you need in order to replace them, and you'll also be able to have a general understanding of what a project looks like from a cost standpoint. A number of plans are generated as a result of that.

Obviously you've got to understand the legacy code. You have to understand what you don't need. There's a lot of time in the concept of deprecation and regimented deprecation on, hey, we really don't need this, we have to use it now, we're going to support it for the next ten years, but we're going to eliminate that. That's going to migrate over to something else. We're going to transfer the whole thing, bring it up live, and then kind of use a strangler approach and eventually carve out the external type of interfaces, the onboarding interfaces, the printing and reporting functionalities, and slowly replace them. You'll be able to understand what that is like from a project standpoint in a wave of deliverables, a product increment type of approach. You'll have test plans, transformation plans, external replacement plans, and hosting plans.

You also get AI-driven documentation, so you'll have English instead of COBOL. You'll be able to understand the details associated with those programs, and you'll also have deep understanding of the implementations. And that's based on our new offer called Juno, and this is available now. Literally, you can talk to it, ask it questions, and it gets your information back. So that helps with that replacement of the SMEs that are dwindling in availability.

You still have your traditional understanding and visibility of the actual code. We're developing control flow graphs and state diagrams, business rules, and again you see on the right-hand side there, there's your dialogue. You can ask general questions, you know, what does this batch program do? How do I schedule a run with this batch program? Tell me how the payment gateway works, and it'll answer those questions in English. And this gives you a little bit more visibility.

You can ask, you know, how to stand up the database, what can I use to replace that database, what are the differences between the two databases, meaning the source and the target, the DB2 versus Postgres. You're able to get detailed information on the legacy. You have insights on the target, and you're able to map your direction on going in between. One of the interesting things is this kind of replaces about, you know, four or five PMs. Okay, you now have an executive dashboard on what's going on. You have visibility in that. Do you have a complete code set? Do you know what the holes are? Do you know what the holes are in your delivery? What, I just offended some people. Excuse me, nothing's going to replace PMs that always have a role.

You'll be able to get the status on those code deliveries. You'll understand and get summaries, detailed summaries on your code quality, how many rules you're violating, whether or not there's security issues. So this is all at a high level. It's a pretty detailed page, but it gives you the insights on the code quality, the SonarQube readings, security flaws at a very, very high level. It also lets you know these dirty little implementations that nobody wants to talk about. There's all sorts of frameworks that have to be implemented. There's difference in the way data is typed in COBOL that's not representable in a native Java.

So those little dirty secrets are now exposed to you, and you know exactly how you can map between the two, how much of it's been done, how much of it still remains. Same thing with those external functions. There's a lot of different ways you can run sort on a mainframe, a lot of different cards that are used, and now you're able to actually see the level of the state of the implementations of those. And you also get a testing coverage. You'll have testing results. Probably the coolest thing about this offer is it's a single button transformation. You click what used to take days to set up and an expert, you can now just click the button as long as you have the complete code set. You do require the complete code set.

You can go through this process. Well, it'll go through the parsing, lexing. You'll get to the point where you understand what the wraps are. You'll resolve, you'll make sure that you've got a complete solution, do the transformation. You'll get the code coming out. You'll see if it compiles. You'll confirm it compiles. You run it through the pipeline. You'll get the unit test information. You get the test coverage information, run through the code quality scans, and run through the actual functional equivalence testings. And I know it sounds like a miracle, but you could do that with a menu click. We've got the demo up and running. You can see it, kick the tires yourself.

You also have a real-time live log. The resolution's terrible on this screen, so you can see it in the demo. You'll see a live log of what you're parsing, what process you're at. So each one of those, as those cycle through, you'll see the actual status in the logs. And then you'll get it. This is another really cool thing. It's not been done. So you tie this in with SonarQube, you get a SonarQube report, we bring that back through an LLM recommended refactorings. So you have agentic refactorings. We'll go through and you can single-click execute on those different refactorings.

You hold those states and you decide if you want to apply them because sometimes when you do those refactorings you get a more verbose solution, your code set increases, and you might decide not to do that refactoring. So here's a case where you're actually able to select which refactorings you want to apply, apply those refactorings, view the results again. Since you have the testing already done and you know it's functionally equivalent, you don't have to worry about that hallucinating and the probability of those being wrong. You have a solid baseline to work from. And that's this is the testing dashboard.

So before I start on the dashboard, we can extract out metadata from the source code. So we get the files that are touched, the tables that are changed, the input parameters that are required. It's basically everything you need for a unit test.

We've now developed instrumentation on the COBOL that will collect that information automatically. It will gather those files, gather those tables, and put them in a package, making them available in the modern environment. So you've got everything you need to not only have the test case, but actually run the functional equivalent test in the modern environment.

That's huge. That saves like six to nine months. Trying to do this manually is, well, there's a lot of system integrators doing a great job at it now. So you end up with functional equivalence testing. You've got, does it run? Does it crash? You've got to fix it, right? But does it run all the way through? Did it have any errors? Did it have good output? Can you compare the output, and then you get it to pass.

So there are like three different states you do for that functional equivalence. You have to make sure every single bit in that representation is the same as the legacy, and this is for thousands and thousands and thousands of test cases, literally thousands of batch programs, hundreds and hundreds of screens. You've got to automate. You also have to be able to do that at the system end-to-end testing level, and this is often done on the back side.

Proven Results and the Path to Continuous Modernization

You do modifications on the scheduler. You could drive it with Python for an orchestrated solution. On the UI side, you could use something like Selenium. So we've delivered a number of these solutions, and a couple I want to bring up are the United States Air Force. Here they saw a 90% cost reduction with ETS. We got that up and running in literally days and were able to complete the refactoring in less than two months.

These are referenceable, and the interesting thing about ITS on the application side is that they took the next step. They replaced, in 48 states, 36 plans, 29 mainframes, they had to go through and change, they had to go through and make it so that they could have a multi-tenanting capability to handle all those different plans. So they basically turned their solution into a SaaS model, and it's operational on AWS right now.

So how did we do with respect to retiring SMEs? You now have JANUS, an agent that gives you insight into those implementations. You've got it in a modern language where you can hire people to actually work on it. You've got documentation, and you have all the test metadata that's required in order to run it again and again and make sure you didn't break it when you apply your agentic solutions.

How do we do on the growing technical debt? Well, we'll make sure all the SonarQube scores are passed with quadruple A's. That's just, you know, we lead the industry in that area, but we'll also be able to provide agentic solutions to get it to be a solution that looks less like COBOL and more like Java, even though it's based on a COBOL implementation.

What about the increased license fees? You're eliminating your legacy license fees, your legacy IT department. You basically, you're on AWS. It's now managed. So you don't have the same type of issues you had with respect to hardware provisioning. It's automatic, and it's also included, so there's huge savings there.

And then as far as being able to move forward, you're now in an environment where you have experts that can work on it, and they can operate and meet your business requirements. Today we're working on extracting out portions of the code out of COBOL that was in COBOL to be able to separate that into a separate application that they can go through and move to a COTS solution. Those are examples.

Oftentimes this will be done in an MSP type of fashion. We actually commit to a multi-year program that will continue to break out services, break out APIs, and be able to, on an ongoing basis, offer the customer new capabilities, remodernization, reimagination, and continuous modernization.

---

; This article is entirely auto-generated using Amazon Bedrock.