acceptodds
Under review as a conference paper at ICLR 2027

Recursive Improvement of a Differentiable Scientific Software Ecosystem

Abstract

Differentiable programming connects scientific computation with gradient-based inference, learning and design. Realizing its potential across the natural sciences requires extending a vast and heterogeneous software ecosystem, a process constrained by the specialized effort needed to implement derivatives, integrate interfaces and assess implementation quality. AI coding agents offer an opportunity to accelerate this transformation, but translating their capabilities into useful scientific software requires identifying research needs and evaluating how well implementations meet them. Here we present an environment for agent-driven evolution of differentiable scientific software that connects demand identification, development and quality evaluation. A unified differentiation interface exposes reusable derivative rules alongside existing numerical routines, allowing different research tasks to share these capabilities. Research requirements are translated into development tasks, with implementations assessed through independent derivative checks, workflow tests and performance evaluation. Validated software, research programs and tests become shared resources for subsequent studies. We construct and validate automatic differentiation extensions across 20 packages spanning physical, chemical and biological modeling, with research workflows demonstrating reuse across tasks. Benchmarks demonstrate computational savings over finite differences in gradient evaluation and complete parameter estimation. Research-driven revisions make previously unsupported workflows differentiable, correct derivatives of scientific observables, and eliminate redundant computation. Quantum-control and thermal-design studies revise objectives in response to physical evaluation, improving the resulting designs while reusing existing derivatives. This work provides a practical approach to expanding differentiable programming across established scientific software and organizing AI agents around the recursive improvement of a shared computational ecosystem.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
automatic differentiation, differentiable programming, scientific software ecosystems, recursive improvement, AI agents, AI for science

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_5muJOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

This paper develops automatic differentiation extensions for 20 scientific packages through agent-driven development and research feedback. The authors perform derivative checks and demonstrate research applications to show how these extensions support gradient-based inference and design, and how their use leads to further software improvement.

Critical strengths
  1. The paper provides reusable derivative capabilities with clear scientific utility. The FiPy and Kwant inverse problems show substantial computational savings while preserving recovery accuracy.

  2. It shows how research use can improve shared scientific software. The Kwant and StochKit2 cases support this through added derivative capabilities and corrections to numerical errors.

Critical weaknesses

None

Questions for authors

None

1 comment
AuthorsOpenReview ↗

Response to Review

Thank you for recognizing the scientific utility of the reusable derivatives and the evidence connecting research use to software improvement. In the revised manuscript, we have added Section 6 and Table 2 to synthesize diagnostic failure modes, differentiability boundaries and routing decisions across agent development and research evaluation, clarified human and agent stage handoffs in Section 2.2, and detailed how our native-interface Kwant and QuSpin extensions complement standalone differentiable solvers in Section 7. All numerical results and comparison conditions are unchanged.

Reviewer_aho2OpenReview ↗
Rating
1
Confidence
2
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

The paper asks the question: How can agent-driven development build and improve a differentiable scientific software ecosystem. It uses agents to incorporate auto differentiation into 20 software packages. It is essentially an agent workflow consisting of two agents that form a loop, updating software and processing development requests. The first steps the agents cover is to add automatic differentiation capabilities. The derivative capabilities are checked using different means, depending on the augmented application. It is shown that massive performance improvements can be gained using automatic differentiation, in comparison to the existing numerical implementation. This in turn enables improvements in the actual research. As a further contribution, reusable abstractions, similar to Julia's Chain rule package are factored out of the individual packages and maintained centrally in a shared ecosystem.

In summary, the paper explores and demonstrates the potential of agent to greatly accelerate evolution of scientific software packages and enables new research capabilities through the integration of automatic differentiation.

Critical strengths

The paper provides an interesting case study that shows the potential agentic development has in advancing scientific software development. It also demonstrate how improved implementations can unlock new research capabilities. The paper shows that huge performance advantage can be gained by employing modern auto diff frameworks and that by using agents this effort can largely be automated. It considers a relatively broad set of applications and discusses aspects on different levels, from raw gradient improvements, to validation up to the research capabilities that are unlocked. We also find it interesting that it considers the full loop including the research applications and shared software components over different application. instead of of narrowly focusing on AD improvements

Critical weaknesses

