What we build

One discipline. Every surface.

The method doesn’t change. Immerse, spot, execute. What changes is where the system lands: a web platform, a phone in the field, a machine on the bench, or hardware that never touches the internet. Everything below ships through the same forward-deployed engagement, with the same gates. The tooling behind the gates is going public as licence reviews clear.

01 · Web platforms & production AI

The work we’re known for.

Most of what we ship lands here: web platforms with AI in the load-bearing path. That phrase has a test. Take the model out, and the workflow should stop. Every build is multi-tenant, with isolation enforced at the database. We measure the result against the real workflow it replaces.

Next.js
React
Postgres
RAG

The default engagement is a 2-hour immersion, then a 6–10 week client-owned build.

Request the 2-hour immersion ›

What we ship

Operational platforms
Consoles that replace the spreadsheet sprawl and become the system of record.
AI in the loop
Retrieval and generation run inside the workflow. A person reviews the output before it becomes the record.
Client portals
Isolation between tenants is enforced at the database, and a harness re-proves it on every commit.
Production RAG & data pipelines
Grounded answers over your own corpus, with the citations attached.

Time to production: 6–10 weeks; Immersion to handover

Isolation: RLS-enforced, live; Harness verdict, not a badge

Residency: Onshore; Data stays in-country

02 · Mobile applications

The same system, in the field.

Field teams don’t work at desks, so the platform goes with them: a React Native or native app that tolerates losing signal and runs on the same governed backend as everything else we ship.

React Native
iOS
Android
Swift
Kotlin

The 2-hour immersion decides whether mobile is the right place to spend the build; the rest of the engagement runs the same way.

Request the 2-hour immersion ›

What we ship

Cross-platform apps
One React Native codebase can cover iOS and Android. Whether it should is a trade we weigh in the immersion.
Native Swift or Kotlin
Performance and deep sensor access are the usual reasons an app needs the platform’s own tools.
Offline-first field tools
They have to survive a full day with no signal. Everything captured offline must arrive intact once coverage returns.
Mobile faces for our platforms
The same backend and permission model as the web platform, so revoking someone’s access revokes it on the phone too.

Backend isolation: Live verdict; Same RLS harness, run in CI

Models: Zero-retention; No training on your data

03 · Desktop applications

It runs where the files live.

Heavy files and local hardware keep some work on the desktop, a long way from any browser tab. For that work we ship applications on Windows, macOS, and Linux. The range runs from a tray utility that removes a daily annoyance up to a full working environment.

Windows
macOS
Linux
Tauri
Electron

Scoped in the same immersion and shipped with the same handover, so your team can run it without us.

Request the 2-hour immersion ›

What we ship

One codebase, three desktops
A web-stack shell in Tauri or Electron. The pay-off is iteration speed.
Native Windows, macOS, Linux
Deep OS integration or raw performance sometimes rules out a shell. Those we write natively.
Hardware- and file-adjacent tooling
Instruments, local file systems, and the software between them.
The platform, installed
Desktop clients for the systems we build, with one governed backend behind them.

Handover: Client-owned; You run it without us

04 · Sovereign software

AI that never leaves the building.

For some clients, onshore isn’t enough. The rule is that data never leaves the premises, which also rules out any model that phones home. So inference runs locally on hardware you control, and nothing in the data plane sits outside infrastructure you own. We build the system, then hand it over with the keys.

Open-weight LLMs
On-prem
Client cloud
Air-gap capable

It starts like every engagement: two hours in the room with the workflow and the constraint. We build sovereign only when sovereignty turns out to be the binding one.

Request the 2-hour immersion ›The full sovereign picture ›

What we ship

Local LLM inference
Open-weight models served on your hardware, and a data path that contains no external inference call.
Your data plane
On-prem or your own cloud tenancy. We never take custody of the data.
Air-gap capable
Some environments cut the uplink entirely. The system is designed to run that way, fully disconnected.
Client-owned, end to end
At handover the infrastructure, the code, the models, and the keys all transfer to you.

RLS tenant-isolation harness

checking

latest run loading…

Live status ›

What we won’t show you

We won’t show you a logo wall of sovereign deployments. We don’t trade on client names. What we can show is the posture we hold ourselves to, live: the isolation harness green on every commit, residency and retention in writing, the subprocessor register down to the last entry. A sovereign build inherits every control on that list.

Residency: Onshore today; ap-southeast-2, or your hardware

Models: Zero-retention; No training on your data

Isolation: Proven on every commit; Result written to the database

Subprocessors: Nothing hidden; The full register, published

Engagement

Two ways into one method.

The default

Forward-deployed

We embed with your team, find the highest-leverage problem, and ship it: 2-hour immersion to client-owned handover in 6–10 weeks.

See how we work ›

Elapsed · 6–10 weeksOwnership · ClientResidency · Onshore

For founders

Startup builds

No team to embed into yet? For funded startups we build the product end to end: same engineers, same gates, same client-owned handover. It still starts with the immersion; the work on the table is your product.

Request the 2-hour immersion ›

Name the surface. We’ll find the lever.

Request the 2-hour immersion ›