Introduction

Product development has always been a relay race. A requirement gets handed from a product manager to a design engineer, who hands a CAD model to a simulation team, who hands validated results to manufacturing, who hands a build plan to quality. Every handoff cost time, and every handoff is a chance for context to get lost.

Autonomous engineering changes the shape of that race. Instead of a relay of humans passing static files to one another, AI agents now sit inside the workflow itself — reading requirements, generating design options, running simulations, flagging risks, and updating downstream systems without waiting for someone to open a ticket. This isn't generative AI drafting a spec for a human to rewrite. It's agentic AI taking the spec, acting on it across multiple tools, and looping a human in only where judgment is genuinely required.

This shift is already underway. Industry research shows a majority of engineering organizations have moved AI agents out of the pilot phase and into production workflows, and Gartner projects that by the end of 2026, roughly 40% of enterprise applications will embed task-specific AI agents — up from under 5% just a year earlier. The question for product organizations is no longer whether to adopt agentic AI, but how to restructure engineering workflows so agents can actually do useful work inside them.

What Autonomous Engineering Actually Means

Traditional engineering automation is rule-based: a macro resizes a hole pattern, a script batch-exports drawings, a PLM workflow routes an approval to the next person in line. It's useful, but it can't reason about a problem it wasn't explicitly told about.

Agentic AI is different. Given a goal and access to the right tools, an agent can plan a sequence of steps, execute them, check its own results, and adjust course. In an engineering context, that might look like an agent that:

• Reads a new performance requirement and proposes several design variants that meet it.
• Runs early-stage simulation or FEA on each variant and ranks them against weight, cost, and manufacturability targets.
• Updates the CAD model and associated BOM for the selected variant.
• Flags a supplier constraint it found in the ERP system before the design ever reaches procurement.

None of these steps individually is new. What's new is that an agent can chain them together, across tools that were never designed to talk to each other, with minimal human prompting at each step.

Why Most Engineering Organizations Aren't Ready Yet

The barrier isn't model capability — it's data. Engineering data still tends to live in disconnected systems: CAD in one vault, requirements in a separate ALM tool, simulation results in local folders, and manufacturing constraints buried in an ERP that nobody outside procurement ever opens. An AI agent can only act on what it can see, and most engineering data simply isn't structured or connected enough for an agent to see the full picture.

This is the same integration problem that has quietly limited automation for two decades, but agentic AI raises the stakes. A person working around a data silo just loses time. An agent working around a data silo makes decisions on partial information — and does it faster and with more apparent confidence than a person would. Gartner's own research suggests that more than 40% of agent projects will fail to deliver their intended value by 2027, and disconnected, low-quality source data is consistently cited as the leading cause.

Surveys of engineering and IT leaders echo the same theme: the teams seeing real returns from agentic AI are not the ones with the flashiest tools, but the ones that did the unglamorous work of connecting PLM, ERP, ALM, and simulation data first.

The Connected Engineering Workflow

A product development environment built for autonomous engineering routes information differently than a traditional one:

Requirements (ALM/PLM): A product requirement or change request is entered once, in a structured format an agent can parse.

Agent Layer: An orchestrating agent interprets the requirement, checks it against existing design constraints, and delegates sub-tasks — generate CAD variants, run simulation, check part availability — to specialized agents or tools.

Engineering (CAD/CAE): Design and simulation tools execute the sub-tasks, returning ranked options with supporting data rather than a single static file.

Procurement & Manufacturing (ERP/MES): Selected designs automatically update cost estimates, check supplier lead times, and generate work instructions.

Feedback Loop: Field or test data flows back to the requirements layer, so the next design cycle starts smarter than the last.

This is the same "digital thread" concept that has been discussed in manufacturing for years — the difference is that the thread now has an active agent walking along it, not just data sitting on it waiting to be queried.

Where This Is Already Showing Up

Design exploration at speed. Engineering teams are using agents to generate and evaluate dozens of design variants against multiple constraints in the time it used to take to model one. Reports on agentic coding and engineering workflows describe teams turning multi-week, cross-functional design iterations into single focused working sessions, because the agent handles the mechanical parts of exploration while the engineer focuses on judgment calls.

Non-experts prototyping real products. Because agents can translate a plain-language goal into working CAD, simulation, or code, people without deep specialist training are increasingly able to build functional prototypes themselves. One widely cited case involved a small, non-technical product team using agentic tools to go from idea to working prototype in hours rather than weeks — letting a lean team punch well above its headcount.

Documentation and compliance that keeps up. Technical documentation, test reports, and compliance packages have historically lagged behind the engineering work itself. Agents that watch the design and test data as it's generated can draft and update this documentation continuously, rather than as a rushed step at the end of a program.

Orchestrated, multi-agent workflows. Analysts increasingly expect single-purpose agents to give way to coordinated teams of specialized agents — one validating a design against regulatory constraints, another checking supplier risk, a third drafting the change notice — all working from shared context and handing off to each other without a human relaying information between them.

The Reliability Question

The more decisions an organization delegates to agents, the more that organization depends on those agents being right — or at least being wrong in ways that get caught. This is where "jaggedness" matters: agents are exceptional at some engineering tasks and surprisingly brittle at others, and the failure modes aren't always obvious until they show up in a released product.

The practical implication is that autonomous engineering doesn't remove human engineers from the loop — it moves them. Instead of doing the mechanical work of exploring a design space, engineers spend more time setting the constraints an agent should respect, reviewing what it produces, and stepping in on the conceptually hard problems that resist easy verification. Organizations that treat this as a governance and oversight problem, not just a tooling purchase, are the ones seeing agentic investments turn into measurable returns rather than rework.

Building Toward It

For a product development organization, the practical path toward autonomous engineering looks less like buying an AI product and more like a sequence of foundational moves:

1. Connect the systems — PLM, ALM, ERP, and simulation tools need to expose structured, queryable data, not just human-readable exports.
2. Clean and structure legacy data — an agent can't reason over a spec buried in an unlabeled PDF or a BOM full of inconsistent part numbers.
3. Start with verifiable tasks — design variant generation, documentation drafting, and compliance checks are easier to hand to an agent and easier to check than judgment-heavy architectural decisions.
4. Build in oversight, not just automation — define where an agent can act independently and where a human sign-off is required, and revisit that line as trust in the system grows.

Conclusion

The organizations that will lead product development over the next few years aren't necessarily the ones with access to the most advanced models — model capability is increasingly a commodity. The advantage will belong to the organizations that did the harder, less visible work of connecting their engineering data so that an agent can actually act on it safely. Autonomous engineering isn't a single tool to install; it's a foundation to build, one integration and one clean dataset at a time. 

References

1. Gartner, 2026 AI Spending and Agentic AI Predictions
2. McKinsey & Company, State of AI 2026
3. Anthropic, 2026 Agentic Coding Trends Report
4. Datadog, State of AI Engineering (2026)
5. Joget/analyst roundup, "AI Agent Adoption 2026: What the Data Shows"