Glossary · Technology and models

Inference: definition, cost and latency

Definition

Inference is the process where a trained AI model turns an input into an answer. Unlike training, which happens once, inference runs again on every request. It determines how fast an answer arrives and what each call costs, because it consumes compute time on processors or graphics cards.

Why the Term Matters

In production the running cost arises not from training but from every single inference. Whoever takes an idea to a prototype needs to know early what a call costs and how long it takes. Otherwise a working demo becomes too expensive or too slow in daily use. A prototype makes inference cost and latency visible on real volume before the build.

When It Is Relevant

  • A service is called often and cost scales with volume.
  • Users expect a fast answer without noticeable waiting.
  • The choice between model sizes directly affects cost and speed.
  • Load peaks must be absorbed without the service breaking down.

When Not

For a one-off test or very rare use, inference efficiency barely matters, here only correctness counts. In an early feasibility check optimisation is premature too. Cost and latency become a topic only once real volume is behind it or users depend on speed.

Industries That Use It

  • Call centres and customer service: many concurrent requests need fast answers, otherwise conversations pile up.
  • Online retail: product search and recommendations must respond in fractions of a second, or customers bounce.
  • Industry and manufacturing: analyses near the machine need low latency instead of a long trip to the cloud.
  • Media and streaming: high user numbers make cost per inference the decisive lever.

Typical Use Cases

  • A smaller model handles simple requests, a large one only the hard cases.
  • Frequent answers are cached to save inference.
  • Long inputs are trimmed to lower compute time and cost.
  • Running near the point of use lowers latency noticeably.
  • A load test checks that the service stays stable under peaks.

Decision Guide

Decision Guide
SignalOptimise inferenceAlternative
High, growing volumecheck a smaller model and cachinglarge model only where needed
Fast answer expectedmeasure and lower latencybreak the task apart
One-off testrather notstart without optimisation
Cost running out of handtrim model size and inputscap volume

Example

An online retailer wants to improve product search with AI. In the workshop a prototype emerges that compares two model sizes and measures response time and cost per request. On real search volume it becomes clear where a smaller model is enough and where caching helps. This describes the method, not an asserted client metric.

Service Connection

The right entry is the AI workshop, then AI implementation and AI development.

Sources

This framing describes common practice around inference for AI models. Concrete costs, latencies and hardware needs depend on the model and setup and should be measured there.

Related topics Open-source modelsLLMOpsAI implementation

Book a strategy call

Test your use case in a conversation. Book your strategy call via the calendar: Book a strategy call. Alternatively by email: info@ki-agentur.co.

  • Pick a slot right in the calendar
  • Clarify your use case and goals together
  • A clear next step after the call

Or send an email to info@ki-agentur.co

Pick a free slot.

Frequently asked questions

Why does every request cost money?
Because every inference consumes compute time. Whether paid through an API or run on your own hardware, each call uses processors or graphics cards. That is why cost scales with the number of requests.
How do you lower inference cost?
Through smaller models for simple cases, caching frequent answers and shorter inputs. Often the combination of these steps helps more than a single big leap.
What affects response time?
Mainly the model size, the length of the output and the distance to the compute infrastructure. Running near the point of use and a well-chosen model shorten the wait noticeably.