Most companies I talk to have an agent somewhere between a demo and production, and it has been there for months. Nobody can say which stage it is in, so nobody can say what would move it. This essay is the map I use to answer that question, and the first in a series that goes deep on the two stages where pilots actually stall.
Where the four words come from
Google Cloud publishes an Agentic AI Transformation Framework. Its whitepaper, The New Agentic Landscape, describes a development lifecycle that runs from reimagining business processes, through use-case design and prototyping, into agent building, with quality and alignment as a continuous loop, all resting on foundational capabilities such as architecture, data, security, governance and what Google calls AgentOps. Google Cloud's own training summarises that lifecycle as four stages: discover, design, build, and scale.
I like the four words. They are the right size for a conversation with a leadership team, and they are vendor-neutral even though Google wrote them down. What follows is my version, shaped by what I have seen go wrong in Microsoft and Google agent projects, and by the open-source work we publish at zoff.tech. Google's framework is a catalogue of activities, roles and tools. Mine is narrower: for each stage, one deliverable the client keeps, and one test that says the stage is over.
Discover: find the work worth automating, and the check that says it worked
The question in Discover is not "where could we use AI". It is "which specific workflow, measured how, is worth a build". The deliverable is a short, costed opportunity map: two or three candidate workflows, the manual cost of each today, a rough build cost, and an honest row of things not to automate yet. I have written about why the audit itself is the product and how to identify the opportunities that are actually worth it.
The exit test is one sentence per candidate: here is how our own code will decide whether a run succeeded. A passing test, a closed ticket, a person's approval. If nobody can write that sentence, the workflow is not ready, and discovering that early is the cheapest thing that will happen all year.
Design: decide what the agent may touch, and write the eval before the prompt
Design is where the agent's boundaries get written down. What it can read, write, change without asking, escalate, and never touch: the permission map. Which knowledge lives in the model, in documents, or in verified experience. Where a verifier sits between the model and anything irreversible.
The deliverable is the evaluation: a set of real cases with expected outcomes and a threshold, written before anyone writes a prompt. The exit test is that the eval exists and has been run against a baseline, even if the baseline is a person doing the job by hand. Sometimes the eval kills the build. That is Design working as intended.
Build: ship something a real person uses by week two, and measure it against a holdout
This is where most of the money goes, and where most of the series goes too. A build at zoff.tech runs six to fourteen weeks. A real user is inside the system by week two, not at the end. The eval runs on every change. A random share of runs is held out so the agent's benefit is a number with an interval rather than a feeling.
The deliverable is a working agent plus three things most builds skip: the eval harness as a product, a runbook for the night it fails, and the holdout result. The exit test is a short list I call "done", and it gets its own essay: when is an agent done.
Scale: the second agent, the sixth month, and the dashboard
Scale is not "more traffic". It is the moment the agent stops being a project and becomes an operation. The second agent has to share permissions, memory and budget with the first. Someone has to own the thing at month six, when the model it was built on is deprecated. A leader has to be able to see, for every run, what it cost, whether it worked, and who is responsible.
The deliverable is an operating model: owner, cost per run, re-evaluation cadence, and observability that lets you answer "why did run 4812 do that" in minutes. The exit test is that the first agent is boring. Nobody talks about it in the Monday meeting, and that is the highest compliment an agent can receive.
Why Build and Scale get the attention
Discover and Design are where consultants like to spend time, because they produce decks. Build and Scale are where the pilot graveyard is. The common failure is a build that ends when the demo works, with no eval, no runbook, no owner and no measurement, followed by a Scale stage that never starts because nobody can prove the first agent helped. The rest of this series is about that gap:
- What a build actually looks like, week by week
- When is an agent done
- The second agent is harder than the first
- Who owns the agent at month six
- What a leader should be able to see about every agent run
- Where your AI pilot is stuck
If you want to know which stage your pilot is in, and what one thing would move it, that is what we do in a free AI readiness assessment. It usually takes one conversation to place it on the map.