Tyche Legacy Bridge AI
Independent proof that your modernized system matches the mainframe. Whoever converts your COBOL (AWS Transform, IBM, a systems integrator or your own team), Legacy Bridge checks the new system's outputs against the old one, record by record, and gives your auditors evidence they can verify. Rules decide the result, not AI. Use the hosted pilot or deploy it inside your own network.
Built for agencies, banks and insurers retiring mainframe workloads, and the integrators who modernize them. Hosted pilot access is available for invited users; deployment on your own servers is also supported.
The converter shouldn't grade its own work
Conversion tools increasingly use AI to rewrite mainframe code and to generate the tests that check it. Legacy Bridge is the independent check: it doesn't convert anything, so it can prove the result.
Independent of the converter
Works with whatever turns your COBOL into a new system: AWS Transform, IBM watsonx Code Assistant for Z, a systems integrator's toolkit or your own developers. It checks the outputs, so the tool that did the conversion never grades its own work.
A verdict made by rules, not AI
Parity results come from fixed, versioned rules: exact decimals, explicit tolerances, typed dates. The same inputs give the same answer every time, and no AI component can mark a run as passed.
Gaps can never pass
A run passes only when every record on both sides is accounted for and every column is compared. Missing mappings, skipped records and processing errors make it incomplete, and reviewer waivers never turn a failure into a pass.
Runs where your data must stay
Install it on your own servers from a signed offline bundle; it makes no outbound connections unless you allow them. Mainframe data is decoded on your side, from EBCDIC and packed decimal, so real production outputs can be compared.
Comparison figures: synthetic benchmark on one laptop (Apple M4, single process), engine time only; the defect suite is part of every test run. Methodology available on request.
One standard of proof for every workload
Large programmes move hundreds of batch jobs in waves, often with more than one vendor. Legacy Bridge gives every wave the same evidence, whichever tool or team did the work.
- Comparisons stream through disk, so input size isn't limited by memory
- Jobs run on a queue; add workers to run more comparisons at once
- Reusable, versioned rulesets for recurring outputs and every migration wave
- Each organisation's data is isolated in the database, not just in the app
Convert with any tool. Prove it with Legacy Bridge.
AWS Transform modernizes mainframe applications onto AWS. Legacy Bridge is not a converter; it is the independent check you can run on any conversion, including one made with AWS Transform.
| AWS Transform for mainframe (per AWS documentation) | Tyche Legacy Bridge AI | |
|---|---|---|
| Where it runs | A managed AWS service in listed AWS Regions. Mainframe capabilities are not listed for AWS GovCloud (US). | Hosted pilot access through Tyche, or your own servers or private network from a signed offline bundle. |
| AI in the process | An agentic AI service built on Amazon Bedrock; some requests can be processed in other AWS Regions. | No AI on customer data by default. Analysis and parity verdicts are deterministic. |
| How equivalence is shown | Generates test plans, data-collection JCL and comparison scripts, which AWS says need review before use. | Compares the actual legacy and modern outputs record by record and produces an evidence package with checksums, the frozen ruleset and every reviewer decision. |
| Target platform | A path from transformed code to running on AWS. | Any platform. Legacy Bridge only needs the outputs of both systems. |
AWS Transform details from AWS's public documentation, checked 18 October 2026: supported Regions, cross-region processing, mainframe workflow and the product page. AWS and AWS Transform are trademarks of Amazon.com, Inc.; Tyche Technologies is not affiliated with Amazon.
From legacy code to proven parity
Each module works on its own, and together they take a workload from discovery to sign-off.
Parity Guard
Prove the modern system produces the same results as the legacy one. Records are compared by key with typed rules (decimals, dates, tolerances), and a run passes only when every record is accounted for. Differences go to reviewers, and evidence packages include checksums.
Integration Mapper
Map jobs, programs, datasets, tables, queues, vendors and manual handoffs from JCL, COBOL and your inventories. Unknown producers, missing consumers and unowned interfaces are reported as gaps rather than guessed.
COBOL, copybooks and JCL
Static analysis of COBOL programs (files, open modes, calls, embedded SQL, CICS, IMS, MQ), copybook record layouts, and JCL with procedures, symbols, overrides and referbacks expanded. Every fact links back to its file and line.
Mainframe data decoding
Decode EBCDIC and ASCII record files (fixed or variable length, zoned and packed decimal, binary, floating point) with their copybooks into CSV or JSONL. Bytes that can't be decoded are counted and reported, never turned into zero.
Data Bridge
Profile legacy data, map fields with approval, run declarative transformations, and reconcile source and target with control totals and referential checks.
Distributed-tier analysis
Optional static reverse engineering of the .NET, JavaScript/Electron, Go, Rust and native software around the mainframe, to find the datasets and services it references. Findings are labelled as hypotheses until verified.
See it in action
Screens from a fictional settlement batch: synthetic programs, jobs and data only.
Parity Guard compares legacy and modern outputs record by record. This fictional run fails: one amount differs, one record is missing and one is duplicated, and every difference is listed for review.
A dependency map built from JCL, a cataloged procedure and COBOL programs. Program files are joined to datasets through the JCL DD statements; gaps such as an unknown producer are shown in red.
COBOL programs analysed without running them: files with their DD names and how they are opened, calls, DB2 tables and CICS resources, each with its file and line.
Copybook record layouts with byte offsets, lengths and types (zoned, packed, binary), used to decode EBCDIC mainframe files into CSV.
Trust you can show an auditor
Your data stays yours
AI processing of customer data is off by default. Data Shield detects sensitive fields, classifications control who sees raw values, and every access is audited. Optional separation of duties stops the person who runs a comparison from reviewing it.
Evidence, not opinions
Deterministic engines with versioned rules. Facts are labelled source-derived, verified or hypothesis, and nothing is presented as more certain than it is.
Runs where you need it
Hosted pilot access through Tyche, or on your own servers from a signed offline bundle with software bills of materials. Customer programs are never executed.
Tyche Legacy Bridge AI is in beta. It supports a documented subset of COBOL and JCL; anything outside that subset is reported for review instead of being guessed. It does not certify compliance or replace independent testing.
Start with a paid pilot
Pick one batch workload. We load its programs, copybooks, JCL and a sample of legacy and modern outputs, map the dependencies, decode the data and run parity, then hand you the evidence package. Subscriptions follow the pilot; contact us for pricing.
- Dependency map with gaps and owners for the chosen workload
- Parity results with every difference reviewed and explained
- An evidence package your risk and audit teams can check
Availability
Prove your modernization before you switch off the mainframe
Tell us about the workload you want to move first. We'll show you its dependencies, its data and whether the new system matches.