The paper is a description of what has been done with agents and describes what is achieved, but is in style not a typical scientific paper. The paper contributes, at least in the main text, very little regarding establishing a scientific methodology that would help the community building reliable agentic systems for such a task. In the 9 main pages of the paper, it is mostly described what is done and what has succeeded and what the agents achieve. However, everyone who has recently been using coding agents for development will not be surprised, that it can help to improve a software ecosystem, including validation and identifying research capabilities. From this point of view, the results are not too surprising, We don't see failure cases or deep insights about better and worse set ups to achieve such a feature. Much of the details live in the appendix, to which the main text often refers. In total, the paper is 39 pages long and the appendix amounts to 23 pages. There are similar problems with the bibliography. There is a huge number of related papers cited, but it remains unclear how the work builds upon these already existing work.

While the report is interesting and may inspire the community, we think the paper has not sufficient methodological content to be of great interest to the ICLR community and therefore recommend not to accept the paper.

Questions for authors
  • How critical is the exact setup of the agents? How much manual labor is still in the whole system, e.g., are evaluation, research targets, development requests curated, e.g., by human-written prompts? Have different configurations of agents with different prompts be tried?
  • How critical is the selection of applications that have been chosen? Is the heterogeneity of the tasks important or could similar results be achieved using task from a much narrower domain? What would be the downside on running the system for each of the 20 packages individually compared to the current shared ecosystem setup?
1 comment
AuthorsOpenReview ↗

Response to Review: Methodology, Failure Boundaries, and Ecosystem Organization

Thank you for recognizing the loop connecting AD development and research use. Your points on methodology, failures and readability motivated a reorganized Section 2.2 on stage handoffs and a new Section 6 with Table 2 on failure modes and routing decisions.

Methodology for reliable agentic scientific AD. Section 6 identifies verification and routing requirements exposed across our builds and research studies:

  • Internal AD consistency needs external native references. In StochKit2, JVP/VJP duality passed while both modes used adaptive rather than requested histogram bins; separately, BioDynaMo's initial sidecar failed native-mechanics parity on 11 cases before repair. We therefore pair clean-checkout design review with evaluation checks reconstructed directly from native trajectories or solvers.
  • Diagnostic routing across kernels, estimators and objectives (Table 2). Exercising package rules in full research workflows exposed cross-API gaps (Kwant gate-to-transmission), multi-query bottlenecks (48 to 6 factorizations) and objective misspecification under exact gradients. Table 2 maps six diagnostic signatures to the component needing change—kernel repair, Monte Carlo support checks, task/grid revision (QuSpin, FiPy) or solver amortization—and the evidence carried forward.

Failure cases and explicit stopping boundaries. The 20-package summaries retain failed, skipped, forward-only and non-differentiable outcomes alongside passes (e.g., PhysiCell 43/80 FAIL, Phonopy 37/47 FAIL; full records in the submitted Supplementary Material, benchmarks/portfolio/). Section 6 and Appendices A.1/C highlight three failure levels:

  1. Construction and domain boundaries: QuSpin's implementation left 2/130 targets BLOCKED on reproducible upstream primal failures rather than fabricating rules. Discrete branches—OpenPNM's 14 invasion cases, BioDynaMo's 10 epidemic cases and FreeSASA's 27 visibility switches—remain explicit boundaries.
  2. Semantic and statistical failures: Beyond StochKit2's bin-mismatch bug and BioDynaMo's 11 pre-repair failures, one repaired StochKit2 512-trajectory ensemble hit an empty bin giving zero empirical gradient and standard error despite a nonzero analytic derivative.
  3. Downstream physical failures: FiPy's revised cloak still yields 2.78 times the bare-core disturbance under an unseen quartic load and fails grid stability (Section 5.2).

Agent configuration, prompts and human involvement. Development agents used Codex (GPT-5.6 Sol) across specification, independent checkout review, revision and implementation (Appendix A.1; runner, prompts and deduplicated target ledgers are in the Supplementary Material). Prompts were refined iteratively without controlled ablations; retained stage records show how review constrains coding: in QuSpin, review separated initial-state from Hamiltonian derivatives; in LALSuite's retained scope-delta subset (137 complete paired records), review modified at least one field in 123/137 records and readiness in 95/137 (marking 77 paths unsuitable; full breakdown in Appendix A.1). Humans selected packages, maintained the generic pipeline, launched jobs and supplied compute (human hours were not logged); agents produced all package targets, designs, code, tests, evaluations and revision requests.

