How long does an AI project take? Timeline by phase.
An honest AI project timeline for buyers: what happens in each phase, what really sets the length, and what you can do to shorten it. With a project plan to copy.
In our projects, a focused AI system, such as an agent that answers questions on one channel and hands over to a person, reaches production in six to ten weeks. A larger project that reads and writes across several business systems takes three to five months. Both start with a short discovery phase, so the plan and dates come from looking at your data and systems, not from a guess.
In our experience, the length is rarely set by how hard the AI is. It is set by how ready your data is, how many systems the agent connects to and how old they are, how fast you get test access and approvals, how many rounds of testing it takes to hit the agreed quality bar, and how long the pilot runs. This guide goes through each phase, shows what makes a project longer or shorter, and ends with a plan you can copy.
How long does it take to build an AI agent?
The table shows typical phase lengths in our projects. “Production” here means launch: the point where the system serves all intended users, after a pilot that is already live for a limited group.
| Phase | Focused system | Larger integration | Ends when |
|---|---|---|---|
| Discovery | One to two weeks | Two to four weeks | You make a written go or no-go decision on a plan. |
| Build | Three to four weeks | Eight to twelve weeks | The system passes the agreed test set in a test environment. |
| Pilot | Two to three weeks | Three to four weeks | Live measures hold for an agreed period with real users. |
| Launch and handover | A few days to a week | One to two weeks | Everyone who should use it can, and your team can run it. |
| Total to production | Six to ten weeks | Three to five months | |
| Operating | Ongoing | Ongoing | The system is retired. |
These are the same milestones the AI statement of work guide uses for a contract. It calls them M1 to M4 and ties each one to a result, not only a date.
What happens in each phase?
Discovery
Discovery answers one question: can this work, with this data, in these systems, to the standard you need? The supplier maps the workflow with the people who do it today, looks at the data, confirms access to each system, and agrees with you what success means as numbers. The most useful output is an evaluation set: a list of real cases, each with the correct outcome, which you sign off. A small prototype is scored against part of it.
The phase ends with a written plan, phase dates, the main risks and a go or no-go recommendation. Public guidance puts this step first too. The UK government’s Guidelines for AI procurement have a heading that reads “Conduct a data assessment before starting your procurement process” and say: “Ensure that a discovery into your data is conducted before you go to market.”
Build
The build connects the system to your tools, writes the rules for what it may and may not do, and improves it until it meets the agreed numbers. Most of the calendar goes on two things. The first is integrations: authentication, field mapping, error handling and what happens when a system is slow or down. The second is evaluation passes.
An evaluation pass means running the whole test set, reading every failure, fixing the cause and running it again. The first pass on real cases usually exposes gaps nobody wrote down: a policy that only one person knows, a record type that behaves differently, a question the documents don’t answer. Each pass takes days, not hours, because the fixes often need an answer from your side. A plan that allows for one pass is a plan that will slip.
Security review belongs here as well, including tests for prompt injection, where instructions hidden in a message or document try to steer the system. Evals before features explains how the test set and the scoring work.
Pilot
The pilot puts the system in front of real users, but only some of them: one team, one region, a share of incoming messages, or every conversation with a person checking the output before it goes out. It exists because a test set, however good, is still a sample. Real users ask things nobody predicted.
Pilot length depends on volume more than on calendar. You need enough real cases to see the rarer request types and the handovers, and enough days for the live measures to settle. A channel with hundreds of conversations a day can show a stable picture in two weeks. A process that runs twenty times a week needs longer. Agree in advance how many cases or weeks count, and what result ends the pilot. AI acceptance testing covers how to set those exit numbers.
Launch and handover
Launch widens access to everyone in scope, in one step or in stages. Handover makes sure your team can run the system without the supplier in the room: documentation, a runbook for incidents, training, a tested rollback, a named manual fallback, and production accounts and keys held by you. For a focused system this takes days. When several departments and systems are involved, it takes longer, mainly because of training and change control.
Operating
Operating has no end date. Someone watches quality and response times, reviews handovers and complaints, reruns the test set after every change, and plans model migrations. More on this below.
What makes an AI project take longer or shorter?
The same system can take six weeks in one company and three months in another. These are the factors that decide it, from what we see in our projects.
| Factor | Shorter when | Longer when |
|---|---|---|
| Data readiness | Documents and records are current, in one place, and someone owns them. | Answers live in people’s heads, old files contradict new ones, or records are incomplete. |
| Number of integrations | The system reads from one or two tools. | It reads and writes across several systems that must stay in step. |
| Age of integrations | Modern tools with documented APIs. | Older systems with no API, custom fields nobody documented, or exports by file. |
| Sandbox access | Test accounts with realistic data arrive in week one. | Testing waits for access, or has to happen against live systems with extra care. |
| Approvals and security review | Reviews are booked at kick-off and the reviewers know what is coming. | Security, data protection or legal review starts only when the build is finished. |
| Languages and channels | One language, one channel. | Several languages or channels, each needing its own test cases and pilot. |
| Regulated domain | Internal use with low stakes. | Health, finance, insurance or legal work, with stricter review and more cases that must hand over. |
| Decision speed on your side | One named owner can answer questions and approve within a day or two. | Questions wait for a weekly meeting, or several people must agree. |
| Acceptance bar | Clear numbers, agreed in discovery, with a person handling what the system can’t. | The bar is unclear, rises during the build, or demands near perfection with no handover. |
| Actions | The system answers and hands over. | It writes records, sends messages or moves work, so each action needs limits and tests. |
Notice that the model itself is not in the list. Picking and prompting a model is a small share of the calendar. The surrounding work is what takes the time, which is why a demo can arrive in days while the production system takes weeks. The six months after the demo explains that gap.
The model is rarely the slow part. Access, data and decisions are.
What do real project shapes look like?
Three common shapes, described in general terms, with where they tend to land in our projects.
A one-channel agent that answers and hands over
An agent on a website chat or a messaging channel answers questions from an approved set of documents, says when it doesn’t know, and passes the conversation to a person with a summary. It reads but does not write. With current documents and one language, this sits at the short end of six to ten weeks. Most of the build goes on the knowledge base, the handover rules and the test cases for questions it should refuse.
An agent that reads and writes to a CRM
An agent that qualifies enquiries, looks up the customer, creates or updates records and books follow-ups. Write access changes the project. Each action needs a limit, a test and often a person’s approval, and the CRM’s custom fields and rules have to be mapped. This usually lands in the middle to upper part of six to ten weeks. It moves toward three months when the CRM is heavily customised, when there is no sandbox, or when a second channel or language is added.
Document automation across several systems
A system that reads incoming documents such as invoices, claims or contracts, extracts the details, checks them against records in two or three other systems, and routes exceptions to the right person. Here the documents vary, the systems are often older, and finance or compliance reviewers have to sign off. In our projects this is three to five months, with a longer build for integrations and a pilot that has to see enough of the unusual documents.
How can you shorten an AI project?
In our projects, most of the time saved comes from work the buyer controls. Five steps make the largest difference.
- Assess your data first. List the sources, who owns each, how current it is and where the gaps are, before you talk to suppliers. The UK guidelines tell buyers to “Assess whether relevant data will be available for the project.” If the answer is no, you have avoided a build that could not work.
- Name one owner. One person who knows the workflow, can answer questions within a day or two, and can approve milestones. A project with three part-time owners runs at the speed of the slowest.
- Give sandbox access in week one. Request test accounts for every system before kick-off. Access requests that go through IT tickets are the most common quiet delay in our projects.
- Collect test cases early. Ask the people who do the work today for 30 to 50 real cases, including the awkward ones, with the right outcome for each. That becomes the start of the evaluation set, so discovery starts from real cases instead of guesses.
- Book the approvals. Put the security review, data protection review, legal check and any IT change board on the calendar at kick-off, with the date the reviewers will receive what they need.
Two more help. Keep the first release narrow, with a written out-of-scope list, so new ideas join the next phase instead of the current one. And agree the acceptance numbers in discovery, so the bar doesn’t move during the build.
Don’t shorten a project by cutting the pilot or the evaluation passes. Those are where problems surface while they are still easy to fix. A system that skips them reaches production sooner and then needs months of fixes in front of customers.
How do you tell a timeline is fiction?
Some plans are wrong on the day they are written. Watch for these signs.
- A firm date before anyone has seen your data. Without a discovery phase, the date is a guess. The UK guidelines warn buyers not to expect “a fully detailed and definite plan”, because AI development is iterative.
- No pilot. The plan goes straight from build to everyone, so the first real users are the test.
- One round of testing. The build ends on a single date with no time for evaluation passes and fixes.
- Integrations described in one line. “Connect to the CRM” with no mention of access, custom fields, sandbox or who on your side grants it.
- No acceptance numbers. If nobody has said what “done” means, the project ends when someone runs out of patience.
- Approvals missing. No security, data protection or legal review appears in the plan, so they will appear later and take longer.
- Nothing after launch. Support ends at go-live, as if the system will stay correct by itself.
- Every phase overlaps. Discovery, build and pilot all run at once to make the total look short.
- The demo sets the date. A prototype built in a week says little about how long production takes.
How much time does an AI system need after launch?
Plan for regular time every month for as long as the system runs. The work is predictable: review live measures and handovers, read a sample of conversations or outputs, rerun the test set after every change to prompts, data or settings, and update content as your business changes. NIST’s AI Risk Management Framework (AI RMF 1.0) notes that “AI systems may require more frequent maintenance and triggers for conducting corrective maintenance due to data, model, or concept drift.” The UK guidelines say the same in buyer terms: “Testing the model on an ongoing basis is necessary to maintain its accuracy.”
The model underneath will also be retired on the provider’s schedule, not yours. OpenAI’s deprecations page lists its minimum notice for generally available models as “At least 6 months.” Anthropic’s model deprecations page says it gives “at least 60 days’ notice before model retirement for publicly released models”, and says that after the retirement date requests to the old model fail. A migration is a small project of its own: switch the model in a test environment, rerun the full test set, fix what changed, then release. Put an owner for these notices in the plan from the start.
The AI project plan template
Copy it, replace every [square bracket], and delete what doesn’t apply. Fill in section 1 before kick-off and the dates in sections 2 to 6 at the end of discovery. The week numbers shown are an example for a focused system.
AI PROJECT PLAN
Project: [project name]
Customer owner: [name, role], approves milestones and answers questions within [2] working days
Supplier lead: [name, role]
Target launch: [date], confirmed at the end of discovery
Version: [1.0], dated [date]
1. BEFORE KICK-OFF, week [0]
1.1 Business measure: [measure]. Baseline [value]. Target [value].
1.2 Data sources: [source, owner, how current, date ready]
1.3 Systems the AI reads: [system, access level, who grants access]
1.4 Systems the AI writes to: [system, actions, who grants access]
1.5 Sandbox or test accounts requested for: [systems], on [date]
1.6 Approvals booked: [security review, data protection review, legal check, IT change board], each with a date
1.7 First [30] real cases with correct outcomes collected by [name]
1.8 Out of scope for this release: [second channel, new language, other]
2. DISCOVERY, weeks [1] to [2]
2.1 Workflow mapped with the people who do it today
2.2 Data assessment: gaps and quality issues reported by [date]
2.3 Access confirmed for every system in 1.3 and 1.4
2.4 Evaluation set: [number] cases, expected outcomes signed off by [name]
2.5 Held-back set: [x]% of cases, kept by the Customer
2.6 Acceptance numbers agreed: pass rate [x]%, critical failures [0], required handovers [100]%
2.7 Baseline: how the team does on the same cases today
2.8 Prototype scored on the development set
2.9 Written plan with phase dates, risks and open decisions
2.10 Go or no-go decision by [name] on [date]
3. BUILD, weeks [3] to [6]
3.1 Integrations, in this order: [system 1], [system 2]
3.2 Handover rules and action limits enforced in code
3.3 Evaluation passes planned: [3]. Each pass runs the full set, reviews every failure and fixes the cause.
3.4 Scores and open questions sent to [name] every [weekday]
3.5 Security review on [date], with prompt-injection cases added to the set
3.6 Exit: passes the held-back set at the agreed numbers in a test environment
4. PILOT, weeks [7] to [9]
4.1 Pilot group: [users, channel or share of traffic]
4.2 Human review: [all outputs or a sample of x%] checked by [name]
4.3 Live measures: [pass rate, handover rate, complaints, response time]
4.4 Measures reviewed [twice a week] by [names]
4.5 Exit: live measures hold for [2] weeks and at least [number] real cases
4.6 Decision by [name]: launch, extend the pilot, or fix and repeat
5. LAUNCH AND HANDOVER, week [10]
5.1 Rollout: [all users at once or in stages, with dates]
5.2 Rollback tested on [date] by [name]
5.3 Manual fallback: [process], owned by [name]
5.4 Runbook, documentation and training delivered to [team]
5.5 Production accounts and keys held by [name] in the Customer's organisation
6. OPERATING, from week [11]
6.1 Live measures reviewed [weekly] by [names]
6.2 Evaluation set reruns on every change and every [month]
6.3 Model deprecation notices tracked by [name]
6.4 A migration starts within [2] weeks of a notice and must pass the held-back set before release
6.5 Review against the business measure every [quarter]
7. RISKS TO THE DATES
7.1 For each risk: owner, date to resolve, and what moves if it slips
a. Data late or incomplete: [owner, date]
b. System access or sandbox late: [owner, date]
c. Approval or review delayed: [owner, date]
d. Acceptance numbers not met after the planned passes: [owner, date]
e. Pilot volume too low to judge: [owner, date]
8. DECISIONS AND WHO MAKES THEM
8.1 Scope changes: [name]
8.2 Changes to the evaluation set or acceptance numbers: [name], in writing
8.3 Go or no-go after discovery: [name]
8.4 Launch after the pilot: [name]
How do you use the plan?
Before you choose a supplier. Fill in section 1 yourself. It shows you where your own delays will come from, and it gives every supplier the same facts to plan against. If you are still comparing suppliers, see how to choose an AI development company.
At the end of discovery. Replace the example week numbers with real dates, and only then treat the launch date as a commitment. Copy the milestones into the statement of work so each one is accepted on a result.
Every week of the build. Look at section 7 first. A risk with no owner or no date is the next slip.
For how we run discovery, build, deploy and operate, including the evaluation set we agree before building, see our services and AI consulting.
Questions buyers ask
How long does it take to build an AI agent?
In our projects, a focused agent on one channel that answers questions and hands over to a person reaches production in six to ten weeks, including discovery and a pilot. An agent that writes to several business systems takes three to five months.
What is a typical AI implementation timeline?
Discovery first, to check the data and agree what success means. Then a build with several rounds of testing against real cases, a pilot with a limited group of real users, and a launch with handover to your team. After that the system needs regular monitoring for as long as it runs.
Can an AI project be done in two weeks?
A prototype or a demo can. A system that real customers or staff rely on usually can’t, because data checks, integrations, testing on real cases, security review and a pilot each take time that no tool removes.
Why do AI projects run late?
In our projects, most often because of data that isn’t ready, slow access to systems, approvals that start too late, and acceptance criteria that were never agreed or that change during the build. The AI itself is rarely the cause.
Is the project finished at launch?
No. Content changes, users ask new things, and model providers retire models on a published schedule. Someone needs to monitor quality, rerun the test set after changes and migrate to new models before old ones are retired.
Should we skip the pilot to launch sooner?
Rarely. The pilot is where real users show what the test set missed, while a person can still catch mistakes. A shorter pilot with clear exit numbers is a better choice than none.