We have all used ChatGPT or Claude to write a Python script for a project. You ask for a MATLAB function to solve a differential equation, and it gives you the code. That is Generative AI. It produces text or code based on probabilistic patterns, acting like a really comprehensive, yet occasionally hallucinating, textbook. But there is a fundamental limit: Generative AI delivers outputs (text, images, code snippets), while engineers need outcomes (a converged simulation, a validated design, a working control loop).
Agentic AI is different. Think of Agentic AI as a Junior Engineer.
If you give a human Junior Engineer a task, they don’t just hand you a piece of paper and walk away. They write the script, run it, see that it crashed, read the error log, google the error, fix the syntax, and run it again until it works. Agentic AI does exactly that. It isn't limited to a chat window; it has "tools"—it can execute code, browse the documentation, check StackOverflow, access the terminal, and even query a database.
While Generative AI is like a student who memorized the textbook, Agentic AI is like a student taking an open-book exam who checks their answers, runs the numbers, and corrects their own mistakes before handing the paper in. It bridges the gap between knowing the syntax and solving the problem.
If you are working in core engineering disciplines—whether Computational Fluid Dynamics (CFD) for mechanical systems, Process Simulation for chemical plants, Geomechanics for mining, or Phase Field Modeling in metallurgy—you know the struggle. You typically spend 20% of your time defining the physics or chemistry and 80% of your time fighting with the solver mechanics.
The workflow usually looks like this:
This manual debugging loop is slow, frustrating, and creates a massive context-switching burden. It requires you to constantly "babysit" the software, checking in every hour just to see if it crashed. It turns highly skilled engineers into log-parsers.
Agentic AI automates the debugging process by closing the loop between code generation and execution. Instead of just generating the setup script and wishing you luck, an Agent has the permission to execute the simulation, monitor the process, and read the output files.
How it works in practice: Imagine a scenario where a simulation diverges due to a stability issue. The Agent parses the log file using specific patterns (like regex or keyword matching). It recognizes that the Courant-Friedrichs-Lewy (CFL) number exceeded the stability limit just before the crash.
It doesn't need to ask you for help; it performs a "Reflection" step, mimicking human reasoning:
It loops this "Action-Observation-Reflection" cycle until convergence is reached. This shifts our role from "script debugger" to "workflow architect." We define the goal (minimize drag, maximize reaction yield, ensure slope stability), and the Agent handles the iterative coding, parameter tuning, and error handling.
Let’s look at Software Defined Vehicles (SDV). Modern cars are basically computers on wheels, often running on "Zonal Architectures" and frameworks like ROS 2 (Robot Operating System). Imagine an Agentic system running inside an autonomous vehicle's central computer or on a connected edge server. It isn’t just looking at the road; it is continuously monitoring the health of the car’s own code performance.
The Scenario: You are driving on a highway, and the Agent notices that the active suspension control loop is taking 15 milliseconds to execute. However, the safety requirement is a strict 10 milliseconds to ensure ride stability. The system is lagging, potentially compromising safety.
The car essentially debugged, optimized, and patched its own dynamics software while moving. This same concept applies to a Chemical Reactor tuning its own PID loops or a Smelting Furnace adjusting its power input based on real-time slag composition analysis.
If you are reading this and feeling nervous about letting an AI modify your solver settings, you are not alone. As engineers, we are trained to be skeptical. We know that Generative AI can "hallucinate"—confidently outputting wrong answers or inventing libraries that don't exist. In engineering, a hallucination isn't just a funny typo; it’s a bridge falling down, a thermal battery runaway, or a mine shaft collapsing.
This is where Physics-Informed Guardrails come in.
An Agentic workflow doesn't just check if the code runs without crashing; it checks if the results make physical sense. We can program the Agent with deterministic "sanity checks" that act as immutable laws. These are not learned patterns; they are hard-coded constraints:
In this setup, the AI isn't an unchecked authority; it’s a worker operating within strict safety cages that you defined. It can be creative with the syntax and optimization, but it cannot break the laws of physics or thermodynamics.
The single "Junior Engineer" Agent is powerful, but the real breakthrough happens when we move to Multi-Agent Systems.
Complex engineering problems are rarely solved by one person. You usually have a CAD expert, a Process Engineer, a Geologist, and a Solver analyst. We can replicate this architecture with specialized Agents communicating via structured data (like JSON or YAML). This is often called the "Assembly Line" paradigm in AI frameworks:
This creates an autonomous feedback loop between specialized sub-agents, orchestrating a complete design cycle while you are in a meeting.
This shift changes what it means to be a "core" engineer. The ability to manually click through a GUI to set up a simulation is becoming a commodity. The valuable skill of the next decade is Orchestration.
We are evolving from operators who turn the cranks to architects who design the machine. The math, physics, and chemistry knowledge remains crucial—you need to know what to tell the Agent to look for—but the mechanics of getting there are being radically abstracted.
For us as Core Engineers - whether Mechanical, Chemical, Metallurgical, Civil, or Mining, the future isn't just about knowing how to mesh a wing in Ansys, it’s about understanding how to build the logic that drives these tools.
We are moving away from manually clicking buttons in a GUI. The industry is moving toward Python-driven workflows where we build Agents to do the heavy lifting.
Agentic AI is the difference between a chatbot that talks about engineering and a system that actually does engineering. It closes the loop between code generation, execution, and validation. For us, it means less time fixing syntax errors and more time solving the physics.
So, if you haven’t started getting comfortable with APIs, scripting, and orchestration frameworks like LangChain or AutoGen, now is a great time to start. The "Junior Engineer" is ready to be hired—you just need to learn how to manage them.