Generative AI Services: Scope, Pricing and Delivery Model (2026 Buyer Guide)

The seven service lines inside "generative AI services"

Before comparing vendors, decide which of these you are actually buying. Most proposals bundle three or four of them without saying so, which is why quotes differ by 5x for what looks like the same project.

• Use-case discovery and feasibility: scoring candidate workflows against data availability, accuracy tolerance, and cost per run.
• LLM application development: chat surfaces, copilots, document generation, summarisation and classification pipelines.
• Agentic workflow engineering: multi-step systems that call tools and internal APIs, with approval gates and rollback paths.
• Retrieval and knowledge infrastructure: ingestion, chunking, embeddings, hybrid search, permissions-aware retrieval (RAG).
• Model selection, fine-tuning and distillation: choosing between frontier APIs and open-weight models, and shrinking cost once accuracy is proven.
• Evaluation, observability and guardrails: labelled eval sets, regression runs on every change, tracing, PII redaction, and audit logs.
• Private and self-hosted deployment: running the whole stack in your VPC or on-premise so prompts and outputs never leave your boundary.

What generative AI services cost in 2026

These are the bands we see across mid-market and enterprise engagements. Quotes far below usually exclude evaluation and integration; quotes far above usually contain a large strategy component.

• Feasibility spike on one workflow: $15k-$45k over 2-4 weeks, ending with a measured accuracy number on your real data.
• LLM application (single surface, integrated): $45k-$120k over 6-10 weeks.
• Production agentic workflow with tool access: $60k-$180k over 8-14 weeks including evals, tracing and human gates.
• Enterprise RAG platform across multiple sources with permissions: $120k-$350k over 12-20 weeks.
• Private or self-hosted deployment uplift: typically 20-35% on top of the equivalent API-hosted build.
• Run cost: $0.002-$0.15 per execution for most text workflows once prompts are optimised and caching is in place.
• Improvement retainer: $8k-$25k per month for eval regressions, model upgrades and new increments.

Model selection is a cost decision, not a taste decision

The model choice sets your unit economics for the life of the workflow. The correct pattern is to build against a frontier model to establish the accuracy ceiling, then push work down to cheaper or open-weight models wherever the eval suite says quality holds.

Concretely: prove the workflow with a top-tier model, capture 200-500 labelled examples from real traffic, then test smaller models and distilled variants against that same set. Most production workflows end up as a routed mix — a small model handling 70-85% of traffic and a frontier model handling the hard tail. That routing decision alone commonly cuts inference spend by 60% or more without moving the accuracy number.

• Frontier API models: fastest to accuracy, highest per-token cost, data leaves your boundary unless a private deployment option is used.
• Open-weight models in your own tenancy: lower marginal cost at volume, full data control, more engineering to operate.
• Fine-tuning: worth it for narrow, high-volume, format-strict tasks — rarely worth it before retrieval and prompting are exhausted.
• Routing and caching: the highest-return optimisation in almost every deployment, and the most commonly skipped.

A delivery model that produces working software

The failure mode in this category is a long analysis phase followed by a rushed build. The sequencing below inverts that — every phase ends with something executable and measurable.

• Week 1-2 — Boundary and baseline: name the business metric, the current baseline number, and the exact workflow boundary. Collect a labelled sample of real inputs.
• Week 3-4 — Feasibility spike: thin end-to-end slice against real data. Report accuracy, latency and cost per run. Kill or continue on evidence.
• Week 5-10 — Production build: integrations, retrieval, tool-calling, approval gates, tracing, and the eval suite running in CI.
• Week 11-14 — Shadow and rollout: run alongside humans on live traffic, compare outputs, then release behind gates that loosen as evidence accumulates.
• Ongoing — Regression discipline: every prompt, model or tool change re-runs the eval suite before it ships.

How to measure ROI before you commit budget

A generative AI service only pays back through one of four mechanisms. Write down which one applies, with numbers, before signing anything.

• Labour displacement: (minutes saved per task × task volume × loaded hourly cost) − run cost − maintenance.
• Throughput gain: additional units processed per period at unchanged headcount, valued at contribution margin.
• Error reduction: current defect rate × cost per defect × expected reduction, verified against the eval set rather than a vendor claim.
• Revenue latency: faster quotes, replies or onboarding converting more of an existing pipeline — measure on a holdout, not in aggregate.
• Subtract honestly: inference, retries, observability, human review time, and roughly 15-20% of build cost annually for maintenance.

Security, data boundaries and compliance

Generative AI touches sensitive data faster than any other project type, and the boundary decisions are hard to reverse later. Settle them in the contract, not in the pitch.

• Name every provider in the request path, including embedding and reranking services.
• Require an explicit no-training clause covering prompts, outputs and telemetry.
• Enforce permissions at retrieval time — a RAG index that ignores document ACLs is a data breach with a chat interface.
• Log prompts and outputs with PII redaction, defined retention, and access controls that an auditor can inspect.
• Ask for ISO 27001 and SOC 2 aligned infrastructure, and a private or self-hosted deployment path if your data cannot leave your tenancy.
• Keep code, prompts, evals and infrastructure-as-code in your repositories from week one so exit is never a renegotiation.

Ten questions that separate builders from deck-writers

Ask these on the first call. Weak vendors answer in adjectives; strong ones answer in numbers and artefacts.

• What accuracy did your last comparable workflow reach, measured how, on what sample size?
• What is the cost per run at our expected volume, including retries?
• Can we see an eval suite from a real project?
• Which parts run in our tenancy, and what leaves it?
• What is your rollback path when a model update degrades quality?
• Who owns the repository and prompts on day one?
• What is the human-in-the-loop design, and what criteria remove a gate?
• How do you handle permissions in retrieval?
• What will our team need to operate this after handover?
• What would make you tell us not to build this?

Frequently asked questions

What are generative AI services?

They are the professional services around building with large language models: feasibility work, LLM application and agent development, retrieval infrastructure, model selection and tuning, evaluation and guardrails, and private or self-hosted deployment. Most vendor proposals bundle several of these, so identify which lines you are paying for before comparing quotes.

How much do generative AI services cost in 2026?

A feasibility spike runs $15k-$45k, a single integrated LLM application $45k-$120k, a production agentic workflow $60k-$180k, and an enterprise RAG platform $120k-$350k. Improvement retainers typically sit between $8k and $25k per month, and run cost is usually $0.002-$0.15 per execution.

How long does a generative AI project take?

A feasibility spike takes 2-4 weeks. A first production workflow typically ships in 8-14 weeks including evaluations, tracing and human approval gates. Enterprise retrieval platforms across multiple permissioned sources run 12-20 weeks.

Should we use a frontier API model or an open-weight model?

Build against a frontier model to establish the accuracy ceiling, then route traffic down to cheaper or open-weight models wherever your eval suite shows quality holds. Most production systems end as a routed mix, which commonly cuts inference spend by 60% or more without losing accuracy.

Can generative AI services run entirely on our own infrastructure?

Yes. The full stack — models, retrieval, orchestration and logging — can run inside your VPC or on-premise using open-weight models, so prompts and outputs never reach a third-party provider. Expect roughly a 20-35% uplift over an API-hosted build in exchange for full data control.

How do we measure ROI on generative AI?

Pick one mechanism — labour displacement, throughput gain, error reduction, or revenue latency — write the baseline number before the build, and subtract inference, retries, human review and about 15-20% of build cost annually for maintenance. Verify the improvement on a holdout rather than in aggregate.