Most AI pilots demo beautifully and die on the way to deployment. I build the ones that don't.
Query success rate on a natural-language analytics system, up from under 60%. Four weeks, including the evaluation harness that proved it.
Measured against a fixed 35-case suite, six domains.Demos are tuned for the happy path. Production isn't. With no evaluation harness, nobody can say whether the thing is good enough, so nobody signs it off. It stays a prototype indefinitely and everyone quietly stops mentioning it.
"It feels faster" does not survive a budget review. If value wasn't instrumented at the start, the programme has nothing to defend itself with at exactly the moment it needs more funding to scale.
Enterprise transformation frameworks are overkill for a 300-person business. Startup-speed delivery is reckless inside a regulated one. Most AI advice is sized for an organisation that isn't yours.
Plenty of people can build an impressive prototype. Far fewer can get one through a procurement cycle, a compliance function and a sceptical engineering team, and still have it running six months later.
Eddie Forson · founder, Kiseki Labs
Before any design decision, I build the evaluation suite: the set of real questions the system has to get right. Every argument after that gets settled by measurement rather than seniority. It is the single highest-leverage week in any engagement and it is almost always skipped.
A 400-person logistics operator and a regulated financial institution need different things, and neither needs what a Series A startup needs. Governance, delivery pace and architecture get matched to how your organisation actually makes decisions and passes review.
Verification layers, self-healing retries, CI, dependency hygiene, a real test suite. None of it is interesting. All of it is the difference between a system your teams depend on and one they route around within a quarter.
Documentation and knowledge transfer are scheduled deliverables. Your engineers should be able to extend the system without me in the room. Consultants who engineer dependency get renewals. They don't get referrals.
A financial services provider onboarding self-employed drivers. Every applicant submitted a form plus supporting documents. An operations analyst then verified each one by hand — reading the documents, cross-checking the details against what the applicant had typed, confirming declared income against actual bank activity. Thirty to sixty minutes per applicant, and the queue only ever grew.
Analyst time per applicant. The saving compounds with volume — and it removed the queue as a constraint on how fast the business could sign people up.
Manual review of every application, document by document. Slow, inconsistent between analysts, and impossible to scale without hiring. The work was necessary — it was a regulated check, not busywork — which is exactly why throwing it away was never an option.
A pipeline that ingests the submission and its attachments, extracts the fields from each document, and reconciles them against each other and against what the applicant entered. Anything that doesn't match is flagged with the specific discrepancy named and routed to a person.
Review time fell from 30–60 minutes to about five. The more useful change was qualitative: the team stopped hunting for problems and started resolving them. The system says what doesn't reconcile, not merely that something doesn't.
Why this should matter to you. This is KYC. The documents differ by industry, but the shape does not: extract from unstructured submissions, reconcile across sources that should agree, escalate the exceptions to a human who now has a specific thing to look at. Any onboarding, claims or compliance function running a manual review queue has this exact problem.
And it never approves anyone. The system narrows the work; the judgment stays with the analyst. That was a deliberate design constraint, and it is the reason the thing was deployable inside a regulated process at all.
Human-in-the-loop by design, not by omission.A platform that let users ask questions of their spreadsheet data in plain English. After months of development it was still returning malformed output, schema validation errors and runtime exceptions on roughly 40% of queries, at an unpredictable 20,000–50,000 tokens a time.
Measured against a fixed 35-case evaluation suite. Zero syntax errors reached execution.
Foundations before architecture: dependency management, linting, CI via GitHub Actions, documentation. Nothing clever.
Built the evaluation suite — 35 cases, six business domains — then used it to settle the core architectural question on evidence: custom DSL, or direct Python generation.
Production pipeline: four specialised agents — planner, code generator, verifier, summariser — with self-healing retry logic.
Integration, documentation, and knowledge transfer to the engineers who would own it afterwards.
Why this should matter to you. The client was small. The problem isn't. Every organisation past a certain size has operational data sitting in spreadsheets that nobody can query without opening a dozen files by hand: finance reporting, supply chain, claims, procurement. The engineering that makes an answer trustworthy is identical at four hundred people as at forty. So is the discipline of proving it.
Fixed scope, fixed fee, defined end date. Straightforward to put through procurement.
| Engagement | Duration | What you get | Right when |
|---|---|---|---|
Opportunity DiagnosticFixed fee |
2–3 weeks |
|
The mandate is clear but the target isn't. |
Pilot to ProductionFixed fee · most requested |
4–8 weeks |
|
Something already half-works and needs to ship. |
Advisory RetainerMonthly |
Ongoing |
|
The decisions are frequent and expensive. |
Team EnablementPer cohort |
4 weeks |
|
Your teams need to use AI, not be briefed about it. |
They are the right questions, and they are usually asked late. Here are the answers before you have to ask them.
Every engagement begins by defining what correct means and building the test set that measures it. Accuracy is stated against a named ground truth and a known test set, or it isn't stated. A system whose quality can't be measured isn't ready to carry a business process.
Data boundaries are a design input, not a retrofit. Which providers see what, retention terms, regional processing, and what never leaves your perimeter are decided at architecture time and written down for your security review.
It will be, sometimes. Systems get explicit verification layers, defined failure behaviour, and human review wherever being wrong is expensive. The goal was never a system that never errs. It's one that fails visibly instead of silently.
You own all of it: code, tests, evaluation suites, and documentation written for the engineers who inherit it. Knowledge transfer is a scheduled deliverable, not a gesture of goodwill in the final week.

I have been building AI systems since 2017. Computer vision first, then machine learning platforms, now LLM agents in production. Much of that was inside large regulated organisations, which means I have spent about as much time in security reviews and change boards as in codebases.
That combination is the whole proposition. The technical half is increasingly commoditised. The half that knows why your deployment will actually be blocked in month three is not.
I take a small number of clients at a time, and I do the work myself.
Thirty minutes on your situation: what you are trying to do, what is in the way, and whether the work is worth doing at all. You will get a straight answer either way, including when the answer is that you don't need me.