Workshop on software strategies for sustainable physical modelling

Breakout discussion topics/questions

These questions are intended to stimulate discussion about sustainable software for reliable weather, climate, and environmental prediction. They explore possible approaches rather than agreed institutional positions or commitments.

The questions are grouped by topic, with some overlap where an issue merits consideration from different perspectives. Participants are encouraged to draw on practical experience, identify evidence and trade-offs, and suggest opportunities for collaboration.

1. Purpose and future role of physical modelling

  • What should be the long-term role of a physics-based global forecast model if machine-learning (ML) forecasting systems continue to improve rapidly?
  • Which parts of ECMWF’s physical-modelling infrastructure and Integrated Forecasting System (IFS) should be maintained, redesigned, or combined with ML approaches? Where should investment increase or decrease?
  • What would success look like for the IFS in ten years: forecast performance, operational reliability, adaptability, portability, openness, support for Member and Co-operating States, or a combination of these?
  • How can the software strategy remain adaptable as the scientific and operational balance between physical and ML-based forecasting changes?
  • How might physical and ML models be combined over the next decade? Should their software ecosystems develop separately or within a common framework, and what can each learn from the other?
  • If data assimilation remains a distinguishing capability of ECMWF, what requirements should it place on future hybrid physical–ML systems?
  • Which assumptions about future modelling and data-assimilation methods are sufficiently well supported to guide infrastructure decisions today?

2. Ownership burden, sustainability, and institutional constraints

  • As code becomes easier to generate, does the capacity to maintain and operate it become the main constraint? If another constraint is more important in your institution, what evidence supports that assessment?
  • What contributes most to the long-term ownership cost of your operational system?
    • Complexity: configurations, options, and exceptional cases that users depend on.
    • Robustness: reliable scheduled execution, recovery from failures, and ease of diagnosis and repair.
    • Integration: coupling, input/output (I/O), workflows, and product generation.
    • Reproducibility and portability across platforms and over time.
    • Institutional knowledge, including the reasons behind design decisions.
    • Operational obligations, including introducing changes while maintaining published schedules and performance targets.
  • Which costs can be reduced, and which are inherent in the system’s responsibilities?
  • Could some maintenance obligations be removed by retiring configurations, use cases, or products? Whose agreement would be needed, and what barriers would have to be addressed?
  • How much essential knowledge remains undocumented? Can AI-assisted code analysis recover the reasons behind an implementation, or only describe its behaviour? How would inferred explanations be checked?
  • Which IFS components offer the greatest benefit from change, and which would be most difficult or costly to change?
  • If designing the IFS today, which existing capabilities or configurations would we choose not to include?

3. Measuring success, adaptability, and value

  • How can a large physical forecasting system remain adaptable, robust, and portable as a greater share of development effort is directed towards ML systems?
  • Could the rate of verified change—validated changes released into operational use per unit of staff effort—provide a useful measure of modernisation?
  • How should this measure be defined and used? Could it reward easily counted changes, discourage necessary but risky work, or overlook scientific value?
  • Does your institution already measure development and validation throughput? Could a shared approach support meaningful comparisons between modernisation strategies?
  • Which foundations deliver the greatest improvement in adaptability per person-year: modularisation, testing, simplification, or governance? In what order should they be addressed?
  • What evidence should lead an organisation to stop or redirect a modernisation activity? What stopping criteria should be agreed in advance?
  • Which milestones and review dates would show whether a strategy is delivering the intended scientific, operational, and service benefits?
  • What staff effort, measured in person-months, and elapsed time would the proposed changes require?
  • Can a minimum viable product be defined, with clear criteria for judging its success?

4. Modernisation strategy: incremental change, replacement, and experimentation

  • Do large language models (LLMs) change the feasibility or economics of large-scale rewrites? Do they make replacement more attractive, or make incremental improvement sufficient?
  • Where could more substantial change deliver greater value than an incremental approach? Which components would be suitable starting points?
  • What evidence would lead you to reconsider your preferred approach?
  • What examples exist of operational-scale systems being replaced from scratch, fully validated, and transferred into sustainable operation on time and within budget, while meeting their intended scope and quality? What enabled success?
  • Could we design a shared experiment comparing replacement and incremental modernisation?
    • Would ecRad, CLOUDSC, or another component be a suitable subject?
    • Which acceptance criteria should be agreed in advance to represent operational requirements, rather than performance in idealised tests alone?
    • Which activities should count towards the total staff effort required to reach acceptance, rather than merely produce a first plausible result?
    • Who should independently assess the results, and which institutions would contribute teams?
  • Where does technical debt accumulate during a rewrite? How can it be addressed throughout development rather than deferred until operational transition?
  • How can comparisons between new and established code account for differences in validation, supported configurations, and operational obligations?
  • When component boundaries are clear, is component-by-component replacement fundamentally different from incremental modernisation? Is the important distinction the method or the scale of change?
  • What would constitute a useful minimum viable product, and how would its evaluation inform the next stage?

