AI & data
End-to-end AI builds for teams who know what the system must do and need it working against real data, real users and a real cost ceiling. You keep every part of it.
The model call is the smallest file in the repository. What takes the time is everything around it: getting data out of the systems it actually lives in, shaping it so retrieval returns the right passage rather than a plausible one, and fitting the result into an existing product with its own auth, interface and latency budget. AI features fail differently from ordinary software — no stack trace, just an answer that reads well and is wrong — so the failure has to be designed for rather than discovered in support tickets.
We build evaluation before we build features. The first artefact on any engagement is a graded dataset your domain experts sign off — the questions that matter, with the answers they would give — versioned alongside the code and re-run in CI on every prompt, index and model change. Without it nobody can tell a genuine improvement from a lucky sample, regressions surface as user complaints weeks later, and every release becomes an argument about vibes rather than a number.
| What is true of this work | What it forces | What we do about it |
|---|---|---|
| Model output is non-deterministic | Tests cannot assert exact strings | Graded golden set in CI |
| Token spend scales with adoption | Success raises the monthly bill | Per-task budget ceiling and caching |
| Source schemas change without notice | Indexes silently go stale | Scheduled re-index with diff alerts |
| Retrieval crosses permission boundaries | Answers can leak restricted documents | Filters applied at query time |
| Providers deprecate and change behaviour | Working prompts quietly regress | Model access behind one interface |
Ingestion, cleaning, chunking and indexing over the sources that hold your knowledge. Hybrid search with reranking, permission filters at query time, and a re-index path for when schemas move.
Permission-filtered retrieval serviceA versioned golden set, graded rubrics per task, and regression gates in CI. Offline scores plus sampling of live traffic, so a quality drop fails a build rather than a ticket.
Versioned eval harnessThe runtime around the model: streaming, request queuing, timeouts and idempotent retries, semantic and exact caching, and degradation to a cheaper path when the primary provider slows down.
Provider-agnostic inference layerWhen prompting cannot hold a format, or volume makes frontier pricing untenable, we build the training set, tune a smaller open-weight model, and score it on the same harness.
Tuned model and datasetInput and output policy checks, schema-validated structured output, confidence thresholds that route to a person, and an approval queue for anything that moves money or writes to a system of record.
Human-review approval queueRequest traces spanning retrieval, tool calls and generation, with token counts attributed per feature and tenant. Budget alerts and per-key rate limits cap a runaway loop in minutes.
Per-feature cost dashboardsA paid fortnight, credited against the build: where the required data lives, how clean it is, who may see it, and a few hundred real inputs with the answers your experts accept.
You getData map and versioned eval set
One complete path end to end — ingestion, retrieval, generation, guardrails, UI — for a single task, in front of real users behind a flag. First demo lands within fourteen days of the build starting.
You getWorking slice on your data
The unglamorous middle: caching, fallbacks, rate limits, permission propagation, structured logging and cost attribution per request. We run load and adversarial passes, then tune retrieval against measured scores rather than instinct.
You getLoad-tested build with cost dashboards
We ship behind progressive rollout with a documented rollback, then transfer the system: architecture walkthrough, a runbook for the failure modes we hit, and a session teaching your team to extend the harness.
You getRunbook, rollback plan, 30-day warranty
Retrieval first — fine-tuning only for format or unit cost
Your knowledge changes weekly, needs citations, and must respect per-user permissions — none of which survive being baked into weights. Tuning earns its place when prompting keeps drifting off a required format, or when distilling a settled task into a smaller model cuts unit cost.
We’d choose otherwise whenthe task is high volume, stable in shape, and under a tight latency budget
Buy the commodity layers, build what your quality depends on
Vector stores, tracing, gateways and annotation tools are commodities — writing your own is a year you will not get back. But retrieval strategy, domain rubric and guardrail policy encode how your business decides things, and a platform that owns those owns your quality ceiling.
We’d choose otherwise whenyour workflow genuinely is generic — off-the-shelf support deflection, with no domain judgement to encode
Only when regulation or sustained volume forces it
Self-hosting buys data residency and a flat GPU bill; it costs an on-call rotation, capacity planning, and quality that trails the hosted frontier by months. Unless traffic keeps an accelerator busy around the clock, the API costs less than the engineer keeping the cluster alive.
We’d choose otherwise whenyour data cannot leave the building — then we design for self-hosting from the first sprint
Fixed pipeline until the task provably needs branching
A deterministic chain is testable, cheap and debuggable; an agent that plans its own steps multiplies latency and token spend, and turns every incident into archaeology. For a lookup with one right answer, a planning loop is a liability, not a feature.
We’d choose otherwise wheninput genuinely varies in shape — multi-document comparison, conditional lookups, recovery from a failed tool call
Fixed price against a scope we define together in the audit, so the build number does not move. What moves budgets on AI work is the running cost afterwards: token spend that scales with adoption, re-indexing as sources grow, and engineering time to hold quality steady through provider changes. We size that envelope during the audit and instrument it.
You do — code, prompts, retrieval indexes, evaluation datasets and any weights produced by tuning on your data all transfer to you at handover, in standard exportable formats. We keep no residual licence, and your data is never used outside your project. Third-party services stay under their own terms, and we name each one before adopting it.
Because acceptance is a number on a dataset you own, not a demo. The golden set is agreed before we build, graded by your experts, and every release reports its score against the previous one. Sign-off is the harness passing thresholds you set on real inputs, including the awkward cases your team chose to break it with.
You get a trace, not a mystery. Every response carries the retrieved sources, the prompt version and the guardrails that fired, so a wrong answer is reproducible within minutes. The design assumes wrongness: high-stakes actions queue for human approval, low-confidence responses hand off rather than guess, and the failing case joins the eval set so it cannot silently return.
Yes, and the ongoing load is smaller than teams expect. Steady state is re-indexing when sources change, reviewing flagged cases, and re-running the harness before any prompt or provider change ships. The stack is ordinary — Python, Postgres, containers, Terraform — so maintainers need backend skills, not a research background. Handover is a scheduled phase, not a final email.
Thirty minutes with the engineers who would build it. You leave with a scope, a timeline and a fixed price — or an honest no, and the reason why.
