OpenAI says GPT-6.1 Sol is dramatically better at migrating legacy code

OpenAI confirmed that its newer models deliver substantial gains when writing and migrating software written in legacy programming languages like COBOL, Fortran, and Visual Basic. According to BleepingComputer's report, the company evaluated its frontier and reasoning architectures against tasks historically constrained by sparse modern training data and scarce documentation. These older codebases continue to run critical global infrastructure, including banking systems and physical safety systems, making reliable automated refactoring a significant engineering priority.

This analysis details the technical benchmarks, migration accuracy metrics, and developer access workflows for OpenAI's legacy code modernization capabilities. It is intended for enterprise software engineers, systems architects, and infrastructure teams managing aging codebases that interface with modern distributed environments. The release examines performance jumps across twenty programming languages, migration paths to contemporary runtimes, and the specific cost and reasoning trade-offs associated with production modernization efforts.

What shipped in OpenAI GPT-6.1 Sol is dramatically better

OpenAI introduced architectural updates across its model family, emphasizing GPT-6.1 Sol and GPT-6 Astra for complex syntax comprehension in low-resource programming languages. To measure these capabilities, OpenAI designed MultiLangBench, an evaluation harness requiring models to build a functional, SQLite-compatible database engine completely from scratch across twenty distinct programming languages. The benchmark targets languages that possess significantly less public code, repository activity, and structured documentation compared to modern standards like Python or JavaScript.

The new evaluation covers enterprise and legacy languages including COBOL, Fortran, Visual Basic, and OCaml, alongside modern targets such as Rust, Kotlin, Java, and C++. Beyond raw generation, OpenAI shipped specialized behavioral migration evaluations designed to transform existing COBOL programs into modern application stacks without modifying runtime behavior or business logic. The shipped models demonstrate that structured reasoning improvements directly translate into higher compliance with complex syntax rules found in legacy execution environments.

What improved in OpenAI GPT-6.1 Sol is dramatically better

Performance across MultiLangBench demonstrates substantial metric gains when moving from prior architectures to the latest systems. GPT-6 Astra achieved an overall average test pass rate of 87.4% across all twenty languages, compared to 26.8% recorded by GPT-5.6 Sol. In standalone COBOL generation, Astra scored 72.1%, rising from 10.9%, while Fortran generation climbed from 21.4% to 83.5%. Additional gains appeared in OCaml, which jumped from 25.6% to 85.8%, and Visual Basic, which advanced from 27.5% to 89.4%.

For direct codebase migration, GPT-6.1 Sol achieved an 86.6% accuracy rate when migrating COBOL code to modern targets at low reasoning effort. This represents a steep improvement over GPT-5.6 Sol, which registered 5.4% accuracy under identical reasoning parameters while operating at higher relative expense. When configured for higher reasoning effort, GPT-6.1 Sol reached 97.9% accuracy on the migration test suite.

What you gain from OpenAI GPT-6.1 Sol is dramatically better

Engineering teams managing aging systems gain an effective pathway for decoupling mission-critical business logic from legacy mainframes and obsolete compilers. COBOL currently powers more than 40% of online banking systems, 80% of in-person credit card transactions, and 95% of ATM transactions worldwide, while Fortran remains active in weather forecasting and nuclear reactor safety analysis. Replacing or updating these stacks has historically been stalled by the risk of introducing behavioral regressions during manual translation.

With GPT-6.1 Sol, teams can generate automated migrations targeting C++, Java, Kotlin, Python, or Rust while preserving program output consistency. Because the model reaches 86.6% migration accuracy at just 61% of the API cost of GPT-5.6 Sol, development teams can run large-scale automated code assessment and initial transformation runs with lower computational overhead. At higher reasoning effort, the 97.9% accuracy rate allows organizations to resolve edge cases that previously prevented automated translation of legacy business rules.

How to get OpenAI GPT-6.1 Sol is dramatically better

Developers can access GPT-6.1 Sol through the standard OpenAI API endpoints, SDK client libraries, and compatible command-line developer environments. Teams integrating these capabilities into continuous integration pipelines or developer workstations should update their local tools to ensure the latest model definitions and reasoning effort parameters are fully supported across all interfaces.

npm install -g @openai/codex

openai api chat.completions.create --model gpt-6.1-sol

codex --model gpt-6.1-sol

export OPENAI_DEFAULT_MODEL="gpt-6.1-sol"

Within interactive CLI sessions and development environments, engineers can switch between standard and reasoning-focused checkpoints directly to balance verification depth against latency during migration runs.

/model gpt-6.1-sol

/model gpt-6-astra

What to watch after OpenAI GPT-6.1 Sol is dramatically better

Despite the high benchmark figures, OpenAI emphasizes that automated outputs cannot be deployed straight to production without rigorous human oversight. Migrating mission-critical infrastructure like banking transactions and reactor monitoring requires comprehensive test coverage, parallel runtime verification, and expert human code review to catch subtle edge-case divergences. The high benchmark scores indicate strong syntactic and logical translation, but integration bugs can still emerge in bespoke enterprise environments.

Engineering leaders should also consider the broader operational context surrounding enterprise infrastructure. Legacy system modernization involves extensive testing against undocumented internal dependencies that standard benchmarks like MultiLangBench cannot simulate. Organizations must validate whether high reasoning configurations justify additional compute latency during batch conversions, and teams must maintain strict behavioral testing suites before deprecating established mainframe runtimes in favor of newly generated modern code.