# AI Development Process: Stages, Timeline, Deliverables and What Slows Projects Down

URL: https://vrisic.com/blog/ai-development-process-timeline-stages/
Last updated: 2026-11-01

**Short answer:** A custom AI project runs through six stages: discovery, data and design, build, testing, launch and support. At Vrisic a single task agent takes 3 to 6 weeks, an integrated agent 6 to 10 weeks and a multi agent system 10 to 16 weeks, because the stages overlap. You should receive a written deliverable at every stage, and a go or no go decision at each gate, not a surprise at the end.

In this guide

1. The six stages at a glance
2. Stage 1: Discovery
3. Stage 2: Data and design
4. Stage 3: Build
5. Stage 4: Testing and evaluation
6. Stage 5: Launch
7. Stage 6: Support and improvement
8. Realistic timelines by project size
9. Where the effort goes
10. What causes delays and how long each adds
11. What you need to provide
12. Stage gates and acceptance criteria
13. Compliance checkpoints
14. Red flags in a vendor’s plan
15. How Vrisic can help
16. Sources

Knowing the process lets you compare quotes, spot missing steps and plan your own team’s time. This is the process we follow at Vrisic, set against general practice. Software teams have used some version of these stages since CRISP-DM, a data mining process published in 1999 with six phases: business understanding, data understanding, data preparation, modeling, evaluation and deployment. AI projects built on language models change the middle of that sequence, because you no longer train a model from scratch, but the logic still holds: understand the problem, check the data, build, test properly, release carefully.

A typical integrated agent, week by week. Vrisic illustrative schedule for a 6 to 10 week integrated agent; real dates depend on access and approvals

## What are the six stages of an AI development project?

The stages run in a fixed order but overlap in time: testing starts while the last features are built, and discovery questions keep arriving until launch. Durations below are for an integrated agent, our middle tier of 6 to 10 weeks.

| Stage | What happens | Typical duration | You receive |
| --- | --- | --- | --- |
| 1. Discovery | Goal, process, data, systems, risks and success measure agreed | About 1 week | Written scope and a fixed price |
| 2. Data and design | Sample data checked, flows, tools, rules and test plan designed | 1 to 2 weeks | Design document and test set |
| 3. Build | Agent, integrations and review screens built in your cloud account | 3 to 5 weeks | Weekly working demos |
| 4. Testing | Accuracy, edge cases, safety and load measured on your cases | 1 to 2 weeks, overlapping build | Test report with scores |
| 5. Launch | Staged rollout with human review at first | 1 to 2 weeks | Runbook and monitoring |
| 6. Support | Monitoring, fixes and improvements | Ongoing, optional | Monthly report |

If you are not sure whether you are ready for stage one, read the AI readiness checklist first; it covers the preparation that makes the first two stages short.

## Stage 1: What happens in discovery, and what should you get out of it?

Discovery turns “we want AI to help with X” into a scoped, priced plan. It should take about a week of elapsed time and a few hours of your team’s. At Vrisic the scoping call is free and the output is a written scope with one fixed price, so you know the cost before any build work starts.

### The questions that matter

- **What is the job, in numbered steps, and where does it go wrong today?**
- **How many times a week does it happen,** how long does each take, and what does the time cost?
- **What is a correct result?** Who decides?
- **Which systems does it touch,** and does each have an API?
- **Which data is sensitive,** and where may it be processed?
- **What happens if the agent is wrong?** This sets how much human review you need.

### Deliverables

- A scope document: what is in, what is explicitly out, and the assumptions the price rests on.
- One success measure with a baseline, for example “order entry from 6 minutes to under 2, errors below 1%.”
- A risk list with owners, including data, access and approval risks.
- A fixed price and a timeline with dates for each stage gate.

A discovery that ends without a written success measure has not finished. Everything later is judged against it.

## Stage 2: What does data and design involve?

This stage checks that the project is possible on your real data and decides how the agent will work. Skipping it is the most common reason projects overrun, since surprises about data and access are far cheaper to find in week two than in week six.

### Data work

- Collect 20 to 50 real examples at first, including awkward ones, with the correct outputs verified by someone who does the job.
- Run them through candidate models to see where each fails. This quickly shows whether a small, cheap model is enough.
- Identify sensitive data and decide what is masked, what is stored and for how long.

