When COBOL changes,
something can go wrong.
AI tools, vendor patches, and developer commits can all change the meaning of COBOL while the compiler stays silent. Refinery reads the code the same way a senior engineer would, and produces attestation evidence for every change.
COBOL is changed
An AI tool, a vendor PTF, or a developer commit modifies a section of code. The compiler accepts it.
Refinery checks the meaning
We compare the original and the new version, not just the syntax, but what the code actually does at runtime.
You get a clear verdict
PASS means the change is safe. FLAGGED means something changed that shouldn't have, with a full report.
Banking
Banks run settlement, interest, and payment processing on COBOL that has been stable for decades. When AI tools modernise this code, even a tiny change to a calculation can produce wrong numbers, and the compiler will not notice.
What gets missed without Refinery
- A rounding step is removed from an interest calculation. The result is off by a fraction of a penny, invisible in testing, but wrong across millions of transactions.
- An error handler is silently deleted. Under normal conditions nothing breaks. Under edge conditions, the program crashes with no recovery.
- A field type is changed to save memory. Downstream programs that read the same field now get garbled data.
What Refinery catches
- Any change to how a calculation is done, including rounding, precision, and order of operations.
- Removed or bypassed error handling in critical payment paths.
- Field type changes that would break any other program reading the same data.
- A map of every batch job and program that would be affected if the change ships.
Real example
An AI tool rewrites an interest calculation and removes the ROUNDED keyword. The compiler produces clean output. The result is now truncated instead of rounded, a difference that accumulates to millions in incorrect charges over a year.
✓ Refinery flags this before it ships.
Insurance
Insurance companies calculate policy values, premiums, and payouts using COBOL that has been tuned over years. A small change to how data is stored in memory can cause those calculations to produce completely wrong results, with no error message.
What gets missed without Refinery
- AI changes how a shared data field is stored. Calculations that worked for decades now read the wrong bytes and produce wrong policy values.
- A condition that handles edge cases in benefit calculations is quietly removed. Works fine for 99% of policies. Fails silently for the rest.
- Shared copybook files that dozens of programs depend on are changed without checking what else uses them.
What Refinery catches
- Changes to how data fields are stored in memory that would break anything reading those fields.
- Removed conditions or logic branches that handle edge cases.
- Every other program in the system that would be affected if a shared data file changes.
- A signed PDF certificate for every change reviewed, with a full explanation of what was verified.
Real example
An AI modernisation tool converts a shared data field from text format to packed decimal to save space. The compiler is happy. But seven other programs that read the same field expect text, and now get unreadable binary data instead.
✓ Refinery flags this before it ships.
Government
Tax systems, benefit calculations, and pension processing run on COBOL that cannot be replaced. When AI tools refactor these programs, silent logic changes can mean citizens receive the wrong amount, or nothing at all, with no alert to anyone.
What gets missed without Refinery
- AI simplifies a section of code by merging two logic paths that were intentionally separate. Edge cases for certain claimant types stop being handled correctly.
- A loop that processes records is refactored. The new version works on the test data but processes some real records twice.
- Validation rules written to comply with specific legislation are removed because the AI sees them as redundant.
What Refinery catches
- Logic paths that have been merged, removed, or reordered, even when the output looks the same on test data.
- Loop and iteration changes that could process records a different number of times.
- Removed validation or condition checks, flagged as potential compliance failures.
- An independent audit trail that your compliance team can show regulators.
Real example
AI removes two paragraphs from a benefit calculation loop, treating them as duplicate code. They were not duplicate; they handled different claimant categories. The program compiles and passes unit tests. Certain claimants receive incorrect payments.
✓ Refinery flags this before it ships.
Retail
Large retailers run stock reconciliation, pricing, and loyalty programmes as overnight batch jobs. These jobs run millions of times a night. A silent error in one program compounds across every transaction it touches before anyone notices something is wrong.
What gets missed without Refinery
- AI optimises a pricing calculation by reordering operations. The result is mathematically equivalent for most inputs, but not for promotional discount stacking.
- A batch job is changed to run faster. The optimisation skips a reconciliation step that catches stock discrepancies.
- A loyalty point calculation is simplified. Points are now awarded using slightly different rounding, wrong for every transaction but never large enough to trigger an alert.
What Refinery catches
- Calculation changes that produce the same result on simple cases but differ on real-world inputs.
- Removed processing steps in batch jobs, even if they look redundant.
- Every downstream batch job and JCL file that depends on the changed program.
- A clear report showing exactly what changed and what it means in plain terms.
Real example
AI refactors an overnight stock reconciliation job to run faster by removing what it sees as a redundant loop. The loop was not redundant; it handled returns processed after close of business. Stock counts are now consistently wrong for any store with late returns.
✓ Refinery flags this before it ships.