See inside your mainframe.
Prove your way out.
LegacyLens maps every COBOL program, JCL job, copybook and DB2 table in your estate — extracts the business rules, plans the migration, and proves the modernized code does exactly what the original did.
The only modernization tool that proves the new code does what the old code did.
Mainframe modernization has one real problem
It isn't writing the new code. It's trusting it.
The knowledge is locked in the code
Forty years of business logic lives in COBOL paragraphs and JCL conditionals, not in any document. When the person who wrote it retires, the logic goes with them.
Rewrites fail on equivalence
Most modernization projects don't fail on writing new code — they fail on proving the new code does the same thing as the old code, for every edge case the business actually relies on.
AI-generated code raises the stakes
An LLM can produce Python that looks plausible in minutes. Whether it's correct is a much harder question — and the one that actually matters when the code moves money or holds customer data.
Everything you need to understand the estate first
Before you rewrite a single line, know exactly what the system does today.
Data lineage & impact analysis
Field-level lineage across COBOL, JCL, DB2 and Teradata. Select any table or column and see everything upstream and downstream before you touch it.
Business rule extraction
Every conditional, calculation and validation pulled out of the code as a plain-English rule, with an SME review workflow to confirm or correct it.
Code quality & findings
Dead code, missing error handling, risky patterns — flagged automatically, with AI-suggested fixes you can review before applying.
Modernization packages
An LLM-ready specification per job, graph or ETL pipeline — execution flow, every program's logic, record layouts, schema — ready for any coding agent.
Migration wave planner
A dependency-ordered rollout plan: which jobs can move first, which can go in parallel, and which are risky because they're tightly coupled or circular.
Database insights
DB2 and Teradata catalog analysis — access patterns, retirement candidates, orphaned tables — from real DBQL usage data, not guesswork.
Run & Verify
Every other tool asks you to trust that the modernized code is correct. LegacyLens proves it — by actually running both versions and comparing what happens.
Real execution, not a claim
The original COBOL is compiled with GnuCOBOL and actually run in a sandbox — or, when you connect one, submitted to a real z/OS test LPAR over z/OSMF. Every result is tagged with which one proved it.
SQL effects, not just row counts
Compares the actual INSERT/UPDATE values each program produces against a real seeded database — catches bugs a counter comparison would miss entirely.
Catches wrong answers, not just crashes
Code that runs cleanly and passes its own tests can still be wrong — a mistranslated rounding rule, a wrong threshold. When the comparison catches a mismatch, LegacyLens feeds the real divergence back and regenerates automatically, up to a configurable number of attempts, until it matches.
A verdict you can read
One scorecard: what was tested, what matched, what didn't — in plain language, not a wall of raw diff output.
What LegacyLens actually reads
Every parser is deterministic and hand-built — no model in the loop for correctness. Here's the full estate coverage, including what we don't parse yet.
✓Languages & programs
- COBOL
- WORKING-STORAGE, dialect detection, COMP-3, REDEFINES, OCCURS DEPENDING ON, level-88, PERFORM graphs, dynamic SQL
- JCL
- Steps, PROC expansion, PARM, symbolic parameters, COND, SMS classes, RESTART=, TYPRUN=, JCLLIB, instream cards
- CICS
- EXEC CICS command classification — screen I/O, program calls, storage, queues, security, program management — online/transaction program detection
- BMS maps
- Field-level screen definitions (DFHMSD/DFHMDI/DFHMDF)
- Copybooks
- Record layouts with byte offsets, DCLGEN table linkage, COPY REPLACING
✓Utilities
- IDCAMS
- VSAM DEFINE CLUSTER/PATH/GDG, KSDS/ESDS/RRDS/LDS derivation, REPRO, DELETE
- DFSORT / SYNCSORT / ICEMAN
- SORT/MERGE FIELDS, INCLUDE/OMIT, INREC/OUTREC/SUM, OUTFIL, JOINKEYS
- ICETOOL
- TOOLIN operators — COUNT, SELECT, SPLICE, DISPLAY, OCCUR, STATS, RANGE, SUBSET, RESIZE
- IEBGENER / ICEGENER / IEBCOPY
- Sequential and PDS copy operations
- IKJEFT01 (TSO batch)
- DSNTEP2/DSNTIAD SQL pass-through, plan and subsystem resolution
- DSNUTILB
- LOAD, UNLOAD, REORG, RUNSTATS, image copy, BIND
- IEFBR14, FTP
- Allocation/deletion intent; FTP PUT/GET sessions
✓Data & scheduling
- DB2
- DDL incl. inline JCL SYSIN, tables/columns/indexes/FKs, &-symbolic names, column-level access, catalog snapshots
- GDG
- Generation stripping and normalization so (+1)/(0) collapse to one logical dataset
- VSAM
- Cluster type, KEYS, RECORDSIZE, CISIZE, FREESPACE, SHAREOPTIONS, alternate index PATHs
- Control-M
- Job dependencies, variables, folded into the orchestration flow diagrams
- CA IDMS
- Schema/subschema DDL — records, sets, owner/member relationships — plus navigational DML (OBTAIN/FIND/STORE/MODIFY/ERASE/CONNECT/BIND) resolved against the declared schema
- Encoding
- EBCDIC / CP037 detection with DBCS heuristics at upload
✓Beyond the mainframe
- Teradata
- BTEQ, FastLoad, MultiLoad, TPT, wrappers, stored procedures, macros, DBQL catalog analysis
- SAS
- Steps, macros, dataset and column lineage, joins, filters, business rules
- Ab Initio
- Graphs, hierarchy, components, .dml/.xfr/.pset, runtime lineage
- Unix shell
- bash/ksh/sh via a real shell grammar, not regex
- Oracle
- Catalog analysis alongside DB2 and Teradata
Detected and reported — not silently skipped
LegacyLens has no parser for these yet. Rather than ignore the files, it fingerprints them and records each one in the Coverage Ledger, so your estate inventory says “we scanned everything — here's exactly what isn't modelled” instead of quietly under-reporting.
Why teams choose LegacyLens
Built for the constraints real mainframe shops actually operate under.
Runs entirely on-prem or air-gapped
Ship as an offline installer — five Docker images, one script. Your code never leaves your network. The license itself is verified offline against an embedded key; there's no phone-home, ever.
Deterministic parsing, AI optional
Every parser (COBOL, JCL, DB2, Teradata, SAS, Ab Initio) is hand-built and deterministic — no model in the loop for correctness. AI is a garnish for summaries and Q&A, never the source of truth.
Bring your own AI, or none at all
Use your own Anthropic/Gemini/DeepSeek key, run Claude via AWS Bedrock inside your own cloud perimeter, or turn AI off completely. Your choice, per deployment.
Verification-first, not claim-first
Run & Verify actually executes the original and modernized code — against a local sandbox, or the real mainframe over z/OSMF — and diffs the results. Every run is tagged by how it was proven: emulated or verified on real z/OS, never blurred together.
A certificate you can hand to an auditor
Every project can generate a cryptographically signed Equivalence Certificate — per-program pass/fail, disclosed gaps, and job-level utility-step verification tiers — so "it matches" is backed by a record, not a slide.
Built for enterprise hygiene
Audit log of who did what and when, structured logging, role-based access, encrypted per-user secrets, and nightly backups with tested restore scripts — out of the box.
Built by someone who's lived it
Built out of real mainframe and Teradata experience — the platforms it analyzes best are the ones its builder has spent years working in.
How it works
Install
Run one script from the offline bundle. Docker Compose brings up the app, database and sandbox images on your own infrastructure.
Point it at your code
Upload source files, connect object storage, or browse a mainframe PDS or SSH server directly and import selected members — no download/re-upload round-trip. LegacyLens classifies and parses everything automatically — COBOL, JCL, copybooks, DB2 DDL, Teradata scripts, SAS, Ab Initio graphs.
Analyze, verify, modernize
Explore lineage, extract business rules, generate modernization packages, and run Run & Verify to prove the new code matches the old before you ship it.
Get LegacyLens
Download the installer and try it free for 7 days — no key, no request, no credit card. Your source code, S3 bucket, and AI key are your own — nothing of ours ships inside the bundle except the license check itself.
Download the installer
A self-contained offline bundle (~710MB) — the app, the database, and the verification sandbox. Runs a free 7-day trial out of the box, no key needed to start. Works fully air-gapped after that first run.
Request your activation key
Your 7-day trial starts the moment you run it — no key needed. When you're ready to keep going, tell us a bit about your environment and we'll email a signed activation key, usually within 1 business day.