### Design work

- **Workflow or agent.** Which steps are fixed code and which need model judgement. Anthropic’s engineering guidance describes workflows as predefined code paths and agents as models directing their own tool use; most business tasks are best as workflows with model steps inside. See AI agent frameworks compared for how that choice affects tooling.
- **Tools and integrations.** Each action the agent can take, with its permissions, limits and approval rules.
- **Human review design.** What the reviewer sees, how they approve or correct, and how corrections feed back.
- **Test plan.** The scored test set and the pass thresholds you will use at the gates.

The deliverable is a design document of a few pages plus the test set. If your scope is uncertain, the [AI Pilot](https://vrisic.com/ai-pilot/) compresses this stage into 10 business days of real work on your data, which many clients find easier than a long document. It is credited against a build started within 60 days. For how a pilot compares with a proof of concept or MVP, see pilot vs proof of concept vs MVP.

## Stage 3: How does the build work, and what should you see each week?

Building happens in your cloud account with your own model keys, in weekly increments that you can see running. A good build never goes quiet for a month. By the end of week one of building you should see the agent complete the happy path on a sample case, even if rough.

1. **Skeleton first.** The agent runs end to end on one case with stubbed tools. This proves the architecture early.
2. **Real integrations next.** Connect to sandbox versions of your systems, one at a time. This is where most surprises appear, and it is why we put access requests in week one of discovery.
3. **Rules and edge cases.** Approval limits, validation and exception handling go in as code, not as prompt text.
4. **Review screens and logs.** The tool people will use to check and correct results, and the audit trail behind it.
5. **Hardening.** Retries, timeouts, idempotent writes so a retry cannot create a duplicate, cost limits per run and secrets handling.

Each week ends with a short demo and a written note covering what was done, what is next, what is blocked and what decision we need from you. For the engineering behind these steps, see how to build an AI agent, and for the work of connecting to your tools see our [AI integration](https://vrisic.com/services/ai-integration/) service.

Why 90% accurate is not enough for repeat use. Vrisic calculation (rate cubed, independent tries); concept from Anthropic, Demystifying evals for AI agents

## Stage 4: How is an AI system tested, and what scores should you expect?

Testing for AI is statistical: you run the agent many times on many cases and measure how often it is right. Anthropic’s guidance on evaluating agents suggests starting with 20 to 50 simple tasks drawn from real failures, converting user reported failures into test cases as you go, and starting early because evals get harder to build the longer you wait. It also describes three grader types, code based, model based and human, and recommends combining them.

### Why consistency matters more than average accuracy

The same guidance distinguishes pass@k, the chance of at least one success in k tries, from pass^k, the chance that all k tries succeed. For a customer facing or money moving agent, the second is the honest measure. The arithmetic is unforgiving: an agent that succeeds 75% of the time on each try passes three tries in a row only about 42% of the time (0.75 x 0.75 x 0.75).

| Success per try | All 3 tries succeed | All 5 tries succeed |
| --- | --- | --- |
| 75% | 42% | 24% |
| 90% | 73% | 59% |
| 95% | 86% | 77% |
| 99% | 97% | 95% |

Computed from the per try rate raised to the power k, assuming independent tries. It is a simplification, but it shows why a demo that works “most of the time” can fail users repeatedly.

### What we test

- **Accuracy on your cases,** by field or by outcome, with the awkward 10% to 20% scored separately.
- **Safety rules.** Attempts to exceed limits, prompt injection through documents or emails, and actions that should always need approval.
- **Failure behaviour.** What happens when a tool is down, a model times out or input is garbage. The correct behaviour is usually to stop and hand over to a person.
- **Cost and speed.** Cost per run and time per run at expected and peak volume.
- **Regression.** Every change reruns the whole test set before release.

Thresholds are agreed in stage two, not negotiated after seeing results. A typical gate reads: at least 95% correct on routine cases, no unsafe action in the safety set, and every failure routed to a human.

## Stage 5: How should an AI system be launched?

Launch in steps that raise trust with evidence, not in one switch. We use three phases, each with an exit rule.

1. **Shadow mode.** The agent processes real work in parallel while your team carries on as normal, and results are compared daily. Nothing the agent does reaches customers or systems of record. Typical length: one week for simple work, up to two or more for complex work.
2. **Assisted mode.** The agent prepares the result and a person approves each one. You measure edit rate, time saved and error catches.
3. **Selective autonomy.** Low risk, high confidence categories go through with sampled review, while the rest stay with a person. Thresholds loosen field by field only as evidence builds.

Launch also covers a runbook (what to do when something is wrong, who is called), monitoring dashboards, alert thresholds, a kill switch and a rollback plan. Staff training takes an hour or two, and its most important message is plain: what the agent will and will not do, and how to flag a mistake.

## Stage 6: What does support and improvement include?

An agent is not finished at launch. Models change, your data shifts, suppliers invent new layouts and new edge cases appear. Support covers monitoring, fixes, prompt and rule updates, model upgrades checked against the test set, and a monthly report of accuracy, cost, volume and overrides. The report matters because it shows whether the savings promised in discovery are real.

Support is optional at Vrisic, and because you own the code, prompts and test data, your own team or another vendor can take it over. Budget a plain amount for ongoing model usage and hosting too; our [AI agent cost guide](https://vrisic.com/blog/ai-agent-development-cost/) explains typical running costs, and the broader [AI development cost guide](https://vrisic.com/blog/ai-development-cost/) shows how stages feed into price.

## What are realistic timelines for each size of project?

Duration follows scope, number of integrations and approval speed far more than lines of code. These are our ranges, delivered at a fixed price after a free scoping call.

| Project type | Typical price | Total time | Discovery | Design | Build | Test and launch |
| --- | --- | --- | --- | --- | --- | --- |
| Single task agent | $8,000 to $25,000 | 3 to 6 weeks | 3 to 5 days | 3 to 5 days | 1.5 to 3 weeks | 1 to 1.5 weeks |
| Integrated agent | $25,000 to $60,000 | 6 to 10 weeks | About 1 week | 1 to 2 weeks | 3 to 5 weeks | 2 to 3 weeks |
| Multi agent system | $60,000 to $150,000 and up | 10 to 16 weeks | 1 to 2 weeks | 2 to 3 weeks | 5 to 8 weeks | 3 to 4 weeks |

The columns do not add up to the total because stages overlap, with testing starting while the last features are built. Add time if data is messy, access is slow or approvals take days.

### A week by week view of an integrated agent

This illustrative schedule shows how a 9 to 10 week integrated agent, for example an invoice or order intake agent writing to one ERP, typically flows.

| Weeks | Stage | Milestone |
| --- | --- | --- |
| 0 to 1 | Discovery | Scope, success measure and fixed price signed off; access requests sent |
| 1 to 3 | Data and design | Test set of 50 cases verified; design and approval rules agreed |
| 3 to 7 | Build | Weekly demos: skeleton, integrations, rules, review screen |
| 6 to 9 | Testing | Test report meets agreed thresholds; safety set passed |
| 9 to 10 | Launch | Shadow mode complete, assisted mode started, runbook handed over |
| 10 onward | Support | Monthly report; thresholds loosen as evidence builds |

## Where does the effort go?

Founders often expect most effort in model work. In our experience it goes mainly into integration, rules, testing and rollout. The split below is Vrisic’s own estimate of typical effort on an integrated agent, not an industry statistic, and it varies by project.

- **Discovery:** about 8%.
- **Data and design:** about 12%.
- **Build (integrations, rules, review screens):** about 40%.
- **Testing and evaluation:** about 22%.
- **Launch and handover:** about 12%.
- **Contingency for scope discoveries:** about 6%.

Note that testing plus launch is about a third of effort. A vendor whose plan shows far less than that is probably skipping something you will pay for later.

Where the effort goes in an integrated agent. Vrisic estimate from typical builds; not an industry statistic

## What causes delays, and how long does each one add?

Delays rarely come from the AI. They come from access, data and decisions. The weeks below are our typical experience, offered as planning estimates rather than measured statistics.

| Cause | Typical added time | How to prevent it |
| --- | --- | --- |
| Test access to systems arrives late | 1 to 4 weeks | Request accounts in the first week; approve sandboxes early |
| No verified examples of correct output | 1 to 3 weeks | Collect 20 to 50 cases in discovery |
| Scope change mid build | 1 to 3 weeks per major change | Written scope; change requests priced and dated |
| Slow feedback on demos | Days per demo | Named owner, feedback within two business days |
| No agreed success measure | Open ended | Write one number with a baseline before design |
| Undocumented rules in people’s heads | 1 to 2 weeks | Have the daily user write exceptions down |
| Security or procurement review | 2 to 8 weeks | Start the review during discovery |
| Legacy system with no API | 2 to 6 weeks | Plan an adapter early; see [legacy modernization](https://vrisic.com/blog/ai-legacy-system-modernization-guide/) |

## What do you need to provide?

The best predictor of a smooth project is how quickly your side responds. Plan for roughly the following, which is a typical estimate and varies with scope.

- **One decision maker** who can approve scope and changes. About 1 to 2 hours a week.
- **One day to day owner** who answers questions and signs off tests. About 2 to 4 hours a week during design and testing.
- **One or two daily users** who check the test set and try the demos. A few hours in total per stage.
- **An IT contact** who grants sandbox access, API keys and network rules, ideally within a week of asking.
- **Sample data and documents,** with sensitive items identified.
- **Feedback within two business days** of each demo.

We are a remote team in India working US, UK and UAE hours, so demos and calls fit your working day. Written weekly notes keep everyone aligned between calls.

## What are stage gates and acceptance criteria?

A gate is a decision point where you can proceed, change course or stop, with evidence in hand. Stopping early is a success if it saves money on a project that would have failed. Gartner has predicted that over 40% of agentic AI projects will be canceled by the end of 2027 because of escalating costs, unclear business value or inadequate risk controls, so the ability to stop cleanly is worth designing in.

| Gate | Evidence you should see | Typical decision |
| --- | --- | --- |
| After discovery | Scope, success measure, fixed price, risks | Approve build or stop |
| After design | Test set results on candidate models; confirmed system access | Proceed, narrow scope or stop |
| Mid build | Working end to end flow on real sandbox data | Confirm scope and launch date |
| Before launch | Test report at or above thresholds; safety set passed | Go to shadow mode or fix |
| After shadow | Agreement rate with staff, silent error sample | Go to assisted mode |
| After assisted | Edit rate, time saved against the baseline | Raise autonomy for safe categories |

Acceptance criteria should be written, numeric and agreed in advance, such as “at least 95% correct on routine cases, zero unsafe actions in the safety set, median handling time under 90 seconds.” Vague criteria like “works well” produce disputes.

## Which compliance checkpoints belong in the process?

Compliance is cheaper when it is part of design than when it is bolted on at launch. Three checkpoints cover most projects.

- **Data protection.** In discovery, list personal data and the lawful basis, and decide where processing happens. A DPA with each model provider is usually needed. For strict cases consider a [private, self hosted model](https://vrisic.com/blog/private-llm-self-hosted-ai/) .
- **Sector rules.** HIPAA for US health data, PCI DSS for card data, and contract terms with your clients all affect architecture and logging.
- **EU AI Act, if you serve the EU.** As reported in 2026, a Digital Omnibus agreement moved high risk obligations for stand alone systems, such as recruitment and credit scoring, to 2 December 2027 and for AI embedded in regulated products to 2 August 2028, while transparency obligations apply from 2 August 2026, with a grace period to 2 December 2026 for machine readable marking on systems already on the market. Check the current text with counsel, because dates and scope are changing.

## What red flags should you look for in a vendor’s plan?

- **No discovery or design stage.** A price quoted before anyone has looked at your data is a guess.
- **“Four weeks” for several integrations** with no mention of access and sandboxes.
- **No test plan,** or testing described as “we will try it and see.”
- **Launch means switching on.** A plan with no shadow or assisted phase.
- **No named owner** on your side, or no feedback schedule.
- **The vendor holds the code, prompts or data,** leaving you unable to move.
- **Open ended time and materials** with no cap or gate. Compare approaches in [how to choose an AI development company](https://vrisic.com/blog/how-to-choose-an-ai-development-company/) .

## How Vrisic can help

We follow this process on every project: a free scoping call, one fixed price in writing, weekly demos, and gates with written evidence. We build in your own cloud account with your own model keys, you own the code, prompts and test data, and there are no per seat fees. Read [how we work](https://vrisic.com/how-we-work/) for the detail, or see our [custom AI software development](https://vrisic.com/services/custom-ai-software-development/) service.

If you want proof before a full build, the [AI Pilot](https://vrisic.com/ai-pilot/) costs $1,500 (£1,200, AED 5,500), takes 10 business days and is credited in full against a build started within 60 days. You can [book a free scoping call](https://vrisic.com/contact/) or message us on WhatsApp at +91 63777 67206.

## Sources

1. [What is CRISP-DM?](https://www.datascience-pm.com/crisp-dm-2/) (Data Science Process Alliance)
2. [Demystifying evals for AI agents](https://anthropic.com/engineering/demystifying-evals-for-ai-agents) (Anthropic Engineering)
3. [Building effective agents](https://www.anthropic.com/research/building-effective-agents) (Anthropic)
4. [Gartner predicts over 40% of agentic AI projects will be canceled by end of 2027](https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027) (Gartner), June 2025
5. [EU AI Act Omnibus Agreement: postponed high risk deadlines and other key changes](https://www.gibsondunn.com/eu-ai-act-omnibus-agreement-postponed-high-risk-deadlines-and-other-key-changes/) (Gibson Dunn), May 2026
6. [The EU AI Act: when does it become enforceable now?](https://www.dataprotectionreport.com/2026/07/the-eu-ai-act-when-does-it-become-enforceable-now/) (Data Protection Report), July 2026

Timelines, effort splits and delay estimates are Vrisic’s planning estimates from typical builds, not industry statistics. Regulatory dates were checked in October 2026 and may change. This guide is not legal advice.

## Frequently asked questions

### How long does AI development take?

At Vrisic a single task agent takes 3 to 6 weeks, an integrated agent that connects to your systems 6 to 10 weeks, and a multi agent system 10 to 16 weeks, because stages overlap. Slow system access, unclear success measures and scope changes are the usual causes of longer timelines. A 10 business day AI Pilot can test the idea first.

### What are the stages of AI software development?

Six stages: discovery, data and design, build, testing, launch and support. Discovery produces a scope and fixed price, design checks real data and defines tests, build delivers weekly demos, testing measures accuracy and safety, launch moves from shadow mode to assisted mode to selective autonomy, and support covers monitoring and improvement.

### What do I need to provide for an AI project?

One decision maker, one day to day owner giving roughly 2 to 4 hours a week, access to test systems, 20 to 50 real examples with verified correct outputs, a list of sensitive data and feedback within two business days of each demo. Late access and missing examples cause most delays, so prepare them in the first week.

### How is an AI system tested before launch?

It is scored on a test set of real cases, including awkward ones, plus a safety set and failure tests, with thresholds agreed beforehand. Consistency matters: an agent that succeeds 75% of the time per try passes three tries in a row only about 42% of the time. Every change reruns the full set.

### Can I test an AI idea before committing to a full build?

Yes. The Vrisic AI Pilot costs $1,500 (£1,200, AED 5,500), runs 10 business days on your own data, and is credited in full against a build started within 60 days. It covers discovery and design in practice, so you see real accuracy on your own cases, and a written recommendation, before committing to the larger fixed price.

### Why do AI projects run late?

Rarely because of the model. Common causes are test access arriving 1 to 4 weeks late, no verified examples of correct output, scope changes mid build, slow demo feedback and security reviews that start too late. Preventing them means requesting access in week one, writing a success measure, and naming one owner who answers within two days.

### What happens after the AI system launches?

Launch is staged: shadow mode, then assisted mode with human approval, then selective autonomy for safe categories. After that, support covers monitoring, fixes, model upgrades checked against the test set and a monthly report of accuracy, cost and overrides. You own the code, so you can maintain it yourself or use another vendor.

---
Vrisic · https://vrisic.com/ · Contact: info@vrisic.com · Book a call: https://vrisic.com/contact/