Application selection and heterogeneity. Packages were selected purposefully across domains and detailed cases retrospectively (without a narrow-domain control). Spanning distinct numerical regimes—implicit PDEs, scattering solves, stochastic trajectories and discrete cutoffs—exercises one stage harness and rule contract across solver-, estimator- and objective-level failure modes.

Shared ecosystem versus separate per-package runs. Each package retains its native simulator and runtime binding (ChainRules, Autograd or ChainRulesCore), built modularly per package (Section 2). Across packages, the shared elements are the specification-review-handoff procedure and the engine-decoupled value + JVP/VJP contract. Within packages and across rounds, retaining shared package rules and research outputs avoided duplicated per-script derivatives—consolidating eight QuSpin workflows into hamiltonian.evolve—and turned Kwant's saved filter design into a regression gate for the later shared-linearization update. Independently organized projects could retain the same resources; these cases establish how the shared contract and retained artifacts operate in our ecosystem.

Readability and bibliography. Moving stage roles (Section 2.2) and decision synthesis (Section 6, Table 2) into the main text reduces appendix jumps. Roughly one-third of the references cite the 20 upstream simulators and models; Section 7 details how we build on ChainRules, coding agents and evaluator-driven search, and how native Kwant/QuSpin rules complement AD-NEGF and GRAPE.jl/Krotov.jl.

Reviewer_q724OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper uses coding agents to add differentiation capabilities to selected computations in 20 scientific software packages. These extensions let research programs calculate how simulation outputs change with input parameters and use those derivatives for parameter estimation, control, and design. Development agents implement the extensions, reviewer agents examine the proposals, and research agents use the resulting capabilities in scientific tasks.

The central idea is to feed problems discovered during research back into the shared software. In Kwant, a device-design task exposes a missing derivative path from gate parameters to electron transmission. After that path is added, further use identifies repeated matrix work, leading to a faster implementation. In StochKit2, a research task reveals that the derivative code uses different histogram bins from the requested observable; the repair makes the calculation follow the specified bins.

The paper validates these changes through comparisons with original software outputs, independent derivative checks, and retests of revised implementations. Complete inverse problems, quantum-control studies, and thermal-design applications demonstrate how the shared derivatives support subsequent research. The authors describe this cycle of research use, software revision, and reuse as recursive improvement.

Critical strengths
  1. The StochKit2 case identifies and repairs a scientifically meaningful error. The old derivative rule changed the histogram bins, so it differentiated a different observable from the one requested. A fixed-bin counterexample and reconstruction from native simulation trajectories verify the repair. The case shows why checking the meaning of a derivative matters alongside checking its numerical consistency.

  2. The Kwant case traces two useful software changes back to research needs. A device-design task first motivates a missing derivative path from gate parameters to transmission. Further use then exposes repeated matrix work. The revised implementation reuses that computation while preserving the tested values and gradients, providing a concrete example of research-guided improvement.

Critical weaknesses
  1. The strongest evidence concerns individual software additions and repairs. The cases show that research use can improve software; they offer limited new guidance about how to organize agents to achieve that improvement. The title and opening therefore suggest a broader contribution than the demonstrated cases establish.

  2. As a resource contribution, the collection needs a clearer comparison with existing differentiation tools and solver integrations. The Kwant and QuSpin additions have useful applications, but their distinctive value relative to those alternatives remains unclear. Speedups over finite differences show computational utility without establishing the size of the new capability gap being closed.

Questions for authors
  1. Which of the three stated contributions is the main reason to accept the paper? If it is the research-driven improvement process, what do the documented sequences teach beyond showing that research use can uncover missing capabilities, bugs, and inefficiencies?

  2. For the gate-to-transmission derivatives in Kwant and the shared propagation derivatives in QuSpin, what are the closest existing alternatives? Please explain the practical limitation that your extensions overcome relative to those alternatives, using the capabilities and downstream tasks already documented in the paper.

1 comment
AuthorsOpenReview ↗

Response to Review: Contributions, Methodological Lessons, and Closest Alternatives

Thank you for the careful review and for highlighting the StochKit2 semantic repair and Kwant's two-stage evolution.

