Migrating a Legacy Scientific Application with an AI Coding Agent: NICAM from Fortran to Kokkos

Abstract: Migrating from Fortran to C++/Kokkos broadens access to hardware accelerators through backends such as CUDA and HIP while offering greater flexibility in software design. However, legacy Fortran applications often have large codebases, making manual porting time-consuming and costly. Recent advances in LLMs and AI coding agents have made large-scale code migration increasingly feasible. In this study, we ported NICAM (Nonhydrostatic ICosahedral Atmospheric Model), a legacy Fortran climate model accelerated with OpenACC, to C++/Kokkos with the assistance of Claude Code. The agent translated the code directly from Fortran to C++/Kokkos under human review. Approximately 140,000 lines of Fortran were analyzed and ported into 35,000 lines of C++/Kokkos, covering the dynamical core and seven physics packages. A 100-member ensemble comparison with the original Fortran model showed that the port is statistically consistent with the original. Performance was evaluated on Miyabi-G, an NVIDIA GH200 cluster, and Sirius, an AMD MI300A cluster. Compared with the Fortran/OpenACC baseline on GH200, the port achieved application speedups of $1.71\times$ on GH200 and $1.54\times$ on MI300A. The CUDA build achieved a GPU kernel-time speedup of $1.38\times$ on GH200. After normalization by peak memory bandwidth, the HIP build on MI300A achieved $0.96\times$ the kernel performance of the Fortran/OpenACC baseline.

• The paper demonstrates the feasibility of migrating a complex scientific application, NICAM, from Fortran/OpenACC to C++/Kokkos using an AI coding agent, resulting in a 1.71× application speedup on GH200.
• The migration process involved iterative testing and human oversight, with a robust verification protocol ensuring numerical consistency and performance improvements, achieving 140,000 lines of code converted.
• This study highlights the role of human supervision and architecture-aware performance tuning, as well as the need for further optimization and comprehensive testing for broader applications.

The paper examines whether an AI coding agent can support the application-scale migration of a mature scientific code from Fortran/OpenACC to C++/Kokkos without sacrificing numerical behavior or accelerator performance. The case study is NICAM, the Nonhydrostatic Icosahedral Atmospheric Model, whose development spans more than two decades and combines a nonhydrostatic atmospheric dynamical core with coupled physical parameterizations. The authors use Claude Code, primarily with the Fable 5 model, as a code-generation and software-engineering agent under continuous human direction and review (2610.41313).

The central claim is deliberately narrower than autonomous software development: a coding agent can perform a substantial direct Fortran-to-Kokkos migration, but only within a workflow that constrains scope, exposes numerical references, enforces iterative compilation and testing, and retains human responsibility for architectural and scientific validation. The resulting port covers approximately 140,000 analyzed lines of Fortran and produces approximately 35,000 lines of C++/Kokkos model source. It includes the dynamical core and seven physics packages: NSW6 cloud microphysics, MSTRNX radiation, Louis surface fluxes, MYNN2 turbulence, McFarlane orographic gravity-wave drag, MATSIRO land-surface processes, and a mixed-layer ocean with sea ice.

Application and migration objectives

NICAM is an appropriate stress test for agent-assisted migration because its computational structure is heterogeneous. The code contains numerical operators, nonhydrostatic dynamics, communication routines, state management, initialization and restart infrastructure, and physical parameterizations with distinct data dependencies. Its original accelerator implementation uses OpenACC, while the target implementation uses Kokkos execution policies, Kokkos::View data structures, and CUDA and HIP backends.

The migration pursued three objectives. First, it sought to obtain a standalone C++/Kokkos implementation rather than a transitional mixed-language executable. Second, it aimed to retain enough of the original organization that corresponding Fortran and C++ components remained identifiable during verification and maintenance. Third, it evaluated whether the common Kokkos implementation could execute effectively on NVIDIA GH200 and AMD MI300A systems.

