Legacy ModernizationAIJoin the waitlist↗

       IDENTIFICATION DIVISION.
       PROGRAM-ID. CUSTACCT.
       AUTHOR. LEGACY-SYSTEMS.
       DATE-WRITTEN. 1987-03-15.
      *
       ENVIRONMENT DIVISION.
       CONFIGURATION SECTION.
       SOURCE-COMPUTER. IBM-3090.
       OBJECT-COMPUTER. IBM-3090.
      *
       INPUT-OUTPUT SECTION.
       FILE-CONTROL.
           SELECT CUSTOMER-FILE ASSIGN TO 'CUSTMAST'
               ORGANIZATION IS INDEXED
               ACCESS MODE IS DYNAMIC
               RECORD KEY IS CUST-ID
               FILE STATUS IS WS-FILE-STATUS.
      *
       DATA DIVISION.
       FILE SECTION.
       FD CUSTOMER-FILE.
       01 CUSTOMER-RECORD.
           05 CUST-ID              PIC X(10).
           05 CUST-SSN             PIC X(11).
           05 CUST-NAME.
               10 CUST-LAST-NAME   PIC X(25).
               10 CUST-FIRST-NAME  PIC X(20).
           05 CUST-BALANCE         PIC S9(11)V99.
           05 CUST-AVAIL-BALANCE   PIC S9(11)V99.
           05 CUST-OVERDRAFT-LIM   PIC S9(7)V99.
           05 CUST-OPEN-DATE       PIC 9(8).
      *
       PROCEDURE DIVISION.
       MAIN-CONTROL.
           PERFORM INITIALIZE-PGM
           PERFORM PROCESS-TRANSACTIONS
               UNTIL WS-EOF = 'Y'
           PERFORM CLOSE-FILES
           STOP RUN.
      *
       PROCESS-DEPOSIT.
           IF WS-AMOUNT > 0
               COMPUTE WS-BALANCE = WS-BALANCE + WS-AMOUNT - WS-FEE
               PERFORM LOG-TRANSACTION
           ELSE
               DISPLAY 'INVALID AMOUNT'
           END-IF.
      *
       PROCESS-WITHDRAWAL.
           IF WS-AMOUNT > 0 AND WS-AMOUNT <= WS-BALANCE
               COMPUTE WS-BALANCE = WS-BALANCE - WS-AMOUNT
               PERFORM LOG-TRANSACTION
           ELSE
               DISPLAY 'INSUFFICIENT FUNDS'
           END-IF.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. CUSTACCT.
       AUTHOR. LEGACY-SYSTEMS.
       DATE-WRITTEN. 1987-03-15.
      *
       ENVIRONMENT DIVISION.
       CONFIGURATION SECTION.
       SOURCE-COMPUTER. IBM-3090.
       OBJECT-COMPUTER. IBM-3090.
      *
       INPUT-OUTPUT SECTION.
       FILE-CONTROL.
           SELECT CUSTOMER-FILE ASSIGN TO 'CUSTMAST'
               ORGANIZATION IS INDEXED
               ACCESS MODE IS DYNAMIC
               RECORD KEY IS CUST-ID
               FILE STATUS IS WS-FILE-STATUS.
      *
       DATA DIVISION.
       FILE SECTION.
       FD CUSTOMER-FILE.
       01 CUSTOMER-RECORD.
           05 CUST-ID              PIC X(10).
           05 CUST-SSN             PIC X(11).
           05 CUST-NAME.
               10 CUST-LAST-NAME   PIC X(25).
               10 CUST-FIRST-NAME  PIC X(20).
           05 CUST-BALANCE         PIC S9(11)V99.
           05 CUST-AVAIL-BALANCE   PIC S9(11)V99.
           05 CUST-OVERDRAFT-LIM   PIC S9(7)V99.
           05 CUST-OPEN-DATE       PIC 9(8).
      *
       PROCEDURE DIVISION.
       MAIN-CONTROL.
           PERFORM INITIALIZE-PGM
           PERFORM PROCESS-TRANSACTIONS
               UNTIL WS-EOF = 'Y'
           PERFORM CLOSE-FILES
           STOP RUN.
      *
       PROCESS-DEPOSIT.
           IF WS-AMOUNT > 0
               COMPUTE WS-BALANCE = WS-BALANCE + WS-AMOUNT - WS-FEE
               PERFORM LOG-TRANSACTION
           ELSE
               DISPLAY 'INVALID AMOUNT'
           END-IF.
      *
       PROCESS-WITHDRAWAL.
           IF WS-AMOUNT > 0 AND WS-AMOUNT <= WS-BALANCE
               COMPUTE WS-BALANCE = WS-BALANCE - WS-AMOUNT
               PERFORM LOG-TRANSACTION
           ELSE
               DISPLAY 'INSUFFICIENT FUNDS'
           END-IF.

      PROGRAM ATMOSPHERIC_MODEL
      IMPLICIT NONE
      INTEGER, PARAMETER :: N = 1024
      REAL*8 :: TEMP(N,N), PRESSURE(N,N)
      REAL*8 :: HUMIDITY(N,N), WIND_U(N,N)
      REAL*8 :: WIND_V(N,N), DT, DX, DY
      INTEGER :: I, J, T, NSTEPS
      REAL*8, PARAMETER :: GRAVITY = 9.81D0
      REAL*8, PARAMETER :: GAS_CONST = 287.05D0
      REAL*8, PARAMETER :: KAPPA = 0.286D0

      DT = 60.0D0
      DX = 1000.0D0
      DY = 1000.0D0
      NSTEPS = 24 * 60

      CALL READ_INITIAL_CONDITIONS(TEMP, PRESSURE, HUMIDITY)

      DO T = 1, NSTEPS
        DO J = 2, N-1
          DO I = 2, N-1
            CALL ADVECT(TEMP, WIND_U, WIND_V, I, J, DT, DX, DY)
            CALL DIFFUSE(HUMIDITY, I, J, DT)
            CALL PRESSURE_GRADIENT(PRESSURE, WIND_U, I, J)
          END DO
        END DO
        IF (MOD(T, 60) == 0) THEN
          CALL WRITE_SNAPSHOT(T, TEMP, PRESSURE)
        END IF
      END DO
      STOP
      END PROGRAM ATMOSPHERIC_MODEL

      SUBROUTINE ADVECT(FIELD, U, V, I, J, DT, DX, DY)
      REAL*8, INTENT(INOUT) :: FIELD(:,:)
      REAL*8, INTENT(IN) :: U(:,:), V(:,:), DT, DX, DY
      INTEGER, INTENT(IN) :: I, J
      FIELD(I,J) = FIELD(I,J) - DT * (
     +  U(I,J) * (FIELD(I+1,J) - FIELD(I-1,J)) / (2*DX) +
     +  V(I,J) * (FIELD(I,J+1) - FIELD(I,J-1)) / (2*DY))
      END SUBROUTINE

      PROGRAM ATMOSPHERIC_MODEL
      IMPLICIT NONE
      INTEGER, PARAMETER :: N = 1024
      REAL*8 :: TEMP(N,N), PRESSURE(N,N)
      REAL*8 :: HUMIDITY(N,N), WIND_U(N,N)
      REAL*8 :: WIND_V(N,N), DT, DX, DY
      INTEGER :: I, J, T, NSTEPS
      REAL*8, PARAMETER :: GRAVITY = 9.81D0
      REAL*8, PARAMETER :: GAS_CONST = 287.05D0
      REAL*8, PARAMETER :: KAPPA = 0.286D0

      DT = 60.0D0
      DX = 1000.0D0
      DY = 1000.0D0
      NSTEPS = 24 * 60

      CALL READ_INITIAL_CONDITIONS(TEMP, PRESSURE, HUMIDITY)

      DO T = 1, NSTEPS
        DO J = 2, N-1
          DO I = 2, N-1
            CALL ADVECT(TEMP, WIND_U, WIND_V, I, J, DT, DX, DY)
            CALL DIFFUSE(HUMIDITY, I, J, DT)
            CALL PRESSURE_GRADIENT(PRESSURE, WIND_U, I, J)
          END DO
        END DO
        IF (MOD(T, 60) == 0) THEN
          CALL WRITE_SNAPSHOT(T, TEMP, PRESSURE)
        END IF
      END DO
      STOP
      END PROGRAM ATMOSPHERIC_MODEL

      SUBROUTINE ADVECT(FIELD, U, V, I, J, DT, DX, DY)
      REAL*8, INTENT(INOUT) :: FIELD(:,:)
      REAL*8, INTENT(IN) :: U(:,:), V(:,:), DT, DX, DY
      INTEGER, INTENT(IN) :: I, J
      FIELD(I,J) = FIELD(I,J) - DT * (
     +  U(I,J) * (FIELD(I+1,J) - FIELD(I-1,J)) / (2*DX) +
     +  V(I,J) * (FIELD(I,J+1) - FIELD(I,J-1)) / (2*DY))
      END SUBROUTINE