5. Programming models, languages, and abstraction boundaries

  • Which programming models are likely to serve weather and climate modelling over the next decade? What balance between high-level abstractions and low-level control will be needed?
  • Is the IFS best served by continued development in Fortran, gradual adoption of Python-based high-level approaches, or a mixed-language architecture?
  • How much should the programming model be shaped by the need to combine physical and ML-based modelling?
  • How can high-level abstractions be introduced without compromising performance, reproducibility, or operational robustness?
  • What dependence on external libraries, compiler infrastructure, and domain-specific languages (DSLs)—such as GT4Py, Numba, and LLVM/MLIR—is acceptable?
  • In a mixed-language system, which layer should control execution? Which programming models work well together, and what data or execution resources must be shared across language boundaries to maintain performance?
  • What should Markdown instruction files for AI coding agents contain to communicate architectural principles, interface requirements, and separation of concerns?

6. External dependencies, licensing, and technology risk

  • What criteria should govern the adoption of external libraries, DSLs, and frameworks?
  • Which requirements for licensing, long-term support, portability, and maintenance are non-negotiable? How should licences for new code be selected?
  • Who carries the risk when a system depends on a framework whose future is outside the institution’s control?
  • Does shared ownership of a dependency reduce that risk, or introduce additional coordination and maintenance obligations?
  • What evidence shows whether releasing components as open source reduces ownership costs through contributions and wider scrutiny, or increases them through support obligations and a broader user base?

7. Architecture, modularity, and composition of the modelling system

  • Which parts of the code base and infrastructure should be shared, and where should organisation-specific implementations be supported?
  • Which future requirements are essential, and which are desirable? Consider:
    • CPU/GPU portability and automatic differentiation, including memory-storage versus recomputation trade-offs.
    • Interoperability across programming languages and the role of shared infrastructure such as Atlas.
    • Global, regional, single-column, seasonal, and climate configurations, including sub-kilometre and decametre-scale applications.
    • Research and academic use alongside operational requirements.
    • Support for multiple services and use cases.
  • Which components would benefit most from architectural change?
  • How should common computational kernels, automatically generated workflows, and explicitly coded control flows be combined?
  • What principles should govern the division of responsibilities between components and higher-level drivers?
    • Should ocean and wave models remain separate components?
    • Should coupling and I/O be managed within a model or by a higher-level driver?
    • How should models be integrated into frameworks such as OOPS?
    • How should different components execute concurrently using different numbers of compute nodes?
  • Which control structures, modules, interfaces, and AI development harnesses should partners share or co-develop?
  • What evidence is available on the effects of unified versus component-specific physics interfaces on forecast quality, particularly at long time steps?
  • Do hybrid physical–ML systems require tighter integration between forecasting and data assimilation, or can they remain loosely coupled through well-defined interfaces?

8. HPC uncertainty, performance portability, and deployment

  • What developments in high-performance computing (HPC) should guide software decisions over the next decade?
  • How should software balance CPU and GPU execution, memory constraints, and adaptation costs while remaining resilient to short-term changes in the hardware market?
  • What requirements for portability and automatic differentiation should be built into the architecture?
  • How can deployment of physical and ML models across different HPC systems, including EuroHPC systems, be made faster and more reliable?
  • What role should external libraries, DSLs, and compiler frameworks play in achieving portability? How should their benefits be weighed against dependency risks?

9. Verification, testing, CI/CD, and operational transition

  • Which practices and tools best support shared planning, repositories, continuous integration (CI), testing, code review, documentation, and coordinated development cycles?
  • How should the costs and benefits of continuous integration and delivery (CI/CD) be assessed?
  • How should responsibilities be divided between research and development teams and operational teams? What degree of shared development and operational responsibility is appropriate, and how should this influence software design?
  • Which acceptance criteria should be agreed before development begins?
  • Which development, review, validation, integration, and operational-transition activities should count towards the effort required to reach acceptance?
  • What level of verification is needed before particular tasks can safely be delegated to AI coding agents? How should permitted autonomy increase as the test framework improves?
  • How should review, accountability, and provenance be maintained when a jointly developed operational code base accepts AI-assisted contributions at scale?

