LARA: Validation-Driven Agentic Supercomputer Workflows for Atomistic Modeling

LARA-HPC is a validation-driven agentic framework designed to automate reliable atomistic modeling workflows on high-performance computing systems by prioritizing simulation-native verification and iterative refinement over simple code generation.

The Gist

Imagine you are trying to build a complex, high-tech LEGO castle, but instead of using your hands, you are giving instructions to a very smart, very fast, but occasionally "clumsy" robot assistant.

This paper introduces LARA-HPC, a new way to manage these robot assistants so they can perform incredibly difficult scientific experiments on the world’s most powerful supercomputers without making expensive mistakes.

Here is the breakdown of the problem and the solution using everyday analogies.

1. The Problem: The "Brilliant but Clumsy" Assistant

Imagine this robot assistant is a genius at reading instruction manuals (Large Language Models), but it has no "common sense" regarding the physical world.

If you ask it to "make a cup of tea," it might:

• The Syntax Error: Try to pour water from a teapot that doesn't exist.
• The API Error: Try to use a spoon to stir, but use it upside down because it forgot how spoons work.
• The Physical Error: Try to boil water in a paper cup, which will melt instantly.

In the world of supercomputing (HPC), these mistakes are a huge deal. Supercomputers are incredibly expensive to run. If the robot assistant makes a "paper cup" mistake, it doesn't just ruin a cup of tea; it wastes thousands of dollars of electricity and hours of precious time that other scientists were waiting to use.

2. The Solution: The "Look Before You Leap" Framework

Currently, most AI systems follow a "Generation-First" approach: they write the code and immediately hit "Go."

LARA-HPC flips this on its head. It uses a "Validation-First" approach. Think of it like a chef who, before turning on a massive, expensive industrial oven, performs a "Dry Run." They check if they have all the ingredients, make sure the recipe makes sense, and ensure the pan is the right size—all without actually turning on the heat.

LARA-HPC does this through three clever layers:

• The Controlled Gatekeeper (RemoteManager): Instead of letting the robot run wild in the supercomputer's "kitchen," the gatekeeper gives the robot a specific set of tools and a strict set of rules. The robot can’t just wander into the pantry; it can only use the tools the gatekeeper provides.
• The "Dry Run" (The Virtual Rehearsal): This is the secret sauce. Before the real experiment starts, the system runs a "fake" version of the simulation. It’s like a flight simulator for scientists. It checks: "Will this simulation fit in the computer's memory?" or "Does this physics setting actually make sense?" If the "flight simulator" crashes, the robot learns from its mistake and tries again before the real plane ever leaves the ground.
• The Multi-Phase Brain (The Thinking Loop): Instead of one giant brain trying to do everything, LARA-HPC uses a team. One "expert" understands the goal, another "coder" writes the instructions, a "critic" looks for mistakes, and the "dry-run" tool provides the reality check.

3. Why This Matters: From "Trial and Error" to "Precision Science"

In the past, using AI for science was like playing a game of "telephone" where the message got distorted at every step. You’d run a simulation, it would fail, you’d fix it, run it again, and fail again.

With LARA-HPC, the AI becomes a Co-Pilot. It doesn't just guess; it verifies.

The result? Scientists can ask complex questions like, "How does this specific molecule stick to this surface?" and the AI can build, test, and double-check the entire mathematical "recipe" automatically. It ensures that when the supercomputer finally starts humming, it is doing work that is scientifically sound, physically possible, and highly efficient.

In short: LARA-HPC turns a "clumsy genius" into a "reliable expert scientist."

Technical Summary

Technical Summary: LARA-HPC: Validation-Driven Agentic Supercomputer Workflows for Atomistic Modeling

1. Problem Statement

While Large Language Models (LLMs) and agentic systems show promise in automating scientific workflows, their application in High-Performance Computing (HPC) environments is hindered by several critical challenges:

