Teams demo agents but ship with copilots, and the data says why
SimScale's 2026 State of Engineering AI Report, released in March from a survey of 350 engineering leaders, contains the clearest number I have seen all year on where agentic AI actually lives in production: copilot adoption runs 67% to 76% depending on the stage of product development, while fully autonomous agent deployment sits around 10%.
I saw the same split in my own work months ago. My agents write, iterate, and explore constantly. Almost everything they produce passes through a check before it ships — an eval, a diff review, a screenshot test. I wrote about the reasoning in Ship on an eval gate: the gate is not bureaucracy, it is how you find out whether the model's good streak is real.
What is the autonomy gap in AI adoption?
The report's sharpest stat is not adoption at all. 87% of organizations report having the governance in place for AI to take autonomous pass/fail decisions at design gates. Only 8% routinely let it happen.
Read that again. Three out of four engineering orgs could hand the decision over. One in twelve does. That is a 79-point gap between permitted and practiced, and the report itself explains it plainly: engineering decisions have consequences in product performance, safety, and compliance, so human oversight stays central even as capability grows.
This is not laggards dragging their feet. These are teams running mature AI programs — the same population where adoption has roughly doubled year over year, design variants have grown close to 4x, and simulation turnaround runs 2.8x faster. The most aggressive AI adopters are the most deliberate about autonomy. That relationship is the point, not a contradiction.
Why does consequence decide adoption, not capability?
Because autonomy is priced per failure, not per token. A copilot that suggests geometry changes costs you seconds if it is wrong. An agent that decides a pressure grading passed costs you a design review cycle, a warranty claim, or a widened bridge guardrail, depending on the week.
Software has the same structure under different stakes. Deterministic builds get fully automated years ago because failure and recovery are both cheap. Where I build, I had an agent delete the wrong table once. It was in a disposable environment, so nothing broke, and the agent got more autonomy in that lane the next day. The same agent never got free rein in the migrations that touch real user data. The models did not change between those two decisions. The blast radius did.
IBM's guide on AI in product development frames the direction the same way: the trend is toward agent systems that support human judgment rather than replace it, with guardrails woven in as governance, not as an apology for guessing wrong. The tooling industry keeps promising self-driving products. The orgs running the technology keep buying copilots. Both groups are looking at the same capability and the same math.
Where can software teams give agents autonomy first?
Use the two-variable test: failure cost and reversibility. Autonomy goes where failure is cheap and easy to spot and undo. Take it away everywhere else.
Concretely, that means agents get free rein on:
- Expensive-to-write walls of straightforward wiring — repetitive, verifiable, low-stakes
- Diffs and feature branches in a sandbox — cost is near zero, undo is one command
- Regenerating anything measurable against an eval — the gate catches the failure you would have caught
And the agent keeps a human decision point for anything that ships, touches stores people trust, or spends money. That boundary is not a feature of immature tooling. It is the product shape of the era — I argued the interface version in Agentic AI needs a permission interface: the most useful UI an agent can have is one that makes its reach visible and asks before it crosses a line.
How do you earn more autonomy for an agent?
Ship it as a copilot and let the record promote it. For each recurring task, track two numbers: how often the output needed a change at review, and how often a miss would have escaped review unnoticed. Those numbers decide the leash length, not the demo.
The SimScale teams that gave pass/fail authority to AI at design gates did not do it because a board post told them to. They did it because the pass/fail call sits downstream of a measured value with a defensible threshold. Software teams can build the same structure — evals as the gates, humans as the auditors running the audit frequency.
That is what the demo culture keeps missing. The autonomy everyone shows in a video runs until the first weird edge case. Autonomy you earned from a review record runs for years.
Frequently asked questions
Consequence, not capability. In SimScale 2026 survey of 350 engineering leaders, AI copilots ran at 67-76% adoption across product development stages while fully autonomous agent deployments sat near 10%. When a wrong call affects product performance, safety, or compliance, teams keep a human in the loop. Autonomy gets deployed where failure is cheap.
About the author
mosh
mosh is a product designer for growth, working with design thinking and ever-improving design systems. What matters: fixing conversion, whether in B2B dashboards or direct-consumer apps.
Keep reading
- Escape Ludo: game design
A covid quarantine project. Sprite design, character formation, levels, and inventory UI for a multiplayer Ludo game.
- Go Laundry: service booking platform
One platform to book cleaning services in Qatar. Art-directed brand mascots, app UI, and UX research.
- SaaS activity tracking: designing an admin log teams trust
Admins needed to see every team action in one place. Research with two managers and eight user stories turned a confusing log into filters, search, share, and export.