Main contribution and what the sequences teach about organizing agents. Our primary contribution is the differentiable scientific software ecosystem across 20 packages together with the empirical study of how connecting package development with research evaluation surfaces and resolves scientific failures. The revised Introduction and Section 2.2 clarify stage roles and handoffs, while the new Section 6 and Table 2 distill three transferable lessons for scientific AD:

  • Internal AD consistency checks miss observable-semantics drift. JVP/VJP duality verifies consistency between derivative modes but does not establish that they differentiate the intended physical quantity: in StochKit2, JVP/VJP duality passed while both modes used adaptive rather than requested histogram bins; separately, in BioDynaMo, initial sidecar rules drifted from native sequential mechanics across 11 cases before repair. Our workflow therefore pairs pre-implementation design review in a clean checkout (which narrowed QuSpin's evolve contract to active initial states under fixed Hamiltonians and time grids) with explicit implementation-stage primal blockers (leaving 2/130 broken upstream calls blocked rather than fabricating rules), explicit non-smooth boundaries (OpenPNM invasion thresholds, FreeSASA visibility switches), and evaluation checks reconstructed directly from native solver outputs.
  • Single-API validation misses workflow bottlenecks and objective limits. Exercising package rules in end-to-end research tasks exposed cross-API gaps (Kwant's gate-to-transmission solve), multi-query solver bottlenecks (reducing 48 LU factorizations to 6 across energies and gates), and physical objective misspecification under exact gradients. Table 2 maps six diagnostic signatures to distinct follow-up actions—separating kernel repair from Monte Carlo support checks (StochKit2's empty-bin zero-gradient artifact at 512 trajectories) and from revising task objectives and grids while reusing the validated rule (QuSpin and FiPy).
  • Retained research artifacts serve as regression gates for later solver updates. Saving Kwant's optimized eight-gate device and reference checks allowed a subsequent round to verify exact value and gradient parity before comparing cost on the shared-linearization update.

Closest alternatives and practical limitations overcome. We agree that FD speedups measure computational utility within a package rather than novelty over specialized differentiable solvers. Our extensions address in-place native-interface integration for models already built in established packages:

  • Kwant vs. AD-NEGF. AD-NEGF (Zhouyin et al., 2023) differentiates tight-binding transport and demonstrates transmission inverse design in a standalone PyTorch NEGF solver, for models formulated in that framework. Our extension instead adds implicit scattering JVPs/VJPs (smatrix_solve_result) directly around native kwant.smatrix (with fixed leads, topology and energy, and caller-supplied local Hamiltonian tangents). Existing Kwant device builders, leads and diagnostics retain their native forward code—completing the gate-to-transmission path absent from our initial scattering-matrix wrapper—and reuse the same verified boundary across filter design and later shared-linearization updates.
  • QuSpin vs. semi-AD control. Goerz et al. (2022) decouple propagation sensitivities from objective differentiation via semi-AD in Julia's GRAPE.jl and Krotov.jl. For studies written in Python/QuSpin, registering shared Hamiltonian and initial-state pullbacks directly at hamiltonian.evolve (for static finite Hamiltonians and fixed times) keeps spin models and symmetry bases in native QuSpin while replacing per-script caller derivatives: eight existing QuSpin workflows migrated to this shared package rule alongside two newly passing derivative checks, and Section 5.1 reuses the same pullback across nominal and coupling-aware control.

Section 7 now presents both comparisons directly, without claiming algorithmic or runtime superiority over AD-NEGF or semi-AD.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of Manuscript Revisions

Thank you for the reviews. Our primary contribution is the construction and empirical study of a differentiable scientific software ecosystem across 20 packages, connecting reusable package-level derivative rules, research programs, numerical checks and saved outputs.

The revised PDF makes five targeted improvements:

  • Introduction, Section 2 and Appendix A.1: clarify the primary contribution, modular per-package rule bindings versus shared cross-task resources, human versus agent responsibilities, and archived target-ledger and design-review records across the submitted supplement.
  • Section 4.2 and Appendix C: document failure cases, historical workflow transitions and subsequent reuse across packages.
  • New Section 6 and Table 2: synthesize verification requirements and development decisions from the recorded failures, mapping six diagnostic signatures (from discrete non-smooth branches and observable-semantics drift to objective misspecification and multi-query solver bottlenecks) to concrete routing actions and stage handoffs.
  • Section 7: compares our in-place Kwant and QuSpin integrations with standalone differentiable solvers (AD-NEGF and semi-AD quantum control) and clarifies how the work builds on prior AD protocols and agent systems.
  • Clarity edits (Section 5.1): streamline task descriptions to reduce cross-references to the appendices.

All numerical results and comparison conditions are unchanged. The submitted Supplementary Material provides source snapshots, stage runner and prompts, research programs and saved-result verification scripts.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.