• High Cost of Failure: Unlike local software engineering, erroneous code in HPC leads to wasted computational resources, failed jobs in high-latency scheduling systems, and scientifically invalid results.
• Complexity of Scientific Correctness: A workflow can be syntactically correct (valid Python) but scientifically "wrong" (e.g., inconsistent physical parameters, incorrect exchange-correlation functionals, or impossible spin configurations).
• Rigidity of Current Tools: Existing "tool-calling" frameworks (like MCP) rely on predefined, static functions. This prevents agents from performing the "methodological branching" required in real research, such as performing convergence studies or adapting model systems dynamically.
• Operational Barriers: Direct LLM interaction with HPC login shells or schedulers poses significant security and reproducibility risks.

2. Methodology

The authors propose LARA-HPC, a framework that shifts the paradigm from "generation-first" to "validation-first" (a "Look Before You Leap" approach). The architecture is built on three pillars:

A. Controlled Execution Layer (remotemanager & MCP):

• Instead of giving an agent direct shell access, the framework uses remotemanager, a Python middleware that formalizes HPC workflows (batch scripts, file staging, job submission) into a programmatic interface.
• It utilizes the Model Context Protocol (MCP) to expose these capabilities as structured, auditable tools. This ensures the agent interacts with the supercomputer through a constrained, safe, and reproducible interface.

B. Multi-Phase Agentic Pipeline:
The framework decomposes the task into four distinct cognitive phases to separate reasoning from execution:

1. Understanding: Extracts scientific intent and maps it to domain-specific modules (e.g., BigDFT).
2. Generation: Uses Retrieval-Augmented Generation (RAG) and code templates to construct candidate workflows, allowing for more flexibility than static tools.
3. Validation (The Core Innovation): A multi-level check involving:
   • Syntactic validation (AST parsing).
   • Structural validation (API usage checks).
   • Simulation-native "Dry-Run" validation: Utilizing the simulation code's internal logic to verify input consistency and resource requirements without running a full, expensive calculation.
4. Review: A "Critic Agent" evaluates the workflow for alignment with user intent and scientific best practices.

C. Simulation-Native Dry-Run Primitive:
The framework leverages the dry_run capability of the BigDFT code. This mode performs input parsing, builds internal data structures (grids, basis functions), and—crucially—estimates memory consumption without performing the actual Self-Consistent Field (SCF) iterations.

3. Key Contributions

• Validation-Driven Paradigm: Introduces a framework where code is iteratively refined through structured feedback from the simulation engine itself before being submitted to the HPC queue.
• Hybrid Autonomy: Achieves "minimal sufficient autonomy"—providing enough flexibility for scientific reasoning while maintaining strict operational safety via a mediated execution layer.
• Resource-Aware Orchestration: Demonstrates how an agent can use dry-runs to perform "pre-flight" resource planning (e.g., determining the necessary number of nodes based on predicted memory peaks).

4. Results and Demonstrations

The authors validated LARA-HPC using Density Functional Theory (DFT) simulations via the BigDFT code:

• Error Correction: The system successfully identified and corrected:
  • API Misuse: Correcting misspelled modules or invalid method calls (e.g., changing get_center_of_mass() to the correct centroid attribute).
  • Physical Inconsistencies: Detecting impossible physical setups, such as a single hydrogen atom assigned an impossible spin polarization.
• Complex Workflow Generation: The agent successfully synthesized a workflow for atomization energy, which required coordinating multiple calculations (molecule vs. isolated atoms) with consistent parameters.
• HPC Resource Optimization: In a large-scale surface adsorption task (291 atoms), the agent used dry-runs to predict a peak memory requirement of ~197 GB. It then autonomously calculated that 10 nodes (with 4 MPI ranks per node) were required to provide sufficient memory headroom, preventing a job failure.

5. Significance

LARA-HPC represents a significant step toward a "co-piloted research ecosystem." It moves beyond simple code completion toward a system capable of performing autonomous, high-fidelity scientific discovery. By integrating domain-specific validation (the "physics") with robust orchestration (the "HPC"), the work provides a blueprint for how the computational physics community can build reliable, agentic AI tools that respect the unique constraints of supercomputing environments.