How we work

Build. Run.

Every engagement leads somewhere deliberate: a platform that works, and someone accountable for keeping it that way.

BUILD

Scoped work orders

We build in fixed-fee work orders with acceptance criteria. You know the price before we start. One client relationship has compounded through 122 of them. You always know what’s being built, what it costs, and when it’s done.

RUN

A standing retainer

Monitoring and alerting, incident response, monthly security triage, upgrades, and an ongoing budget for making things better. It keeps platforms alive and improving, and it is staffed and priced as engineering.

Before either If it isn’t yet clear which you need, a Platform Health Check is a short, fixed-scope look at what you have: architecture, reliability, integration debt, and where AI genuinely fits. You get an engineer’s honest read and a prioritised plan, whether or not you build with us.

Inherited platforms

We’ll run what your last partner built.

Plenty of studios ship and vanish. We do the opposite: we take over live platforms - other people’s code, mid-flight, documentation optional - and make them dependable. We’ve done it with a national retailer’s inventory systems, a health marketplace’s engineering, and a device fleet’s entire cloud estate. Some platforms we run, we built. Others we took over. Both get the same standard.

AI, inside our own delivery

Engineering, multiplied.

AI makes each of our engineers several. That’s why a team our size runs national platforms. It writes code and tests inside real client work; it triages security findings across whole codebases in a sitting. And every line it touches is reviewed by seniors who know what good looks like.

HUMAN IN THE LOOP The developer - a person Sets intent and acceptance criteria · reviews outputs · approves and merges THE THREE AI SURFACES PLAN & REASON Assistant in the browser, connected to real code, issues, errors, quality data. BUILD Agent in the editor and terminal, executing changes inside the repo. REVIEW First-pass review on every pull request. Always comments. Never approves. THE DELIVERY LOOP · ONE TASK PER BRANCH ISSUE PLAN BUILD PULL REQUEST FIRST REVIEW HUMAN GATE MERGE · CI · OBSERVE THEN THE NEXT TASK GOVERNED TOOL ACCESS One company identity, single sign-on, per-tool token scopes. SOURCE & PRS · RW CODE QUALITY · RW ERRORS · RW STORAGE · RO IDENTITY · RO EMAIL · RO OUR OWN RAILS Self-hosted, ephemeral CI runners - a clean workspace for every job. At runtime, every agent action passes a policy check: allow, deny, or ask a human. NOTHING AN AGENT PRODUCES IS TRUSTED UNTIL IT BUILDS, PASSES TESTS AND WORKS IN THE RUNNING PRODUCT.
How we build - humans command, agents execute, humans release.

How a task actually ships

One task per branch · no agent approves its own work

  1. 01 · Intent

    An engineer frames the task and what “done” means. Humans set direction; that never changes.

  2. 02 · Plan

    AI reasons over the real context: the actual code, issues, errors and quality data.

  3. 03 · Build

    An agent writes the change, tests included, on its own branch. Nothing it produces is trusted yet.

  4. 04 · First review

    Automated review comments on every pull request. It always speaks; it never approves.

  5. 05 · The human gate

    A senior engineer reviews and merges. Every merge carries their name.

  6. 06 · Run Running in production today, by us

    Built, tested, observed in the running product. Then the loop starts again on the next task.

The rails it runs on

Governed access

Every AI tool signs in with one company identity, scoped to exactly what it needs: read-write where it has earned it, read-only where it hasn’t. Each tool carries its own credentials.

Our own rails

Continuous integration runs on our own clean-room runners, and quality gates only ratchet upward: test coverage climbs and cannot slide back.

Guardrails at runtime

When what we ship is itself agentic, every agent action passes a policy check - allow, deny, or ask a human - with an approval inbox for anything risky.

AI, built for clients

AI you can run.

Anyone can train a model. The part that decides whether AI becomes an asset or an incident is everything around it, forever after. We implement AI the way we implement everything: built properly, then run properly.

  • Check the data at the door. Models fail quietly when their input drifts. We validate and quarantine data before it reaches a model, so bad input raises an alert before a model ever sees it.
  • A model without a paper trail is a liability. Every model we run is versioned, its training data reproducible, its outputs traceable. When someone asks "why did it say that?", there’s an answer.
  • Same model, same answer, everywhere. The model that was tested is - exactly - the model that runs, whether it lives in the cloud, in a store, or inside a sensor.
  • Watch for drift like you watch for downtime. The world changes under every model. A confidently wrong model is worse than a down one - so we monitor for it the way we monitor uptime.
  • Inference where the data should live. Not every model belongs in someone else’s cloud. We run models locally - on devices, on premises, on hardware we own - when privacy, sovereignty or cost says so. Data classification decides which model sees which data.
FROM RAW DATA TO AN ANSWER YOU CAN STAND BEHIND DEVICES IN THE FIELD STORES & SYSTEMS PEOPLE & APPS CHECKED AT THE DOOR Validated before any model sees it QUARANTINED an alert, not a wrong answer CONDITIONED Schema enforced - shaped exactly as the model was trained DETERMINISTIC INFERENCE Pinned runtime - same model, same answer, everywhere MODEL REGISTRY versioned · reproducible AN ANSWER YOU CAN STAND BEHIND Traceable to its inputs and its model version DRIFT WATCHED LIKE UPTIME WHERE IT RUNS - BY THE DATA’S CLASSIFICATION, NOT BY CONVENIENCE CLOUD ON PREMISES ON DEVICE Sensitive and regulated data infers locally. A CONFIDENTLY WRONG MODEL IS WORSE THAN A DOWN ONE.
AI you can run - built properly, then run properly.

Working with us

One bar, no bench

You pay for engineers who have done this before. The people you meet are the people who build it, and the people who run it.

Measured in years

Our best client relationships are measured in years. We work inside your context: your tools, your stores, your regulators.

Your IP, your platform

What we build for you belongs to you: code, documentation and the knowledge to hold it. We earn the run work; we don’t hold it hostage.

Bring us the platform.

One conversation is usually enough to tell whether we should build it, run it, or take a fixed-scope look at it first.

Talk to an engineer