# How We Mapped a 35-Million-Line Mainframe in 4 Days - Stephen Chin, Neo4j & Neeraj Deshmukh, Blitzy

Stephen Chin, Neo4j · Neeraj Deshmukh, Blitzy

[Talk page](https://ai.engineer/talks/oWqsBuhRRZ4-we-mapped-35-million-line-mainframe) · [Video](https://www.youtube.com/watch?v=oWqsBuhRRZ4)

## How Blitzy Mapped a 35-Million-Line Mainframe in Four Days, and What It Takes to Move the Money

Stephen Chin of Neo4j and Neeraj Deshmukh of Blitzy follow an interest payment from a COBOL batch job to its Java replacement, showing how to find the dependencies an agent needs and test whether the money comes out right.

### The mobile banking app has a nightly batch job underneath it

[0:14](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=14s)

A customer can bank from a phone while decades-old software handles the account. Under that interface, business rules determine what should happen, nightly batch jobs do the work, and data contracts govern what one program can expect from another. Stephen Chin starts here because it explains why engineers hesitate over a one-line change. The line is easy to edit. Finding every process whose behavior depends on it can take much longer.

About 30 years earlier, Chin was a Java developer migrating COBOL applications off mainframes. These were multiyear projects. His team could translate the code and test it, yet still miss a corner case that surfaced as a small, consequential bug. In his experience, projects often failed. Neeraj Deshmukh takes up that testing problem with an example small enough to follow from the job invocation to the money it records.

### Follow an interest posting through AWS CardDemo

[1:58](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=118s)

AWS CardDemo is a public demonstration system developed by Amazon. Deshmukh picks one operation, computing interest. A batch job calls the interest program. The program works with record layouts defined in COBOL copybooks and produces VSAM data. To follow one posting, start with the inputs and the job that supplies them, inspect the layouts the program uses, then follow the account update and the outgoing transaction. The arithmetic sits partway along that path.

Now give an AI coding tool the instruction to convert the interest formula from COBOL to Java. It can find the expression and produce a translation. That instruction gives it little reason to inspect the precision of the record holding the amount, the update to the account, the transaction output, or the contract under which the batch job runs. Each affects what it means to post the right amount. Deshmukh describes the missing knowledge as the other 14 places the logic is used. A reviewer looking only at the translated expression has the same blind spot.

![A solid cyan line connects the interest formula the agent found to the Java migration request. Dashed red lines lead to four missing pieces of context: record precision, account update, transaction output and batch contract. A pipe sprays water in the background.](https://ai.engineer/api/talk-essay-media/4bdb6eb36142e87eca0b87b10ab2731472546b47a469d90c1956c54929ccbefe)

The cost of missing context when moving interest calculation to Java

### Three ways to retrieve context, with different results

[3:55](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=235s)

Deshmukh asks why expanding context would fail to solve this. Chin distinguishes three retrieval approaches. A vector database finds material by similarity. It may surface another passage about interest, while a relevant layout matters because the program includes it. A relational database offers a larger repository of facts, accessible, for example, through an MCP server issuing SQL queries. Chin describes that pattern of use as a single-hop lookup. A graph supports multi-hop retrieval: begin at a program, find the job that executes it, inspect the copybook it includes, and follow its outputs. Each connection gives a reason to retrieve the next piece.

There is also a limit to what a model can use once the material has been found. Chin contrasts an advertised million-token window with his estimate of 200,000 or fewer usable tokens, citing declining accuracy as the window fills. The speakers also give a rough effective-context estimate of 20 to 30 percent and discuss codebases exceeding 200,000 to 300,000 lines. Those are different units and rough estimates. The practical problem is selection. A prompt presents material in sequence, while a program's caller, layout, and output may occupy distant parts of a repository.

### Give each dependency a source location and a revision

[6:03](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=363s)

In the graph of CardDemo, the interest program connects to the job that executes it, the copybooks it includes, and the outputs it produces. Deshmukh draws attention to what accompanies each edge. It retains its identity, its origin in the repository, the revision, and the symbols it touches. The evidence identifies the file, the span of source, and how the relationship was extracted. An engineer investigating a dependency can go back to the code that established it.

![The INTCALC job executes the highlighted CBACT04C program. The program includes a copybook that defines DIS-INT-RATE, reads and updates ACCOUNT-FILE, and writes TRANSACT. A legend distinguishes observed edges from inferred edges.](https://ai.engineer/api/talk-essay-media/edc27523f69b4ae7c39c3eb51c5ebed4fd5a4899239c823f5724742da6846a94)

Code becomes a graph that keeps its source

Blitzy updates the graph on every merge and invalidates relationships that have ceased to hold. That matters during a migration because the map is also an input to subsequent changes. Once a program or its dependencies change, an agent assigned to the next job needs the relationships supported by the merged revision. An accurate inventory of the original mainframe would, on its own, describe an increasingly old version of the system.

### Package the evidence for one agent’s assignment

[7:08](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=428s)

Each Blitzy agent receives a task context packet. It contains the task description, where the work belongs in the graph, the relevant slice of source, the constraints on the change, and the available evidence. The packet also identifies unanswered questions the agent is supposed to work on. In the interest example, the batch caller and the included layout belong together in the assignment even though they live outside the formula being translated.

![A flowchart shows a shared system graph and persistent memory feeding a highlighted task context packet. An agent uses the packet and tools to produce a patch with test evidence. Unresolved questions trigger fresh retrieval.](https://ai.engineer/api/talk-essay-media/a75072a10d4cbe53685e2bb9d90604d2f7d52bc88fe4e48c9088fe931bb6db27)

A context packet for each agent

This is what Deshmukh means by “infinite code context.” The software estate can be much larger than one prompt because an agent can access the information relevant to its task when it needs it. The graph supplies the connections. The packet narrows those connections to a particular decision and distinguishes what the source already establishes from what still needs investigation.

### Approve the transformation before generating code

[7:53](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=473s)

Deshmukh likens Blitzy's process to compiling the knowledge in an enterprise. First it reverse-engineers the software estate to extract business logic, workflows, and hidden dependencies. The user then supplies requirements and rules for the proposed change. These feed an agent action plan, the specification that states the scope, what will be transformed, and which behaviors must carry over. A domain expert reviews that plan against the intended outcome and approves it before agents begin generation.

Agents have access to the repository and instructions for building the environment and running the software. When the source leaves a behavioral question open, they can execute the program, observe what happens, and use that observation while making the change. The deliverable has two parts. A pull request contains the tested code. A project guide documents what changed and the evidence used to validate it. That gives the person reviewing a consequential change both the implementation and an account of how it was checked.

### Thousands of agents share a plan and test as they go

[9:32](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=572s)

Deshmukh pairs what he calls hyperscale orchestration with extreme validation. Thousands of agents share the approved plan, while each works with the context relevant to its assignment. For a split such as interest calculation and account updating, the common specification matters: the work can be divided, but both pieces still have to satisfy the same posting behavior. Deshmukh says Blitzy spends more compute on testing than on code generation.

He identifies four controls throughout the process. System-level context exposes dependencies beyond the component being edited. Continuous validation checks the code during generation. Explicit guard layers apply security, governance, and compliance requirements, particularly important for financial systems. Finally, a human owns the decisions that matter. An existing defect is one such decision. If the replacement is supposed to reproduce today's behavior, correcting a defect changes the target and requires an explicit choice.

### Compare what each operation returns, writes, and emits

[11:35](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=695s)

For the interest operation, preservation has several observable dimensions. The monetary amount has a precision and a rounding behavior. The account has a balance after the update. A transaction record leaves the program. Failures have outcomes too. Blitzy runs tests against the existing system as a baseline, exercises the modern system with equivalent inputs, and compares the results operation by operation. A matching return value leaves open whether the program persisted the same balance or emitted the same transaction.

![The same versioned fixtures and controlled clock feed a COBOL baseline and a Java candidate. Arrows from both lead to a comparison of four outputs, labeled diff=0.](https://ai.engineer/api/talk-essay-media/651f7c3f1acf1e425c9769ea8574522f072d3cb457cc36138206196fc53a99ad)

Parity is proven, not promised

The checks accumulate. Generated code must compile and pass unit tests. At runtime it must integrate with the existing framework. Each write must achieve data parity, and the full workflow must reproduce the baseline, including error outcomes for the failure cases exercised. Deshmukh sets the target at zero differences for the operations being compared. He gives a customer's acceptance result as an example: at a Fortune 100 insurer, a transpiled job produced output identical byte for byte to its golden mainframe baseline. That is a concrete comparison for a particular job.

### The Java calculation compiles and misses by one cent

[13:26](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=806s)

Chin remembers making decimal-arithmetic and rounding mistakes as a Java developer. Did the AI do better? In Deshmukh's interest example, the generated Java compiled and produced an amount that looked reasonable to someone familiar with Java. On the test input, the Java calculation rounded up and posted one cent more than the COBOL baseline.

![Three cards compare results for one calculation. COBOL stores $16.66, the illustrative Java mutation rounds to $16.67 with HALF_UP, and Java with RoundingMode.DOWN matches the $16.66 baseline.](https://ai.engineer/api/talk-essay-media/9c5ee34f618f1a0eaab5d7e735225a212126dbde62ab5e309fe2396f41d667fc)

One cent exposes the difference

The mainframe run supplied the decisive expected value. A unit test written from the translated expression could have endorsed the Java result, and a reviewer inspecting the amount in isolation could easily have accepted it. Comparing the two implementations on the same operation exposed the cent. Deshmukh asks the audience to imagine that discrepancy recurring across a million transactions. Even at one cent, the team needs to know which accounts and records its calculation would change.

### An 18-day migration, a four-day map, and a policy platform

[14:22](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=862s)

Deshmukh reports three engagements with different deliverables. At a tier-one bank, the starting point was a monolithic trade-posting engine with stored procedures and writes across databases. Blitzy converted it into six capability modules using PostgreSQL, Java, TypeScript, and Python. Deshmukh reports full behavioral parity, more than 4,000 tests, and a modern codebase less than half the size of the old one. Delivery took 18 elapsed days. The bank's original plan had allocated 18 engineer-weeks, a labor estimate rather than an elapsed-time measurement.

On the 35-million-line mainframe, the four-day result was reverse engineering. According to Deshmukh, the customer had already spent about eight months and several million dollars with a systems integrator and had no usable result to show. The customer described the earlier experience as inspecting individual modules in a dark room with a pencil light. Seeing the mapped system felt like switching on the overhead light. What the customer could now see was how the pieces related across the estate.

![A bar chart compares the time to map a Fortune 100 insurer’s mainframe into a knowledge graph. The short cyan bar shows 4 days for Blitzy. The long orange bar shows 8–12 months for a typical SI.](https://ai.engineer/api/talk-essay-media/56584e01ddee0750b32ccc70554444932edc2e22e734c23f3aed2087f53467ce)

Mapping a ~35M-line mainframe

The third engagement involved modernizing a 25-million-line policy administration monolith. Deshmukh says Blitzy completed the work nine times faster than he estimates an engineer using IDE-based agentic tools would have done it. He also reports that 85 percent of the code was completed autonomously and that almost 90 percent of that portion made it into production.

### Use the updated interest path to introduce a promotional rate

[16:37](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=997s)

Deshmukh returns to CardDemo with a different assignment. Suppose the business now wants a promotional interest rate. The modernization has left the team with a graph of the upgraded posting path, established governance rules, and an expanded test suite. Engineers can trace where the new rate should apply and use the existing comparisons for postings that should continue to behave as before. The domain decision concerns which behavior to change. The earlier work supplies evidence about everything that decision touches.

![A checklist shows what the promotional-rate feature can reuse, including a test for the one-cent rounding rule. A list alongside names the knowledge layer, governance rules, and test suite from prior changes.](https://ai.engineer/api/talk-essay-media/072c750a0abb6840dccc891fbad20e5a47105646f03a5fbf0c281323cb775b5b)

Adding a promotional interest rate to AWS CardDemo

Deshmukh extends that reasoning to new products, feature development, security detection and remediation, and evidence for compliance audits. Chin describes moving from code relationships to business rules and processes, with possible applications in tracking rule changes, examining DORA compliance across a system, and investigating financial fraud. For practitioners who want to inspect the example, Deshmukh points to the Blitzy Sandbox, which includes the AWS CardDemo modernization and accepts users' own code. Chin points to the Nodes Conference for 24 hours of sessions on building and applying knowledge graphs.

## Key takeaways

- Scope a financial migration around a complete posting. Identify the batch caller, record layout, persisted balance, transaction output, and failure outcomes before assigning the arithmetic.
- Keep the repository revision and source span behind each dependency. Refresh the graph on merge so the next agent can work from the code that actually exists.
- Use the existing system to establish expected behavior. Compare equivalent runs at each write and across the complete workflow, and ask a domain expert to decide which existing defects should change.

## Slides

### The software beneath the surface — business rules, batch jobs and data contracts

[0:28](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=28s) [Against a backdrop of industrial pipes, a highlighted box for mobile, web and APIs sits above three stacked boxes describing the business rules, batch jobs and data contracts they can depend on.](https://assets.ai.engineer/sites/aiecode2025/sha256/e2053875cb1b70aa1f2efbc586d5cca0b1d73849a1af309ed747161209807ad2.webp)

THE STAKES
The software beneath the surface

A modern experience
mobile, web, APIs

Can depend on decades of connections

Business rules
Decades of encoded behavior the business still needs

Batch jobs
Nightly runs, ordering, restart expectations

Data contracts
Record layouts, precision, signs, encodings

### The software beneath the surface — COBOL use, retirements and the agentic AI forecast

[0:59](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=59s) [Three side-by-side cards show an estimate of 220B lines of COBOL in production, an annual COBOL engineer retirement figure of ~10%, and a forecast that 40%+ of agentic AI projects will be cancelled by 2027. The forecast card is highlighted in red. Each card has a source beneath it.](https://assets.ai.engineer/sites/aiecode2025/sha256/fcdd601281a44c12f12bdf0a83f375728efd58aba8bd9678e31b5960029a8770.webp)

THE STAKES
The software beneath the surface

220B
lines of COBOL still in production
use
Widely cited industry estimate (Reuters, 2017)

~10%
of COBOL engineers
retire every year
Open Mainframe Project, 2020

40%+
of agentic AI projects forecast
to be cancelled by 2027
Gartner forecast, June 2025

### Follow the interest calculation in AWS CardDemo

[2:39](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=159s) [White text over a large copper pipe introduces the AWS CardDemo credit card example. It identifies the input records, job, account updates and transaction output involved in calculating interest.](https://assets.ai.engineer/sites/aiecode2025/sha256/4d3348e5011e5e5e1f6b7fda9f631d989cece5e7cb1ab08ff867acd5a9a38697.webp)

ONE CREDIT CARD SYSTEM • AWS CARDDEMO
Follow the interest calculation

WHY THIS PATH

The output is money. The behavior depends on input records, the job
that runs it, account updates and transaction output, not just the
formula.

Keep this one path in mind.

Every idea in this talk comes back to it.

AWS open-source sample. Diagram simplified from public source; not a bank deployment

### The cost of missing context when moving interest calculation to Java

[3:02](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=182s) [A solid cyan line connects the interest formula the agent found to the Java migration request. Dashed red lines lead to four missing pieces of context: record precision, account update, transaction output and batch contract. A pipe sprays water in the background.](https://assets.ai.engineer/sites/aiecode2025/sha256/4bdb6eb36142e87eca0b87b10ab2731472546b47a469d90c1956c54929ccbefe.webp)

THE REAL PROBLEM
The cost of missing context

(what the agent found)
Interest formula

“Move interest calculation to Java”

Record precision          Account update
Transaction output        Batch contract

### More context isn’t the fix. Relationships are. — Vector, relational and graph comparison

[3:56](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=236s) [Two upper boxes describe vector similarity and joins in a relational database. A highlighted graph box spans the width of both below them and describes traversal by following pointers.](https://assets.ai.engineer/sites/aiecode2025/sha256/8b653d39e7d88fed5bcd0e825f008abe0f8273b99c7c2eb32ed489e4d882c091.webp)

WHY IT’S HARD
More context isn’t the fix. Relationships are.

Vector only
Find what’s similar,
not what’s connected

Relational
Every hop in another join;
deep traversal gets heavy

Graph
A hop is a pointer. Traversal is the native operation

### Accuracy (%) as context length grows

[4:53](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=293s) [A line chart shows accuracy declining for GPT-4.1, GPT-4o and Gemini 2.0 Flash as context length grows. Gemini 2.0 Flash has the steepest decline. Text beside the chart defines effective length using 85% of short-context accuracy.](https://assets.ai.engineer/sites/aiecode2025/sha256/db1a98b9297e67915bc5a913de21a3b347575678aca3608d43066c4fdf8fe4d5.webp)

WHY IT’S HARD
More context isn’t the fix. Relationships are.

Accuracy (%) as context length grows
100
80
60
40
20
0
1  2  3  4  5  6  7  8

GPT-4.1 (1M advertised)
GPT-4o (128K advertised)
Gemini 2.0 Flash (1M advertised)

Every model falls well short of its
advertised window. Effective length
(≥85% of short-context accuracy) is
a small fraction of the total.

Source: Modarressi et al., “NoLiMa: Long-Context Evaluation Beyond Literal Matching,” ICML 2025
(Adobe Research).

### Code becomes a graph that keeps its source

[5:59](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=359s) [The INTCALC job executes the highlighted CBACT04C program. The program includes a copybook that defines DIS-INT-RATE, reads and updates ACCOUNT-FILE, and writes TRANSACT. A legend distinguishes observed edges from inferred edges.](https://assets.ai.engineer/sites/aiecode2025/sha256/edc27523f69b4ae7c39c3eb51c5ebed4fd5a4899239c823f5724742da6846a94.webp)

WHAT SOLVES IT
Code becomes a graph that
keeps its source

INTCALC
Job
executes
CBACT04C
Program

includes
CVTRA02Y
Copybook
defines
DIS-INT-RATE
Field

reads / updates
ACCOUNT-FILE
Data store

writes
TRANSACT
Output

EVERY EDGE KEEPS ITS SOURCE

Identity
Repository • revision • symbol

Evidence
File + source span • extraction method

Freshness
Re-extract on every merge; invalidate affected
edges

Observed: extracted from code
Inferred: proposed by a model

Illustrative teaching schema; names from AWS CardDemo.

### A context packet for each agent

[7:02](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=422s) [A flowchart shows a shared system graph and persistent memory feeding a highlighted task context packet. An agent uses the packet and tools to produce a patch with test evidence. Unresolved questions trigger fresh retrieval.](https://assets.ai.engineer/sites/aiecode2025/sha256/a75072a10d4cbe53685e2bb9d90604d2f7d52bc88fe4e48c9088fe931bb6db27.webp)

MEMORY FOR AGENTS
A context packet for each agent

Infinite Code Context: managed access to the whole system as needed, not an infinitely large window.

Shared
System graph

Shared
Persistent memory

retrieve

Task Context Packet
Task
Source slice
Constraints
Evidence
Unresolved questions

ground

Execute
Agent + tools

Produce
Patch + test evidence

Unresolved questions trigger fresh retrieval. Evidence stays linked to its source.

### Blitzy: An Enterprise Compiler

[7:52](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=472s) [A six-step workflow runs from reverse engineering to a pull request and Project Guide. Human approval is highlighted between planning and generation. Below it, the knowledge graph describes the existing system, and the approved plan describes the intended change.](https://assets.ai.engineer/sites/aiecode2025/sha256/ae97928844b439f67025421816e5c7cb89465138d245777d4eee58fa2da4a4f2.webp)

HOW BLITZY WORKS
Blitzy: An Enterprise Compiler

Reverse engineering
Requirements + rules
Agent action plan
Human approval
Generation + validation agents
Pull request + Project Guide

Knowledge graph + technical spec
What exists. Refreshed on every merge.

Approved plan
What we intend to change.

Repository + build environment
Private dependencies, runtimes, instructions. A specification can’t replace a runnable system.

100M+ lines per codebase, compiled into a living knowledge graph agents can act on

### The Graph is essential. Combined, it compounds.

[9:25](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=565s) [Three panels joined by plus signs describe keeping a knowledge graph current, coordinating thousands of agents on one plan, and validating changes before a pull request. An equals sign connects the three to production-safe change.](https://assets.ai.engineer/sites/aiecode2025/sha256/bda3121b05180cc84d9d9dfa5e0bfd0dff39eeca7cee6709c0f123c269e11b9b.webp)

WHAT MULTIPLIES THE MAP
The Graph is essential.
Combined, it compounds.

Knowledge graph
THE SOURCE OF TRUTH
The Hard Part
Complete, consistent and current across languages, decades of code and every merge

+

Hyperscale orchestration
THOUSANDS OF AGENTS, ONE PLAN
The Hard Part
Every agent kept inside its effective context, with nothing lost between them

+

Extreme validation
PROOF BEFORE ANY PULL REQUEST
The Hard Part
Most compute goes to validating, not generating: parity, tests, security checkpoints

= Production-safe change at enterprise scale
Shared context doesn’t eliminate coordination. Together, they turn a map into outcomes.

### The plan before the work

[10:20](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=620s) [Scope, transformation, and preservation sit above a five-step workflow. Domain review and approval precede generation. Four boxes below describe system-level context, continuous validation, explicit guardrails, and human decisions.](https://assets.ai.engineer/sites/aiecode2025/sha256/701d424a4cac19da71c0bcb77c07388b6116232a3771780dfb5caff367f2174a.webp)

THE PRODUCTION-SAFE PATTERN
The plan before the work

Scope
Files, dependencies and exclusions

Transformation
Source behavior to target design

Preservation
Precision, outputs and failure paths

Target state + source analysis
Agent Action Plan
Domain review
Approve
Generation

FOUR CONTROLS ON EVERY CHANGE

System-level context
Every change affects the whole estate, so every plan sees it

Continuous validation
Proven enterprise-grade testing as agents work, not after

Explicit guardrails
Governance and security designed in from the first step

Human in the lead
People own the decisions that matter, before code is written

### The behavior that must survive

[11:22](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=682s) [A three-column table pairs four mainframe components with migration targets and the contracts to inspect. The rows cover business behavior, screen workflows, data meaning, and batch execution and restart.](https://assets.ai.engineer/sites/aiecode2025/sha256/3a6673e19311328e924cb54c4606c8b1256cd150f413cb864ced49f868c45a87.webp)

MIGRATION CROSSES SYSTEM BOUNDARIES
The behavior that must survive

A new runtime still has old obligations. Defects get an explicit decision; intended rules get preserved.

Source	Target	Contract to inspect
COBOL logic	Java 21 + Spring Boot	Business behavior
BMS screens	React UI	User workflows
Copybooks + VSAM	Java models + PostgreSQL	Data meaning
JCL jobs	Spring Batch	Execution and restart

Targets follow the public CardDemo migration PR. Contracts are review obligations.

[11:38](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=698s) [Four boxes group migration obligations into Money, State, Failure, and Operations. The Money box highlights decimal precision and rounding.](https://assets.ai.engineer/sites/aiecode2025/sha256/8b00ac3ed8ade5b889035f75ae6c28332db0618f298edd59bf87491b9319ce61.webp)

MIGRATION CROSSES SYSTEM BOUNDARIES
The behavior that must survive

A new runtime still has old obligations. Defects get an explicit decision; intended rules get preserved.

Money
Decimal precision
and rounding

State
Balances and
transaction records

Failure
Error outcomes
and recovery

Operations
Ordering, throughput
and restart

### Parity is proven, not promised

[12:01](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=721s) [The same versioned fixtures and controlled clock feed a COBOL baseline and a Java candidate. Arrows from both lead to a comparison of four outputs, labeled diff=0.](https://assets.ai.engineer/sites/aiecode2025/sha256/651f7c3f1acf1e425c9769ea8574522f072d3cb457cc36138206196fc53a99ad.webp)

CONTINUOUS VALIDATION
Parity is proven, not promised

Versioned fixtures + controlled clock

COBOL baseline
• Returned values
• Persisted state
• Transaction output
• Error outcomes

Java candidate
• Returned values
• Persisted state
• Transaction output
• Error outcomes

Contract-aware comparison
diff=0

### Multi-layered tests and validation

[12:44](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=764s) [Five stacked boxes pair each layer with its checks, from static analysis and unit tests at the source to end-to-end behavioral parity at the highlighted API layer.](https://assets.ai.engineer/sites/aiecode2025/sha256/a3706ef25588cb9131da5854ef13fcbac4bfa8262fc4aeac9d5321ec2f78cc5f.webp)

CONTINUOUS VALIDATION
Multi-layered tests and validation

Source
Static analysis, unit tests

Compiler
Build verification

Runtime
Integration tests

Database
Data parity on every write

APIs
End-to-end behavioral parity

### One cent exposes the difference

[13:25](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=805s) [Three cards compare results for one calculation. COBOL stores $16.66, the illustrative Java mutation rounds to $16.67 with HALF_UP, and Java with RoundingMode.DOWN matches the $16.66 baseline.](https://assets.ai.engineer/sites/aiecode2025/sha256/9c5ee34f618f1a0eaab5d7e735225a212126dbde62ab5e309fe2396f41d667fc.webp)

WHY THE HARNESS MATTERS
One cent exposes the difference

Both versions compile. Only the side-by-side comparison catches the cent.

1,000.50 x 19.99 ÷ 1,200 = 16.6666625

COBOL baseline
$16.66
Two decimals,
NO ROUNDED

Mutated Java
$16.67
HALF_UP rounding

Preserving the rule
$16.66
BigDecimal + RoundingMode.DOWN

Illustrative mutation, not a Blitzy defect. The upstream program stores two decimal places without ROUNDED.

### From one interest path to a full trade-posting engine — capabilities

[14:20](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=860s) [Five rows list functions from trade ingestion through same-day settlement. A before-and-after caption contrasts the monolith and its cross-database writes with six capability modules on PostgreSQL.](https://assets.ai.engineer/sites/aiecode2025/sha256/c75eed6fb7ac67ca5c529f3e5a94164fc00a9d9f574e13215b3e9a3f678ee36b.webp)

CASE STUDY • TIER-ONE BANK • INVESTMENT ACCOUNTING
From one interest path to a full
trade-posting engine

Trade ingestion
Posting
Inventory: FIFO/LIFO tax-lot depletion
Tax-lot management
Cash and same-day settlement

Before = monolith, stored procedures, cross-database writes
After = 6 capability modules on PostgreSQL; Java, TypeScript, Python

### From one interest path to a full trade-posting engine — results

[14:54](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=894s) [Four cards report 100% behavioral parity across write targets, 18 days versus an 18 engineer-week plan, 4,022 tests, and 41% of legacy code volume plus a new UI and API.](https://assets.ai.engineer/sites/aiecode2025/sha256/3bde1f13f329884336b6735ba68f49e1b262544dc706af3c9cdb108634f7f0ae.webp)

CASE STUDY • TIER-ONE BANK • INVESTMENT ACCOUNTING
From one interest path to a full
trade-posting engine

100%
behavioral parity,
every write target

18 days
versus an 18
engineer-week plan

4,022
tests;
1.45 : 1 test-to-code
ratio

41%
of legacy code
volume, plus new UI
and API

### Mapping a ~35M-line mainframe

[15:28](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=928s) [A bar chart compares the time to map a Fortune 100 insurer’s mainframe into a knowledge graph. The short cyan bar shows 4 days for Blitzy. The long orange bar shows 8–12 months for a typical SI.](https://assets.ai.engineer/sites/aiecode2025/sha256/56584e01ddee0750b32ccc70554444932edc2e22e734c23f3aed2087f53467ce.webp)

CASE STUDY • FORTUNE 100 INSURER
Mapping a ~35M-line mainframe

~35M lines of mainframe code into a knowledge graph
Blitzy    4 days
Typical SI    8–12 months

Next: COBOL → idiomatic Java forward engineering completed on a 5M-line
application, with parity against the mainframe baseline

### Across finance & adjacent regulated industries

[16:25](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=985s) [Four panels report results for a bank compliance engine, an accounting and consulting firm’s backlog, an insurer’s engineering pilot, and a telecom’s COBOL-to-Java project.](https://assets.ai.engineer/sites/aiecode2025/sha256/1b8bce32b4d1fab4790053c000f3bd08e251da3651b58674661aeaf5d896800f.webp)

THE PATTERN HOLDS
Across finance & adjacent regulated
industries

Different firms, different systems, one common thread: understand the whole system before you change it.

Tier-one bank: compliance engine
11M lines understood in 7 days vs. a 200-day estimate; 30 year old
desktop app rebuilt for the web in 15 weeks vs. 61

Top-5 U.S. accounting and consulting firm
“Five months to build went to five or six days.” 5-year backlog
compressed to 1 year

Large insurer: enterprise pilot
10–15× engineering velocity and 80–95% autonomous completion across
upgrades, new features and security fixes (CIO-reported)

Major regulated telecom
Compliance-critical COBOL app to Java: 1 month with 1 engineer vs.
12 months with 6

### What the map unlocks beyond modernization

[16:35](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=995s) [Six panels pair uses of system-wide understanding with examples. Highlighted results include a trade-posting engine reaching 100% parity in 18 days, a vulnerable function found across 3 services, and 4,022 generated tests.](https://assets.ai.engineer/sites/aiecode2025/sha256/a2dc79796475a1c6e12faced71d73f9391cfbe5d12ac64a3b00e50481faa25c9.webp)

BEYOND MODERNIZATION • WHAT THE MAP UNLOCKS
Modernization is the entry point, transformation is the goal

Each requires system-wide relational understanding, not just good code generation.

Reverse Engineering
Extract all business logic, dependencies, data architecture, and
operational workflows.
11M-line compliance engine understood in 7 days and operational
workflows.

Platform Modernization
Eliminate technical debt and modernize your architecture without
multi-year programs or ballooning budgets.
Trade-posting engine: 100% parity in 18 days

Accelerate Product Development
Compress development cycles from months or years to weeks;
reallocate capital from execution to growth.
New feature on a legacy core: 3 days vs. 14

CVE Identification & Remediation
Expand test coverage and remediate security vulnerabilities to
mitigate enterprise risk.
Vulnerable function found across 3 services

Greenfield App Development
Turn product specs into fully built, production-ready applications in
weeks instead of months.
5-month build delivered in 5–6 days

Documentation & Testing
Create traceable technical specifications for any codebase.
Dynamically updates with new commits.
4,022 tests generated for the trade-posting rebuild

### Adding a promotional interest rate to AWS CardDemo

[16:56](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1016s) [A checklist shows what the promotional-rate feature can reuse, including a test for the one-cent rounding rule. A list alongside names the knowledge layer, governance rules, and test suite from prior changes.](https://assets.ai.engineer/sites/aiecode2025/sha256/072c750a0abb6840dccc891fbad20e5a47105646f03a5fbf0c281323cb775b5b.webp)

BEYOND MODERNIZATION • WHAT THE MAP UNLOCKS
Modernization is the entry point, transformation is the goal

BACK TO AWS CARDDEMO
New feature: add a promotional rate to the
interest path in the modernized app
✓ Context slice: already mapped
✓ Preservation contract: carried forward
✓ One-cent rounding rule: already a test
✓ Harness: re-run, not rebuilt

New work utilizes the foundations laid by prior changes:
• Updated knowledge layer
• Established governance rules
• Expanded test suite

Illustrative, on the public AWS CardDemo sources.

### Tracing a tier-one bank’s regulatory controls to code

[17:25](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1045s) [Three panels describe what auditors needed, why manual review stalled, and how the bank traced controls to code. A bar chart compares about 50 working days for a dedicated team with 7 days for one part-time subject matter expert using Blitzy.](https://assets.ai.engineer/sites/aiecode2025/sha256/8ffe9552df2e13ab25f2b17f7e79df09a94d136c892b00e08fbfb78b293fdf8d.webp)

CASE STUDY • TIER-ONE BANK • AUDIT & REGULATORY
Turning an audit blocker into audit-ready
evidence

The Ask
Auditors needed documented proof of how key
regulatory controls are carried out in the code.

The Blocker
Manual review of decades of legacy code couldn't give a
confident answer.

The Approach
Traced each control through the code that runs it, with
every finding tied to its exact location.

86% faster to audit-ready evidence

Traditional approach: dedicated team, pulled off planned work
~50 working days

With Blitzy: one part-time SME, team stays on planned work
7 days

### Tier-one bank audit results for time, staffing, and traceability

[17:45](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1065s) [Three stacked cyan boxes summarize the bank’s audit results. Evidence took 7 days versus about 50, one part-time subject matter expert handled the work, and every finding pointed to its location in the code.](https://assets.ai.engineer/sites/aiecode2025/sha256/1b4f411fe57f9163744880cc198be797d98a8df02f8c96d264a31d6952df3862.webp)

CASE STUDY • TIER-ONE BANK • AUDIT & REGULATORY
Turning an audit blocker into audit-ready
evidence

Time to evidence
7 days vs ~50 days

Team capacity
One part-time SME, not a dedicated team

Audit confidence
Every finding traced to its exact place in the code

### From a code graph to regulation & risk

[17:54](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1074s) [Four concentric circles show the code graph at the center, surrounded in turn by business rules, business processes, and regulation & risk. The diagram overlays a cutaway view of city infrastructure.](https://assets.ai.engineer/sites/aiecode2025/sha256/8886aaf17f4b94cf673b34435e04982e1bdca21607861e34a169e62ea5f1a25f.webp)

WHERE THIS GOES
From a map of your
software to a map of
your enterprise

Regulation & risk
Business processes
Business rules
Code
graph

### Enterprise map uses: regulatory dependency maps, business rules, process impact and agent context

[18:12](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1092s) [Five stacked panels describe enterprise uses for the graph. The first gives a seven-day bank audit example. The highlighted final panel describes an agent using a client’s reason for requesting 500 shares to recommend another way to offset the risk.](https://assets.ai.engineer/sites/aiecode2025/sha256/c11bf50b22421fce7dc52e59b41a5707d5d391f35ef8d5d6c91f302050f5fef6.webp)

WHERE THIS GOES
From a map of your
software to a map of
your enterprise

Regulatory dependency maps
Proven: a tier-one bank's regulatory controls traced to code for
auditors in 7 days. DORA requires mapping ICT interdependencies

Business-rule catalogs
Rules traceable to the code that enforces them, for audit and
model-risk review

Process-level impact
“What breaks downstream if we change this product rule?”

Shared context for every agent (direction)
One graph behind fraud, financial-crime and service agents

FURTHER OUT
A client asks for 500 shares of a blue-chip stock. An agent that
knows why (to offset a specific risk) recommends a better way to
get there.

## Full transcript

[0:00](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=0s) We have a really exciting session for you guys.

[0:14](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=14s) So you probably don't realize how many systems and how much of the infrastructure which drives

[0:22](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=22s) modern finance, which drives all the things which happen in the financial district in

[0:26](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=26s) New York City, are driven off very old systems which can use a lot of modernization.

[0:35](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=35s) And you probably interact with them on your cell phone, maybe you're banking on a mobile

[0:40](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=40s) app, but you don't realize that underneath the covers, there's business rules.

[0:45](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=45s) There's batch jobs running in nightly processes.

[0:48](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=48s) You have all these different data contracts and things running under the covers.

[0:51](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=51s) And it's running on infrastructure which people are frankly afraid to touch.

[0:57](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=57s) If you make one little line of code change, you risk breaking the whole system.

[1:03](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=63s) And so this is a fun fact about myself.

[1:07](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=67s) So now I'm known for doing a lot of developer relations, AI conferences, book writing.

[1:13](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=73s) Back 30 years ago, I was a Java developer who was migrating COBOL code off mainframes and figuring

[1:23](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=83s) out how to modernize applications.

[1:26](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=86s) And it was multi-year projects, very challenging work, which inevitably you hit little bugs and

[1:34](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=94s) issues.

[1:34](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=94s) You couldn't test it thoroughly enough to hit all the different corner cases.

[1:37](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=97s) And very, very challenging projects, which often failed.

[1:43](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=103s) So I think that what we're going to show you today is amazing because it's a new path forward

[1:47](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=107s) where you can drive the change and you can actually do this.

[1:53](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=113s) But why don't you tell us a little bit about how this works, Neeraj?

[1:58](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=118s) Thank you, Steve.

[1:58](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=118s) So we're going to do this with an example, right?

[2:04](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=124s) In the context of a public demo system, which Amazon developed a few years ago.

[2:10](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=130s) This is the AWS card demo.

[2:13](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=133s) And I'm going to take a specific example here where we are trying to compute interest.

[2:21](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=141s) Right.

[2:22](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=142s) And so as you can see in this little chart, we have a batch job that's calling the interest

[2:29](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=149s) program, which is getting copy books and layouts and then generating basically vSAM data.

[2:38](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=158s) Right.

[2:38](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=158s) And so the output here is money.

[2:42](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=162s) And, of course, the result depends on the inputs, the job that runs it, the account updates,

[2:50](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=170s) not just the formula for computing the interest.

[2:53](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=173s) And so let's remember this example.

[2:56](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=176s) We're going to keep coming back to this, hit that theme over and over again as we progress

[3:02](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=182s) through the talk.

[3:04](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=184s) So when I want to modernize this and I tell AI, hey, change that formula from COBOL to Java,

[3:11](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=191s) all it's going to do is find the formula, try to convert that.

[3:16](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=196s) Right.

[3:17](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=197s) What it doesn't find is the record precision, the account updates, the transaction output,

[3:24](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=204s) the batch contract.

[3:25](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=205s) And if you miss any of these, you're not guaranteed to get the right outcomes.

[3:32](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=212s) So the failure here is not that AI can't write the code.

[3:37](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=217s) It's that AI doesn't know the 14 other places where that logic, that code is being used.

[3:45](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=225s) Okay.

[3:45](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=225s) And this looks pretty scary.

[3:46](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=226s) I mean, besides the AI not knowing the code, that pipe looks like it's about to burst.

[3:51](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=231s) Yeah.

[3:51](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=231s) And, of course, the AI doesn't know that it's going to happen any moment now.

[3:55](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=235s) So, Stephen, you would think that a context expansion would fix this.

[4:01](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=241s) Why doesn't that happen?

[4:02](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=242s) Yeah.

[4:03](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=243s) So I think that one of the things, actually, the previous presenter talked a bit about this,

[4:08](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=248s) how we've all been relying on better models, on having better systems, better AI systems

[4:13](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=253s) to solve this.

[4:15](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=255s) And, frankly, it hasn't been working for these sorts of use cases.

[4:18](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=258s) And the reason is context.

[4:20](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=260s) So you can do vector databases to get and expand your context.

[4:25](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=265s) But all it gives you is similarity searches.

[4:27](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=267s) You can do relational databases as well.

[4:31](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=271s) And this gives you a much bigger repository.

[4:34](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=274s) You can hook it up via an MCP server.

[4:35](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=275s) But, again, you're limited on kind of single hop and, like, looking up facts and information

[4:41](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=281s) by SQL queries.

[4:42](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=282s) What a graph gives you is a graph gives you this multi-hop accurate information and context

[4:50](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=290s) for your model.

[4:51](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=291s) And the reason why this context is so important is because your model cannot possibly give you

[5:00](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=300s) the right results because it can't utilize its own context.

[5:03](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=303s) So most models, you know, nowadays are advertised with a million token context windows.

[5:08](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=308s) But what do they actually, how much usable context do you actually get?

[5:14](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=314s) And the reality is you get 200K or less usable context, right?

[5:18](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=318s) So it's, by study, the accuracy goes down dramatically as you fill the context more.

[5:25](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=325s) And this means you have to give precise and accurate context.

[5:29](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=329s) Yeah, the effective context these days is about, like, 20 to 30%, which means about, like, 200,000

[5:37](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=337s) to 300,000 lines of code.

[5:39](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=339s) If your software is bigger than that, too bad.

[5:42](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=342s) You're going to start losing information.

[5:45](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=345s) So context is serial, but information has relationships.

[5:50](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=350s) Information has connections between it.

[5:53](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=353s) And this is the key to how you can actually line up your data.

[5:59](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=359s) Yeah.

[6:03](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=363s) Yeah.

[6:04](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=364s) So, I mean, here, so code becomes a graph, right?

[6:07](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=367s) You can see all of these relationships that are being mapped here now.

[6:11](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=371s) And, like, the program is there.

[6:15](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=375s) It has the job that's executing it, the copybook that are getting included, so on and so forth,

[6:20](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=380s) the outputs.

[6:21](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=381s) The important part here is the stuff on the right.

[6:26](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=386s) Yeah.

[6:27](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=387s) So every edge in the graph keeps its identity, right?

[6:32](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=392s) Where did it come from in the repo?

[6:33](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=393s) What revision was it?

[6:35](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=395s) What symbols does it touch?

[6:36](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=396s) There is evidence for the file and the source span, how it was extracted.

[6:41](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=401s) And the graph keeps getting updated on every merge.

[6:45](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=405s) As the code changes, so does the graph.

[6:47](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=407s) And that way, you keep it fresh, you keep it current, you invalidate stuff that is no longer valid.

[6:54](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=414s) Yeah.

[6:54](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=414s) And you can see that the code is very much a graph-shaped problem.

[6:57](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=417s) So just from the structure and the relationships, it's something where you have a lot of interconnects.

[7:04](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=424s) And then when you, why don't you talk about how this works for agents?

[7:08](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=428s) Sure.

[7:09](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=429s) So each agent in Blitzy has a specific task context packet.

[7:16](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=436s) And that includes what the task description is, but also where does it belong to in that graph, right?

[7:23](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=443s) There's the slice of the source, right?

[7:25](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=445s) 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.

[7:35](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=455s) So, and this is what we mean by infinite code context, right?

[7:38](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=458s) It's not remembering the entire information in your code base, in your software estate.

[7:44](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=464s) It's basically having access to the right information at the right time in the right place.

[7:53](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=473s) So Blitzy effectively works like a compiler for the entire knowledge in the enterprise, right?

[8:00](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=480s) You start off by reverse engineering the entire software estate.

[8:03](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=483s) You extract the business logic, the workflows, the hidden dependencies.

[8:09](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=489s) Then you get the requirements and the rules from the user to say, what do you want to do with this?

[8:14](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=494s) And you convert that into an actionable agent action plan, right?

[8:19](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=499s) This is the spec that you're going to use to make that forward change.

[8:25](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=505s) Note that next block there.

[8:26](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=506s) There is a human approval, right?

[8:27](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=507s) Nothing happens without a human in the lead making decisions at every key point, right?

[8:35](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=515s) But once you have that plan reviewed and approved by the human, now the agents go off.

[8:41](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=521s) They do the code generation.

[8:44](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=524s) But there is also validation that is baked into it at every step.

[8:47](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=527s) 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 in the form of a project guide.

[8:59](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=539s) So there is a human approval at every step that matters.

[9:06](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=546s) 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 to just static information.

[9:21](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=561s) You can actually observe the runtime behavior and make changes accordingly.

[9:25](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=565s) So the knowledge graph basically drives all of this, right?

[9:32](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=572s) But that's not the only thing that helps here.

[9:36](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=576s) There are two other things that compound the impact that this has.

[9:41](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=581s) One is hyperscale orchestration.

[9:43](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=583s) Like we have thousands of agents who all share that plan.

[9:47](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=587s) Every agent has access to the effective context and there is nothing lost between them.

[9:53](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=593s) And couple that with extreme validation, right?

[9:57](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=597s) You have testing happening at every stage of code generation.

[10:01](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=601s) We actually spend more computes on testing than we do on code gen.

[10:06](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=606s) And this results in what is effectively production safe code that has been tested, validated at enterprise scale.

[10:15](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=615s) And so it is safe to make merges into your production systems.

[10:19](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=619s) So the agent action plan is the spec, right?

[10:25](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=625s) That's the plan before you start doing any actual work.

[10:29](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=629s) And it decides what the scope is, what gets transformed, and what must be preserved, right?

[10:36](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=636s) And a domain expert, a human, would review this, make sure that it's aligned with their expectations, approve it.

[10:45](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=645s) And this is coupled with the four controls that are inherent at every step.

[10:50](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=650s) There is system level context.

[10:52](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=652s) That's the knowledge graph we talked about, right?

[10:55](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=655s) Every change impacts the entire state.

[10:57](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=657s) So everybody needs to be aware of that, right?

[10:59](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=659s) There is continuous validation.

[11:00](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=660s) So testing, testing, testing, right?

[11:03](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=663s) There is no substitute for that.

[11:05](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=665s) You have explicit guard layers in place to address your security, your governance, your compliance requirements.

[11:11](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=671s) These are inherent to any regulated industry and, of course, finance, right?

[11:15](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=675s) And then the human in the lead, because the decisions that matter are owned by real people.

[11:20](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=680s) The AI is not making them autonomously.

[11:22](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=682s) And this, of course, preserves the behaviors, right?

[11:28](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=688s) The existing behaviors have to be transferred as is to the modernized code.

[11:35](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=695s) And how do you verify that?

[11:39](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=699s) Right.

[11:40](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=700s) So in this case, we want to preserve the money, like the precision, the rounding.

[11:46](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=706s) We want to preserve the state, the balances, and the transaction records, failures, operations, everything, right?

[11:54](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=714s) If we have defects, they also need to be managed with explicit decisions.

[11:59](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=719s) The rules have to be preserved as well.

[12:02](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=722s) And you have to prove the parity.

[12:04](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=724s) You can't take it as an assumption or as a promise.

[12:09](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=729s) So the way we do that is there is testing on the baseline.

[12:13](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=733s) There is equivalent testing happening on the modern system.

[12:18](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=738s) And we are looking at inputs and outputs, the returned values, what states get persisted,

[12:23](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=743s) what does the transaction output look like, right?

[12:26](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=746s) What are the error outcomes?

[12:27](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=747s) Not just the happy path, but how do you deal with bad situations?

[12:33](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=753s) And all of those have to be exactly matching in the context of each operation.

[12:40](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=760s) And the differences have to be none.

[12:42](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=762s) That's our promise to deliver this.

[12:47](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=767s) So this is layered.

[12:49](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=769s) This doesn't happen only in the end.

[12:51](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=771s) This is baked into the very fabric of the code generation.

[12:54](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=774s) Every line of code that gets generated gets built and tested with unit tests.

[12:58](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=778s) The build has to be compiled.

[13:01](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=781s) Runtime integration, it has to fit within the existing kind of framework that you have.

[13:06](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=786s) Your data parity has to be there on every write.

[13:11](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=791s) And the end-to-end workflow has to be identical.

[13:13](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=793s) So this is a quote from one of the customers where we actually did this.

[13:18](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=798s) The transpile job produces output that is per byte identical to the golden mainframe baseline.

[13:23](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=803s) This is from a Fortune 100 insurance.

[13:26](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=806s) And here's a fun example.

[13:28](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=808s) So this is something I can get into as an old Java developer where we made lots of errors with big decimals and rounding in our implementation.

[13:37](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=817s) So AI can do this better, right?

[13:40](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=820s) Right.

[13:40](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=820s) I mean, you would think so, right?

[13:42](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=822s) Because you computed a Java version of this formula to compute interest, right?

[13:50](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=830s) COBOL behaves differently than Java.

[13:51](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=831s) Java has an inherent rounding up built into it.

[13:55](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=835s) What that means is the modern code compiles.

[13:59](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=839s) It generates results that you believe are correct because it's behaving like normal Java would, right?

[14:06](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=846s) But you have this little difference of that one cent that happened because of the inherent rounding.

[14:10](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=850s) If you didn't have that parity test, you wouldn't have caught this.

[14:16](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=856s) And now imagine this happening over a million transactions.

[14:19](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=859s) Fine.

[14:22](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=862s) So that was just one kind of simple example, right?

[14:27](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=867s) But now you can think of like a full trade posting engine where this gets applied throughout the entire workflow.

[14:33](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=873s) This is something that we did for a tier one bank where we had a monolith that had stored procedures,

[14:38](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=878s) cross database kind of write access going on.

[14:44](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=884s) This got converted into six capability modules with PostgreSQL, Java, TypeScript, Python,

[14:50](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=890s) a fully modern stack and with full parity, right?

[14:56](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=896s) And took only 18 days.

[14:59](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=899s) Whereas their original plan was to have 18 engineer weeks dedicated to this project, right?

[15:05](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=905s) This was doing things the kind of human way.

[15:09](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=909s) With Blitzy, it got reduced to 18 days, right?

[15:12](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=912s) We wrote 4,000 plus tests.

[15:14](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=914s) The modern code was less than half the size of the old stack.

[15:21](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=921s) And the customer was happy.

[15:24](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=924s) There is no doubt that we can use Blitzy to modernize the whole system is what they said.

[15:30](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=930s) Another example, mapping a 35 million line mainframe.

[15:33](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=933s) This is something that they had spent on an SI about eight months, several million dollars,

[15:39](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=939s) and had nothing to show for it.

[15:41](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=941s) Blitzy reverse engineered that in a matter of four days.

[15:44](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=944s) And this is what they have to say.

[15:46](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=946s) They have been in a dark room with a pencil light inspecting each individual module.

[15:50](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=950s) Blitzy feels like flipping on the overhead light, seeing the whole room at once.

[15:55](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=955s) This is what AI accompanied by a knowledge layer can do for you.

[15:59](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=959s) Another example, we modernized a 25 million line monolith.

[16:06](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=966s) This was a policy admin platform.

[16:08](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=968s) Again, compared to a human aided by AI, like your typical IDE-based agentic tools,

[16:15](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=975s) would have taken a certain amount of time.

[16:17](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=977s) We did it nine times faster.

[16:19](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=979s) 85% of the code was autonomously completed.

[16:22](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=982s) And almost 90% of that made it into production.

[16:27](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=987s) This extends to different systems.

[16:29](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=989s) Different companies.

[16:30](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=990s) As long as you understand the whole system, before you change it using AI, you're good.

[16:37](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=997s) And this doesn't just stop at modernization.

[16:39](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=999s) Ultimately, transformation is the goal.

[16:42](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1002s) Blitzy is not a modernization platform.

[16:44](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1004s) It is a transformation platform.

[16:46](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1006s) You can do new product development.

[16:49](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1009s) You can add new features.

[16:50](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1010s) You can do security remediation and detection.

[16:53](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1013s) All kinds of use cases open up when you have that entire state available to you.

[16:56](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1016s) And so, 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.

[17:08](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1028s) You already have the upgraded knowledge path now because you already have the modern system.

[17:14](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1034s) Your knowledge layer got updated.

[17:16](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1036s) You have your governance rules established.

[17:18](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1038s) You have your test suite expanded.

[17:20](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1040s) So, now this becomes a lot easier and faster and cheaper to do than it had been before.

[17:28](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1048s) 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 audit-ready compliance issues.

[17:45](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1065s) So, as you can see, this is heading beyond software and mapping the whole business now.

[17:54](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1074s) Yeah.

[17:54](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1074s) So, I think that you can see the power of building a modern enterprise layer on top of a knowledge graph.

[18:04](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1084s) And it starts with a graph, builds out to 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 to expand your business.

[18:19](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1099s) So, you can now do, for example, DORA compliance on your entire system to make sure it meets regulatory requirements.

[18:28](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1108s) You can track business rule changes.

[18:31](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1111s) You can do financial fraud and build use cases, which will track down other sorts of problems.

[18:38](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1118s) And this expands to even further out where you can extend your system and build more value off of it.

[18:46](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1126s) We want to leave you with a few references to take with you.

[18:51](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1131s) So, one is the Nodes Conference.

[18:55](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1135s) That's the QR code on the left.

[18:56](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1136s) Nodes Conference is a full 24 hours of sessions learning on knowledge graphs on how you can build and apply a bunch of these concepts for our knowledge graphs to your own systems.

[19:08](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1148s) And, Neeraj, you want to talk about?

[19:10](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1150s) Yeah.

[19:10](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1150s) The Blitzy Sandbox, that's the QR code on the right, will allow you to, in fact, bring in your own code and see this for yourself.

[19:17](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1157s) Don't just take our word for it.

[19:18](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1158s) You can also see the AWS card demo modernization that we showed here as an example there.

[19:26](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1166s) Okay.

[19:26](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1166s) So, thanks so much for joining our session at ANG in New York City.

[19:30](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1170s) And if you have any more questions, feel free to drop by the Neo4j booth or come up and chat with us after the talk.

[19:35](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1175s) Thank you.

[19:36](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1176s) Thank you very much.

[19:37](https://www.youtube.com/watch?v=oWqsBuhRRZ4&t=1177s) Thank you.