The target application replaces Fortran namelists with YAML configuration parsed through the header-only fkYAML library. It retains the selected physics-package identifiers and rejects unported configuration branches explicitly. This is an important engineering choice: the port is not presented as a complete translation of every NICAM capability, but as a production configuration with a clearly delimited supported feature set.

Human-directed agentic workflow

The workflow is organized as an iterative milestone process. The human first defines the objective, environmental constraints, file-access rules, build requirements, and numerical assumptions. Claude Code then inspects the Fortran source in planning mode, proposes a dependency-aware migration plan, and records the plan in a progress document. Development proceeds module by module only after the human approves the plan.

The agent translates Fortran modules into C++ classes within the nicam namespace. Model state is represented by Kokkos Views owned by class instances, making data lifetime explicit. Before device execution, shallow local View handles are captured by value in KOKKOS_LAMBDA bodies rather than capturing host-side objects or pointers. This design corresponds well to Kokkos’s host/device execution model and also enables isolated unit tests in which only the objects required by a routine are instantiated.

The translation maps Fortran modules and implicit use-based dependencies to explicit C++ interfaces. OpenACC compute regions become Kokkos::parallel_for calls, Fortran arrays become Views, and nested loops are expressed through multidimensional execution policies. Kokkos::LayoutLeft preserves the original Fortran-oriented memory ordering, with the horizontal index contiguous in memory. The implementation also uses C++ templates to reduce duplication between single- and double-precision variants, although the reported experiments use double precision.

The agent used existing OpenACC annotations as evidence about parallel regions and data movement, but the authors did not treat source directives as authoritative optimization specifications. In one example, the agent attempted to carry Fujitsu-specific prefetching directives into the new implementation. Those changes were removed because they were not justified by the intended initial port. This episode demonstrates that source annotations can guide translation while still requiring semantic interpretation and architectural review.

The workflow’s strongest feature is its separation of translation from acceptance. Each milestone requires component-level tests, regression testing against previously translated components, short integrated runs, and human review of source organization and call order. The agent generated code and tests, but the human reviewed structural decisions and numerical results. The paper reports that code generation generally proceeded faster than human inspection, making review capacity rather than translation capacity the practical bottleneck.

Layered numerical verification

The validation protocol contains three tiers designed to address different failure modes.

The first tier uses reference dumps generated by the original Fortran implementation. Before translating a routine, the authors save its inputs and outputs from a reference execution. The corresponding C++/Kokkos test supplies the same inputs and compares the translated outputs against the saved results. The default criterion is a relative error no larger than $10^{-13}$ or an absolute error no larger than $10^{-12}$; many quantities agree at approximately $10^{-15}$. Exceptions are permitted for ill-conditioned intermediate quantities, but their downstream effects must still satisfy strict checks.

This procedure provides rapid feedback for local translation errors, but it cannot validate the production dataflow by itself. The paper gives a concrete failure case: all unit tests for the physics packages passed, yet an integrated run showed a systematic discrepancy in surface downward longwave radiation. The unit test supplied surface temperature directly from a reference dump, whereas the coupled model had to reconstruct that temperature during initialization. The translated code omitted this reconstruction. Thus, routine-level testing had bypassed an error in the producer of a routine’s inputs. The integrated test exposed and enabled correction of the defect.

The second tier therefore compares 30- or 60-step coupled model runs with the Fortran reference. It examines model fields together with energy and mass budgets, initialization, coupling, and repeated execution. This tier is particularly important for a legacy climate model because correctness depends not only on the local algebra of a routine but also on the ordering and coupling of state transformations.

The third tier addresses the fact that chaotic atmospheric simulations should not be expected to remain trajectory-identical after small floating-point perturbations. The authors generated two 100-member ensembles by applying independent uniform temperature perturbations in the interval $[-10^{-10},10^{-10}]$ K to identical initial states. Each implementation used the same perturbed initial states and ran for 10 model days. Diagnostics were summarized over model days 5–10 and compared through $z$-scores computed relative to the Fortran ensemble.

