Most AI contracts in the region are still priced like software projects: a licence, a block of professional services, maybe a support fee. That model made sense when the deliverable was a system that either worked or did not. AI programs are different. The value sits in individual use cases, and some will land better than others. Pricing should reflect that.
The framework-agreement approach
On a recent smart-complaints program with a regulatory authority, we structured the work as a framework agreement covering six AI agents inside the existing complaints workflow. Each agent is a use case. Each use case has its own acceptance criteria, agreed and signed before build starts. Payment for a use case is released only when the business owner accepts it on real data.
This sounds risky for the vendor, and it is meant to be. It forces discipline on both sides. The vendor scopes carefully and pushes back on vague requirements, because vagueness now costs them money. The client names an owner and makes data available on time, because acceptance cannot happen without both.
What goes into acceptance criteria
Good criteria are few, measurable and owned. For a complaint-triage agent they might be: classification accuracy above an agreed threshold on a held-out sample; routing time reduced against the current baseline; every recommendation logged with its evidence; and a supervisor able to override with one action. Notice that two of the four are about governance, not accuracy. In government, an agent that is accurate but not auditable will not be accepted, and it should not be.
Why sponsors like it
For the sponsor, each accepted use case is a small piece of evidence they can take to leadership. Instead of defending a large annual spend, they can show six signed acceptances, each tied to a measurable improvement. That makes the next budget cycle easier and protects the program when priorities shift.
Time and materials
- Pays for effort
- Scope creep is profitable
- Hard to justify renewal
- Risk sits with client
Paid per accepted use case
- Pays for results
- Scope is fixed per case
- Each payment is evidence
- Risk is shared
Where it does not fit
This model needs a stable foundation. If the data platform, identity and logging are not in place, the first use case carries all of that cost and the economics break. In those cases we price the foundation as a fixed-scope phase, then move to per-use-case payments on top. It also needs a client willing to name owners. Without an owner, there is nobody to accept, and the contract stalls.
Writing the framework agreement
The framework agreement itself stays short. It sets the commercial rules once: the rate card, how a use case is defined, how acceptance works, what happens when a use case is rejected, and how data and intellectual property are handled. Each use case is then added through a short call-off schedule that names the owner, the scope, the acceptance criteria and the price.
Two clauses deserve special care. The first is rejection. If a use case fails acceptance, the vendor gets a defined window to fix it, and if it still fails, the client can close it without payment and without penalty on either side. That makes the risk real but bounded. The second is change. If the client changes the process the agent supports in the middle of the build, the acceptance criteria are re-baselined in writing before work continues.
Running acceptance well
Acceptance is an event, not an email. We run it as a short session with the business owner, using a held-out sample of real cases the build team has not seen. The owner reviews the results, the audit log and a handful of individual recommendations in detail. If the criteria are met, the acceptance certificate is signed in the room. Running it this way takes an afternoon and removes weeks of back-and-forth.
Over a program, these certificates add up to something valuable: a documented record of what AI has actually delivered for the organisation, use case by use case, in the owner's own words.
Pricing each use case
How do you price a use case before it is built? We size it on three things: the number of systems it touches, the volume and quality of the data, and the depth of the human review it needs. A use case that reads from one clean system and supports a reviewer is small. One that writes back into several systems, handles sensitive personal data and drafts formal decisions is large. Agreeing these size bands in the framework agreement means each new call-off can be priced in minutes, and the client can compare use cases on a like-for-like basis when deciding what to fund next.
Done well, paying for accepted use cases turns the commercial model into a delivery tool. Everyone is working towards the same milestone, and every invoice is proof that something useful went live.