10. Agentic coding and AI-assisted software engineering

  • How might AI-assisted software engineering change over the next decade? Which tasks can LLM-based tools realistically take on?
  • What have coding agents achieved in practice: understanding and documenting legacy code, generating tests, refactoring without changing behaviour, translating individual modules, removing unused code, or optimising performance?
  • What has failed, and what can be learned from those failures?
  • Which characteristics most influence success: test coverage, modularity, documentation, coding style, or other factors? What does this imply for modernisation priorities, including those of FORGE?
  • How should sustainable software design and interfaces support reliable use of coding agents?
  • What should instructions for agents specify about architecture, permitted changes, validation, and acceptance criteria?
  • How can AI-assisted tools simplify deployment across HPC systems or identify code that can safely be excluded from a particular build?
  • How should the scope of delegated work depend on the quality of the test framework?
  • What shared rules do co-development partners need for reviewing AI-assisted contributions and recording their provenance?
  • Should machine readability become an explicit criterion in coding standards, interfaces, and documentation? Where might it conflict with human readability, and how should those trade-offs be resolved?

11. Skills, staffing, and organisational capability

  • What balance of scientific, software-engineering, verification, and operational skills will institutions need over the next decade?
  • If generating code becomes less costly, how should recruitment and professional development adapt?
  • How can institutions sustain physical-model development as more effort is directed towards ML systems?
  • How can code review, validation, and long-term maintenance be made as attractive and professionally rewarding as developing new code?

12. Co-ownership, governance, and the shared component ecosystem

  • What are the development priorities of ECMWF, Météo-France, ACCORD partners, and Member States? How could a shared software framework accommodate them?
  • Which parts of the IFS/Arpège code base and supporting infrastructure should remain jointly owned, and where might separate implementations better serve distinct requirements?
  • What component boundaries and interfaces enable effective shared ownership while keeping coordination and maintenance costs manageable?
  • What successful examples exist of jointly maintained, performance-critical software? What arrangements for review, releases, decision-making, and partners’ rights to withhold approval made them work?
  • Which mechanisms best support shared planning, repositories, testing, documentation, and development cycles?
  • How should common I/O standards and infrastructure accommodate different scientific and operational needs?
  • If language choice is made component by component, how can partners with different language strategies maintain a coherent ecosystem? When does this flexibility strengthen collaboration, and when does it fragment it?
  • How should responsibility for external dependencies and technology risk be shared?
  • What roles should open-source contributors, academic partners, and institutions outside European consortia play in co-development and knowledge exchange?

13. Open source, community participation, and support obligations

  • How can open-source development broaden participation and make better use of expertise across institutions and international partnerships?
  • What evidence is available on the balance between external contributions and the additional maintenance and support obligations that open-source releases create?
  • What licensing, contribution, governance, and support arrangements are needed for sustainable participation?
  • Could a jointly authored community position paper on high-level programming abstractions be a useful workshop output? How should its scope, authorship, and governance be agreed?

The position-paper question builds on a suggestion by Chris Maynard (Met Office) during discussions at PASC26 in Bern in June 2026.

14. Hybrid physical–ML modelling

  • How might physical and ML models be combined over the next decade?
  • Should their software ecosystems develop separately or within a common framework? Which practices and technologies can usefully transfer between them?
  • What long-term role should physics-based global models play as ML forecasting systems improve?
  • How strongly should hybrid modelling requirements influence programming models and infrastructure?
  • Which assumptions about future hybrid methods are sufficiently well supported to guide software design today?
  • What requirements does data assimilation place on hybrid systems?
  • Should forecasting and data assimilation be more tightly integrated, or connected through clearly defined interfaces?

15. Data assimilation in future physical–ML systems

  • If data assimilation remains a distinguishing capability of ECMWF, how should it shape the design of future hybrid systems?
  • Which methodological assumptions are sufficiently well supported to guide infrastructure decisions now, and where should the design preserve flexibility?
  • Should data-assimilation software remain separate from the forecast model, or should their development be more closely integrated? What role should OOPS play?
  • How should portability and differentiation requirements influence the interface between assimilation and forecasting?
  • What can be learned from incorporating Copernicus Atmosphere Monitoring Service (CAMS) requirements, including aerosol modelling, into both assimilation and forecasting?
  • What architectural lessons arise when coupling physical processes represented at different resolutions?

16. Workflow orchestration, I/O, and service integration

  • Which workflow, testing, documentation, and development practices can usefully be shared across institutions?
  • How should I/O responsibilities be divided between models, coupling infrastructure, and higher-level drivers?
  • Which common standards can accommodate different scientific and operational requirements?
  • How should the placement of ocean, wave, coupling, and I/O components support flexible orchestration and reuse?
  • How should responsibilities at the research-to-operations interface influence workflow and software design?
  • How can deployment across HPC systems be automated while preserving reproducibility and operational reliability?
  • How should the architecture support multiple services and use cases, including the distinct requirements of Copernicus services and Destination Earth?