Across 59 quantities, including energy and mass budgets, surface fluxes, and global means and standard deviations of atmospheric fields, the two implementations showed strong distributional agreement. Of the 5,900 member–quantity scores in each ensemble, 95.3% fell within $|z| \leq 2$ for both implementations. The median number of quantities outside this interval was two per member in each ensemble. These results support statistical consistency for the tested configuration and time horizon, rather than bitwise identity or universal physical equivalence.

The qualification is important. The ensemble procedure is inspired by CESM ensemble-consistency testing but does not implement the full principal-component-based acceptance procedure. The simulations cover only 10 days, the diagnostics are restricted to 59 quantities, and the unit-test inputs are not claimed to cover boundary cases systematically. The results therefore establish evidence of consistency, not an exhaustive correctness proof.

Performance portability and measured speedups

Performance evaluation used Miyabi-G, equipped with an NVIDIA GH200, and Sirius, equipped with AMD MI300A accelerators. The Kokkos implementation was compiled with CUDA on GH200 and HIP on MI300A. The Fortran/OpenACC baseline was evaluated on GH200 using NVIDIA’s Fortran compiler and OpenACC support.

For a 120-step run of the gl07rl00Az78 configuration, the Fortran/OpenACC baseline required 81.0 seconds. The CUDA Kokkos build required 47.3 seconds on GH200, while the HIP build required 52.6 seconds on MI300A.

Implementation	Platform	Application time	Speedup relative to Fortran/GH200
Fortran/OpenACC	GH200	81.0 s	1.00×
Kokkos/CUDA	GH200	47.3 s	1.71×
Kokkos/HIP	MI300A	52.6 s	1.54×

The 1.71× application speedup on GH200 and 1.54× speedup on MI300A are stronger than the kernel-only improvements because the Kokkos implementation reduces staging and synchronization overhead. The original Fortran implementation repeatedly gathers state from global arrays into per-region work arrays and uses explicit OpenACC waits at those boundaries. The port instead retains prognostic state in device-resident full-domain arrays and performs more operations in place.

Kernel-level measurements provide a more controlled comparison. Accumulated GPU kernel execution time per model step was 441.6 ms for Fortran/OpenACC, 320.6 ms for Kokkos/CUDA on GH200, and 349.1 ms for Kokkos/HIP on MI300A. These correspond to kernel-time speedups of 1.38× and 1.27×, respectively.

The largest GH200 reductions occur in the dynamical core, where the kernel-time contribution decreases from 243.3 to 178.9 ms per step. The port also reduces “get/set variables” time from 15.3 to 4.3 ms and surface-flux/turbulence time from 58.8 to 28.5 ms. The latter improvement follows fusion of adjacent computations, which reduces launch and intermediate-memory overhead but produces larger kernels that may be more difficult to inspect and maintain. Performance is not uniformly improved: the amortized MSTRNX radiation cost increases from 41.9 to 46.3 ms on GH200.

The results also expose the distinction between portability and portability without tuning. The MI300A has higher nominal peak memory bandwidth and FP64 throughput than the GH200, yet its unnormalized application and kernel times are slower. The HIP build reuses CUDA-oriented MDRange tile sizes, which the authors identify as a likely source of inefficiency. After normalizing by peak memory bandwidth, the MI300A HIP kernel performance is approximately 96% of the Fortran/OpenACC baseline on GH200. The paper also reports that the HIP build achieves approximately 70% of the CUDA Kokkos kernel performance after bandwidth normalization. These comparisons suggest that the shared implementation is viable across architectures, but not yet equivalently tuned for each backend.

