An AI agent picks up a firmware task on a connected product: cut the time a device takes to reconnect after a Wi-Fi drop. As it works, it runs the cross-domain scenario suite. The suite flashes the build to a test device, drops the network, watches the device reconnect, and checks that telemetry resumes in the cloud backend and that the app shows the device back online.
The first run fails, because the cloud session doesn't resume. The agent reads the result, fixes the session handling, and runs the scenario again. By the time an engineer looks at the change, it has already validated itself on real hardware, against the current app and a live staging backend.
From first line of code to verified change: a few hours.
The code half of the transition has already arrived. Wherever teams put AI agents to work, firmware, app, and cloud changes that took weeks to write now take days or hours. The half that decides who benefits is everything after the code: how a change gets verified, approved, and shipped.
The half that decides who benefits is everything after the code: how a change gets verified, approved, and shipped.
What does software-company speed look like for connected products?
Shipping at agent speed runs on continuous delivery underneath: automated tests on every commit, continuous deployment, a change going from code to production in hours. Pure software companies laid that track years ago. So when the agents arrive, they slot onto a path that is already paved.
That does not make the move automatic even there. Handing real work to agents is a shift for a pure software company too. But the groundwork is in place, so the shift is shorter: the pipeline already carries a change from commit to production without a human gate in the middle, and an agent is one more author feeding it.
The org chart had already followed that workflow. Developers own the full life of their changes, and automated tests stand in for the manual verification gates that used to sit between a change and production.
Connected products start further back, and they have hardware in the loop on top. But the shape is the same. The flows that cross firmware, app, and cloud get exercised on real devices as part of the work, not saved for a gate at the end. Agents use the scenario suite as they work, so the pull-request gate just confirms what the development loop already showed.
Agents use the scenario suite as they work, so the pull-request gate just confirms what the development loop already showed.
So the verification role changes. Verification engineers design the cross-domain scenarios, keep the test rig running, and read the trends across thousands of automated runs. The running itself is continuous and automated. Software verification made the same shift a decade ago, from running tests to building the system that runs them. Connected product verification is making it in months, because the agents set the pace.
Why do AI agents make the release process the competitive gap?
Take two connected product companies. Same market, same AI agents, code coming out at the same rate.
One reorganized around continuous delivery: cross-domain verification inside the workflow, an automated release process, the verification team focused on scenario design. The other kept its old structure, a weekly integration pass, a manual verification gate, a monthly release train, all built for code that took weeks to write.
The first company ships verified updates every week. A customer-reported bug is fixed and deployed within days. New features reach the market in weeks, because every step between code and customer runs at the pace the agents set.
At the second company, the same volume of code piles up behind the monthly gate and ships in large batches.
The agents are equally productive at both. The difference is organizational, and it shows up straight away in the market: release cadence, fix turnaround, feature lead time.
Producing code at software-company rates is now within reach of any connected product company that adopts agents. Shipping at those rates is the part each company decides for itself, through the release process, the shape of the verification function, and how soon verification moves into the development workflow.
The agents changed how fast code gets written. The release process decides how fast verified product reaches the customer, and the companies that line the two up are setting the pace for connected products.
See how Groundrun keeps firmware, app, and cloud verified together at the pace your agents work, on the platform overview.