{"id":18913,"date":"2026-10-30T18:52:15","date_gmt":"2026-10-30T22:52:15","guid":{"rendered":"https:\/\/blogs.mathworks.com\/simulink\/?p=18913"},"modified":"2026-10-30T19:21:18","modified_gmt":"2026-10-30T23:21:18","slug":"behavioral-models-with-agentic-ai-powered-mbse","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/simulink\/2026\/10\/30\/behavioral-models-with-agentic-ai-powered-mbse\/","title":{"rendered":"Behavioral Models with Agentic-AI-powered MBSE"},"content":{"rendered":"
<\/span><\/div>
\"\"<\/img><\/a><\/div>
Today I am happy to welcome back<\/span> <\/span>Sarah Dagen<\/span><\/a> <\/span>from<\/span> <\/span>MathWorks Consulting Services<\/span><\/a> <\/span>for another visit to the Galactic Soup Factory!<\/span><\/div>
.<\/span>\"\"<\/img><\/div>
When we left off using agentic AI and MBSE to design an intergalactic soup factory, we were evaluating 3 physical design variants. I am continuing the trade study in this article, but this time it is based on dynamic simulations rather than static analysis. <\/span><\/div>
\"\"<\/img><\/div>

A reminder of what happened so far <\/span><\/h2>
I started by using a coding agent along with the <\/span>Simulink Agentic Toolkit<\/span><\/a> and <\/span>System Composer<\/span><\/a> to <\/span>import and analyze system requirements and develop functional, logical, and physical architectures<\/span><\/a>. <\/span><\/div>
Then, I had the agent propose three different physical architecture variants that could meet the requirements, and developed <\/span>architectural analysis and a trade study<\/span><\/a> to evaluate the variants against each other. <\/span><\/div>
These are our three architecture candidates: <\/span><\/div>
HyperCook<\/span> prioritizes throughput with four parallel continuous cook lines.<\/span><\/div>
\"\"<\/img><\/a><\/div>
LeanBroth<\/span> prioritizes budget margin with two batch kettles and one prep station.<\/span><\/div>
\"\"<\/img><\/a><\/div>
EverSimmer<\/span> prioritizes robustness: three fully independent production cells, each a complete prep-cook-quality control-pack chain. You can still produce soup even if one or two entire cells fail.<\/span><\/div>
<\/span>\"\"<\/img><\/div>
Using architectural analysis and trade study techniques, EverSimmer emerged a strong choice. It had the highest score in the majority of weighting scenarios. <\/span><\/div>

Let\u2019s add behaviors!<\/span><\/h2>
All of the analysis up to this point was based on static calculations and spec-sheet type data. To get a deeper understanding of how these different factories would actually work, I used the agent to help build some behavioral models. These are models that have executable semantics, like our static architectures, but also time-dependent equations. <\/span><\/div>
When I originally designed these variants, I aimed to reuse as many architectural sub-components as possible. There are differences in peripheral details, but fundamentally they are all doing the same thing with different combinations of the same components \u2013 things like preparing ingredients, cooking, quality control and packaging. So when it came to modeling the behaviors, I asked the agent to create parameterized reference models that could be reused in all the architectures. <\/span><\/div>
To start to get a feeling of how those factories operate, I worked with the agent and made the following component models: <\/span><\/div>
Component model<\/span><\/div><\/td>
What it models<\/span><\/div><\/td><\/tr>
Storage<\/span><\/div><\/td>
Storage buffer, starvation, and overflow<\/span><\/div><\/td><\/tr>
Prep Unit<\/span><\/div><\/td>
Preparation with rate limits and startup lag<\/span><\/div><\/td><\/tr>
Cook Line<\/span><\/div><\/td>
Continuous cooking and power consumption<\/span><\/div><\/td><\/tr>
Cooking Vat<\/span><\/div><\/td>
Batch cooking and thermal dynamics<\/span><\/div><\/td><\/tr>
Quality Control Station<\/span><\/div><\/td>
Inspection, contamination detection, and calibration<\/span><\/div><\/td><\/tr>
Packager<\/span><\/div><\/td>
Rate-limited packaging with backlog<\/span><\/div><\/td><\/tr>
Production Supervisor<\/span><\/div><\/td>
Production modes and failed-line control<\/span><\/div><\/td><\/tr>
Production Cell<\/span><\/div><\/td>
Integrated preparation through packaging<\/span><\/div><\/td><\/tr><\/table>
<\/span><\/div>
I didn\u2019t give the agent much direction on <\/span>how<\/span> to model anything. It made some technical decisions that I might not have made myself, but it generally got the job done and was good enough to bring insights. I told the agent to use the whole spectrum of modeling tools at its disposal. For example, for the cooking vat, the agent decided on its own to use Stateflow to implement the control mode logic and Simscape for the physical systems. <\/span><\/div>
\"\"<\/img><\/div>
\"\"<\/img><\/div>
These are good choices, for a real project I would probably have spent more time planning with the agent before letting it build to make sure those decisions were my own. <\/span><\/div>

The architecture is the model<\/span><\/h2>
One of the most powerful features of System Composer is its simulation capabilities, which is very different from many other MBSE tools. You can add Simulink models and behaviors directly in System Composer architecture models! <\/span><\/div>
Here\u2019s a little video showing how you can navigate directly from a system-level architecture down into behavioral models \u2013 a state chart in Stateflow, in this case: <\/span><\/div>
\"\"<\/img><\/div>

Simulating the dynamics<\/span><\/h2>
Once I had my architectures elaborated with behaviors, I needed to build simulation scenarios and test cases to observe the system dynamics. <\/span><\/div>
Working with the agent, I created several suites of tests to simulate different operational scenarios. The scenarios are based on the system requirements, and include traceability to the requirements.<\/span><\/div>
<\/span>\"\"<\/img><\/div>
<\/span><\/div>

Simulate!<\/span><\/h2>
Right away I can see interesting results. In the nominal operation case, I can see that the output of each factory varies over time even after it reaches nominal production, and sometimes has very large dips. Here\u2019s the factory output rate of each variant from a cold start:<\/span><\/div>
<\/span>\"\"<\/img><\/div>
I wanted to dig in to what is causing the production rate changes, and I was especially interested in what is happening with LeanBroth at around 7,500 seconds. <\/span><\/div>
\"\"<\/img><\/div>
At first, I started doing what I would usually do: log signals I suspect are involved and start overplotting data until I find a relationship\u2026 but then I remembered: I have an agent! I asked that agent to explore the results and create plots that would explain the observations, and it came up with this: <\/span><\/div>
First, the periodic dips in factory output:<\/span><\/div>
<\/span>\"\"<\/img><\/div>
And next, what\u2019s going on at around 7,500 seconds:<\/span><\/div>
<\/span>\"\"<\/img><\/div>
Those are interesting behaviors that I could only learn about with dynamic simulations, and it was very convenient to have the agent as a partner to investigate this. <\/span><\/div>

System-level Insights<\/span><\/h2>
After running through different simulated operational scenarios, I was able to learn new things about my design variants. I asked the agent to summarize insights that were discovered after running both the static analyses and the dynamics simulations: <\/span><\/div>
Observation<\/span><\/div><\/td>
HyperCook<\/span><\/div><\/td>
LeanBroth<\/span><\/div><\/td>
EverSimmer<\/span><\/div><\/td><\/tr>
Static \u2192 simulated throughput (bowls\/hour)<\/span><\/div><\/td>
320 \u2192 308.4<\/span><\/div><\/td>
210 \u2192 196.8<\/span><\/div><\/td>
240 \u2192 231.9<\/span><\/div><\/td><\/tr>
Time to first packaged output<\/span><\/div><\/td>
2.0 minutes<\/span><\/div><\/td>
57.3 minutes<\/span><\/div><\/td>
57.3 minutes<\/span><\/div><\/td><\/tr>
Time to sustained nominal production<\/span><\/div><\/td>
13.6 minutes<\/span><\/div><\/td>
62.6 minutes<\/span><\/div><\/td>
62.6 minutes<\/span><\/div><\/td><\/tr>
Energy per bowl (kWh)<\/span><\/div><\/td>
1.562<\/span><\/div><\/td>
0.822<\/span><\/div><\/td>
1.216<\/span><\/div><\/td><\/tr>
Production retained after worst single fault<\/span><\/div><\/td>
~ 0%<\/span><\/div><\/td>
~ 0%<\/span><\/div><\/td>
67.3%<\/span><\/div><\/td><\/tr><\/table>

Summary<\/span><\/h2>
Adding behaviors brought the trade study beyond spec-sheet comparisons, revealing differences in operational behaviors including startup time, energy use, and fault resilience. The agent helped me build reusable models and explore these scenarios cheaply. Now, the choice of soup factory rests not just on its architecture, but on how it behaves in operation.<\/span><\/div>

Now it's your turn<\/span><\/h2>
The whole project is on GitHub as a runnable reference example: models, requirements, analysis, tests, and the documentation set. You can open the project and <\/span>open this guided tour<\/span><\/a>. <\/span><\/div>\r\n
\r\n<\/div>