Artificial intelligence is changing how algorithms are conceived, how software is written, and how its outputs are verified. This conversation takes stock of where the field of simulation and modelling stands today and opens a discussion on future directions and best practices — how to safeguard reliability and scientific creativity, how to adapt notions of authorship and ownership for AI-assisted code, and how to preserve and ideally enhance the rich commercial and academic software ecosystem that has driven the growth of computational science in research and development.

The conversation will take place at EPFL, in room BCH 2103 and online.
Zoom link https://epfl.zoom.us/j/68443642155?pwd=ZPjdZw2KmHzeQ9Pu376iLb0OyMXCV8.1

Tentative program

15:00 Welcome and introduction
15:10 Georg Kresse, University of Vienna, Austria
15:30 Miguel Marques, Ruhr University, Bochum, Germany
15:50 Michele Ceriotti, EPFL, Switzerland
16:10 Short break
16:20 Enrico Riccardi, UIS, Norway
16:35 Luigi Genovese, CEA Grenoble, France
16:50 James Kermode, University of Warwick, UK
17:05 Discussion
17:30  Apero for in person participants

The end of human programming? Managing a multi-agent codebase at VASP

Georg Kresse, University of Vienna

At the VASP Software GmbH, about 70% of our team now uses multi-agent LLM pools to develop software. This rapid shift has shattered the traditional coding pipeline, with code generation now happening so quickly that human review is impossible. This forces us to rely on AI itself for validation and regression testing. While the resulting code may not be aesthetically pleasing, it is undeniably efficient. In this talk, I will share the practical realities of transitioning a major scientific codebase to AI. I will discuss the economics of agent workflows, the continuous leakage of open-source and closed-source IP, the limits of LLMs at the frontier of physics and the profound, often challenging, impact that this shift is having on developer morale.

The code writes itself; the physics does not — libxc and waw

Miguel Marques, Ruhr University

libxc is the library of exchange–correlation functionals that most electronic-structure codes call; since May 2026, 129 of its 305 commits were written with a large language model. waw is a Wannier-function engine that did not exist on 1 July 2026 and five weeks later had 69,000 lines of Python, 1,233 tests, and 65 notebooks reproducing the wannier90 tutorials, essentially all of it machine-written under supervision. I will show what this looks like in practice: what the model does better than I do, where it produces plausible and wrong physics, and what validation is now the only thing that separates the two.

The sound of atoms: using AI to accelerate discovery across disciplines

Michele Ceriotti, EPFL

AI is taking over by storm code generation, testing and review. A series of recent high-profile examples from the pure and applied mathematics community has shown that a similar revolution is happening for more formal tasks such as theorem proving and algorithm development. I will present an example of using AI to identify shortcomings of the structural representations that underpin most of classical and recent equivariant machine-learning architectures for atomistic modeling. The counterexamples found by the AI are much stronger than those identified by Sergey Pozdnyakov and Michael Willatt in 2020 [Phys. Rev. Lett. 125, 166001 (2020)], which raises questions about the role of humans in the math-adjacent activities in our community. Besides the result itself, the discovery process reveals one very powerful mode of operation of LLMs: discovering relevant results from different disciplines, translating them to the language of another community and the use case at hand.

Rare events, routine agents: from PyRETIS to Agent-TIS

Enrico Riccardi, UIS

PyRETIS is our open-source library for sampling the paths of rare events with TIS, RETIS and REPPTIS. It drives GROMACS, LAMMPS, CP2K, OpenMM and other molecular dynamics (MD) engines. From its first commit in January 2015 to March 2026 it was written by hand, in 2,381 commits, up to 65,000 lines of Python source and 25,000 lines of tests. Since April 2026, 1,361 of 1,475 further commits have been co-written with a large language model: in six months, more than half the commits of the previous eleven years. The source has grown to 133,000 lines, the tests to 143,000, and the unit tests from 770 to 4,352. Of the 327,000 lines now in the source, tests, examples, documentation and agent skills, 64% were last changed by an agent-assisted commit (52% of the source, 81% of the tests) and 36% remain as written by hand.

