In many medium-sized companies, central processes run on software that is older than the employees who operate it. Payroll accounting, inventory management, billing logic: the actual business logic is often contained in COBOL programs, Fortran calculations or Visual Basic applications that have grown over decades. Documentation rarely exists, and the original developers are usually no longer with the company.
This is precisely where a current development at OpenAI comes in. The company has specifically optimised its latest models for programming languages for which, compared with Python or JavaScript, there is only a small amount of publicly available training material.
The reported figures
OpenAI refers to a new benchmark called MultiLangBench, which covers over 20 programming languages. A benchmark is a standardised test run that can be used to compare models with one another. According to the information provided, GPT-6 Astra achieves a test pass rate of 87.4 per cent there, while the older GPT-5.6 Sol came in at 26.8 per cent.
For COBOL migration specifically, OpenAI states an accuracy of up to 97.9 per cent for GPT-6.1 Sol. This is a figure that is particularly interesting with regard to financial infrastructure, because a large proportion of the COBOL inventories used worldwide are located there.
By way of context: benchmark values are laboratory values. They indicate how well a model performs under defined test conditions, not how well it translates a specific specialist application that has grown over more than 30 years with undocumented special cases. Nevertheless, the jump from under 30 to over 85 per cent is large enough to raise anew the question of use in real projects.
Why legacy languages are difficult for AI models
Language models learn from text. The more code in a language that is publicly available, the better models master its idioms, error patterns and conventions. With COBOL, Fortran and Visual Basic, the situation is the reverse: most productive code is located in closed corporate environments and does not appear in public repositories.
In addition, these languages are often closely interwoven with the platform on which they run. A COBOL program accesses file formats, transaction monitors or database accesses that no longer exist in this form in a modern service environment. A pure language translation does not solve this problem.
What a migration actually comprises
Anyone replacing a legacy application is rarely faced with a pure translation task. Typically, several work packages arise:
- Inventory: Which programs are still running at all, which are effectively dead? In grown systems, this is not a trivial question.
- Reconstructing business logic: What does the code do and why? Here a model can provide good service by converting undocumented routines into comprehensible descriptions.
- Defining the target architecture: Rebuild the monolith one-to-one or split it into services? No model makes this decision.
- Interfaces and data: Data formats, character sets and record structures from the legacy world must be mapped cleanly.
- Test coverage: Without robust tests, it cannot be demonstrated that the new implementation does the same as the old one.
The real opportunity of the new model generation lies less in automatic full migration than in accelerating these preparatory tasks. Making code readable, mapping dependencies and deriving test cases from existing behaviour are tasks in which a strong model can shortcut weeks of manual analysis.
Risks that remain
An accuracy of just under 98 per cent sounds reassuring, but it is not automatically so. In billing logic, two per cent of divergent cases can mean that an incorrect amount arises in every fiftieth transaction. What is decisive, therefore, is how deviations are detected, not how rarely they occur.
A practicable approach is one in which the old and new systems run in parallel for a time and their results are compared automatically. Only when no deviations occur over a relevant period is the switch made. This principle is older than AI-supported migration, but it becomes more important through it, because more code is produced in a shorter time.
A second point is confidentiality. Legacy code frequently contains trade secrets, pricing logic or customer data in test data sets. Anyone who hands such code over to an external service needs a clear arrangement on where it is processed and what happens to the data.
Step by step instead of big bang
The most widespread mistake in modernisation projects is the attempt to replace everything at once. More realistic is an approach in which individual functional areas are extracted one after another and connected to the legacy system via defined interfaces. The legacy system shrinks over months instead of being switched off on a single cut-off date.
In this picture, better models above all shift the effort per step. What previously failed because of a lack of knowledge about the legacy code becomes more plannable.
Classification for web and software projects
For projects that are to connect a grown specialist application to a modern web interface or to services, the barrier to entry drops noticeably: the legacy code can be understood and documented more quickly before a single line is even rewritten. However, the architecture decisions, the test discipline and the business sign-off remain unchanged in human responsibility.
Anyone planning modernisation should therefore schedule the new tools as an accelerator for analysis and test setup, not as a replacement for a cleanly scoped migration project.