AI Coding Agents Cut Scientific Software Work From Hours to Minutes, OpenAI Report Shows

OpenAI has published a report documenting eight real-world projects in which scientists used coding agents to modernize old, neglected scientific software, mostly in the life sciences. In several cases, the gains are measured not in percentages but in orders of magnitude.

The report, titled "Scientific computing in the age of agentic AI," describes projects run by outside researchers and engineers who used OpenAI's Codex and Anthropic's Claude Code agents to work on scientific code. The work ranged from routine maintenance and targeted performance optimization to migrations between programming languages and redesigning algorithms for GPU architecture.

From 15 Hours to 15 Minutes

The most measurable example is RustQC, a project by Seqera that merged 15 separate quality-control tools used after the read-mapping stage of the popular nf-core/rnaseq pipeline for RNA-seq analysis into a single binary program written in Rust. On a dataset of 186 million reads, the original sequential process took 15 hours and 34 minutes and generated 2.5 terabytes of disk I/O. The version rewritten with agent help did the same job in 14 minutes and 54 seconds, using 0.1 terabytes.

The report's authors emphasize that the new tool's output is identical in format and figures to the source tools and compatible with the MultiQC reporting system, so labs can deploy it without changing the rest of their analysis pipelines.

Two Models, Mutual Checks

In three of the eight projects described, including the largest one, researchers combined Codex with Claude Code in an approach the report's authors called "adversarial pairing" - one model wrote the code, the other reviewed it, and the roles alternated. The idea was to exploit the fact that models from different labs tend to make different kinds of mistakes.

Two models from two different labs make different mistakes: when both flag the same line of code, it is almost always a real bug, and when they disagree, that disagreement points exactly to where a human should look - from OpenAI's report "Scientific computing in the age of agentic AI"

When rewriting a 20,000-line genome aligner from C/C++ to Rust, the agent reached 99.8 percent agreement with the original's results relatively quickly, but closing the final 0.2 percent took more iteration time than the first 90 percent of the work. The cause was layered bugs that the agent's own tests could not distinguish from correct program behavior.

Humans Still Must Check the Results

The report is not a blanket endorsement of unsupervised automation. The authors state plainly that the main bottleneck remains validating the agent's output, which still requires human judgment. In the cases described, agents handled specific, well-defined tasks efficiently, but could not independently determine whether their work was scientifically correct or met the team's expectations.

That distinction matters for labs considering similar deployments: an agent can speed up writing and rewriting code by an order of magnitude, but responsibility for verifying the correctness of scientific results stays with the researchers. In practice, this means small teams gain the ability to take on work that previously would have required hiring specialized engineers, but it does not exempt anyone from the need for code review and testing.

Codex's Growing Role

The report's publication fits a broader trend of growing Codex use inside OpenAI itself - according to earlier company data, the share of employees using agents reached nearly 98 percent, and Codex now accounts for most of engineers' token usage across nearly every department. The scientific computing report shows a similar pattern - the agent as the default tool for code maintenance and migration - starting to spread beyond the company's own walls, into genomics labs and other centers working with large, rarely updated codebases.

For Polish scientific institutions and bioinformatics labs that often maintain older analysis scripts written over many years, OpenAI's report offers a concrete benchmark: the order-of-magnitude speedup achievable when modernizing code, provided researchers maintain rigorous verification of results rather than relying solely on unit tests written by the same agent that wrote the code.