In path sampling, a wrong change rarely crashes. It shifts an acceptance rule or the order of the random draws, and the rate constant comes out plausible and wrong. So we built the development around separate agents that write, test, review and verify the code, none of them judging its own work: the tests of new code are written from its specification by an agent that has not seen the implementation, a failing test is judged by an agent with a clean context, and a review finding is kept only when a second agent reproduces it. Every change then climbs a four-level ladder. Unit tests check the algorithms against hand-computed and closed-form results. Complete runs on six engine suites are compared with committed references, byte for byte or within a recorded tolerance, on the reference build of each engine. Every tutorial runs to completion. A validation suite of long runs ends the ladder: the deviations of 19 independent runs from the analytical Kramers-Mel'nikov-Meshkov rate, 2.5 x 10^-7, are distributed as statistical error should be: median 0.8 sigma, one run at 2.0 sigma. Reference outputs move only with a named cause, and a frozen output counts as a regression check, never as evidence that a value is correct.

What we learned became Agent-TIS, which ships with PyRETIS and serves the users as much as the developers. Its user skill teaches a researcher's own AI agent to set up, run and analyse a path-sampling study: it holds a minimal recipe for small, locally hosted models, a guide for diagnosing a run that looks wrong, and checks of a setup against a case with a known analytical rate. Every rate the agent reports carries its statistical error, the crossing probability of each interface, the input, the commands and the software versions, so the result can be audited and repeated. A developer skill, with seven role prompts for sub-agents, brings the same discipline to changing the code. Beyond the code, we support research groups that want to integrate an agent into their own simulation workflow. I will show both skills at work on a live problem. I will also show where the agents produce science that looks plausible but is wrong, and why the order parameter, the stable states and the verdict on convergence remain the scientist's.

From writing code to designing tools: scientific software in the age of assisted developments

Luigi Genovese, CEA, Grenoble

Assisted coding is rapidly changing how scientific software is produced, but faster code generation does not necessarily make scientific software development simpler. Computational science relies on domain knowledge, reproducibility and validation that cannot be inferred reliably from syntactically correct code alone. I argue that this fact shifts - rather than diminishes - the role of the scientific software developer: from controlling every implementation detail, towards designing the interfaces, tools and validation mechanisms through which both humans and automated agents interact with scientific software.

will illustrate this transition through the recent evolution of the BigDFT ecosystem, from numerical kernels and modular libraries to scientific objects, remotely orchestrated HPC workflows and emerging machine-facing interfaces. Rather than replacing this established software hierarchy, domain-specific tools can expose controlled capabilities at several levels of abstraction, providing multiple front-ends to the same underlying scientific software.

I will then discuss LARA-HPC (recently accepted preprint, see link below) as a concrete realization of this approach for agentic atomistic simulations on HPC systems. By combining controlled execution with simulation-native validation and iterative agentic refinement, it illustrates how humans-controlled agents can operate on complex scientific software without lose of scientific control. These developments suggest that the central question may no longer be simply who writes the code, but where scientific expertise and responsibility should reside when code and computational workflows are increasingly mediated by coding assistants.

https://arxiv.org/abs/2604.22571

Effective Agentic Coding for Scientific Computing

James Kermode, University of Warwick

Agentic coding tools now write most of the code in some of our projects: in ace-jax, a JAX implementation of the atomic cluster expansion, almost all code was agent generated. The code was the easy part. The human work was deciding what "correct" means: parity tests against independent codes, benchmarks, and certification. Even then, a bug slipped past automated tests because they asked the wrong questions. A Terminal-Bench-Science task I wrote tells the same story: once a problem is fully specified, the newest models solve it. The skills that make agentic AI safe (knowing when to interrupt, what to validate against, and which question to ask) came from years of struggle. I will argue that research training must deliberately protect them, and describe the HetSys Centre for Doctoral Training AI policy and mini-viva assessment as part of the response.

Previous CECAM and MARVEL lectures can be found at

https://www.materialscloud.org/learn/sections/Btmngu/marvel-events

https://www.cecam.org/lectures