Agentic AI is increasingly supporting engineering workflows, from requirements analysis and testing to model development and verification. As adoption grows, organizations are exploring how to integrate these capabilities into established engineering processes without losing visibility into how changes are evaluated and approved.

I talked with Tianyi Zhu, Senior Product Manager at MathWorks, about the role of system-first engineering in agentic AI workflows, how engineering teams can evaluate and review AI-generated changes, and what it takes to scale these approaches across organizations.

Why do AI-generated outputs that look correct still fail in engineering systems?

AI-generated outputs can appear correct because they often satisfy local expectations at the artifact level. A model may be structurally valid, code may compile, and tests may execute successfully. But engineering correctness depends on system behavior, not just on whether individual artifacts look right. Failures often emerge when software, controls, and connected components interact.

For example, an agent may modify a controller and pass local tests, but the change can still produce unexpected behavior once integrated with the broader system. The generated artifact may be technically valid while still failing to meet overall system requirements.

Engineering systems can’t be evaluated only by the correctness of individual outputs. What matters is the effect those changes have on system behavior and whether they meet requirements.

Why does agentic AI require a system-first approach to actually work?

In a system-first approach, teams work from a shared executable system context, including system architectures, executable models, test harnesses, requirements links, and CI workflows. Together, those artifacts give teams a common basis for simulation, verification, and day-to-day engineering work across domains.

The executable model and its associated verification assets become the reference point for expected system behavior. Teams evaluate changes against the same interfaces, requirements, assumptions, and verification criteria even when work spans multiple connected models.

That helps teams identify problems earlier in development. A change can be evaluated through simulation, testing, and analysis before it creates downstream integration issues. Agentic AI benefits from that environment because those changes can be evaluated within the same system context. Without it, an agent may produce outputs that appear reasonable but are inconsistent with the intended system behavior.

What does it look like to use agentic AI in a system-first workflow?

Agentic AI works best when it’s grounded in the full system context. For example, an engineer might ask an agent to update a controller to satisfy a new requirement. The agent can propose modifications to the model, check interfaces and data dependencies, and run model checks. Then it can execute the test harness, compare logged signals against requirements-linked tolerances, and identify failures. It’s also able to generate or update tests and summarize the results.

Those activities don’t automatically justify design changes. Agentic AI helps automate engineering tasks that would otherwise be manual and time-consuming, but validation does not become optional. An engineer still has to confirm that the update works before it can move forward. Simulation, testing, and analysis provide the evidence needed to make that decision.

Agents can generate useful models and test changes, but they could also create models that are structurally valid while implementing incorrect behavior. Access to requirements, models, interfaces, tests, and simulation results helps keep those changes aligned with engineering intent.

Engineers define what needs to be verified and what evidence is required to approve a change. Agentic AI can help orchestrate and execute checks, but responsibility for approval remains with the engineering team.

What does engineering accountability look like in agentic AI workflows?

Engineering decisions should be based on reproducible and reviewable evaluations rather than from generated output alone. Every proposed change needs to be evaluated against requirements, models, and automated verification workflows. The goal is not perfect, bit-for-bit agreement in every environment. What matters is that results are reproducible within defined tolerances and that differences can be explained and traced.

Simulation and verification provide objective evidence about how a change affects system behavior. Logged results and test artifacts create an audit trail that engineers can follow before approving a change. Agentic AI can generate proposals and help automate verification activities, but decisions still depend on engineering review, traceability, and evidence.

How do engineering teams scale agentic AI?

Most organizations begin with focused workflows where the value and risk are well understood. Early efforts often center on generating tests, reviewing models, analyzing requirements, developing documentation, or modifying a subsystem. Teams usually begin with a single use case and build from there.

As teams build the evidence needed to evaluate and review AI-assisted changes, agentic workflows can expand to support larger portions of the development process.

Scaling successfully requires teams to develop, verify, and approve work in a consistent way. Teams achieve that consistency by working from the same engineering standards, verification practices, version control, reusable test assets, and approval processes. A common foundation built on model architectures, requirements traceability, and regression testing workflows helps teams understand and review results across projects and teams.

As adoption grows, engineers remain responsible for reviewing outcomes and approving changes. Agentic AI can help automate engineering work, but accountability for the delivered system remains with the engineering team.