Plugging a model into a product takes an afternoon. Making it reliable in front of real customers takes the rest of the project. That second part is the work: framing the exact task given to the model, measuring what it produces, and deciding what happens when it gets things wrong.
Sorting, summarising, classifying, drafting, tracking what is falling behind. The repetitive work that eats your days, delegated but supervised.
Features that would not exist without it: understanding free text, voice, documents. Designed around what a model can actually do.
A battery of test cases before launch, running costs worked out, and a defined behaviour for the day the model answers nonsense.
Reading, filing, tagging, forwarding to the right person. Repetitive, draining, and exactly what a model does well once the task is properly bounded.
They describe a problem, dictate a message, send a photo or a document. Handling that without AI means a thirty-field form nobody fills in.
The prototype impressed, then it started making things up in front of a customer. The problem is rarely the model: it is the missing measurement and guardrails around it.
The right answer starts with a precise task and a number, not an assistant parked in the corner of the screen. We frame what is worth doing, and we also say when the answer is no.
A prototype evaluated on your own cases, not on a demo
The cost per use, quantified before going live
The system's limits, written down in plain terms
Training a model from scratch: in nearly every case it is expensive, slow and unnecessary.
An assistant that answers anything on any topic, with no boundary: the surest way to get an embarrassing public answer.
Promising a success rate before measuring it on your own data.
A real question, to settle before writing the first line. Depending on how sensitive the data is, we pick a provider processing in Europe, filter what leaves, or use a smaller model running on your own server. The choice is made with you, and it is written down.
These systems bill by the amount of text processed, which makes the invoice invisible until you model it. We measure the cost of one run during the prototype and multiply by your real volume: you get an estimated monthly cost before deciding, not a surprise on the first statement.
By measuring it, like everything else. We assemble a set of cases drawn from your own activity, each with its expected answer, and the system is scored against them at every change. That is what lets us say 'nine times out of ten' instead of 'it seems to work well'.
It will get things wrong; the question is what that costs. We define the fallback together: ask a human to confirm, refuse to answer, or fall back to a simple rule. An AI that says 'I don't know' beats one that invents, and that is a design decision, not luck.