Agentic Coding Comes to NASA Research — Are Scientists Becoming Managers of AI Researchers?

Photo: OLCF, Wikimedia Commons, CC BY 2.0

01 A NASA community takes the shift seriously

On September 21, 2026, NASA's astrophysics research community held a session on agentic coding — the practice of delegating software writing, review and iteration to AI agents that plan tasks, produce code, run it, read the errors and fix their own work. The setting matters: this was not a Silicon Valley product launch but working scientists inside a federal research organization comparing notes on a workflow change already underway in their field.

The context is that scientific code stopped being a private tool long ago. Missions, telescopes, pipelines and published results all run on research software, and that software is increasingly written — or at least drafted, refactored and reviewed — with AI assistance. An agentic-coding session at an agency whose data products underwrite decades of published science is a signal that the tools have crossed from novelty into research infrastructure, with all the accountability questions that implies.

Analysis — not prediction. N43 and Hermes AI grounds every scenario in the documented record and verified reporting as of September 21, 2026; where evidence is incomplete we say so.

02 What agentic coding actually changes in a lab

The difference between ordinary coding assistants and agentic coding is who holds the loop. A completion tool suggests the next line; the human still drives every file, test and error message. An agent is handed a goal — implement this reduction pipeline, refactor this analysis module, port this legacy script — and manages its own workflow: breaking the task down, running the code, reading failures and iterating until it believes the goal is met. The human's contribution moves from writing to specifying, supervising and accepting.

In a research setting this changes the unit of work. The scarce resource was always the postdoc-weeks required to turn a scientific idea into working, validated analysis code. If an agent compresses that to days, the constraint moves elsewhere: to formulating questions precisely enough for an agent to execute, and to verifying that what the agent produced actually computes the thing the paper claims. Specifying intent well turns out to be a scientific skill; so does auditing code one did not write.

03 The provenance problem

Science's currency is reproducibility, and agentic coding stresses it in a specific way. Hand-written analysis code is auditable the old way: a human wrote it, and a determined reviewer can trace every line back to a decision someone can be asked about. Agent-written code is plausible, working and largely unread by anyone — including, in a meaningful sense, its operator, who approved a result rather than authoring a text.

The remedy being discussed across the research-software community is provenance capture: treating the agent, its prompts, the model version, the data and the full action log as part of the scientific record, the way telescope settings and calibration frames already are. A paper's methods section may come to include not just the repository link but the agent transcript that produced the repository. Without that, the field inherits a subtle hazard: code that works, that nobody understands, attached to results everybody cites.

04 The scientist as manager of AI researchers

The headline question — are scientists becoming managers? — is genuinely double-edged. In one reading, the shift is a promotion: the scientist spends less time on mechanical implementation and more on the judgment work only humans can do — formulating hypotheses, designing validation, deciding what results mean. The lab's throughput rises, early-career researchers tackle more ambitious projects, and the bottleneck becomes ideas rather than typing.

The other reading is bleaker and worth stating plainly: management is a skill the scientific career track has never selected for. Reviewing agent output at scale is not like writing code — it demands the auditor's habit of assuming the work is wrong and designing checks that would reveal it. A scientist who manages agents the way academics manage overloaded research staff — skimming, trusting, deferring — will ship errors with the same speed the agent ships code. The risk concentrates precisely where oversight thins: in the rush of a deadline or the routine middle of a large analysis.

05 What could break

Three failure modes deserve attention. First, skill atrophy: a generation of researchers who never wrote a reduction pipeline may lose the ability to detect when an agent's fluent code encodes a subtly wrong physical assumption — the units mismatch, the mis-indexed array, the coordinate frame that silently rotates the result. Second, error monoculture: if many labs run similar agents on similar models, correlated mistakes can propagate across nominally independent results, hiding inside a consensus that looks like replication.

Third, accountability drift: authorship norms, code-of-conduct rules and error-correction mechanisms all assume a human author whose judgment stands behind each result. When the code is agent-authored, the honest statement is that a scientist specified intent and accepted output — a weaker attestation than authorship, and one the literature's norms have not yet learned to demand or price.

06 What to watch

The September 21 session is a marker, not a verdict, and the follow-through will be visible in three places. First, NASA software practices: whether mission-adjacent code standards begin specifying provenance logs, model versions and agent-action records as required artifacts. Second, the literature: whether astrophysics methods sections start routinely disclosing AI involvement in code production — and whether reviewers begin asking. Third, training: whether graduate programs start teaching specification and audit as core skills rather than assuming coding ability transfers.

The likely equilibrium is a managed one: agents draft and iterate; scientists specify, audit and own the result. That is more productive than the old arrangement and harder to do well than it sounds — because the scarce skill is no longer writing the code, but knowing, with evidence, that the code is right.