TL;DR & Quick Summary
A statement of work (SOW) for AI development has to do things an ordinary software SOW doesn't, because AI output is probabilistic and depends on your data. The sections that prevent most disputes:
- Outcome and success measure, with a baseline and a target
- Scope and explicit non-scope
- Data and access assumptions, and what happens if the data is worse than assumed
- Acceptance tests: a test set, metrics, and pass thresholds agreed before the build
- Change control
- Ownership: code, accounts, test set, documentation
- Running costs and handover
- Key Takeaway: If the SOW says the system will be "accurate" or "intelligent", it has said nothing. If it says "handles at least X% of the 100 agreed test cases correctly, with no more than Y serious errors", it has said something both sides can test.
- This is not legal advice. Have a lawyer review final terms, especially on liability, data protection and ownership.
- Get Started: Want help drafting one? Schedule a strategy call with Cogniq AI or see our custom AI development services.
Why AI Needs a Different SOW
In ordinary software, a feature works or it doesn't. A button either submits the form or fails. You can write acceptance criteria as yes or no.
AI features work some of the time. A system that classifies support emails might be right 91% of the time on one kind of email and 70% on another. Without a measure, "it works" can mean anything, and the vendor and client will reasonably disagree at the end.
AI also depends on your data. A vendor who prices a project assuming clean, accessible records will find messy, locked-in ones in the first week. A SOW that doesn't say what happens then leaves one side absorbing the cost.
Both problems are solved the same way: write the measure and the assumption down.
Section 1: Outcome and Success Measure
State the business outcome in one or two sentences, and give a measure with a baseline and a target:
- Outcome: reduce the time agents spend answering order-status emails.
- Baseline: about 400 emails a week, 4 minutes each, measured over the last four weeks.
- Target: the system resolves at least 30% of order-status emails with no agent involvement within three months of launch.
If you can't measure the baseline yet, make measuring it the first task in the project. Our AI readiness checklist covers what to settle before you write any of this.
Section 2: Scope and Non-Scope
Write what's included in a short list of specific deliverables, then a separate list of what's not included. Non-scope is where most disagreements are prevented. Typical items:
- Which channels are covered (email only, or chat and phone too)
- Which languages
- Which systems are integrated, and whether access is read-only
- What the system may do on its own and what needs human approval
- What's explicitly excluded: other workflows, a mobile app, historic data migration
Vague words such as "support", "integrate" and "optimise" hide scope. Replace them with nouns: which system, which action, which users.
Section 3: Data and Access Assumptions
List the data the project depends on, where it lives, who provides it and by when. Then state what happens if the assumptions turn out wrong:
- Data not delivered by the agreed date: the schedule moves by the same number of days
- Data quality worse than assumed: both sides review the findings, and the plan or the price is adjusted through change control
- Access delayed: same as above
This clause isn't a trap for the client. It protects both sides from the most common surprise in AI work. If a data audit is part of the first phase, say so, and say what the outputs are.
For forecasting projects, our data-readiness guide covers what the data needs to contain. For older systems, AI integration for legacy systems explains why access route changes cost.
Section 4: Acceptance Tests
This is the section that matters most. Agree it before the build:
- A test set. At least 50–100 real cases, each with the expected result, and some deliberate hard cases: missing information, conflicting records, requests the system should refuse.
- Metrics and thresholds. For example: at least 85% of test cases handled correctly without a person; no more than 2% serious errors; every sensitive action routed for approval; average response under 5 seconds.
- How it's run. Who runs the test, on what version, in what environment, and how results are recorded.
- What happens if it fails. For example: the vendor has 15 working days to fix and re-test before any payment tied to acceptance is affected.
- Ongoing quality. Whether the thresholds apply only at acceptance or also during a warranty period.
Keep the test set in the client's hands. It's the single most valuable asset for judging the system and any later change. Our AI agent evaluation framework covers what a good test set contains.
Section 5: Delivery Plan and Milestones
Break the work into phases with a clear output and decision at the end of each:
- Discovery: data audit, scope confirmation, test set built
- Build: the system, integration and a first internal test
- Parallel run: the system runs alongside the current process without acting
- Limited live use: a share of real cases
- Full use and handover
Tie payments to milestones that can be checked, not to calendar dates alone. Our guide to how long it takes to build a custom AI agent gives typical timings for each phase.
Section 6: Change Control
AI projects change as data problems and new cases appear. Agree how:
- Any change is described in writing, with its effect on cost and time
- Named people on both sides approve it before work starts
- Work that isn't approved isn't billable
- A short list of change types that don't need a formal process, such as fixing a bug or adjusting wording
Without this, scope grows silently and the final invoice surprises everyone.
Section 7: Ownership
State ownership of each item separately:
| Item | Usual position |
|---|---|
| Code and configuration built for the project | Client owns |
| Prompts, workflows and evaluation test set | Client owns |
| Documentation and runbooks | Client owns |
| Cloud and model-provider accounts | Client's accounts, vendor works inside them |
| Client data and outputs derived from it | Client owns |
| Vendor's pre-existing tools and libraries | Vendor owns, client gets a licence to use them |
Avoid proprietary platforms that only the vendor can operate unless you accept that dependence knowingly. Ask what it would cost to move the system elsewhere. Our guide on AI agent development company vs in-house team has a handover checklist.
Section 8: Running Costs
The build price isn't the whole price. The SOW should include an estimate of monthly running costs at your expected volume:
- Model usage: per-token charges, estimated per case from the test set
- Hosting and databases
- Third-party services
- Support and maintenance, and what the retainer covers
Ask the vendor to show the calculation, not just the total. Our cost-per-ticket guide shows how to estimate AI cost per case.
Section 9: Security, Privacy and Governance
Cover:
- What data goes to which model provider, under what terms, and where it's stored
- Who can access production data, and how that access is logged
- How incidents are reported and within what time
- What the system may never do without human approval
- How the vendor handles your data at the end of the project
Controls such as logging and approvals are a real part of the cost. Our guide to what AI governance costs with legacy systems shows how to size them. Have legal and security review this section in particular.
Section 10: Handover
Write the handover as deliverables, not a hope:
- Architecture overview and setup instructions
- Runbooks for common failures
- The test set and how to run it
- Training for the people who will own the system
- A supported transition period during which your team makes changes and the vendor reviews them
Name the people who will receive each item. A handover with no recipient is a handover that doesn't happen.
A Short Example of Good Acceptance Wording
Compare these two:
- Weak: "The system will accurately answer customer order-status enquiries."
- Strong: "Acceptance requires that, on the 100-case test set agreed on [date], the system produces a correct answer without human involvement for at least 85 cases, produces no more than 2 answers that state incorrect order information, and routes all 12 designated edge cases to a person. Tests will be run by the client's support lead with the vendor present."
The second version can be tested, argued with, and signed. The first can only be argued about.
Red Flags in a Vendor's SOW
- No acceptance test, or one defined only by the vendor
- Scope described in adjectives rather than deliverables
- Fixed price with no stated data assumptions
- Code and accounts held by the vendor
- No mention of running costs
- Handover as "knowledge transfer as required"
- Payment due in full before the system has run on real cases
If you're still choosing a vendor, our RFP checklist and guide to shortlisting AI agencies come first.
Conclusion
An AI statement of work works when it replaces adjectives with tests. Write the outcome with a baseline and a target, list scope and non-scope, state the data assumptions and what happens if they're wrong, agree the acceptance tests before the build, and set out change control, ownership, running costs and handover. Then have a lawyer review the terms.
Schedule a strategy call with Cogniq AI to scope your first AI project, or explore our custom AI development services.



