Software. Hardware.
Infrastructure. AI.
Whichever it takes.
Most real projects don't fit cleanly inside one discipline. They need a web app and a sensor, an AI model and an install script, a dashboard and a device in the field. We build across them and own the seams where they meet — and ship the result as one running system.
your team uses
on a Tuesday.
The day-to-day software a team actually opens to do its work — built to streamline how the work happens, not to add another tool to the pile. Internal tools that replace the spreadsheet sprawl, dashboards that surface the numbers that matter, APIs that close gaps between disconnected systems, customer-facing web apps that look like a team built them on purpose. Built in whatever stack fits the job — Node/Express, Bun/Hono, Python/FastAPI — and shaped around the operator, not the framework.
The use case is the variable. The discipline — scoped tight, polished, real-user-tested — is constant.
touches the
physical world.
When a build has to read the world or drive something in it — a sensor, a custom board, an edge box, a device on a network — we handle the physical layer and wire it into the software as one system. Off-the-shelf parts where they fit; custom boards we spec and get fabbed through partners where they don't. The system reaches into the physical world — integrated, not bolted on.
The device is the variable. The principle — the physical layer integrated into the software, not bolted on — is constant.
the right tool.
AI used because it's the right tool for the job — not because it's the headline of the quarter. Local language models with retrieval-augmented generation over a real corpus. Computer vision running on the edge, tuned to the subject at hand. Document understanding grounded in cited sources. On hardware our clients own when privacy demands it, in the cloud when that fits better — always with the model on a leash that audits, scopes, and grounds it.
The subject and the corpus are the variable. The principle — grounded, cited, auditable output, deployed where it fits — is constant.
that ships
the system.
The bits that turn a working prototype into a system that runs in production, every day, without us being there. Repeatable installs, private mesh networks, audit logging from row one, role-based access on every surface, hardware provisioning, update paths the client controls. The infrastructure isn't an afterthought — it's the difference between "we built it" and "it's running."
The site is the variable. The discipline — repeatable, auditable, recoverable — is constant.
shipped together.
Most real projects need more than one of the boxes above. A web app talks to a piece of firmware talks to an AI model talks to an install script talks to a mesh network. The boundary between disciplines is where most teams lose months. RioLabs ships across the boundary — one team, one phone number.
This is the build type we exist for — the one where owning the whole arc is the point. Not best-in-class at any one layer; the whole thing built, installed, and supported by the people who scoped it.