White-label AI work, and how it actually goes

An agency wins a fixed-price build. Somewhere in the scope is a sentence like "the system should automatically read uploaded invoices and populate the records", priced as a fortnight because it reads like a fortnight.

It is not a fortnight. It is the part of the project with unbounded downside, because "reads invoices" has no defined success criterion and the client's mental model is that it works every time.

This is the most common reason an agency subcontracts AI work, and the shape of that subcontract decides whether it goes well.

The risk is not that the AI part is technically hard. It is that it is the only part of a fixed-price contract with no natural definition of done.

What the agency is actually buying

Not capacity. Agencies have developers. What they are buying is:

A bounded number. "This will cost £X and here is the accuracy you get" — which requires having built enough of these to know.

Someone who owns the failure mode. When the client asks why it got an invoice wrong, there is an answer, and it is not "the AI is probabilistic".

A definition of done. An eval number that both sides agreed to in advance, replacing "it should work".

That last one is the whole product. An AI feature with no accuracy target is never finished, and never-finished is what turns a profitable fixed-price project into a loss.

Three shapes, and which works

Fully white-labelled, no client contact. We work through the agency; the client never knows we exist. Cleanest commercially and the highest-risk technically, because every technical question travels through a translation layer and comes back approximated. Works when the scope is genuinely well-defined — a self-contained extraction service with a fixed interface.

Badged as a specialist subcontractor. The client knows a specialist is involved; the agency remains the prime and owns the relationship. This is the one that usually works. Direct access on technical calls, no confusion about who the client is, and the agency does not have to relay questions about confidence thresholds.

Joint delivery. Both firms visible, separate contracts. Fine between peers, awkward when the agency wanted a subcontractor rather than a partner. Rarely the right shape for one component of someone else's project.

The second one solves the problem that kills the first: the agency's project manager should not be the interface for a conversation about what a review queue should do.

The three failure modes worth structuring against

The scope was written by someone who has not built one. "Extract data from documents" in a signed contract, with the client's expectation set at human accuracy. Fixing this after signature is a renegotiation.

Structure: a paid scoping phase before any fixed price, producing a document with document types, volumes, an accuracy target per field, and what happens to the exceptions. See how to scope an AI feature. If the agency will not pay for scoping, that is information.

Nobody has the client's real documents. The estimate is built on three sample PDFs the client picked. Production sends the long tail, accuracy is fifteen points lower than the demo, and both firms are surprised together.

Structure: a representative sample before quoting — a hundred documents, sampled rather than chosen. Without them the quote is a range, and the range is wide, and that has to be visible in the proposal rather than discovered in month three.

The AI component is delivered and nobody can maintain it. Six months later the agency needs a change, the specialist is on another project, and there is a prompt in a file with no eval suite and no way to tell whether an edit made things worse.

Structure: the eval harness and golden set are deliverables, in the repository, with the agency's team walked through running them. This is the difference between a handover and an abandonment.

Pricing that reflects where the uncertainty is

Fixed-price on an AI component before seeing the data is a bet, and it gets priced as one — badly for whoever is wrong.

What works: fixed price on the parts that are engineering, ranged on the part that is measurement. The pipeline, the queue, the interfaces, the integration — all knowable, all fixed. The accuracy target on a corpus nobody has seen is staged:

1. Scoping and baseline — fixed, small. Sample the documents, build the golden set, measure what a straightforward implementation achieves. Ends with a number.
2. Build to target — fixed, quoted against that number.
3. Beyond the target — hourly, optional, with diminishing returns stated plainly.

Stage one frequently changes the project. Sometimes the baseline is already good enough and stage two is smaller than expected. Sometimes it reveals that the target is not reachable on those documents at any price, which is a bad conversation to have in week three and a catastrophic one to have in month five.

What we hold to

Stated because it is the part agencies ask about, and because writing it down is the commitment:

• We do not approach the end client. Not during, not after. The agency's relationship is theirs.
• The code is the agency's, along with prompts, eval sets and labelled data. No runtime dependency on us.
• We will say no to an unreachable target before a contract rather than after one. This costs us work occasionally and it is the only version that survives a second project.

That third point is the honest one. The reason to write it down is that the alternative — agreeing to a number that cannot be hit — ends the relationship with the agency, and the agency relationship is worth considerably more than any single project.

More in seven questions for an AI contractor, hiring an AI engineer vs bringing in a firm, and fractional AI engineering.