Legacy

1959

The year COBOL was born. 220 billion lines of it still run in production.

Modern

Sixty yearsof code.Finally translated.

Join the waitlist→

Read the premise

2028

The year we ship the AI that finally rewrites it.

The Premise

The world runs on yesterday.

Half a century ago, engineers wrote the systems that quietly run the modern world — payrolls, settlements, air-traffic, utility grids. Their authors have retired. Their languages have been declared dead a dozen times. The code persists.

Modernization has remained slow, brittle, and outrageously expensive. We are building the AI that finally makes it tractable.

Lines of COBOL still running in production

More than every line of Python, Java, and JavaScript ever shipped — combined.

fig.01

$0T

In commerce processed every day through COBOL systems

Behind every wire, swipe, and settlement — code older than the internet.

fig.02

0 / 100

Of the world's largest banks still run on mainframes

The systems quietly underpinning the modern economy.

fig.03

Of IT leaders cite legacy as the #1 barrier to modernization

It isn't optional anymore. It's overdue.

fig.04

“The hardest software problem of the next decade isn't building new systems. It's translating the ones we can no longer afford to rewrite by hand.”

— From the founding memo

The Product

An AI that reads, reasons, and rebuilds.

Built from the ground up for the dialects, idioms, and architectural assumptions of 1970–2005. Not a generic copilot retrofit.

