ENGINEERING THE NEXT GENERATION

Logo
Home/Blog/AI Development Statement of Work: What to Include Before You Sign
Vendor SelectionStatement of WorkAI DevelopmentProcurementContracts

AI Development Statement of Work: What to Include Before You Sign

November 17, 2026
Glowing contract document with highlighted sections and a signature line beside an AI core
Most AI project disputes start in a sentence the statement of work left vague.

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:

  1. Outcome and success measure, with a baseline and a target
  2. Scope and explicit non-scope
  3. Data and access assumptions, and what happens if the data is worse than assumed
  4. Acceptance tests: a test set, metrics, and pass thresholds agreed before the build
  5. Change control
  6. Ownership: code, accounts, test set, documentation
  7. 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:

  1. 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.
  2. 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.
  3. How it's run. Who runs the test, on what version, in what environment, and how results are recorded.
  4. 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.
  5. 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.

Frequently Asked Questions

The business outcome and the success measure, what is in scope and what is explicitly out of scope, the data and system access each side will provide, acceptance tests with a test set and pass thresholds, a delivery plan with milestones, change control, ownership of code, accounts and data, running cost estimates, security and privacy terms, and a handover plan. For AI work the acceptance tests and the data assumptions matter most, because they are where projects usually go wrong.

Because the output is probabilistic. A normal feature either works or does not. An AI feature works some percentage of the time, so the contract has to say how it will be measured, on which cases, and what pass rate counts as done. It also depends on your data, so the contract has to say what happens if the data is worse than assumed.

Agree a test set of real cases before the build, with the expected result for each. Set thresholds, for example the share of cases handled correctly without a person, the maximum rate of serious errors, and response time. State how the test is run, who runs it, and what happens if the system misses the target, such as an agreed period to fix it before payment is affected.

Usually the client, for anything built specifically for the project: the code, configuration, prompts, evaluation set and documentation. The vendor typically keeps ownership of its pre-existing tools and gives the client a licence to use them. Agree this in writing, and make sure the work lives in repositories and cloud accounts the client owns, so the project can continue without the vendor.

Write a change-control process into the statement of work: any change is described in writing, estimated for cost and time, and approved by named people on both sides before work starts. AI projects tend to change as data problems and new cases appear, so a clear process prevents both silent scope growth and disputes about what was agreed.

For anything involving personal data, regulated sectors, significant spend or intellectual property, yes. This guide covers the commercial and technical content a good statement of work should contain. It is not legal advice, and a lawyer should review the final terms, particularly on liability, data protection and ownership.