Whenever people talk about AI coding chops, all the spotlight goes to trendy languages: Python, TypeScript, React, or Rust. Meanwhile, the global financial system still runs on codebases written back when Yuri Gagarin first flew to space.
Roughly 95% of all ATM transactions worldwide and interbank clearing systems are handled by COBOL—a language from 1959. Its original authors retired decades ago, documentation has vanished, and public GitHub repos are next to nonexistent. Banks have been terrified to touch their IBM mainframes: a single cent-rounding bug could trigger lawsuits.
A new OpenAI study suggests we're standing on the edge of a massive refactoring wave. The GPT-6.1 Sol model showed an extraordinary leap in understanding and porting low-resource legacy languages.
From 5% to 98%: The Power of Synthetic Execution Traces
On a semantic migration benchmark moving COBOL to modern languages, the previous generation barely scratched the surface:
- GPT-5.6 Sol solved only 5.4% of tasks;
- The new GPT-6.1 Sol pushed baseline reasoning up to 86.6%;
- And with High Reasoning Effort enabled, migration accuracy reached an astonishing 97.9%.
How did OpenAI train a model without massive code corpora? The secret lies in Synthetic Execution Traces. They taught the neural network to simulate mainframe registers and step-by-step in-memory operations. Instead of guessing text patterns, the model learned to physically trace the underlying algorithms.
On MultiLangBench (building a database engine across 20 languages), flagship GPT-6 Astra scored 87.4%, lifting the COBOL score to 72.1%.
As we saw in the evolution of the GPT-5.6 Sol model line, specializing in deep reasoning pays off far more than simply piling on more training text.
The COMP-3 Trap: Why You Can't Translate Old Code Naively
The biggest landmine in modernizing banking code is packed decimal arithmetic (Packed Decimal, or COMP-3 format in COBOL).
COBOL enforces strict fixed-digit precision: unless you explicitly add a ROUNDED directive, extra digits are simply truncated toward zero. Using standard float or double types introduces rounding drift and breaks financial balances.
Here's a classic COBOL interest calculation:
IDENTIFICATION DIVISION.
PROGRAM-ID. CALC-INTEREST.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-PRINCIPAL PIC 9(7)V99 COMP-3 VALUE 10000.00.
01 WS-RATE PIC 9V9999 COMP-3 VALUE 0.0525.
01 WS-INTEREST PIC 9(5)V99 COMP-3.
PROCEDURE DIVISION.
COMPUTE WS-INTEREST = WS-PRINCIPAL * WS-RATE.
DISPLAY "Calculated Interest: " WS-INTEREST.
STOP RUN.
GPT-6.1 Sol catches that truncation behavior and generates equivalent Rust code with strict decimal precision:
use rust_decimal::Decimal;
use rust_decimal_macros::dec;
use rust_decimal::RoundingStrategy;
fn calculate_interest(principal: Decimal, rate: Decimal) -> Decimal {
// In COBOL COMP-3 without explicit ROUNDED, the result truncates to 2 decimal places toward zero
let raw_interest = principal * rate;
raw_interest.round_dp_with_strategy(2, RoundingStrategy::ToZero)
}
fn main() {
let principal = dec!(10000.00);
let rate = dec!(0.0525);
let interest = calculate_interest(principal, rate);
println!("Calculated Interest: {}", interest); // Exactly 525.00
}
Never use floating-point types when migrating financial algorithms. Accuracy requires fixed-point decimal types and an explicit truncation strategy.
OpenAI's study proves that reasoning models have reached the point where we can safely modernize critical global infrastructure.