IRead

Understand intent, not just syntax.

A semantic model of the codebase: control flow, data shape, hidden invariants, and the business intent encoded over forty years of patches.

Cross-file dependency and call graphs
Pattern, idiom and anti-pattern detection
Dead-code, dark-data and ghost-branch surfacing
Cyclomatic complexity, coupling, drift

IIReason

Map decades of intent into modern architecture.

Choose your target stack. Our planner reconciles the source intent with idiomatic patterns in the destination — typed, modular, observable.

Target-aware refactoring strategies
Domain decomposition and module boundaries
Schema and storage migration plans
Risk-ranked execution roadmap

IIIRebuild

Generate code with provable equivalence.

Production-grade output verified against the source through symbolic execution, generated property tests, and side-by-side replay on real workloads.

Idiomatic Java, Kotlin, Scala, C#, F#, TypeScript, Python, Go, Rust, C++
Auto-generated test parity suites
Differential replay against legacy traffic
Auditable transformation map per commit

In Practice

From this. Into this.

Real output. A 1987 COBOL deposit routine, modernized to idiomatic Java with the original business logic preserved line-for-line in the transformation map.

ACCT-DEPOSIT.CBL

COBOL · 1987

01      * ACCT-DEPOSIT — applies a deposit to a customer balance
02       IDENTIFICATION DIVISION.
03       PROGRAM-ID. ACCT-DEPOSIT.
04 
05       DATA DIVISION.
06       WORKING-STORAGE SECTION.
07       01  WS-AMOUNT       PIC S9(9)V99.
08       01  WS-BALANCE      PIC S9(11)V99.
09       01  WS-FEE          PIC S9(5)V99 VALUE 2.50.
10 
11       PROCEDURE DIVISION.
12       PROCESS-DEPOSIT.
13           IF WS-AMOUNT > 0
14               COMPUTE WS-BALANCE = WS-BALANCE + WS-AMOUNT - WS-FEE
15               PERFORM LOG-TRANSACTION
16           ELSE
17               DISPLAY 'INVALID AMOUNT'
18           END-IF.

