AI & Data
Generative AI, minus
the demo theatre
The hard part of generative AI is not producing text. It is knowing when the output is wrong, catching it before a customer sees it, and holding the token bill flat while volume grows tenfold — which is where most pilots quietly stop.
Overview
Generative systems with measured output quality and a bill you can predict.
We have shipped generative features into claims handling, contract review, product cataloguing and internal search across four sectors. The pattern that works is narrow scope, retrieval over your own documents, structured output with a schema, and an evaluation set that a domain expert wrote rather than an engineer.
The pattern that fails is a general assistant with an open text box and no working definition of correct. It demos beautifully, gets used for a fortnight, then quietly stops because nobody trusts an answer they cannot verify. We will push you towards the narrow version, and towards shipping it to twenty users before two thousand.
Cost is an engineering constraint here, not a finance afterthought. Prompt caching, model tiering by task difficulty, retrieval that returns 4KB rather than 40KB, and hard per-tenant rate limits are all design decisions we make on day one, because retrofitting them after launch means rewriting the orchestration layer.
- 11.4s
- Median contract clause review time at Aldridge Risk, from 6 minutes
- 94.2%
- Answer accuracy on the expert-written grading set at launch
- £3,180
- Monthly token spend after model routing and caching, from £9,400
Capabilities
What this covers
Six areas we staff properly. If your problem sits outside them, the honest note at the foot of this page says so.
Retrieval-augmented generation over your corpus
Chunking tuned to your document structure, hybrid keyword and vector search, and re-ranking before the model sees anything. Answers cite the source paragraph so a reviewer can check them in seconds.
Structured output and schema enforcement
Generation constrained to a JSON schema with validation and repair on failure, so downstream systems receive typed data rather than prose to parse. Malformed output becomes an error, not a surprise.
Evaluation and regression testing
A golden set written by your subject matter experts, scored with a mix of exact match, rubric grading and pairwise comparison. Every prompt change runs the suite before it reaches production traffic.
Guardrails and content safety
Input classification, output filtering, prompt-injection defences for any system that reads untrusted documents, and a refusal path that logs the case rather than silently returning nothing at all.
Cost engineering and model routing
Cheap models handle the routine 80 percent, with escalation to a larger model only when confidence or task type demands it. Prompt and response caching typically halve the monthly bill within a fortnight.
Fine-tuning and adapter training
When prompting plateaus, we train LoRA adapters on your labelled examples and compare honestly against the prompted baseline. We have recommended against fine-tuning more often than we have recommended it.
Deliverables
What you get
- Retrieval pipeline with document ingestion, chunking and re-ranking
- Prompt and orchestration code under version control with change review
- Expert-written golden evaluation set and automated scoring suite
- Guardrail layer covering injection, PII redaction and output filtering
- Token spend dashboard with per-tenant and per-feature attribution
- Rollout plan with staged user cohorts and a documented kill switch
Stack
What we build it with
- OpenAI API
- Anthropic Claude API
- Llama 3
- LangGraph
- LlamaIndex
- pgvector
- Qdrant
- vLLM
- Ragas
- Pydantic
- Langfuse
- Redis
Process
How the engagement runs
Two-week increments against a written definition of done. You can stop at any increment boundary and keep everything built so far.
Use-case triage
We rank candidate use cases by volume, cost of error and how checkable the output is. The checkable, high-volume, low-blast-radius one goes first.
Corpus and grading set
Your experts write forty to eighty graded examples of good and bad answers. This is the highest-leverage week of the engagement and we do not skip it.
Prototype and measure
A working retrieval and generation loop scored against the grading set, with token cost per request recorded from the first day rather than estimated later.
Harden and guard
Schema enforcement, injection defences, rate limits, caching and fallbacks. The system should degrade to a search result rather than to an invented answer.
Staged rollout
Twenty internal users, then a department, then general availability, with the grading suite run on live samples weekly and a rollback documented at each step.
When this is the wrong engagement
If the task has exactly one correct answer that a database query can return, generative AI adds latency, cost and a failure mode you did not previously have to manage.
FAQ
Questions we get asked
- Should we use a hosted model API or self-host?
Most enterprises should start hosted and move selectively. Self-hosting on vLLM becomes cheaper somewhere above roughly 40 million tokens a day, and only if you already run GPU infrastructure. Below that, the engineering time costs more than the API ever will.
- How do you stop the model inventing answers?
By constraining what it can say. Retrieval limits the context to your documents, the schema limits the shape of the output, and every claim carries a source reference a reviewer can open. Where nothing relevant is retrieved, the system returns search results and says so.
- Can this work on documents containing personal data?
Yes, with redaction at ingest, field-level access control carried through retrieval, and inference logs that store hashes rather than raw text. We have run this pattern under GDPR with a DPIA and a documented lawful basis, which your legal team signs, not us.
- How long before we see something real?
A measurable prototype in four to six weeks, general availability usually between three and five months, depending on how long the corpus takes to get clean. The corpus is nearly always the long pole, and it is the part we cannot compress by adding people.
Related