Rethinking CAE: From GUI-Based Workflows to AI-Driven Simulation Systems

If we compare modern industry to a building, then CAE (Computer-Aided Engineering) simulation software is the foundation hidden underground.

Most people use cars, smartphones, or high-performance servers every day, yet few realize that before these products are ever manufactured, they have already undergone thousands or even millions of “virtual experiments” inside computers. Will the battery overheat? Will the structure crack? Is the flow channel design efficient? Does the thermal system meet performance requirements? Increasingly, these questions are no longer answered through physical testing, but through CAE simulation tools that predict behavior in advance.

Over the past decades, CAE has driven the digital transformation of the entire manufacturing industry. From finite element analysis (FEA) to computational fluid dynamics (CFD), from structural strength evaluation to complex multi-physics simulations, CAE has become a core infrastructure in modern engineering R&D workflows. At the same time, however, CAE has always faced a fundamental challenge: software is becoming more powerful, but also significantly harder to use. Engineers are required to master extensive domain knowledge and complex workflows in order to fully leverage simulation capabilities.

If we break CAE software down, it essentially consists of two parts: the front-end GUI (Graphical User Interface) and the back-end solver.

Many people assume that the GUI is the most important part of CAE software. In reality, the GUI is merely a bridge between the user and the solver. When engineers click buttons, fill in parameters, select materials, and set boundary conditions, they are not directly “using software” in a conceptual sense — they are generating a sequence of instructions that define the simulation problem.

Take OpenFOAM as an example. It is fundamentally a command-line-based simulation platform. Users must prepare mesh files, physical properties, boundary conditions, and solver control files before executing the simulation. What commercial CAE software provides through graphical interfaces is essentially a wrapper that transforms these complex text-based configurations into more user-friendly menus and buttons. Every click in the GUI ultimately generates corresponding configuration files or commands. After hundreds or even thousands of such interactions, a complete simulation setup is formed and passed to the solver for execution.

From this perspective, the traditional CAE workflow can be abstracted as:

Engineer → GUI → Input Files → Solver → Simulation Results

For decades, the evolution of industrial software has primarily focused on improving GUIs. Vendors continuously added new modules, refined interfaces, and expanded parameter options to enable engineers to handle increasingly complex problems. However, this approach has also created a new issue: as software becomes more powerful, it also becomes more complex, significantly increasing the learning curve for new users.

Today, however, large language model (LLM)-driven Agent technologies are beginning to challenge this paradigm. Unlike humans, Agents do not care what buttons look like or where menus are located. They directly interpret user intent.

For example, in traditional OpenFOAM workflows, engineers must manually create meshes, define inlet velocities, select turbulence models, choose solvers, and verify dozens of configuration files. In the future, an Agent may only need a natural language instruction such as:

“Build a steady-state CFD model of an automotive radiator, with inlet velocity 5 m/s, using the k-ω SST turbulence model.”

The Agent would then automatically handle geometry processing, mesh generation, parameter configuration, and job submission, ultimately returning simulation results.

The workflow then evolves into:

Engineer → Agent → Input Files → Solver → Simulation Results

In fact, this has already happened. The GUI does not completely disappear, but its importance is significantly reduced. Engineers will no longer need to learn how to operate software step by step; instead, software will need to understand engineering intent.

*https://arxiv.org/html/2506.02019v2*

A more fundamental transformation is happening at the solver level. For decades, the core competitiveness of CAE software has been rooted in numerical solvers. Whether finite element analysis (FEA), computational fluid dynamics (CFD), or electromagnetic simulation, all rely on discretizing and solving partial differential equations. To achieve high accuracy, these solvers often require significant computational resources, with complex simulations taking hours, days, or even weeks to complete.

In recent years, artificial intelligence methods have begun to reshape this landscape. Approaches such as CNNs, GNNs, Transformers, and PINNs are increasingly being used to replace or augment traditional solvers.

*https://github.com/WillDreamer/Awesome-AI4CFD*

CNNs can learn physical field distributions on structured grids, enabling fast prediction of flow, temperature, and stress fields. GNNs are naturally suited for finite element meshes and irregular geometries, showing strong potential in structural and fluid simulations. Transformers, with their powerful sequence modeling capabilities, are being explored for multi-physics prediction and complex system modeling. PINNs go even further by embedding physical governing equations directly into the training process, ensuring that predictions satisfy physical constraints.

These methods do not necessarily replace traditional solvers entirely, but in many cases they act as surrogate models. Simulations that once took hours can now be approximated in seconds.

This raises an important question: if Agents are replacing GUIs and AI solvers are replacing parts of traditional solvers, will CAE software eventually disappear? The answer is likely the opposite. CAE software will not disappear. In fact, its importance may increase. The reason is fundamental: the effectiveness of AI depends heavily on data.

All machine learning models — CNNs, GNNs, Transformers, or PINNs — require large datasets for training. In internet applications, such data comes from text, images, videos, and user behavior. However, industrial engineering is fundamentally different.

Real-world physical data is extremely expensive to obtain. To build a dataset for automotive aerodynamics, extensive wind tunnel testing is required. To collect battery thermal management data, complex experimental setups are necessary. To study material failure, destructive testing must often be performed. In many industrial scenarios, a single experiment can cost tens of thousands of dollars.

More importantly, humans cannot generate unlimited physical-world data the way the internet generates digital data.Currently, the primary source of data for industrial AI is CAE simulation software itself.

Most datasets used to train AI solvers are generated by running traditional numerical solvers at scale. Researchers execute tens of thousands or even millions of CFD, FEA, or electromagnetic simulations and use the results as training data for neural networks. In other words, behind many AI models lies an even larger traditional solver infrastructure.

This creates a closed loop:

Traditional solver generates data → AI learns patterns → AI accelerates prediction → traditional solver validates results

In the foreseeable future, this loop is unlikely to be broken.

At the same time, AI is fundamentally better at interpolation than extrapolation. When trained data is sufficiently dense, AI models can make extremely fast and accurate predictions. However, when encountering problems outside the training distribution, their reliability can degrade significantly.

For example, a model trained on automotive aerodynamics may never have seen a novel aircraft configuration. A model trained on conventional battery systems may not generalize to next-generation materials. A model trained on standard heat exchanger designs may fail on entirely new topology-optimized flow structures.

Yet it is precisely these “never-seen-before” problems that define engineering innovation.

For such cases, engineers must return to first principles, relying on partial differential equations, numerical discretization methods, and high-fidelity solvers to obtain trustworthy results. Innovation, by definition, exists where no historical data is available — and this is exactly where AI struggles the most.

Therefore, a new division of labor is likely to emerge. AI will handle around 80% of routine engineering tasks: parameter sweeps, design space exploration, optimization, and rapid performance prediction. Agent systems and AI solvers will dominate this layer. The remaining 20% — complex physics, extreme conditions, novel designs, and critical validation — will continue to rely on traditional CAE solvers.

From this perspective, AI is not the end of CAE software, but rather an amplifier of its capabilities.

In the future industrial software ecosystem, traditional solvers will not disappear but will gradually move behind the scenes. Engineers will no longer spend most of their time operating complex software interfaces; instead, they will focus more on true engineering innovation.

Perhaps the most advanced industrial software of the future will no longer be a system with thousands of menus and buttons. Instead, it will be an intelligent engineering platform composed of Agents, AI models, and high-fidelity solvers.

And traditional CAE software will remain its most fundamental and indispensable infrastructure.