How to run an agentic AI project: a step-by-step playbook

In this lesson you'll learn:

• the twelve steps of an agentic AI project, in order, with the owner of each;
• what each step leaves behind, so you know when it is done;
• where the model helps at each step, and the one decision per phase it must never make.

Sound familiar?#

• The project plan is a Gantt chart with "build the agent" as one bar in the middle.
• Nobody can say who decides whether the agent is good enough to launch.
• The steps exist, but in the wrong order: the prototype came first and the requirements were written around it.

The order is the point. Every step below makes a later one cheaper, and doing them out of order is how agentic projects end up rebuilt.

The twelve steps#

P0 · Frame: is it worth doing, and is it AI at all?#

Step 1 · Measure the pain. Turn the request into one line: who has the problem, how often, what it costs today, and the evidence. Owner: product manager. P0 Frame

Step 2 · Decide whether it is AI at all. A genuine judgement call? Enough volume? Recoverable if wrong? Two or three of your top five requests will come back as rules. Owner: product manager.

Step 3 · Size the value and set autonomy per action. Net value after running and checking it, and an autonomy level for each action from what a mistake costs. Owner: product manager, with the sponsor.

P1 · Design & Spec: what exactly, and under whose authority?#

Step 4 · Map every step. Tag each step exact, best-guess or consequential; exact work goes in code. Owner: solution architect. P1 Design & Spec

Step 5 · Write the eight-field spec and derive the bars. One screen, acceptance in EARS, a bar per slice from damage and saving. Owner: product manager, with QA. How accurate an agent must be

Step 6 · Set the authority budget, and sign the hard gate. Every tool banded, every cap in a signature with a test. Nothing enters P2 until the spec, the bars and the budget are signed. Owner: solution architect. The hard gate

P2 · Build & Prove: does it meet the bar, slice by slice?#

Step 7 · Cut bolts, walking skeleton first. One unknown per bolt, cut by dependency, integrated the same day. Owner: engineering lead. Bolts vs sprints

Step 8 · Build the exact floor and the gated tools. Functions and tests before prompts; caps that raise; confirmation tokens the model cannot mint. Owner: engineering lead. Guardrails that hold

Step 9 · Put the harness in CI. Golden cases per slice, the lower bound reported, a merge blocked when a touched slice falls below its bar. Owner: QA lead. Prove the bar

Step 10 · Run it in shadow. The agent decides on live traffic and acts on nothing; agreement per slice over a window fixed in advance. Owner: QA lead. Shadow and cut-over

P3 · Run & Learn: is it still true, and what did it cost?#

Step 11 · Cut over at 5%, widen on evidence, rehearse the rollback. Each widening names the evidence that earned it. Owner: product manager and DevOps. P3 Run & Learn

Step 12 · Watch, report, and feed the next P0. Drift against two thresholds; the saving beside the spend; every incident turned into a control and a brief. Owner: sponsor. Drift · Postmortems

Where the model helps, and where it must not#

The board above draws it phase by phase: the model drafts, you check, and one thing per step is never delegated. The model can draft the pain register from interview notes, the spec from the PRD, the tests from the spec and the postmortem from the trace. It must not decide what a mistake costs your business, which actions it may take alone, whether a slice is good enough, or who is accountable: those are facts about your business, regulator and ledger that no context makes knowable from outside.

Where you'll use it#

• As the project plan's skeleton: twelve steps, each with an owner and an artefact, instead of one "build the agent" bar.
• In a kick-off, to show every role where it is accountable, and where it deliberately is not.
• As an audit checklist for a project already under way: find the first step that was skipped.

Why it matters#

Most agentic projects have the right activities in the wrong order. The prototype arrives before the pain is measured, so the value is unknown; the build starts before the bar is set, so "good enough" is argued at launch; the cap is decided in a document and enforced nowhere. The order in this list is what prevents each of those.

Key takeaways#

1. Twelve steps, four phases, one owner each, and the order is what makes later steps cheap.
2. Every step leaves an artefact, so "done" is something a sceptic can open.
3. The model drafts, you check, and one decision per step is never delegated.

FAQ#

What are the steps of an AI project?#

Measure the pain; decide whether it needs AI; size the value and set autonomy; map every step; write the spec and derive the bars; set the authority budget; cut bolts; build the exact floor and gated tools; put the harness in CI; run in shadow; cut over and widen; then watch, report and feed the next cycle.

How long does an agentic AI project take?#

It depends less on building than on evidence. A small change can run all twelve steps in an afternoon; a new agent typically takes weeks, and the longest single wait is usually the live evidence needed to widen a cut-over, which is set by traffic, not effort. SkyWays, this manual's worked example, ran ninety days.

Who should lead an agentic AI project?#

Each phase has one accountable owner (product manager, solution architect, engineering lead, and the sponsor for the running system) and the sponsor owns the lifecycle as a whole. A programme or delivery manager runs the cadence and the board across them.

What is the most common mistake?#

Building a prototype first and writing the requirements around it. The prototype then decides the autonomy, the architecture and the bar by default, and the team spends the rest of the project defending decisions nobody made on purpose.

Apply it in your role#

Across the enterprise. Run every AI project on the same twelve steps. The portfolio view is then comparable (which step, which evidence, which owner) whatever method each team uses inside it.

The ten-minute workflow. An honest status report in one prompt:

Here is our project status: <board export or notes>. Place each piece of work at the step it has
evidence for, not the one claimed: measure the pain, AI-fit, autonomy, step map, eight-field spec,
authority in code, bolts, harness, shadow, widen, drift, two numbers. List what each needs to move on.

Sources and credits#