Multi-Agent Collaboration for Automated Design Exploration on High Performance Computing Systems

This paper introduces MADA, a Large Language Model-powered multi-agent framework that automates complex design workflows on High Performance Computing systems to iteratively refine and optimize scientific simulations, specifically demonstrated through the suppression of Richtmyer-Meshkov Instability in Inertial Confinement Fusion.

The Gist

Imagine you are trying to design the perfect recipe for a cake, but instead of baking it in your kitchen, you have to send the ingredients to a massive, super-fast industrial bakery (a High-Performance Computer, or HPC) that can only bake one cake at a time, and it takes hours to get the result back.

In the past, if you wanted to find the perfect cake, a human scientist would have to:

1. Write down the recipe.
2. Send it to the bakery.
3. Wait hours for the cake.
4. Taste it, write notes, and realize, "Hmm, too much sugar, not enough heat."
5. Rewrite the recipe and repeat the whole cycle.

This is slow, boring, and exhausting.

Enter MADA: The "AI Kitchen Manager"

This paper introduces MADA (Multi-Agent Design Assistant). Think of MADA not as a single robot, but as a highly organized team of specialized AI chefs working together to solve complex scientific problems without needing a human to micromanage every step.

Here is how the team works, using our kitchen analogy:

1. The Team Members (The Agents)

Instead of one AI trying to do everything (which often leads to confusion), MADA splits the work among three specialists:

• The Geometry Agent (The "Architect"):
  • Job: Before baking, you need a mold. In science, this is the "mesh" (a digital 3D shape).
  • Analogy: This agent is like an architect who instantly draws the perfect cake mold based on your description. If you say, "Make the edges wavy," the Architect instantly redraws the mold to match, checking to make sure it won't collapse. It speaks the language of the tools (like Cubit) automatically.
• The Job Management Agent (The "Runner"):
  • Job: Sending the recipe to the bakery and waiting for the result.
  • Analogy: This agent is the runner who takes the mold and ingredients to the super-bakery (the HPC). It knows exactly how to book the oven, how long to wait, and how to pick up the finished cake. If the oven breaks or the cake burns, it knows to tell the team immediately.
• The Inverse Design Agent (The "Taste-Tester & Strategist"):
  • Job: Tasting the cake, figuring out what went wrong, and deciding the next recipe.
  • Analogy: This is the smartest chef. It tastes the cake (analyzes the data), says, "The center is too dry," and then thinks: "Okay, let's try lowering the temperature by 5 degrees and adding more butter." It doesn't just guess; it uses logic to propose the next best recipe.

2. How They Talk (The "Model Context Protocol")

You might wonder, how do these agents talk to the bakery and the mold-making tools? They use a universal translator called MCP (Model Context Protocol).

