- Intent boundary: Users, systems, upstream events
- Orchestration: Planners, routers, multi-agent graphs
- Tools: APIs, RPA, retrieval, code execution
- Memory: Short-term, long-term, episodic, semantic
- Guardrails: Input · tool · output policies
- Evaluation: LLM-as-judge, golden sets, red-team
Selecting use cases that survive real data
Generative workloads succeed where the source content is structured enough to retrieve accurately and the output is checkable. Document summarisation, drafting with human review, knowledge answering over curated corpora and structured extraction clear that bar. Open-ended reasoning over messy, contradictory enterprise content does not — and it is where most PoC graveyards start.
Retrieval quality is the whole game
In production incidents we review, the model is rarely at fault. The retrieval is: stale documents, conflicting policy versions, chunking that severs tables from their headers, and permission filters applied after retrieval instead of within it. Budget more for content remediation and retrieval evaluation than for model work, and measure retrieval precision separately from answer quality.
Evaluation before scale, in CI
A golden set of 100–300 real questions with graded reference answers, run on every prompt, model or index change, with a pass threshold that blocks deployment. Without this you cannot upgrade a model, change a prompt or re-index a corpus without risking silent regression — which is why so many generative systems freeze on the day they go live.
Production gates that risk functions accept
Permission-aware retrieval, input and output policy checks, full audit trail linking answer to sources and tool calls, human review on any action with financial or clinical consequence, and documented model-change control. In regulated sectors these are not enhancements — they are the difference between production and an indefinite pilot.
Cost control at production volume
Model routing by task complexity, caching on repeated retrieval, context trimming, and per-workload cost budgets with alerting. Cost per successful task is the metric — cost per token tells you nothing about whether the workload is economic. Model all of it at peak volume before you commit to a rollout.
Where generative AI is genuinely the right tool
Generative models excel at four things in the enterprise: turning unstructured content into structured data, drafting text that a human will review, retrieving and synthesising across scattered documents, and translating between formats or languages. They are a poor and expensive fit for deterministic calculation, exact lookups, and decisions requiring reproducible outputs. A large share of disappointing enterprise deployments are simply misapplications — a model asked to do arithmetic a query could do, or asked to be an authoritative source when it should have been retrieving one.
Retrieval quality decides output quality
In grounded enterprise applications, most quality problems are retrieval problems wearing a model costume. Chunking strategy, metadata and filtering, hybrid keyword and vector search, reranking, and freshness of the index all matter more than the choice between frontier models. Evaluate retrieval separately from generation: measure whether the right passage was in context before judging whether the answer was right. Teams that skip this diagnostic spend months swapping models to fix an indexing defect.
Cost engineering from the first prototype
Unit economics should be instrumented before scale, not after the first invoice shock. The levers are well understood: route cheap-first and escalate to larger models only when a check fails, cache aggressively at the prompt and retrieval level, keep context lean rather than stuffing whole documents, batch where latency allows, and set per-workflow budgets with alerting. Reporting cost per completed task alongside quality makes the trade-off visible to the business owner rather than hidden in a platform bill.
Evaluation is the deliverable that outlives the model
Golden sets, task-success definitions, LLM-as-judge rubrics with human calibration, regression thresholds in CI and drift monitoring in production are the assets that let you change models safely for years. They are also the deliverable most often skipped, because they are unglamorous and nobody demos them. Insist that any engagement leaves behind evaluation infrastructure you own and can run without the partner.
From prototype to production: the missing middle
The gap between a convincing prototype and a supported production service is where most generative programs die. Crossing it requires identity and entitlement enforcement, observability and tracing, rate limiting and graceful degradation, prompt and configuration version control with promotion between environments, an incident runbook, a rollback path, and a named on-call owner. None of it is exotic engineering — it is simply the work that no prototype required, which is why it never appears in the original plan or budget.
Use case selection and the honest no
The most valuable early contribution a consulting partner makes is declining use cases. A request to summarise regulated disclosures verbatim, to compute figures a query should compute, or to answer from data the enterprise cannot expose should be redirected rather than attempted. Maintain a written pattern library of what generative approaches suit and what they do not, and use it in intake conversations. Programs that accept every request build a portfolio of half-working assistants and lose the credibility needed for the ones that would have worked.
Security and data protection in generative systems
Generative systems introduce specific exposures: prompt injection through retrieved or user-supplied content, data leakage through over-broad retrieval, over-permissioned tool access, and derived artefacts such as embeddings and transcripts falling outside existing retention policy. Mitigations are architectural — treat all retrieved content as untrusted input, enforce entitlement at the tool layer rather than in the prompt, scope retrieval per user, classify and govern derived data, and red-team before launch with adversarial cases in the regression suite.
Human oversight and the review burden
Many generative deployments assume a human will check the output, without asking whether checking is faster than doing. If verifying a draft takes as long as writing it, the deployment has moved effort rather than removed it. Design for verifiability: cite sources inline, highlight what was extracted versus inferred, show confidence honestly, and structure output so a reviewer can scan rather than read. Measure review time explicitly during the pilot — it is the number that determines whether the business case is real.
Organisational patterns for generative delivery
Successful teams pair a domain expert with an engineer for the whole build rather than gathering requirements once. The domain expert curates the evaluation set, judges output quality and owns the knowledge; the engineer owns retrieval, tools and integration. This pairing catches quality problems in days rather than at user acceptance testing, and it produces the golden set that lets the workflow be maintained after the project ends.
What to insist on in a statement of work
Require a production deliverable rather than a prototype, evaluation infrastructure you own, documentation of prompts, tools and retrieval configuration, cost per task instrumentation, an incident runbook, and named internal engineers pairing throughout with a transfer milestone. Specify who owns the intellectual property and what happens on exit. These clauses cost nothing to include and determine whether you own a capability or rent one.
A ninety-day engagement structure that produces production software
Weeks one and two: select a single workflow with a named business owner, document the current process and its measurable baseline, confirm data access and entitlements are technically possible, and agree what success means numerically. Weeks three to five: build the retrieval foundation — content selection, chunking, metadata, hybrid search and reranking — and evaluate retrieval on its own before writing a line of generation logic, because a retrieval defect diagnosed here saves a month of model experimentation later. Weeks six to eight: build the generation layer and tool integrations, instrument tracing and cost per task from the first call, and construct the golden evaluation set with the domain expert who will own quality permanently. Weeks nine to ten: harden — entitlement enforcement at the tool layer, prompt-injection defences treating all retrieved content as untrusted, rate limiting, graceful degradation, versioned configuration with environment promotion, an incident runbook and a rollback path. Weeks eleven and twelve: shadow run against real inputs with human output comparison, tune against observed failures rather than anticipated ones, and measure review time to confirm the business case is real. Week thirteen: limited production release with progressive ramp and a named on-call owner. The deliverables at the end are a workflow in production, an evaluation harness running in CI that the enterprise owns, documented configuration, cost per task reporting, and at least one internal engineer who has shipped a change unaided. Engagements structured this way produce software; engagements structured around discovery, design and recommendation phases produce documents that describe software.
How to evaluate a consulting partner
Ask to meet the engineers who will do the work, not the leadership who sold it, and ask them to walk through a system they built end to end: retrieval design, evaluation harness, entitlement enforcement, cost per task, incident history and what they changed after it. Ask what they would refuse to build. Ask how knowledge transfer is structured and what your team will be able to change unaided at the end. Ask for a fixed first increment with a defined production outcome rather than an open discovery phase. Ask who owns the evaluation sets, the prompts and the infrastructure code — the answer should be you, in your repositories, from the first commit. Partners who answer these fluently will also tell you which parts of your ambition are premature, which is the single most useful thing a partner can do. Partners who answer with methodology diagrams and accelerator names are selling a programme rather than a system.
- Pick workloads where retrieval is accurate and output is checkable
- Retrieval quality, not model choice, explains most production failures
- A golden set in CI is what lets you change models and prompts safely
- Track cost per successful task, not cost per token, at peak volume
- Use generative models for extraction, drafting, synthesis and translation — not for arithmetic or reproducible decisions.
- Diagnose retrieval separately from generation; most quality failures are indexing and reranking failures.
- Instrument cost per completed task from the first prototype and route cheap-first with budgets and alerts.
- Evaluation infrastructure you own is what makes future model changes safe and cheap.
Questions leaders ask us
- What does generative AI consulting include?
- Use case selection against real data, retrieval and content remediation, evaluation harness design, production gates for risk and compliance, cost control at production volume, and delivery of the first workloads into production.
- Why do generative AI proofs of concept fail to reach production?
- Usually retrieval quality — stale or conflicting content, chunking that breaks structure, and permission filters applied after retrieval — combined with no evaluation harness, so nobody can prove the system is safe to scale.
- How do we control generative AI costs?
- Route by task complexity, cache repeated retrieval, trim context, and set per-workload budgets with alerting. Measure cost per successful task at peak volume rather than cost per token at pilot volume.
- When is generative AI the wrong choice?
- For deterministic calculation, exact lookups and any decision that must be reproducible and auditable at the token level. Use queries, rules or deterministic services and let the model handle language, not arithmetic.
- Do we need fine-tuning?
- Rarely at first. Retrieval quality, prompt structure and tool design resolve most gaps. Consider tuning for consistent format, domain tone or latency and cost reduction once a stable evaluation set exists.
- How do we control generative AI cost at scale?
- Cheap-first routing with escalation on failed checks, prompt and retrieval caching, lean context, per-workflow budgets with alerting, and cost per completed task reported next to quality.
- What separates a prototype from a production service?
- Entitlement enforcement, observability, rate limiting and degradation behaviour, versioned configuration with environment promotion, an incident runbook, rollback and a named on-call owner.