Context is all you need: Towards autonomous model-based process design using agentic AI in flowsheet simulations

This paper presents an agentic AI framework that leverages large language models to autonomously generate valid code for industrial chemical process flowsheet simulations, demonstrating its effectiveness through multi-agent collaboration on complex tasks like reaction/separation and distillation processes.

The Gist

Imagine you are trying to build a complex machine, like a giant, high-tech coffee factory that turns beans into a perfect latte, but you have to do it by writing a very strict, ancient language that only a few experts understand. If you make one typo, the whole machine explodes (or in engineering terms, the simulation crashes).

This is the challenge chemical engineers face every day. They need to design processes to turn raw materials (like oil or biomass) into useful products, but the software they use is rigid, and the learning curve is steep.

The Paper's Big Idea:
The authors of this paper asked: "What if we could hire a team of AI robots to do this for us?"

They didn't just ask the AI to "guess" the answer. Instead, they built a two-person AI team (a "Multi-Agent System") that works together like a seasoned architect and a meticulous construction worker.

The Two AI Team Members

Think of the system as a construction project with two distinct roles:

1. The "Architect" (The Process Development Agent)

• Who they are: This AI is the big-picture thinker. It's like a senior engineer who knows the laws of physics and chemistry.
• What they do: They look at the raw materials (e.g., "We have water and some weird chemical") and the goal ("We need to separate them"). They don't write code. Instead, they draw a blueprint. They say, "Okay, we need a mixer here, a heater there, and a distillation tower to separate the liquids."
• Superpower: They can do math in their head (or on a digital notepad) to estimate how much stuff flows where. They figure out the logic of the process.

2. The "Builder" (The Chemasim Modelling Agent)

• Who they are: This AI is the master of the specific, finicky software tool called Chemasim. It's like a construction worker who speaks the exact dialect of the building codes.
• What they do: The Architect hands them the blueprint. The Builder translates that into the strict, computer-readable code that the simulation software understands.
• Superpower: They are incredibly careful. If the code has a typo, the simulation crashes. The Builder knows how to fix it, run the test, see the error message, and try again until the machine runs smoothly.

How They Work Together (The "Agentic" Magic)

In the past, if you asked an AI to design a chemical plant, it might hallucinate a machine that doesn't exist or write code that breaks immediately.

This new system works like a feedback loop:

1. The Architect designs a separation process (e.g., "Let's use a distillation column to separate alcohol from water").
2. The Builder writes the code for that column.
3. The Simulation Engine runs the test.
4. The Result: If the simulation says, "Error! The pressure is too high," the Builder reads that error, fixes the code, and runs it again.
5. The Loop: If the simulation says, "Hey, this design isn't separating the chemicals well," the Builder can even talk back to the Architect and say, "Your blueprint is wrong; we need more stages in the tower."

The Three "Test Drives"

To prove this team works, the researchers gave them three different puzzles to solve:

1. The Reaction Factory: They asked the AI to design a process to make a specific chemical (Ethyl Benzene) from others. The AI successfully figured out the recipe, the order of mixing, and how to recycle the leftovers to save money.
2. The Pressure-Swing Trick: They gave the AI a mixture that is impossible to separate at normal pressure (like trying to separate oil and water that are stuck together). The AI realized, "Ah, if we change the pressure, they separate!" It designed a system that switches between high and low pressure to do the job.
3. The "Magic Ingredient" Hunt: They gave the AI a mixture that needed a special helper chemical (an "entrainer") to separate. The AI had to pick the best helper from a list of candidates. It correctly identified which chemical would work best and designed a process using a "decanter" (a separator that splits liquids based on density) to finish the job.

Why This Matters (The "So What?")

The Old Way: A human engineer spends weeks or months reading manuals, writing code, debugging errors, and tweaking designs.
The New Way: The AI team does the heavy lifting. The human engineer becomes the "Manager," reviewing the AI's blueprints and giving the final green light.

The Catch (Limitations):
The paper admits the AI isn't perfect yet. If the chemistry gets really weird (like a mixture with five different chemicals that all hate each other in complex ways), the AI sometimes gets confused. It's like a GPS that knows the main highways perfectly but gets lost in a maze of tiny, winding backroads.

The Bottom Line

This paper shows that we are moving toward a future where AI doesn't just write code for websites; it designs entire chemical factories.

Instead of a human struggling to learn a 50-year-old, text-based software language, they can now talk to an AI team. The AI handles the tedious coding and debugging, while the human focuses on the creative engineering. It's like giving a chemical engineer a super-powered assistant that never gets tired, never makes a typo, and is always ready to run the simulation one more time to get it right.

Technical Summary

1. Problem Statement

The chemical industry faces significant challenges in adapting processes to new feedstocks (e.g., biomass, CO2). Traditional process synthesis is iterative and sequential, relying heavily on human expertise to conceptualize flowsheets before simulation. While recent advances in Reinforcement Learning (RL) and Large Language Models (LLMs) offer alternatives, they face specific limitations:

• RL Limitations: Often restricted to simplified thermodynamic systems and pre-defined superstructures, with poor generalization to unseen mixtures.
• LLM Limitations: General-purpose LLMs lack training on highly domain-specific, proprietary syntax used in industrial process simulators (e.g., BASF's Chemasim). Furthermore, LLMs struggle to autonomously interact with simulation engines to handle convergence issues, error messages, and iterative model refinement.
• The Gap: There is a need for an autonomous system that can not only conceptualize chemical process designs based on thermodynamic principles but also implement them in valid, executable code within a rigorous industrial simulation environment without human intervention.

2. Methodology

The authors propose a Multi-Agent AI Framework integrated into the Chemasim environment (BASF's in-house, text-based process modeling tool). The system utilizes state-of-the-art LLMs (specifically Claude Opus 4.6) and operates without fine-tuning, relying instead on in-context learning.

A. The Multi-Agent Architecture

The system consists of two distinct agents with specialized roles:

1. Process Development Agent (The "Architect"):

   • Role: Solves abstract process synthesis problems (e.g., determining separation sequences, selecting entrainers).
   • Capabilities: Accesses tools for thermodynamic calculations (azeotrope detection, miscibility gaps) and performs mass balance computations via free-form Python coding.
   • Input: Technical prompts regarding feed composition and constraints.
   • Output: A unit-by-unit process design document, including estimated flow rates, compositions, and preliminary specifications (e.g., reflux ratios, stage counts).

2. Chemasim Modelling Agent (The "Implementer"):

   • Role: Translates the abstract design into valid Chemasim syntax and manages the simulation engine.
   • Capabilities:
     • In-Context Learning: Uses technical documentation, commented examples, and "how-to" guides provided in the prompt to generate correct syntax for a proprietary language.
     • Autonomous Execution: Directly manipulates text-based input files, triggers simulation runs, and parses console output/error messages.
     • Iterative Refinement: Implements a unit-by-unit procedure. It adds one unit operation, runs the simulation, checks for convergence, and only proceeds to the next unit if the current step is stable. It utilizes "re-run" (Nachstart) features to use previous results as initial guesses for the solver.
   • Best Practices: The agent is instructed to follow specific heuristics for difficult units (e.g., distillation columns), such as starting with fixed flow/ratio specifications before switching to purity targets to ensure convergence.

B. Interaction Loop

The agents interact via a feedback loop where the Modelling Agent can report simulation status (converged/failed) back to the Development Agent, though in the reported work, the primary flow is sequential. The system runs within Visual Studio Code, leveraging GitHub Copilot as the interface.

3. Key Contributions

• Proprietary Syntax Generation: Demonstrated that modern LLMs can generate valid syntax for a highly specialized, proprietary industrial tool (Chemasim) using only in-context learning (documentation + examples), eliminating the need for fine-tuning.
• Autonomous Simulation Loop: Developed a framework where an AI agent can autonomously run simulations, interpret error messages, correct syntax/logic errors, and manage solver initialization strategies to achieve convergence.
• Decoupled Design and Implementation: Created a separation of concerns where one agent handles the chemical engineering logic (thermodynamics/mass balance) and another handles the software engineering logic (syntax/simulation execution).
• Text-Based Interface Advantage: Highlighted that text-based modeling tools (unlike GUI-heavy commercial simulators) are uniquely suited for agentic AI, allowing agents to manipulate models with the same flexibility as human users.

4. Results

The framework was validated on three distinct case studies involving masked components (A, B, C, etc.) to prevent the AI from relying on memorized process data:

1. Reaction-Separation Process (Ethyl Benzene Synthesis):

   • The agent successfully designed a flowsheet involving a reactor, two distillation columns, and a transalkylation reactor.
   • It correctly handled mass balances, recycle streams, and impurity purges.
   • Result: The rigorous simulation results (green numbers in diagrams) showed excellent agreement with the agent's initial mass balance estimates (blue numbers).

2. Pressure-Swing Distillation (Binary Azeotropes):

   • Tested on two systems: n-propanol/benzene (minimum boiling) and acetone/chloroform (maximum boiling).
   • The agent correctly identified the pressure-dependence of azeotropes and designed a two-column sequence operating at different pressures to break the azeotrope.
   • Result: The agent successfully converged the simulations, though it occasionally selected conservative parameters (high reflux/stages) to ensure stability rather than economic optimality.

3. Heteroazeotropic Distillation (Entrainer Selection):

   • Tasked with separating water and 1,4-dioxane using different entrainer candidates.
   • The agent analyzed ternary diagrams and miscibility gaps, correctly selecting the entrainer with the largest miscibility gap (Benzene) for a single-column design.
   • Result: When prompted to optimize for energy, the agent proposed a modified design with a pre-separation step, which rigorous simulation confirmed would reduce energy demand by >60%.

5. Limitations and Future Directions

• Complex Thermodynamics: The system struggled with highly complex ternary/quaternary systems involving multiple azeotropes and narrow miscibility gaps (Case Studies 4 & 5). It failed to propose viable designs for crossing distillation boundaries in these scenarios without specific human guidance.
• Optimization: The current framework focuses on feasibility and convergence, not economic optimization. It lacks integrated numerical optimization tools (e.g., MINLP) to minimize costs or energy.
• Feedback Mechanism: While technically possible, the feedback loop between the Modelling Agent and Development Agent was underutilized. Future work should leverage this to allow the Design Agent to re-evaluate concepts when the Simulation Agent encounters persistent convergence failures.

6. Significance

This paper represents a significant step toward autonomous chemical process development. It proves that:

1. Agentic AI can bridge the gap between abstract chemical engineering concepts and executable industrial simulation code.
2. Context is sufficient for LLMs to master proprietary languages, challenging the assumption that fine-tuning is always necessary for domain-specific tasks.
3. The future of process simulation may shift from Graphical User Interfaces (GUIs) to text-based, agent-driven interactions, enabling faster, more iterative, and potentially fully autonomous process design cycles.

The work suggests that while current LLMs cannot yet replace human engineers for the most complex, novel thermodynamic challenges, they can significantly accelerate the design of standard processes and serve as powerful decision-support tools for industrial applications.