That 844-year COBOL calculation? Sovereign beats it.

A calculator did the rounds on LinkedIn this year. Move 800 billion lines of COBOL to Java with 100,000 developers and AI help, it said, and the job takes 844 years. Without AI, 1,212 years.

Look at where those years go, and you can see why Sovereign beats it.

Where the 844 years go

Rewriting the code itself, the part most people picture, comes to about 34 years. Most of the rest is spent answering two questions:

• What does the old system actually do? Discovery, requirements and business analysis: about 115 years.
• Does the new system do exactly the same? Testing, parallel running and user acceptance: about 363 years.

Anyone who has run one of these programmes knows this. The rewriting is not what takes the time. Knowing what the old system does, and proving the new one matches it, is.

Sovereign answers both questions by machine, with no AI

Sovereign does not guess. It reads, rebuilds and proves by exact analysis of the code, so the same system gives the same answer every time, and every answer can be traced and checked.

1. It reads the code. The code is the most complete description of what a system does. Sovereign reads every program and lists every business rule it finds, each one traced to the file and line it comes from.
2. It rebuilds the system in modern code, from what it read.
3. It proves the rebuild behaves the same. It runs the old and the new on the same inputs and compares the results. Wherever the original compiler or interpreter can be run, the comparison is byte for byte against the original program itself.

Your people stay in charge. A named person approves every step that builds, moves or switches anything, and the gaps nobody ever wrote down go straight to the people who know the system.

58,000 modules in one run

On 2 October 2026 we ran Sovereign on an estate the size of a large organisation’s: 58,000 modules and 72.7 million lines. In one run, on one Mac, Sovereign:

Reading took 19 minutes. Rebuilding took 41. Checking took 53.

The work the calculator gives hundreds of years of analysis and testing, Sovereign did in an afternoon. And it used no AI: the calculator’s 5x AI multiplier never came into it.

Every size of estate

The same holds at every size. Below, each calculator’s discovery, requirements, rebuild and testing phases are scaled to the estate and to a realistic team. Sovereign’s times are measured, one run on one machine.

One business system, read, rebuilt and checked in less time than it takes to make a coffee.

And the calculator’s own question, all 800 billion lines? At the rate Sovereign ran, if each of the calculator’s 100,000 developers had one Sovereign machine instead, every line would be read, rebuilt and checked in about 20 minutes. Not 844 years.

From the first read to switching the old system off

Rebuilding and proving is the heart of it, but a move off a legacy system does not end there. Sovereign carries it the whole way:

1. Understand. Every program, rule and dependency, traced to its source, in an assessment report your board can read.
2. Rebuild. Modern code, generated from what was read, with a modern web front end built from the rebuilt system.
3. Prove. Old and new run side by side on the same inputs until every difference is explained.
4. Move the data. Every legacy record moved and matched field by field, with the proof kept.
5. Map the controls. The audit and regulatory controls of the old system mapped to the new one, with the trail kept.
6. Switch over in steps. 25%, 50%, 75%, then 100% of the work moves to the new system, measured against the old at every step, and rolled back automatically if anything drifts.
7. Own it. The old system is switched off with a signed-off record for your board and auditors, and your team owns the new code outright.

Proven against the original, language by language

Sovereign works with what organisations actually run. COBOL, Fortran, PL/I, MUMPS, Perl, REXX and ColdFusion are rebuilt and proven in the product today, each checked against its own compiler or interpreter. That includes 1,413 public REXX programs proven against the Regina interpreter, all 180 open programs of the US government’s Fortran test suite proven against GNU Fortran, and PL/I proven against IBM’s own PL/I compiler. The batch job scripts that tie a mainframe estate together are read and checked against a real IBM mainframe operating system.

Built for an enterprise

• No AI. Nothing is sent to an AI model, and nothing depends on one. The results are exact and repeatable.
• Fully air-gapped. Sovereign runs on your own hardware with no internet connection at all. Your code and data never leave the building.
• Every decision is recorded. Who approved what, and when, is kept in an audit trail for your auditors and regulators.
• Every result can be checked. Each proof comes with an evidence bundle your own team can re-run, without us and without Sovereign.

What this means if you run a system you cannot switch off

The two questions that fill most of the 844 years are answered by machine, in hours or days, with proof you can check. The move itself happens in measured steps you can reverse. Your experts spend their time on the decisions only they can make.

The first step

The first step is an assessment. Sovereign reads your code and gives you a report: what the system does, where the risk is, and what moving off it would take. The scope is fixed and agreed before any work starts, and you decide afterwards whether to go further.

Get in touch