Strong-scaling experiments on GH200 show that the Kokkos implementation remains faster over the tested ranges. For the 40-region, approximately 56-km configuration, increasing from one to ten nodes reduces Fortran execution time from 0.623 to 0.087 seconds per step and Kokkos execution time from 0.348 to 0.060 seconds per step. For the 640-region, approximately 14-km configuration, increasing from 16 to 40 GPUs reduces the corresponding times from 0.706 to 0.353 seconds and from 0.381 to 0.182 seconds. Both implementations depart from ideal scaling as local workload decreases, with a larger relative departure for Kokkos in the 40-region case. The port therefore preserves a performance advantage while exposing communication and launch overheads at smaller per-device workloads.

Agent consumption and human effort

The recorded agent usage totals 4.0248 billion tokens, with an estimated API list-price equivalent of approximately USD 5,589. Cache reads account for 96.5% of tokens and approximately 55.4% of the estimated cost; cache writes account for 3.2% of tokens and 33.8% of cost. The workflow generated 12.13 million output tokens over 23 active days.

The authors recorded 797 human instructions and 6,007 assistant messages, or an average of 7.5 assistant messages per instruction. These measurements include porting, code review, verification, test-kit generation, plotting, and data analysis. They do not represent total human labor: time spent exclusively on code review or cluster operations was not recorded. Consequently, the cost estimate is an accounting of agent consumption rather than a complete cost-benefit analysis of migration.

The paper also reports practical interruptions caused by subscription usage limits. The agent could generate implementation changes faster than the human could review them, and pauses sometimes raised concerns about whether sufficient context would be available when work resumed. The authors explicitly caution that the instruction counts reflect a conservative first application-scale workflow, including repeated requests for confirmation that might be reduced in a more mature process.

Limitations and open questions

The port does not cover all NICAM components or configuration branches. It targets one selected production configuration, and the unsupported branches are rejected rather than translated. The correctness evidence is correspondingly configuration-specific. The ensemble test covers 100 members per implementation and 10 model days, with diagnostics evaluated over days 5–10. It does not establish consistency for longer climate integrations, alternative resolutions, different physics selections, or data-assimilation workflows.

The component tests also rely on a limited collection of dumped reference inputs. As the initialization error demonstrates, direct routine comparison can miss defects in upstream data production and coupled execution. More systematic boundary-condition coverage is required before the testing strategy can support stronger claims about the complete application.

Performance portability remains incomplete. The HIP build inherits CUDA tile sizes, and the authors have not yet determined whether the remaining MI300A gap arises primarily from execution-policy choices, multidimensional index calculations, conditional branches, or other implementation details. Kernel fusion improves performance in some subsystems but can reduce readability and complicate maintenance. The paper therefore leaves open how to balance backend-specific optimization against preservation of a comprehensible common source.

Finally, the reported agent cost excludes human review time, which the authors identify as substantial. The study establishes that an agent can produce the translated implementation, but it does not quantify the total labor required to establish scientific trust in that implementation or compare it against a carefully designed manual migration. It also does not isolate the contributions of the underlying LLM, the Claude Code tool environment, Kokkos abstractions, source-code quality, or the extensive human-directed verification process.

Conclusion

The paper demonstrates a complete, application-scale migration of a selected NICAM production configuration from Fortran/OpenACC to C++/Kokkos using a human-directed coding agent. Approximately 140,000 lines of Fortran were analyzed and reduced to approximately 35,000 lines of C++/Kokkos source covering the dynamical core and seven physics packages. Layered validation found strong statistical agreement between 100-member Fortran and Kokkos ensembles, with 95.3% of 5,900 member–quantity scores within $|z| \leq 2$ in both implementations.

The port also improved measured performance relative to the GH200 Fortran/OpenACC baseline: 1.71× in application time on GH200, 1.54× on MI300A, and 1.38× and 1.27× in kernel time for CUDA and HIP, respectively. These results support the feasibility of agent-assisted modernization, but specifically under human supervision, reference-driven testing, and architecture-aware performance analysis. The unresolved questions concern broader configuration coverage, longer integrations, systematic boundary-case testing, MI300A-specific tuning, and the full human cost of establishing correctness.