• Analogy: Imagine the bakery and the mold-maker only speak "Machine Code" (a language humans can't read). MCP is like a universal translator that lets the AI team speak "English" to the machines. The AI says, "Make a wavy mold," and MCP translates that into the specific code the mold-maker understands. This means the team can swap out tools (like changing from one bakery to another) without retraining the whole team.

3. The Real-World Test: Stopping "Explosive Jets"

The authors tested this system on a very hard problem: Inertial Confinement Fusion.

• The Problem: Imagine a shockwave hitting a material. Sometimes, it causes tiny, violent "jets" of material to shoot out, ruining the experiment (like a soda can exploding when shaken too hard). Scientists want to design the container so these jets don't happen.
• The Challenge: There are billions of possible shapes for the container. A human couldn't test them all.

What MADA Did:

1. Round 1: The team generated 20 different container shapes, sent them to the super-computer, and waited.
2. Round 2: The "Taste-Tester" (Inverse Design Agent) looked at the results. It realized, "Ah! The shapes with a specific wavy pattern worked best."
3. Refinement: It then generated 20 new shapes, but this time, it focused only on that specific wavy pattern to fine-tune it.
4. Result: In about 40 minutes, MADA found a design that reduced the explosive jets significantly. A human expert would have taken days to do this manually.

4. The "Fast-Forward" Mode (Surrogate Models)

The paper also showed that MADA can use a "crystal ball" (a machine learning model) to skip the baking entirely.

• Analogy: Instead of actually baking 100 cakes, the AI uses a crystal ball that predicts how the cake will taste based on the recipe.
• Result: MADA tested hundreds of designs in seconds using this crystal ball, finding the perfect design almost instantly. It even explained why it chose that design (e.g., "I chose this because the alternating signs created the best balance").

Why This Matters

Before MADA, scientists spent 80% of their time managing the "logistics" (sending jobs, fixing errors, formatting data) and only 20% of their time on the actual science.

MADA flips this. It handles the boring logistics automatically.

• For the Scientist: They just say, "I want to stop the jets," and the AI team does the rest.
• For Discovery: We can now test ideas faster than ever before, exploring millions of possibilities to find solutions for climate change, new materials, and clean energy.

In short: MADA is like hiring a team of expert robots that can build, test, and improve complex scientific designs while you sit back and watch the breakthroughs happen.

Technical Summary

1. Problem Statement

Scientific discovery in fields like Inertial Confinement Fusion (ICF), climate modeling, and material science requires exploring vast, complex design spaces. Traditional workflows are heavily manual and cumbersome, requiring scientists to:

• Manually construct workflow graphs and define execution logic.
• Configure simulations, manage job submissions on High-Performance Computing (HPC) systems, and parse output files.
• Interpret results to manually decide on the next design iteration.

This "orchestration overhead" diverts researcher time from scientific reasoning to administrative tasks. While workflow management systems (e.g., Pegasus, Merlin) automate job execution, they lack the adaptability to dynamically adjust strategies based on intermediate results without explicit human reconfiguration. There is a critical need for closed-loop, automated workflows that integrate simulation, analysis, and design exploration to accelerate discovery.

2. Methodology: The MADA Framework

The authors propose MADA (Multi-Agent Design Assistant), a framework powered by Large Language Models (LLMs) that coordinates specialized agents to automate the scientific design loop.

Core Architecture

MADA decomposes the scientific workflow into three specialized agents orchestrated by a planning component (built on the AutoGen framework). These agents communicate via the Model Context Protocol (MCP), an open standard that allows LLMs to interact with external tools through a client-server architecture.

1. Job Management Agent (JMA):

   • Role: Handles the execution of simulation ensembles on HPC systems.
   • Tools: Interfaces with HPC schedulers (specifically Flux) and simulation codes (specifically Laghos, a high-order Lagrangian hydrodynamics solver).
   • Function: Submits jobs, monitors status, collects results, and manages resource allocation. It abstracts the complexity of scheduler APIs.

2. Geometry Agent (GA):

   • Role: Automates the generation of simulation-ready meshes and geometries.
   • Tools: Interfaces with Cubit (Sandia National Labs) and PMesh (LLNL).
   • Mechanism: Uses Retrieval-Augmented Generation (RAG) to access documentation and example scripts. It constructs geometric graphs to understand topology and spatial relationships, translating natural language requests into executable DSL (Domain Specific Language) or Python code for mesh generation. It includes a verification loop to ensure generated meshes are valid.

3. Inverse Design Agent (IDA):

   • Role: Drives the optimization and design-space exploration.
   • Function: Analyzes simulation outputs to extract Quantities of Interest (QoI), ranks configurations, and proposes new candidate designs.
   • Flexibility: Can operate in two modes:
     • High-Fidelity: Directs the JMA to run full physics simulations.
     • Surrogate-Based: Queries pre-trained Machine Learning (ML) surrogate models for rapid evaluation (milliseconds vs. minutes).

Human-in-the-Loop

The system supports expert interaction via CLI and GUI. Experts can define objectives, constraints, and variable ranges, review intermediate results, and redirect the exploration strategy based on domain knowledge, blending automated efficiency with human intuition.

3. Key Contributions

• MADA Framework: A novel multi-agent system that orchestrates end-to-end scientific design exploration on HPC, replacing manual workflow management with autonomous, adaptive agents.
• Specialized Agent Implementation:
  • A JMA for managing large simulation ensembles via Flux.
  • A GA for automated mesh generation using Cubit/PMesh with RAG-enhanced reasoning.
  • An IDA for inverse design and optimization guided by simulation data.
• MCP Integration: Demonstrates the use of the Model Context Protocol to seamlessly wrap existing scientific tools (simulators, schedulers, meshers) into a standardized interface for LLM agents, ensuring interoperability without modifying the underlying tools.
• Iterative Refinement: The system successfully executes closed-loop design cycles where agents analyze results and autonomously refine the search strategy for the next iteration.

4. Results and Evaluation

The framework was evaluated on the Richtmyer–Meshkov Instability (RMI) suppression problem, a critical challenge in ICF where shock waves amplify material interface perturbations.

Case Study A: High-Fidelity HPC Simulation

• Setup: MADA managed the full loop on the Tuolumne supercomputer (LLNL), generating meshes via Cubit, running Laghos hydrodynamics simulations, and analyzing results.
• Process: Over two rounds, the system evaluated 40 configurations (20 initial Latin Hypercube samples + 20 focused samples).
• Outcome: The system reduced the RMI growth metric (QoI) from 4.1 to 3.7 (a 10% improvement).
• Efficiency: The entire optimization process took ~40 minutes. Without MADA, a human expert would require days to manually configure, run, and analyze comparable studies.

Case Study B: Surrogate-Based Optimization

• Setup: The IDA used a pre-trained ML surrogate model to simulate high-velocity copper impact, bypassing the need for full physics simulations.
• Process: The agent performed three rounds of refinement (~30 evaluations) to minimize and maximize RMI.
• Outcome:
  • Minimization: The agent found the global optimum in fewer than 40 evaluations, matching the performance of 100 runs of a gradient-based optimizer (L-BFGS-B) but with interpretable reasoning.
  • Reasoning Trace: The agent successfully deduced that "sign alternation" in geometric parameters drives RMI growth, providing a logical explanation for its design choices, which traditional optimizers cannot do.

5. Significance

• Acceleration of Discovery: MADA significantly reduces the time-to-solution for complex design problems by automating the "boring" parts of the workflow (meshing, job submission, parsing), allowing scientists to focus on hypothesis generation and interpretation.
• Scalability and Flexibility: By using MCP, the framework is tool-agnostic. It can integrate new simulators or schedulers simply by wrapping them in an MCP server, making the system reusable across different scientific domains.
• Interpretability: Unlike "black box" optimization algorithms, the LLM-based agents provide natural language reasoning traces, explaining why certain designs were chosen, which builds trust and aids scientific insight.
• Bridging HPC and AI: This work demonstrates a practical pattern for coupling LLM reasoning with the rigorous constraints of HPC infrastructure, moving beyond simple chatbots to active, autonomous scientific collaborators.