Scientific Computing in the Age of Agentic AI

On July 28, 2026, OpenAI published a field report called Scientific Computing in the Age of Agentic AI that documents how eight research teams used coding agents to modernize scientific software. Most of the projects live in the life sciences — genomics, immunology, and simulation — but the lessons translate directly to any engineer maintaining numeric, data-heavy codebases. Because what the report describes is not a niche bioinformatics story. It is the shape of your job a few years from now.

The full paper is worth a read, but the plot is easy to summarize. Five teams ran on Codex alone, three on a mix of Codex and Claude Code. The work spanned the boring end of the spectrum (packaging, builds, test wiring) through targeted optimizations and all the way to large-scale language migrations and GPU-native redesigns. Five of the eight touched genomics tools you have probably installed once in a lab: cyvcf2, hifiasm, MHCflurry, FastQC, Trim Galore.

Why Research Code Was Stuck

Here is the context the report starts from. Most scientific software began as code bolted onto a paper — written by a small academic team, tight on time, with no budget for packaging, testing, or long-term support. The result is infrastructure that is slow, fragile, and constant work to keep alive. Published studies of research code and omics tools found that much of it fails to install in a fresh environment or run as documented at all. When your data generation outpaces your analysis tooling, the bottleneck is never the science. It is the plumbing.

Coding agents attack that bottleneck directly by making engineering labor cheap. A genome-variant parser like cyvcf2 got its legacy build and packaging system replaced by a modern, unified process using GPT-5.5 — the kind of work a maintainer would normally dread and postpone for years. Teams that used to avoid rewrites because they could not afford the engineering time now attempt them.

From Implementation to Orchestration

The most consistent finding across all eight case studies is that the researcher's job changed. Nobody described the work as "the agent wrote the code." They described it as: specify what to build, define how correctness gets measured, break the work into manageable chunks, and decide when it is ready to ship. Implementation moved to the agent. Verification and orchestration stayed human.

That is a bigger shift than it sounds. For years we treated "being a developer" as synonymous with "writing code." The report suggests the durable skill is running the loop — feeding the agent, reviewing its output, catching the subtle wrongness, and owning the final call. The researchers remained in control of scientific direction and the quality bar, but the velocity uplift was real enough that some small teams took on work that previously needed dedicated engineering support.

Verification Is Now the Bottleneck

Here is the uncomfortable part. Agents handled well-scoped requests effectively, but they could not reliably judge whether their own work was scientifically valid — and they often sounded confident while shipping clear errors. So every team had to build a verification strategy, and the strongest ones shared a shape: an external reference or a measurable acceptance target.

Concretely, that meant exact output agreement against a reference implementation, parity with an existing tool, appropriate statistical behavior, or answers precomputed from simulated data. In other words, the validation became a test harness you can write down before the agent starts:

import numpy as np

def verify_rewrite(agent_fn, reference_fn, n_samples=10_000, seed=42):
    """Reject the rewrite unless output agrees with the reference."""
    rng = np.random.default_rng(seed)
    inputs = [rng.normal(size=512) for _ in range(n_samples)]
    mismatches = sum(
        1 for x in inputs
        if not np.allclose(agent_fn(x), reference_fn(x),
                           rtol=1e-9, atol=1e-12)
    )
    print(f"{mismatches}/{n_samples} inputs diverge from the reference")
    return mismatches == 0

The report makes a point every agent user should tattoo on their monitor: a rewrite is not done because it runs and produces plausible numbers. It is done because an independent target says so. If you cannot name the acceptance target before you start, you are not ready to let an agent rewrite your numerics.

The Last Mile Takes the Longest

A second recurring theme: none of the projects were one-shot. Teams broke broad goals into small changes, then looped through intermediate benchmarks and test systems, feeding failures back into the agent. Initial implementations came fast — impressively fast. But resolving edge cases and subtle numerical differences consumed most of the effort. The "last mile" of an implementation was the real project.

This maps exactly to what we said about AI writing pipelines needing a human review step: the agent gets you 90% quickly, and the last 10% is where correctness actually lives. Budget for the loop. Do not treat "first correct-looking run" as "done."

Stewardship Still Matters

The report ends on a warning that is easy to miss under the good news. Cheaper implementation means teams can now produce many similar rewrites — which fragments users and spreads thin the expert attention each tool needs. Modern rewrites that nobody owns become tomorrow's abandoned code.

Two of the projects (MHCflurry and cyvcf2) were incorporated back into their original upstream projects. Another, rustar-aligner, moved under new community stewardship because the original project had died. The rule is blunt: coordinate with existing maintainers early, and if a separate implementation is necessary, give it a clear owner and a credible maintenance plan. The same logic applies when you rewrite a tokenizer or port a pipeline — we made exactly this argument for Gigatoken and the Rust modernization wave.

What This Means for You

Strip away the genomics and the report reads like a manual for the next era of software work. Agents lower the cost of maintenance, migration, and optimization. Your value stops being typing and starts being judgment: what to build, how to verify it, and who will keep it alive.

Brent Pedersen, the cyvcf2 maintainer, put it better than the whole report: "With coding agents, it's quite easy to go fast; for now, to go far in science, there's still a need for expert guidance, understanding, taste, and care."

Go fast. Just make sure the loop is human at both ends — defining what right looks like, and deciding when it shipped.