groundrun.io
Platform

Groundrun is the validation layer for AI coding agents, specifically tailored for connected products.

Groundrun is a software platform that validates code written by your AI coding agents, so your connected product keeps working. Groundrun flashed your AI coding agents' changes directly on your hardware, with your app and your cloud, end-to-end. The result: confidence that your system works, always.

Line drawing: a laptop running the team's coding agents, beside a runner with two devboards and a phone cabled to it.
What changes

Trust your biggest moves on the roadmap with the agents.

On your roadmap What changes across the product
Move the product line to a new chipset
The firmware under every product changes, along with the timing the app and your cloud were built around.
Rewrite the app
Every flow runs through new screens, against the same devices and the same cloud.
Move from Bluetooth to Wi-Fi
Onboarding is new in three places at once: the app's setup screens, the credentials in the firmware, and the account claim in your cloud.
Make your product remotely reachable
Add a hub to your system.
Launch a second product on the same app and cloud
The app and your cloud serve two products at once.
Improve battery life
How long a battery lasts depends on how often the app and your cloud wake the device, so the agent measures the current with all three running together.
Upgrade a vendor SDK
Make sure everything keeps working with the latest vendor fixes in place.

Work like this keeps arriving for as long as your product ships.

The hardware in rigs

Your customer's experience, reproduced on your hardware.

Your boards and a phone with your app plug into a runner, a Raspberry Pi-class computer that flashes the firmware, drives the phone and checks your test cloud.

Line drawing of a desk rig: two devboards and a phone, each cabled to the desk runner, with a laptop running a coding agent behind them.
Desk rig. On every developer's desk.
Line drawing of a lab rig: five devboards and a phone cabled to a USB hub, the hub cabled to the lab runner, and the runner and the hub plugged into a power switch. Below, two laptops running coding agents and a CI pipeline run on the same rig.
Lab rig. A power switch power cycles the entire rig between each run.
Rig
Power cycles the rig and flashes the new image onto the boards
They come up cold, running what is under test
App
Pairs the device over Bluetooth from the phone on the rig
The device appears in the app
Cloud
Takes the device's claim against your test cloud
The account owns it, and the app shows it online
Cloud
Sends an update to the claimed device
The device reports the version it is running
App
Transfers the device to a second account
The second account sees it online

A device coming out of the box, step by step. Each step checks what your customer would see at that moment. The record of each run holds the device log, the serial line, the cloud trace, the app screen, the current each board draws, and the timing, together. Groundrun's drivers handle microcontrollers like the Silicon Labs EFR32, the Espressif ESP32, and the Nordic nRF54.

How it sits in your work

The agent works from how your product behaves.

In a typical session the agent flashes its new build onto a board, runs the pairing flow with your app against your test cloud, reads which step failed, fixes the code, and runs the flow again. It can also take a screenshot or a screen recording of the phone to see what the app shows.

The coding agents the team runs today, in harnesses like Claude Code, Codex, and OpenCode, drive the whole system from inside their loop, so a change arrives in your repository already validated on your hardware.

See it on your product

Coverage

Every flow your product runs.

We map your flows with you, in the team's own words. Each one becomes scenarios that run on your hardware: one for the flow as it's meant to go, and one for each condition the product meets in the field, such as the power cutting out while an update installs.

The Groundrun flow builder. On the left, the unboxing flow with the four scenarios it was broken into. In the middle, the sequence a scenario runs through, with a power cut landing part way down it. On the right, the selected step with the conditions the team can add to it.
Flow What it validates
Out of the box
The device is on, claimed, and working in the app
An update arriving
It lands, and the device runs it
A transaction across the product
It completes, and every record of it agrees
The network changing underneath it
The device is back online, and the app shows it
A week of running, then catching up
Everything it recorded arrives, and reconciles
The system

The platform the agents and the team both work in.

Four parts carry your flows from the team's words to the hardware they run on. The team directs what gets validated while the agents drive it as they work.

Flow builder

Your flows, in the team's own words, become the scenarios that run.

Generates the scenarios from each flow

Coordinator

Compiles each scenario for the rig it will run on, picks the rig, and keeps the record of every run.

Starts each compiled run on its rig

Runner

Flashes the boards, holds their serial lines, drives the phones, and works your test cloud through the scenario.

Collects the logs and readings from every run

Supervisor

Switches the power on the rig, so that every run begins on hardware that has just come up cold.

Power-cycles the boards before every run
What you get

Confidence that keeps up with the agents.

Every change arrives with the flows it ran on your hardware behind it.

Get started

Put the whole product in the agents' loop.

Your hardware, your cloud, your app, working together on the rig.

Tell us about your product. We'll map your flows with you and show you what validation inside the agents' loop looks like on your hardware.

Book a demo