Software. AI.
Connected systems.
Whichever it takes.
Most real projects don't fit cleanly inside one discipline. They need a web app and a model that reads your data, a dashboard and the sensors feeding it, an automation and the infrastructure to run it. We build across them and own the gaps where they meet — and ship the result as one running system.
your team
lives in.
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 with real design behind them, not just function. 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.
the right tool.
AI used because it's the right tool for the job — not because it's the headline of the quarter. Private AI that runs on your own documents and answers from them, showing its sources. Automations and custom agents that take repetitive, multi-step work off your team — wired to your own tools, with skills you define and a human in the loop. Copilots grounded in your documents. Computer vision running on-site, tuned to the subject at hand. 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.
meets the
physical world.
When a build has to read the world or drive something in it — a sensor, an edge box, a device on a network — we connect the physical layer to the software as one system. Off-the-shelf parts where they fit, their data pulled into one place, and the logic running on a box on-site so it keeps working without the cloud. When a build truly needs custom electronics, we spec it and get the boards fabbed through partners. Integrated, not bolted on.
The device is the variable. The principle — the physical layer integrated into the software, not bolted on — 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 model talks to a sensor talks to an install script talks to a network. The boundary between disciplines is where most teams lose months. RioLabs ships across the boundary — one team that owns the whole arc.
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.