//AI Integration
AI that does one job, and can be checked
Most AI projects fail the same way: a model is asked to decide something nobody can verify, and six months later nobody trusts the output. We build the other kind — a model given a narrow job inside a system that already has rules, where every answer is traceable and a person signs off on anything that matters. We run one ourselves, in production, and it is the reason this page exists.
What our AI integration work covers...
Document Q&A over your own archive
Best for a brochure site, landing page, or clearly scoped feature. Fixed price, fixed timeline.
Drafting — reports, proposals, descriptions
Best for a brochure site, landing page, or clearly scoped feature. Fixed price, fixed timeline.
Classification and routing of incoming work
Best for a brochure site, landing page, or clearly scoped feature. Fixed price, fixed timeline.
Assistants with a tool registry, not free rein
Best for a brochure site, landing page, or clearly scoped feature. Fixed price, fixed timeline.
Support bots that know your product
Best for a brochure site, landing page, or clearly scoped feature. Fixed price, fixed timeline.
The plumbing — evals, versioning, cost control
Best for a brochure site, landing page, or clearly scoped feature. Fixed price, fixed timeline.
//how we build it
How an AI feature actually gets built
[01]
Find the narrow job
One repeated task, with an owner and a cost today. "Add AI to the product" is not a brief; "stop a manager rewriting the same report intro forty times a month" is.
[02]
Agree what good looks like
Twenty real examples with the answers you would accept. This becomes the eval set, and without it nobody can tell whether a prompt change helped.
[03]
Build the boring half
Queue, retries, timeouts, recovery after a crash, versioned prompts, a cost ceiling. A model call that fails silently is worse than no feature.
[04]
Ship behind approval
First release drafts for a human. Once the eval set and the team both trust it, the approval step can be relaxed — deliberately, not by drift.
5
LLM workflows we run in production inside our own CRM
0
of them write a number a client sees without a human check
4 wks
to a pilot that either works on your data or does not
100%
of prompts and workflows delivered as files you own
//the rule
Where the model is allowed to decide
This is the whole design question, and almost every failed AI project got it wrong. Our rule is simple enough to say in one line: the model writes language, the system decides facts, and a person approves anything a client will see. The three columns below are how that plays out in the CRM we operate.
//model's job
Language
Wording, ordering, tone, summary. Things where a wrong answer is a bad sentence, not a bad decision.
the commentary on a report
the intro paragraph of a proposal
how a task is phrased in a plan
//system's job
Facts
Numbers, composition, eligibility. Deterministic code, with a rule you can read and a result you can reproduce.
which tasks enter a plan — from findings
every metric in a report — from a snapshot
the price — written by a person, unseen by the model
//human's job
The signature
Nothing reaches a client on the model's authority. Approval is a state in the database, not a habit someone might skip.
a plan is approved before it is visible
an assistant proposes an action plan and waits
a report is published by a person, then frozen
//the proof
Five workflows, running on our own money
We did not read about this pattern. Our SEO platform runs five LLM workflows every working day, and each one is deliberately narrow. The prompts and their versions live in files under source control rather than pasted into a console, so a change to how the model behaves is a commit someone reviewed — and an old output can always be traced to the exact prompt that produced it.
That is the part clients underestimate. The model is a week of work; making its behaviour reviewable, testable and cheap to run is the rest of the project.
[01]
Plan generation
wording and ordering; the composition comes from findings
[02]
Report narrative
comments on the numbers, never writes them
[03]
Proposal draft
the intro only — the price is human-written and hidden from it
[04]
Knowledge classification
tags an uploaded document so retrieval can filter it
[05]
The assistant
reads the domain, proposes an action plan, writes nothing itself
//the objections
What you are probably thinking
This is the service where the sales pitch and the engineering reality are furthest apart. Here is what we actually say.
“It makes things up.”
It does, and no prompt fixes that. The design answer is to never ask it for a fact you care about. Numbers come from the database, eligibility comes from rules, and the model gets the narrow job of saying it in words. In our own reports the model cannot see a figure it did not receive.
“Our data cannot leave the company.”
Then it does not. Options, cheapest first: strip identifiers before the call, use an EU-region endpoint with a no-training agreement, or run an open model on your own hardware. Each costs more than the one before it, and we will tell you honestly which your case actually needs.
“What will it cost to run?”
A number we can estimate before building, because the volume and the prompt size are both known. Most back-office workflows land in tens of euros a month, not thousands. A cost ceiling and per-feature usage logging are part of the build, so a bill never surprises you.
“Will it be obsolete in six months?”
The model will change; the workflow around it should not. We keep the provider behind an interface and the prompts in versioned files, so swapping a model is a config change and an eval run. That is the whole reason to build it as software rather than as a clever prompt.
“Could we just use ChatGPT?”
For a person doing a task occasionally, yes, and we will say so rather than quote you. It stops working when the task repeats daily, needs your data, has to land inside another system, or has to produce the same shape of answer every time. That is the line between a habit and a feature.
“Our team will not trust it.”
They should not, at first. That is why the first release drafts and a person approves. Trust arrives when the team has watched it be right for a few weeks — and the approval step stays available for the cases where it is wrong.
//case studies
Three features, in production
All three run inside our own SEO platform, which is the honest version: we shipped these on ourselves first. Our own product. Time savings are measured on our team — yours will differ.
drafting
A six-month plan in minutes, not a day
The crawler finds the issues, the catalog decides which tasks apply, and the model writes them up and orders them across the months. A manager edits and approves instead of starting from an empty document.
who picks the tasks
the catalog
who writes them
the model
who approves
a person
reporting
Commentary the numbers cannot contradict
A monthly report freezes its figures at creation. The model receives that snapshot and writes only the narrative around it, so the text can never disagree with the table above it — a failure mode we had seen elsewhere.
figures the model writes
none
report after publishing
frozen
client sees it
after approval
assistant
An agent that proposes and waits
It can read the domain through a registry of tools scoped to the user's role, and it can suggest a sequence of actions. It cannot execute one. Confirmation is a click, and the click is the point.
tools it can read
role-scoped
actions it can take alone
zero
audit trail
every step
//what it costs
Start with one workflow
Nobody should buy an AI programme. Buy one workflow, measure it against the eval set, and decide about the second one with evidence. Model usage is billed at cost, separately from our fee.
FEASIBILITY SPRINT
from €4K
4 weeks
One workflow on your real data, an eval set, a cost estimate, and a yes or no you can act on.
INTO PRODUCTION
from €8K
6–12 weeks
Queues, retries, versioned prompts, approval states, usage logging, and the UI around it.
WE KEEP IT HONEST
from €399
per month, rolling
Eval runs after every model change, prompt tuning, cost review, and a swap when a better model lands.
//questions
AI integration questions, answered
Which model do you use?
Whichever wins on your eval set at an acceptable cost — usually an OpenAI or Anthropic model, sometimes a self-hosted open one when the data cannot leave. The provider sits behind an interface, so this is a decision you can revisit without a rewrite.
Do you train a model on our data?
Almost never, and we will usually talk you out of it. Retrieval over your documents solves most of what people mean by "train it on our data", costs a fraction, and updates the moment you upload a new file. Fine-tuning is for format and tone, not for knowledge.
Can you add AI to a product you did not build?
Yes, and it is a common starting point. We need read access to the data the feature would use and a clear owner on your side. If the data is scattered across four systems with no single source of truth, that is the first project, and we will say so.
What happens when the model gets it wrong?
A person catches it, because the first release always drafts. Beyond that: every output is logged with the prompt version that produced it, bad cases go into the eval set, and the next prompt change is measured against them. Getting it wrong is expected; not noticing is the failure.
When would you tell us not to bother?
When the task happens twice a month, when nobody can say what a correct answer looks like, when the data does not exist yet, or when a rule in code would do the job more cheaply and never hallucinate. Three of those four come up regularly on first calls.
//tools
What we build it on
self-hosted models
SEO
the platform these workflows run inside
Web development
the product an AI feature has to live in
Pricing
fixed price, time and materials, or a dedicated team
//contact us
Tell us the task. We will tell you whether a model should do it.
Thirty minutes, free, with an engineer. We look at what the task is, whether the data exists, what a correct answer looks like, and roughly what it would cost to run. Plenty of these calls end with "write a rule instead" — that answer is free too.