Services

Five engagement types. Each is scoped on the call, priced after the scope, and shipped against a clear definition of done. No retainers we can't justify, no pricing page that anchors before we've talked.

• AI and ML systems: RAG, agents, evals, and model serving

  Production pipelines, tool use, guardrails, evals, and a cost ceiling you set on purpose.

  The interesting work is rarely the model. It's the ingestion path, the eval set you trust, the guardrails, the cost ceiling, the fallback when the API has a bad day. We build the system around the model so the model can be wrong without taking the product down. Python, PyTorch, Hugging Face, FastAPI, plain SQL where it earns its keep.

  What done looks like: A model in production with eval coverage you trust, a documented cost profile, and an honest answer to "what happens when it's wrong."

• Agent systems for software delivery

  Contract-first agent fleets, autonomous coding workflows, and the human-in-the-loop gates that keep them merging cleanly.

  The pattern behind our own agent-driven delivery system: small, contract-defined units of work that agents pick up in parallel, with humans on the merge button instead of the typing keyboard. We set it up against your codebase (the instruction files the agents read, the task contracts, the checks that gate a merge) and hand back the runbook. The interesting work is in the contracts, the gates, and the failure modes. We've spent real cycles on all three.

  What done looks like: An agent workflow set up on a real branch of your repo, with every change going through your review gates before a person approves the merge, plus the documentation your team needs to keep it healthy after we leave.

• Data science and decision systems

  Turn the data you have into the decisions you need. Analytics, decision-support surfaces, and the discipline of asking the right question first.

  The hard part isn't the dashboard. It's deciding which number a leader actually has to look at, and trusting how the number got there. We default to plain SQL and small models, and we know when the problem actually calls for a larger one. That foundation is decision-support work in healthcare and manufacturing, carried forward with an AI/ML stack underneath.

  What done looks like: A decision surface a real leader uses without translation, a documented data lineage, and a measurable change in how fast a call lands.

• Usability and accessibility audits

  Task-level interaction modelling, expert heuristic review, and a WCAG scan on every step. What we measure and what we model are reported separately.

  We run your product as a specific person would: a named persona with a device, a connection speed, a language, and a reason to be there. Every step is captured and scanned for accessibility violations with axe-core, not just the steps we thought to check. Predicted effort is modelled with the Keystroke-Level Model (the Card, Moran and Newell operators), and the interface is reviewed against Nielsen's heuristics. We do not read effort, confusion or frustration off a user, and we do not present a model as a measurement. Where a person would hesitate or give up is a reviewer finding tied to a specific step, labelled as such. This is the method; there's no public example audit on the site yet.

  What done looks like: A findings list where every item cites the step and the evidence behind it, each marked measured or modelled, ranked by how likely it is to stop someone. Everything is re-checked against the raw evidence first, and whatever does not survive that check is discarded rather than padding the count.

• AI safety, alignment, and ethics consulting

  Threat modeling for autonomous systems, the human-in-the-loop line, and what to never automate. Drew's research thread brought into the engagement.

  The questions about how autonomous systems should and shouldn't be built belong upstream of the code, not in a press release after the incident. We help draw the line on which decisions are eligible for automation at all, audit-trail the ones that are, and design the kill switches before they're needed. It's engineering that takes the failure modes seriously.

  What done looks like: A documented safety posture for an AI feature your team is shipping, an audit trail your compliance team can read, and a defensible answer to "who's responsible when this thing is wrong."

Not sure which of these you're asking for? That's fine, most clients aren't. Tell us what you're trying to do and we'll name the engagement type for you.