Groundrun is the validation step inside agent-driven development of a connected product. Your flows run on your own hardware, with your app and your test cloud in the run, and the AI coding agents invoke them from inside the loop where they work.
Move faster: with Groundrun, you develop at the speed of agents
Agents write code at machine speed, but code has to be validated before anyone trusts it. Groundrun gives you in-loop validation: when an agent changes the firmware, the app, or the cloud, that change is run on real hardware at the speed it gets developed.
It flashes its build onto a device on the rig, walks the pairing flow with the real app against your test cloud, reads the step that failed, fixes it, and goes again. All of it inside the same working session.
Whatever answers the does-it-work question is what sets the shipping pace. On the rig it comes back in minutes.
You can develop with agents faster than your organization can trust the result.
You can develop with agents faster than your organization can trust the result.
Groundrun is where that gap closes. The company ships at the pace the agents work.
Be ambitious: with Groundrun, your next move will always be bold
Move the whole product line onto a new chipset. Replace the radio. Rewrite the app on a new data model. With Groundrun in the loop, work like that is work you can trust the agents to do.
It reaches into every part of the product at once, so what matters is knowing the whole thing still works while it is half rebuilt. The scenarios walk the flows your customers walk, on the real devices, the whole way through the rebuild. An agent that breaks the claim flow finds out while it is still the one holding the change.
Battery life looks like a firmware job, while what drains a device is how often the app and the cloud wake it up.
Battery life looks like a firmware job, while what drains a device is how often the app and the cloud wake it up.
A notification that fires twice, a cloud that retries on a short timer, a sync interval set at launch. Current draw is measured on the rig, so an agent can change the app's subscription, run the scenario, and read the milliamps back. It's a whole-product problem an agent can hold in one loop.
Be confident: with Groundrun, you always know your product works
When your newest release reaches your customers, you know that onboarding has already run hundreds of times that month, on real devices, against every version of the app and the cloud the team produced.
And the flows carry the conditions your product meets in the field. Power cut in the middle of a firmware update. Connectivity dropped while a device is being claimed. The scenario stages the condition and checks the path back.
- PASS Phone scans the code, opens a secure connection, hands over credentials
- PASS Device joins the network and appears in the account
- FAIL Power cut mid-update: device returns on the old image, app reports it updated
- Agent has the app read the version the device reports, resubmits
- PASS Power cut mid-update: device returns and the app shows what it is running
The failure comes back with the step that produced it, while the change is still on the workbench.
Play to your strengths: with Groundrun, you focus on what your customers need
Your team knows what your customers need and want. Which feature they keep asking for, which flow they walk every morning, what would make them recommend the product to someone else.
Agents are good at the part underneath, and fast at it: writing the change, running it against the real product, reading what broke, and going again until the flow passes.
So the time goes where the knowledge is. What the product should do and where the quality bar sits stay engineering decisions, while the agents make the product do it.
Things keep improving: with Groundrun, improvements compound
When new code is written and found to work, the code that was already there keeps working. The scenarios make sure of it.
The onboarding flow mapped at the start keeps walking every version of the product that comes after it. And it travels: a scenario names the device it needs, so when the product line gains a variant, the flows the last product earned come with it.
The product line grows, and the coverage that took months to build grows with it.
Everything written down: with Groundrun, the system documents itself as it changes
Agents are great with code, and work even better with a written description of the system. Decisions get written down as they are made, the same way the work gets validated as it lands.
The agents work on a documentation tree alongside the code, so a change that lands updates the document describing that part of the system, and the document is reviewed with it.
Somebody joining next year reads it instead of asking, and a decision made two years ago can be found. The agents read it before they touch anything, so the better the ground truth is written down, the further they get on their own.
The sky is the limit
How much of the product the agents can take on is set by how much of it can be validated. Groundrun is what moves that line.
It starts where you put it. The flows come from your team, so we sit down together, map how your product is actually used, and agree which of those get validated first. The rig is built around them, with the boards your product ships, your app on real phones, and your test cloud behind it.
Every flow that joins the map is more of the product the agents can be handed. The ceiling is what the loop around them can check, and a loop is a thing you can build.
Start with the platform overview.