○ source · indexed18 ln · ↑ ingested

AccountDeposit.java

Java 21 · 2026

01// Generated by Legacy Modernization AI · semantic equivalence verified
02public final class AccountDeposit {
03    private static final BigDecimal FEE = new BigDecimal("2.50");
04 
05    public Result deposit(Account account, BigDecimal amount) {
06        if (amount.signum() <= 0) {
07            return Result.invalid("amount must be positive");
08        }
09 
10        var balance = account.balance()
11            .add(amount)
12            .subtract(FEE);
13 
14        ledger.record(account, amount, FEE);
15        return Result.ok(balance);
16    }
17}

● equivalence verified17 ln · ↻ regenerated

Transformation Map · excerpt

PIC S9(11)V99

Replaced with BigDecimal — preserves exact decimal arithmetic, eliminates COMP-3 packing risk.

PERFORM LOG-TRANSACTION

Inlined as a method call to ledger.record(), traced to existing audit hooks.

IF WS-AMOUNT > 0 / ELSE DISPLAY

Promoted to early-return guard — same branch, modern control flow, no GO TO.

The Process

Three movements, one outcome.

01/ Sweep
Feed it the codebase. Get the full map.
A complete semantic atlas of your system in hours, not months. Modules, dataflows, dependencies, dead branches, security debt — all surfaced and ranked.
artifact · 01●
deep-sweep.report.json
Cyclomatic82
Coupling61
Dead code34
Dark data49
02/ Translate
Choose your stack. Watch the transformation.
Pick a target — Java, Python, Go, Rust, TypeScript. The model rebuilds your system idiomatically, with module boundaries that match your domain, not the legacy file structure.
artifact · 02●
modernize.plan.diff
-PERFORM CALC-INTEREST UNTIL EOF.
-MOVE WS-RATE TO WS-OUT-RATE.
+interest = computeInterest(account);
+audit.record(account, interest);
ledger.commit(transactionId);
03/ Verify
Every transformation comes with proof.
Generated property tests, symbolic equivalence checks, and shadow-replay against production traffic. You get a transformation map, not a black box.
artifact · 03●
equivalence.proof.log
✓Symbolic equivalence on 1,247 paths
✓Shadow replay · 14 days production traffic
✓Generated property tests · 312 / 312 passing
✓Numeric drift · ±0.000 across all decimals

The Coverage

Sixty years of dialects. One model.

Trained on every major mainframe and enterprise dialect from the punch-card era through the early web. Targeting the modern stacks teams actually want to ship on.

est. 195901

COBOL

→JavaKotlinGo

Banking · Insurance · Government

est. 195702

FORTRAN

→PythonRustC++

Scientific · Defense · HPC

est. 199803

VB6

→C#TypeScript

Enterprise apps · Internal tools

est. 197004

Pascal

→GoTypeScript

Embedded · Education · Tooling

est. 196405

PL/I

→JavaScala

Mainframe transaction processing

est. 198006

Ada

→RustC++

Aviation · Defense · Real-time

est. 195907

RPG

→JavaKotlin

IBM i · ERP · Manufacturing

est. 199508

Delphi

→C#F#

Desktop · POS · Industrial

est. 199109

PowerBuilder

→TypeScriptC#

Client-server · Forms-over-data

est. 196610

MUMPS

→PythonJava

Healthcare · Epic systems · Banking ledgers

+ ALGOL · JCL · CLIST · Forth · Modula-2 · Smalltalk on the roadmap

The Waitlist

Bring us your hardest system.

We're in the early phase of building what may be the most demanding software product of the decade. Public launch is targeted for Q1 2028. Until then, we're talking to enterprises with mission-critical legacy stacks — to learn what to build first.

→For organizations with active modernization mandates

→Conversations under NDA, on your terms

→Help shape what we ship in v1

→First in line when access opens

Form · 01● The Waitlist is currently closed