Models
COBOL, Fortran: OpenAI pitches AI for legacy migration
OpenAI reports 86.6% successful COBOL migrations with GPT-6.1 Sol, up from 5.4%. We look at the tests, the real prices and the limits.
On October 19, 2026, OpenAI published results on so-called "low-resource" languages: COBOL, Fortran, Visual Basic and OCaml, languages with far less public code than Python or JavaScript. The headline numbers are striking, but they come from two tests OpenAI designed itself, and only one of them is public (OpenAI). Here is what was measured, what it costs, and what to check before you believe it.
In short
- COBOL migration: GPT-6.1 Sol succeeds on 86.6% of migrations at low reasoning effort, against 5.4% for GPT-5.6 Sol, and 97.9% at higher effort, according to OpenAI.
- Building software: on MultiLangBench, GPT-6 Astra passes 87.4% of tests on average across 20 languages, against 26.8% for GPT-5.6 Sol. COBOL remains the hardest, at 72.1%.
- Public test: MultiLangBench is released under the Apache-2.0 license on GitHub. The COBOL migration test is not.
- Price: GPT-6.1 Sol costs $2 per million input tokens and $10 per million output tokens in the API (OpenAI).
Why COBOL still matters
OpenAI notes that COBOL runs more than 40% of online banking systems, 80% of in-person card transactions and 95% of ATM transactions, figures it takes from a third-party source (OpenAI). Anthropic cites the same order of magnitude: 95% of ATM transactions in the US (Claude).
The problem is well known: incomplete documentation, original developers long gone, business rules that now live only in the code. Models trained mostly on modern code have historically been weak here.
The topic moves markets. On February 23, 2026, Anthropic said Claude Code could automate the exploration and analysis of COBOL systems; IBM shares fell 13.2% that day, their steepest drop since October 2000 (Reuters). OpenAI is entering contested ground.
How the two tests work
MultiLangBench asks the model to write a database engine compatible with SQLite 3.40.1, from the documentation alone and with no internet access. The program receives a starting database and an SQL query, writes a modified database, and the real SQLite checks the result. Every trace of SQLite must be removed from the environment, and a solution written in the wrong language, or mixing several, scores zero (MultiLangBench README).
The tests come from SQLite's TCL suite: of about 51,000 tests, 24,000 could be converted. To keep costs down, the README recommends running only 272 of them. The score is a pair: test pass rate and the API cost to get there.
The COBOL migration test asks the model to translate COBOL programs into C++, Java, Kotlin, Python or Rust while preserving their behavior. A migration only counts if every hidden test passes, with byte-for-byte identical output. OpenAI gives a telling example: COBOL's fixed-point arithmetic drops extra decimal digits unless rounding is requested. A rewrite that rounds runs without errors but produces different amounts (OpenAI).
Results, language by language
On MultiLangBench, at maximum reasoning effort, GPT-6 Astra improves in all 20 languages, according to OpenAI:
- COBOL: from 10.9% to 72.1%;
- Fortran: from 21.4% to 83.5%;
- OCaml: from 25.6% to 85.8%;
- Visual Basic: from 27.5% to 89.4%.
Astra scores above 83% in 19 of the 20 languages. The small GPT-6 Luna model averages 40.3%, better than GPT-5.6 Sol, at an estimated API cost of $0.77 per sample against $3.48, about 78% less (OpenAI).
On COBOL migration, GPT-6.1 Sol goes from 5.4% to 86.6% at low effort, at 61% of GPT-5.6 Sol's API cost, and reaches 97.9% at higher effort. OpenAI itself describes the test as "close to saturation".
Real prices
Standard API rates per million tokens, short context (OpenAI):
- GPT-6 Astra: $10 input, $50 output;
- GPT-6.1 Sol: $2 input, $10 output, $0.10 cached input;
- GPT-6 Luna: $0.10 input, $0.50 output.
Batch and Flex modes halve these prices, a real argument for bulk migrations that don't need an instant answer. Long context doubles GPT-6.1 Sol's input price, to $4.
On the subscription side, Codex is included in ChatGPT Plus at $20 a month with GPT-6.1 Sol, and in Pro plans at $100, $200 or $500 a month; API-key usage is billed at API rates (OpenAI).
Realistic use cases
- Map before migrating: have the model document a program and its dependencies, which Anthropic also describes as the most expensive step (Claude).
- Migrate one component at a time: a module with clear boundaries, parity tests written before translation, then validation.
- Maintain without migrating: fix a bug in Fortran or Visual Basic when nobody on the team knows the language anymore.
The limits
- In-house tests: OpenAI designed both evaluations, and the only comparison is with its own previous model. No figures are given for Anthropic, Google or open-weight models.
- Unverifiable migration score: the COBOL test is not published; we don't know how many programs it contains, how long they are or where they come from. A 97.9% score on an unknown set mostly says the test has become too easy.
- Results missing from the repo: OpenAI says it is releasing per-language results, but on October 20 the GitHub repository only holds the license, README, scripts and tests (GitHub). There is no harness to run a model end to end either.
- Small sample: 272 recommended tests out of 24,000 converted.
- Translation is not modernization: a real project also covers data, operations, compliance and business validation. OpenAI acknowledges that production use "still requires expert review and testing" against the system's business rules and dependencies (OpenAI).
The progress is real on OpenAI's own numbers, but it still needs independent tests on real production code.
What it means for developers
First, the drop in cost matters as much as the score. A model at $2 and $10 per million tokens, with a half-price Batch mode, makes it plausible to run an entire portfolio of programs through repeated attempts, which made little sense with a previous model at a 5.4% success rate, according to OpenAI's own figures.
Second, value shifts to tests. A successful migration is defined by behavioral parity; teams that already have regression suites on their legacy systems will benefit first. Others will have to build them, and that is where an agent can help.
Third, measure it yourself. MultiLangBench provides a reproducible method, but you have to build your own agent loop around it. For a real COBOL project, the only measure that counts is a sample of your own programs, with your own expected outputs.
Finally, with Anthropic and now OpenAI in this space, this is the time for a limited pilot, not a full migration on the strength of a vendor benchmark.