GPT-6.1 Sol coding took its biggest leap in COBOL: on OpenAI's COBOL migration test, GPT-6.1 Sol scored 86.6% at low reasoning effort, up from just 5.4% for GPT-5.6 Sol, and hit 97.9% at higher effort. On top of that, it matches GPT-6 Astra on DeepSWE v1.1, OpenAI's real-codebase software engineering benchmark, at roughly a fifth of the cost.
📺 Watch: GPT-6.1 Sol Just Made a HUGE Breakthrough in Coding!
🔥 Get the Agent OS as a free bonus: AI Profit Boardroom members get the full Agent OS zip, prompt libraries, daily tutorials and weekly live coaching calls. → Get inside
So yes, a 60-year-old language is at the centre of the biggest AI coding jump of the year. Not Python. Not JavaScript.
I made a video on this because the jump matters way beyond old code. If a model can rewrite a banking program and keep every output byte identical, it can handle a lot of the boring, high-stakes work in your codebase too. Here's what OpenAI is claiming, what the coding numbers say, how to run it in Codex and agents, and when I'd reach for something else.
Want the exact Codex setups, prompts and agent workflows I use? They're inside the AI Profit Boardroom for $69/mo, updated as new models land.
The COBOL breakthrough OpenAI is claiming
On October 19, 2026, OpenAI published a research post on coding in what it calls low-resource programming languages. Think COBOL, Fortran and Visual Basic.
Why low-resource? There's far less code and documentation out there for models to learn from compared to Python or JavaScript. But these languages still run critical systems. OpenAI cites figures that COBOL supports more than 40% of online banking systems, 80% of in-person credit card transactions and 95% of ATM transactions. Fortran shows up in weather forecasting and nuclear reactor safety analysis.
Here's the problem teams face. The documentation is often incomplete. The original developers have left. And key business rules only exist inside the code itself.
How the migration test works
OpenAI's test asks the model to migrate COBOL programs into C++, Java, Kotlin, Python or Rust while keeping exactly what each program does.
That's harder than it sounds. OpenAI gives a great example. COBOL's fixed-point arithmetic throws away extra decimal digits unless you explicitly ask it to round. If your rewrite rounds those values instead, the code runs fine with zero errors and quietly gives you different financial results.
So the scoring is brutal. Hidden tests. Byte-for-byte parity on observable outputs. A migration only counts if every single test passes.
The result
GPT-6.1 Sol hit 86.6% at low effort. GPT-5.6 Sol hit 5.4% at the same setting, and 6.1 Sol did it at 61% of the API cost. Turn the effort up and it reaches 97.9%, which OpenAI says brings the test close to saturation.
OpenAI also flags the catch, and I made the same point in my video. This isn't production-ready on autopilot. OpenAI says applying it to real software still needs expert review and testing against the system's business rules and dependencies.
The second test: SQLite in 20 languages
OpenAI also built MultiLangBench. The model has to build a SQLite-compatible database engine from scratch, in 20 different languages, across a long coding session. It has to organise the codebase, manage state, handle errors and add features without breaking what already works.
The headline score there belongs to GPT-6 Astra: an 87.4% average test pass rate, up from 26.8% for GPT-5.6 Sol. COBOL went from 10.9% to 72.1%. Fortran from 21.4% to 83.5%. OpenAI published the setup and test suite on GitHub so anyone can check the results. OpenAI didn't publish a GPT-6.1 Sol score on this one, so don't confuse the two.
📺 Watch: Qwen 3.8-Max, Fable 5 and GPT-5.6 Sol: Who Wins?
GPT-6.1 Sol coding benchmarks
The COBOL test is the flashy one. But if you write modern code, the number that matters most is DeepSWE v1.1. It measures original, long-horizon software engineering tasks in real codebases.
Here's every coding-relevant result OpenAI has published for 6.1 Sol, side by side.
| Test | What it measures | GPT-6.1 Sol | Comparison |
|---|---|---|---|
| COBOL migration (low effort) | Behaviour-preserving rewrites | 86.6% | GPT-5.6 Sol 5.4% |
| COBOL migration (higher effort) | Same test, more thinking | 97.9% | Near saturation |
| DeepSWE v1.1 (high) | Real-codebase engineering | 75.2%, $0.65/task | Astra 74.1% at $4.43/task |
| DeepSWE v1.1 (medium) | Same, cheaper setting | 73.0%, $0.42/task | GPT-6 Sol 56.6% |
| Terminal-Bench Science (max) | Code and terminal research work | 57.0%, $5.47/task | Astra 68.1% at $23.80/task |
Two things jump out.
First, medium effort is the sweet spot on DeepSWE. 73% for 42 cents a task. That's basically Astra-level output for small change.
Second, more effort isn't always better. On OpenAI's DeepSWE chart, 6.1 Sol peaks at high effort with 75.2%, then dips to 71.9% at xhigh and max while costing more. OpenAI says it beats GPT-6 Sol's best DeepSWE score by 6.4 points at a lower reasoning effort and cost.
Numbers on a vendor chart only go so far. I test models on real business builds in Goldie Bench, and that's where you see whether a model actually finishes the job.
If you want help figuring out which coding jobs in your business are worth handing to an agent, grab a free AI strategy session.
📺 Watch: GPT-6 + Doug: OpenAI's Secret AI
Running GPT-6.1 Sol in Codex and agents
OpenAI's Codex docs are direct about it: for complex coding and agentic workflows, use GPT-6.1 Sol when it's available to your account and client.
Here's how to switch it on.
- CLI: launch with codex --model gpt-6.1-sol, or the short form codex -m gpt-6.1-sol.
- One-off runs: codex exec -m gpt-6.1-sol "Review the current changes"
- Make it default: add model = "gpt-6.1-sol" to your config.toml. The desktop app, CLI and IDE extension all share that file.
- Mid-session: type /model to switch models or change reasoning effort.
Effort in Codex runs from Light to Ultra. Light shows up as Low in the CLI. Max gives the model more time on one task. Ultra splits the work across subagents running in parallel. OpenAI says most tasks don't need Max or Ultra, and the DeepSWE chart backs that up.
Building your own agent on the API? The model ID is gpt-6.1-sol. Use the Responses API for tool calling, since Chat Completions doesn't support tools for this model. You get hosted shell, apply patch, code interpreter, MCP, skills, computer use and tool search, plus a 1,050,000-token context window. That's room for a big chunk of a repo.
One migration gotcha from OpenAI's guide. GPT-6.1 Sol doesn't support "none" reasoning effort. If your old GPT-6 Sol agent used none, set it to low.
And cost adds up fast in agent loops. Cached input is $0.10 per million tokens, so agents that keep reusing the same repo context get much cheaper per step.
I run Hermes every day inside my Agent OS with a profile per model. If you want to see that wiring, my Hermes GPT-6 post shows the GPT-6 models in Hermes, and my Agent OS guide shows the full system.
Practical coding workflows that fit this model
Here's where I'd point it first.
- Legacy migrations. Rewriting old code into a modern language while keeping behaviour identical is exactly what OpenAI tested. Write the tests first, then let the model migrate, then have a human check the business rules.
- Code review on every change. Run codex exec with a review prompt on your diff. At medium effort it's cheap enough to do on every pull request.
- Long refactors in real repos. That's what DeepSWE measures. Give it the repo, a clear goal and a test command.
- Bug hunts and outages. Speed matters here. OpenAI says Ultrafast brings up to 8x faster token generation in Codex, on the Pro $500 plan and eligible Enterprise and Edu plans.
The AI Profit Boardroom has the prompt library and a 30-day AI agent roadmap to get these running, plus four coaching calls a week.
When to pick another model
6.1 Sol isn't the answer to everything. If you're weighing up a model stack for your team, a free AI strategy session is the quickest way to get it right.
Hardest research problems: OpenAI says GPT-6 Astra still has the top Terminal-Bench Science score and should be used for the toughest scientific tasks.
Flashy front-end visuals: in my launch video, its one-prompt 3D worlds were playable but less polished than Sonnet 5.5's.
Cheap, high-volume jobs: GPT-6 Luna is the fast, low-cost tier. On MultiLangBench it reached 40.3% at about $0.77 per sample. Compare the two in GPT-6 Sol vs GPT-6 Luna.
For the full non-coding picture, specs, pricing and availability, read my GPT-6.1 Sol overview.
FAQ
Is GPT-6.1 Sol good at coding?
Per OpenAI, yes. It matches GPT-6 Astra on DeepSWE v1.1 at roughly a fifth of the cost, and scores 86.6% on its COBOL migration test at low effort.
Can GPT-6.1 Sol migrate COBOL to production by itself?
No. OpenAI says production use still needs expert review and testing against your system's business rules and dependencies.
How do I use GPT-6.1 Sol in Codex?
Run codex --model gpt-6.1-sol, or set model = "gpt-6.1-sol" in config.toml. It's on Plus, Pro, Business, Enterprise and Edu. Free and Go aren't included at launch.
Ready to put AI coding agents to work in your business? Book your free AI strategy session and we'll find the quickest wins.
