How We Mapped a 35-Million-Line Mainframe in 4 Days - Stephen Chin, Neo4j & Neeraj Deshmukh, Blitzy
https://www.youtube.com/watch?v=oWqsBuhRRZ4
AI Engineer · 19 min · 212 sentences · sentence-level transcript from YouTube's caption track; each line begins at the time shown

[00:01] [music]
[00:12] We have a really exciting session for you guys.
[00:14] So, um you probably don't realize how many systems and how much of the infrastructure which drives modern finance, which drives all the things which happen in the financial district in New York City
[00:28] are driven off very old systems which can use a lot of modernization.
[00:35] And you probably interact with them on your on your cell phone, you maybe you're banking on a mobile app, but you don't realize that underneath the covers there's business rules, there's batch jobs running in nightly processes.
[00:48] You have all these different data contracts and things running under the covers.
[00:52] And it's running on infrastructure which people are frankly afraid to touch, right?
[00:57] If you if you make one little line of code change, you risk breaking the whole system.
[01:03] And um so this is um fun fact about myself.
[01:07] So, um you know, now I'm I'm known for doing a lot of developer relations, AI conferences, book writing.
[01:13] Um back 30 years ago, I was a Java developer who was migrating COBOL code off mainframes and like, you know, figuring out how to modernize applications.
[01:26] And it was multi-year projects, very challenging work which inevitably you hit little bugs and issues.
[01:34] You couldn't test it thoroughly enough to hit all the different corner cases and very very challenging projects which often failed.
[01:43] So, I think that what we're going to show you today is amazing cuz it's a new path forward where you can drive the change and you can actually do this, but
[01:54] um why don't you tell us a little bit about how this works, Neeraj?
[01:58] Thank you, Steve.
[01:59] So, we're going to do this with an example, right?
[02:03] Uh, in the context of a public demo system which Amazon developed a few years ago.
[02:10] This is the AWS card demo.
[02:12] And going to take a specific example here where we are trying to compute interest, right?
[02:22] And so, as you can see in this little chart, we have a batch job that's calling the interest program which is getting the copybooks and layouts and then generating basically VSAM
[02:37] data, right?
[02:38] And so, the output here is money and of course, the result depends on the inputs, the job that runs it, the account updates, not just the formula for computing the interest, right?
[02:53] So, let's remember this example.
[02:56] We're going to keep coming back to this, hit that theme over and over again as we progress through the talk.
[03:04] So, when I want to modernize this and I tell AI, hey, change that formula from Cobalt to Java, all it's going to do is find the formula, try to convert that, right?
[03:17] What it doesn't find is the the record precision, the account updates, the transaction output, the batch contract.
[03:25] And if you miss any of these, you're not guaranteed to get the right outcomes.
[03:32] So, the failure here is not that AI can't write the code.
[03:37] It's that AI doesn't know the 14 other places where that logic, that code is being used.
[03:45] Okay, and this this looks pretty scary.
[03:46] I mean, besides the AI not knowing the code, that pipe looks like it's about to burst.
[03:51] Yeah, and of course, the AI doesn't know that it's going to happen any moment now.
[03:54] So, Stephen, you would think that a context expansion would fix this.
[04:01] Why doesn't that
[04:02] Yeah.
[04:03] So I I think that one of the things actually the previous presenter talked a bit about this, how we're we've all been relying on better models, on having better systems, a better AI systems to solve this.
[04:15] And frankly, it hasn't been working for these sorts of use cases and the reason is context.
[04:20] So you can do vector databases to get and you know expand your context, but all it gives you is similarity searches.
[04:28] You can do relational databases as well and this gives you a much bigger repository.
[04:34] You can hook it up via an MCP server, but again, you're you're limited on kind of single hop and like looking up facts and information by SQL queries.
[04:43] What a graph gives you is a graph gives you this multi hop accurate information and context for your model.
[04:51] And the reason why this context is so important is because your model cannot possibly give you the right results because it can't utilize its own context.
[05:03] So most models, you know, nowadays are advertised with a million token context windows.
[05:09] Um but what do they actually how much usable context do you actually get?
[05:15] And the reality is you get 200k or less usable context, right?
[05:18] So it's by by study the accuracy goes down dramatically as you fill the context more and this means you have to give precise and accurate context.
[05:30] Yeah, the effective context these days is about like 20 to 30% which means about 200 to 300,000 lines of code.
[05:39] If your software is bigger than that, too bad.
[05:42] You're going to start losing information.
[05:45] So context is serial, but information has relationships.
[05:50] Information has connections between it.
[05:53] And this is the key to how you can actually line up your data.
[06:03] Yeah.
[06:04] So I mean here so code becomes a graph, right?
[06:06] You can see all of these relationships that are being mapped here now.
[06:10] Uh, and like the the program is there.
[06:15] It has the the job that's executing it, the copy book that are getting included, so on and so forth, the outputs.
[06:21] The important part here is the stuff on the right.
[06:27] So, every edge in the graph keeps its identity, right?
[06:32] Where did it come from in the repo?
[06:33] What revision was it?
[06:34] What symbols does it touch?
[06:36] There is evidence for the file and the and the source span, how it was extracted.
[06:41] And the graph keeps getting updated on on every merge as the code changes, so does the uh the graph.
[06:48] And that way you keep it fresh, you keep it current, you invalidate stuff that is no longer valid.
[06:54] Yeah, and you can see that the code is very much a graph-shaped problem.
[06:57] So just from the structure and the relationships, it's something where you have a lot of interconnects.
[07:03] Um, and then when you what why don't you talk about how this works for agents?
[07:08] Sure.
[07:09] So, each agent uh in Blitzz has a specific task context packet, right?
[07:16] And that includes what the task description is, uh but also where does it belong to in that graph, right?
[07:23] There's the slice of the source, right?
[07:25] What constraints it has imposed, what evidence it has available, and what questions are still not answered that that agent is now supposed to work on.
[07:36] Uh, and this is what we mean by infinite code context, right?
[07:38] It's not remembering the entire uh information in in your code base, in your software estate.
[07:44] It's basically having access to the right information at the right time, in the right place.
[07:53] So, Blitzz effectively works like a compiler for the entire knowledge in the enterprise, right?
[08:00] You start off by reverse engineering the entire software estate.
[08:04] You extract the business logic, uh the workflows, the dependencies.
[08:09] Then you get the requirements and the rules from the user to say, what do you want to do with this?
[08:14] And you convert that into an actionable agent action plan, right?
[08:19] This is the spec that you're going to use to make that forward change.
[08:25] Note that next block there, there is a human approval, right?
[08:28] Nothing happens without a human in the lead making decisions at every key point, right?
[08:35] But once you have that plan reviewed and approved by the human, now the agents go off, they do the code generation.
[08:44] But there is also validation that is baked into it at every step.
[08:47] And so the end result is you get tested and validated code in the form of a pull request and an evidence documentation for what has happened and how it has been validated
[08:58] in the form of a project guide.
[09:00] So there is a human approval at every step that matters.
[09:07] And because you have access to the full repository and you also have the instructions about how to build the environment, how to run the code, you are not restricted
[09:19] to just static information.
[09:21] You can actually observe the runtime behavior and make changes accordingly.
[09:28] So the the knowledge graph basically drives all of this, right?
[09:32] But that's not the only thing that helps here.
[09:37] There are two other things that compound the impact that this has.
[09:41] One is hyperscale orchestration.
[09:43] Like we have thousands of agents who all share that plan.
[09:47] Every agent has access to the effective context and there is nothing lost between them.
[09:54] And couple that with extreme validation, right?
[09:57] You have testing happening at every stage of code generation.
[10:02] We actually spend more computes on testing than we do on code gen.
[10:06] And this results in what is effectively production safe code, that has been tested, validated at enterprise scale and so it is safe to make merges into your production systems.
[10:22] So the agent action plan is is the spec, right?
[10:25] That's the plan before you start doing any actual work and it decides what the scope is, what gets transformed and what must be preserved, right?
[10:37] And a domain expert, a human would review this, make sure that it's aligned with their expectations, approve it and this is coupled with the four controls that are inherent
[10:49] at every step.
[10:50] There is system level context, that's the knowledge graph we talked about, right?
[10:55] Every change impacts the entire estate, so everybody needs to be aware of that, right?
[10:59] There is continuous validation, so testing, testing, testing, right?
[11:03] There's no substitute for that.
[11:05] You have explicit guardrails in place to address your security, your governance, your compliance requirements.
[11:11] These are inherent to any regulated industry and of course finance, right?
[11:15] And then the human in the lead because the decisions that matter are owned by real people.
[11:20] The AI is not making them autonomously.
[11:25] And this of course preserves the behaviors, right?
[11:28] The existing behaviors have to be transferred as is to the to the modernized code and how do you verify that?
[11:39] Right.
[11:40] So in this case like we want to preserve the money like the precision, the rounding.
[11:47] We want to preserve the state, the balances and the transaction records, failures, operations, everything, right?
[11:54] If we have defects, they also need to be managed with explicit decisions.
[11:59] The rules have to be preserved as well and you have to prove the parity.
[12:04] You can't take it as an assumption or as a promise.
[12:09] So the way we do that is there is testing on the baseline.
[12:14] There is equivalent testing happening on the modern system, and we are looking at inputs and outputs, the returned values, what states get persisted, what is the transaction output look like, right?
[12:26] What are the error outcomes?
[12:28] Not just the happy path, but how do you deal with like bad situations?
[12:33] And all of those have to be exactly matching in the context of each operation, and the differences have to be none.
[12:43] That's our promise to deliver this.
[12:47] So this is layer, right?
[12:49] This doesn't happen only in the end.
[12:51] This is baked into the very fabric of the code generation.
[12:53] Every line of code that gets generated gets built and tested with unit tests.
[12:58] The build has to be compiled.
[13:01] Runtime integration, it has to fit within the existing kind of framework that you have.
[13:07] Your data parity has to be there on every write, and the end-to-end workflow has to be identical.
[13:15] So this is a code from one of the customers where we actually did this, right?
[13:18] The transpiled job produces output that is byte for byte identical to the golden mainframe baseline.
[13:23] This is from a Fortune 100 insurance.
[13:27] Here's a fun example.
[13:29] So so this is something I can get into as an old Java developer where we we made lots of errors with big decimals and rounding in our implementation.
[13:37] So AI can do this better, right?
[13:40] Right.
[13:40] I mean you you you would think so, right?
[13:43] Because like you computed a a Java version of this this formula to compute interest, right?
[13:50] Cobol behaves differently than Java.
[13:51] Java has an inherent rounding up built into it.
[13:55] What that means is the modern code compiles, it generates results that you believe are correct because it's behaving like normal Java code, right?
[14:06] But you have this little difference of that 1 cent that happened because of the inherent rounding.
[14:12] If you didn't have that parity test, you wouldn't have caught this.
[14:15] And now imagine this happening over a million transactions.
[14:19] Fun.
[14:22] So that was just one kind of simple example, right?
[14:27] But now you can think of like a full trade posting engine where this gets applied throughout the entire workflow.
[14:33] This is something that we did for a tier one bank where we had a monolith that had stored procedures uh cross database uh kind of uh write access going on.
[14:44] This got converted into six capability modules uh with PostgreSQL, Java, TypeScript, Python, the fully modern stack uh and with full parity.
[14:56] Right?
[14:56] And took only 18 days uh whereas their original plan was to have uh 18 engineer weeks dedicated to this project.
[15:05] Right?
[15:05] This was doing things the kind of human way.
[15:09] Uh with Blitzz, it got reduced to 18 days.
[15:12] Right?
[15:12] We We wrote 4,000 plus tests.
[15:14] Uh the modern code was less than half the size of the of the new of the old stack uh and the customer was happy.
[15:24] There is no doubt that we can use Blitzz to modernize the whole system is is what they said.
[15:30] Another example, mapping a 35 million line mainframe.
[15:34] Uh this is something uh that they had spent on an SI about eight months, several million dollars and had nothing to show for it.
[15:41] Uh Blitzz reverse engineered that in a matter of four days and this is what they have to say.
[15:46] They've been in the dark room with a pencil light inspecting each individual module.
[15:50] Blitzz feels like flipping on the overhead light, seeing the whole room at once.
[15:55] This is what AI accompanied by a knowledge layer can do for you.
[16:01] Right?
[16:02] Uh another example, we modernized a 25 million line monolith.
[16:06] This was a policy admin platform again uh compared to a human aided by AI like your typical IDE based uh agentic tools uh would have taken a certain amount of time.
[16:17] We did it nine times faster.
[16:19] 85% of the code was autonomously completed and almost 90% of that made it into production.
[16:27] This extends to different systems, different companies.
[16:30] As long as you understand the whole system before you change it using AI, you're good.
[16:37] And this doesn't just stop at modernization, right?
[16:39] Ultimately, transformation is the goal.
[16:42] Britezi is not a modernization platform.
[16:44] It is a transformation platform.
[16:46] You can do new product development.
[16:49] You can add new features.
[16:50] You can do security remediation and detection.
[16:53] All kinds of use cases open up when you have that entire estate available to you.
[16:59] And so another coming back to the card demo, now that you have modernized it, you may want to add a new feature, a promotional rate to the interest path, right?
[17:09] You already have the upgraded knowledge path now because you already have the modern system.
[17:14] Your knowledge layer got updated.
[17:16] You have your governance rules established.
[17:18] You have your test suite expanded.
[17:20] So now this becomes a lot easier and faster and cheaper to do than it had been before.
[17:28] And then you can do this beyond the code to expand this kind of knowledge to apply to new cases, new use cases like providing audience, providing evidence for like audit ready
[17:44] compliance issues.
[17:49] So as you can see, this is heading beyond software and mapping the whole business now.
[17:57] Yeah, so I think that you can see the power of building a an modern enterprise layer on top of a knowledge graph.
[18:05] And it starts with a graph, builds out the business rules, business processes, and then allows you to build end-to-end systems which not only solve the modernization use case, but they also give you capabilities
[18:18] to expand your business.
[18:20] So you can now do um for example, Dora compliance on your um entire system to make sure it meets regulatory requirements.
[18:29] You can track business rule changes.
[18:31] You can do financial fraud and build um use cases which will track down other sorts of problems and this expands to even further out where you can extend your system and build more value off of it.
[18:47] We want to leave you with a few references to um to take with you.
[18:51] So um one is the Nodes conference, that's the QR code on the left, is a full 24 hours of sessions learning on knowledge graphs on how you can build and apply a bunch of these concepts
[19:05] for our knowledge graphs to your own systems.
[19:08] And um Niraj, you want to talk about
[19:10] Yeah, the Blu Age sandbox, that's the QR code on the right, will allow you to in fact bring in your own code and uh see this for yourself.
[19:17] Don't just take our word for it.
[19:19] You can also see the AWS card demo modernization that we showed here uh as an example there.
[19:26] Okay, so thanks so much for joining our session at A and G in New York City.
[19:30] And um if you have any more questions, feel free to drop by the Neo for J booth or come up and chat with us after the talk.
[19:35] Thank you.
[19:36] Thank you very much.