Most AI roadmaps are a list of ambitions with quarters attached. This one is sequenced by
dependency: each stage produces an asset the organisation owns, and each gate has to close
before the next stage is worth starting. Run them out of order and you get the familiar
result — an impressive demonstration attached to nothing.
The full picture sits on the AI transformation page; this is the
stage-by-stage detail.
Stage 01 — Establish the floor
What happens. Measure the real workload: query volume per month, average context
length, peak concurrency, and which modalities are actually in scope. Then run the
arithmetic on whether owning infrastructure makes sense at all.
Why it is first. Because it can end the programme, and it should be allowed to.
Below roughly 90,000 queries a month, no on-premise deployment pays back inside three
years — including the cheapest one available. That figure ignores electricity and staff
time, so the true floor sits higher. A team of twelve at around 400 queries each per month
spends about ₹1,200 a month on frontier API access — roughly ₹43,000 over three years,
against ₹8.1 lakh of hardware. The correct advice there is to use a cloud API.
Above the floor, volume sets the pace. A mid-enterprise reference fleet crosses over at 18
months at one million queries a month, 12 months at 1.5 million, and 9 months at two
million. An entry deployment crosses at around four months, because the hardware costs a
tenth as much.
The variable most organisations miss is context length, which moves the crossover more
than hardware price does. Longer contexts, premium model tiers and agentic workloads that
chain several model calls per user action all pull crossover earlier — they raise token
throughput without raising capital cost. Retrieval-heavy and agentic work run long contexts
by construction, which is the actual commercial argument for owning.
What you own at the end. A sizing model and a defensible go/no-go, with the assumption
set written above the table rather than buried in it.
Gate: finance can reproduce the number without the vendor in the room.
Stage 02 — Ground the estate
What happens. Connect the document estate. Parse it — layout-aware, because a table
that becomes a wall of text is a table that produces wrong answers. Chunk it. Index it with
hybrid retrieval, lexical and semantic together, because business vocabulary contains part
numbers and clause references that pure semantic search handles badly.
Then do the part that decides whether the project ships: inherit the source system's
permissions into the index.
Why it matters more than the model choice. An index that does not carry the estate's
access model will surface documents to people who could not open them in the original
system — and the defect is invisible in testing, because pilot users usually have broad
access. It appears months later, in front of exactly the wrong person.
This stage is also where scope discipline pays. Ingesting everything is slower, more
expensive and worse than ingesting the corpora that answer real questions. Start with the
document sets attached to decisions people actually make.
What you own at the end. A retrieval index over your own corpus that is faithful to
your access model.
Gate: a user with restricted access runs a query designed to surface a restricted
document, and does not get it.
Stage 03 — Answer, with citations
What happens. Put grounded question-answering in front of the people who need it, with
every answer carrying its source to page level.
The distinction that matters. A system that answers is not the same as a system that
answers checkably. Without a citation path the burden of correctness transfers silently
from the system to the reader, which is what compliance functions object to even when they
phrase it differently.
The failure to test for before going wide. Aggregation questions are not retrieval
questions. "How many of our contracts carry an uncapped indemnity" requires every
contract to be examined, not ten passages to be found. A retrieval system will answer from
ten passages and return a confident number that is wrong. Route those questions
differently, or refuse them explicitly — a system that says "this requires a full scan"
is more valuable than one that guesses.
What you own at the end. Cited answers over your own knowledge, on your own hardware.
Gate: a reviewer can trace any sampled answer back to the paragraph that produced it.
Stage 04 — Act, under budget
What happens. Move from answering to doing. Agents execute multi-step work — pulling a
record, drafting a document, updating a system — under explicit step and token budgets,
with circuit breakers and human checkpoints at the decisions that warrant them.
Why budgets are the design centre. An agent without a step budget is an unbounded
process attached to your systems. Budgets, scope isolation so an agent reaches only its
assigned data, and signed hand-offs between agents are what make autonomy something a risk
committee can approve. The useful framing for that committee is not "how capable is it"
but "what is the maximum damage a single run can do, and how would we know".
What you own at the end. Workflows that execute, each action attributable and logged.
Gate: a run can be reconstructed after the fact — who triggered it, what context it
used, what it changed.
Stage 05 — Scale and own
What happens. Extend across functions on the same core rather than buying a second
system. Connect internal systems over MCP so agents reach what you already run. Keep
models, index and memory in-house.
The economics of this stage are the point of the whole programme. The second
deployment in an organisation costs less than the first, because retrieval, agent runtime
and the privacy rail are already installed and only the domain configuration is new. That
is the difference between a platform and a subscription: the platform gets cheaper per use
case, the subscription gets more expensive per seat.
What you own at the end. A platform. The accumulated context — corrections, domain
vocabulary, institutional judgement built up over months — is an asset on your side of the
wall rather than a relationship that ends with a contract.
Gate: a new use case can be stood up by your own team without the original vendor.
On timelines
Deployment of the platform itself runs in days, not quarters, because the stack is
built once and configured per organisation rather than rebuilt each time. What varies —
sometimes by a lot — is stage 02. The state of the document estate is the schedule risk on
almost every programme, and any timeline offered before that estate has been surveyed is a
guess.
Sequence honestly, let stage 01 be allowed to end the programme, and the rest follows.
Next: Build, buy or rent enterprise AI
· Why AI pilots fail to reach production
