Inference
Running a trained model to produce an output: an answer, a summary, a transcript. Every model API call is an inference request.
Plain definitions for the words you meet when you buy, run and compare models.
The building blocks: what a model is, what a token is, and what happens when you call one.
Running a trained model to produce an output: an answer, a summary, a transcript. Every model API call is an inference request.
Building a model on huge datasets. Expensive, rare, and done mostly by model labs.
Extra training on a customer's own data to specialize an existing model for a task, tone or domain.
The trained AI system, e.g. Llama, Mistral, Qwen, DeepSeek, GPT or Claude.
The files that make up a trained model. Whoever has the weights can run the model.
The number of learned values in a model, written like 8B or 70B (billions). A rough signal of capability and of cost to run.
The unit models read and write. In English, one token is roughly three quarters of a word.
Input (prompt) tokens are sent to the model; output (completion) tokens are generated by it. Output is slower to produce and priced higher.
The most tokens a model can handle in one request, input and output combined, e.g. 128K.
The instructions and content sent to a model. The system prompt is the standing instruction an app sends with every request.
Numeric representations of text or images, used for search, matching and recommendations rather than for writing text.
Pulling relevant passages from the customer's own data into the prompt so the model answers from that data.
An application where a model plans and takes several steps, calling tools and other models along the way.
A model's ability to output structured requests to use external tools or APIs.
Forcing a model to reply in a fixed format such as JSON.
An open standard for connecting models and agents to tools and data sources.
Models that handle more than text: images, audio, video, speech-to-text or text-to-speech.
Open or closed, big or small: how models differ and what their licences allow.
The most capable models at any given time, usually from big labs such as OpenAI, Anthropic and Google. Almost always closed.
Available only through its creator's API or approved cloud partners. Weights are never released.
A model whose weights are published for anyone to run under a license, e.g. Llama, Mistral, Qwen, DeepSeek, gpt-oss.
Strictly, open-source AI means weights plus code and enough training detail to rebuild the model, under terms that allow any use. Most "open" models only publish weights.
The legal terms for using a model. Apache 2.0 and MIT are permissive; custom licenses can cap company size, restrict uses or require attribution. Meta's license for its multimodal Llama models, which covers all of Llama 4, grants no rights to EU-based companies (Llama 4 policy).
A dense model uses all its parameters for every token. An MoE model uses only some "experts" per token, written as total vs active parameters (e.g. 235B total, 22B active).
A model that writes out internal reasoning before answering, which improves results on hard tasks. Reasoning tokens are billed, usually as output.
A compact model, typically under about 10B parameters, cheap and fast to run.
Training a smaller model to imitate a larger one, keeping much of the quality at lower cost.
A light fine-tuning method that produces a small add-on file instead of a full new model. Many LoRAs can share one base model on the same GPUs.
Who built a model and where. Some buyers restrict models from certain countries, for example Chinese labs.
The main public hub where open models are published and downloaded. "Bring your own Hugging Face model" means deploying any model hosted there.
What "fast" means. The numbers that describe how quickly answers arrive.
How long a request takes. For generative models it splits into time to first token and per-token speed.
Time from sending a request to receiving the first token back.
Average gap between generated tokens after the first one.
Tokens a single request receives per second while generating.
Total tokens or requests a deployment processes per second across all users.
Total time from request to complete response, including the network.
Percentile latency. P95 means 95% of requests were faster than this value.
Number of requests processed at the same time.
Throughput that actually meets the latency target.
Delay while a model loads onto a GPU before it can serve, e.g. after scaling up from zero. Ranges from seconds to minutes.
Caps on requests per minute and tokens per minute for an account or API key.
A standard test. Quality benchmarks (e.g. MMLU, GPQA, SWE-bench) rate the model; serving benchmarks (e.g. Artificial Analysis, MLPerf Inference) rate speed, and sometimes price, across providers and hardware.
How inference is priced, and how to compare one bill with another.
The standard serverless pricing unit, usually quoted separately for input and output tokens.
One per-token price assuming a typical input-to-output ratio. Benchmark sites commonly use 3:1.
A discounted price for input tokens the provider has recently processed (see prompt caching).
A discount, often around 50%, for requests processed asynchronously within a window such as 24 hours.
Shared endpoints billed only for tokens used, with no capacity commitment. Also called model-as-a-service (MaaS).
The price of one GPU for one hour; the unit for dedicated capacity.
A model running on GPUs reserved for one customer, billed by time rather than tokens.
A balance bought in advance that usage draws down.
A contract to buy a set amount of capacity or spend over a term in exchange for a lower rate.
Capacity reserved in units of throughput rather than GPUs. Azure calls these PTUs; Amazon Bedrock and Google Vertex AI have equivalents.
The minimum spend agreed in a contract; overage is usage above it, billed at an agreed rate.
Spare capacity sold at a discount that can be taken back at short notice.
Different prices for the same model based on speed or reliability. Priority costs more and is served first; flex is cheaper and slower.
Charges for moving data out of a cloud.
Full cost of a solution: compute, engineering time, operations, compliance, support and switching.
The cost of one business outcome: a ticket resolved, a document processed, a call handled.
Models split text into tokens differently, so the same text can be a different number of tokens on each model.
Buying through the AWS, Azure or Google Cloud marketplaces, often counted against an existing cloud spend commitment (e.g. AWS EDP, Microsoft MACC).
Prices for a given level of model capability keep falling fast, year after year.
Where a model runs and who shares the machine it runs on.
Serverless: shared endpoints, pay per token. Dedicated: GPUs reserved for one customer, pay per hour.
Multi-tenant: customers share infrastructure. Single-tenant: hardware dedicated to one customer.
A pre-configured model, GPU and serving setup tuned for a good default.
A web interface for trying models with prompts before writing any code.
A region is a geographic location; zones are separate data centers within it.
Running in several regions and sending each request to the nearest or healthiest one.
Adding or removing GPUs automatically with demand. Scale-to-zero turns everything off when idle.
The model runs inside the customer's private cloud network, so traffic never crosses the public internet.
The provider's software runs in the customer's own cloud account, under their billing and controls.
Inference on hardware in the customer's own data center.
A deployment with no internet connection at all.
A mix of cloud and on-prem, or of serverless and dedicated.
Running models close to the user or on their device.
An API that accepts OpenAI's request format, so existing code works by changing the base URL and key.
Hosting a customer's own fine-tuned or proprietary weights.
The techniques behind quicker, cheaper answers from the same model.
Storing a model's numbers in fewer bits. Lower precision means less memory and faster, cheaper inference, with some risk to quality at the lowest levels.
Processing many requests together on one GPU. Continuous batching adds and removes requests on the fly.
Memory a model keeps of tokens already processed in a request, so it doesn't recompute them. Grows with context length.
Reusing the processed state of a repeated prompt prefix, such as a long system prompt or document.
A small draft model guesses several tokens ahead and the large model checks them in one step. The output is unchanged.
Prefill processes the input prompt (compute-heavy, sets time to first token). Decode generates output one token at a time (memory-heavy, sets tokens per second).
Running prefill and decode on separate GPU pools so each can be tuned on its own.
Splitting one model across several GPUs because it doesn't fit on one, or to make it faster.
Software that runs models on GPUs and handles batching and caching, e.g. vLLM, SGLang, TensorRT- LLM, with NVIDIA Dynamo coordinating them at scale. llama.cpp and Ollama are popular for local use.
Policies that decide where each request runs based on a goal such as lowest cost, best performance or best quality.
Sending each request to the most suitable model, e.g. easy requests to a small model and hard ones to a large one.
Returning a stored answer when a new request means the same as an earlier one, skipping the model.
The share of GPU time and capacity doing useful work.
The chips and machines that run models, and why capacity is tight.
The chips that run models. NVIDIA GPUs dominate; "accelerator" also covers AMD GPUs and custom AI chips.
NVIDIA's previous data center generation. The H100 is still the market's reference GPU; the H200 adds more memory.
NVIDIA's current volume generation, much faster than Hopper and built for low-precision (FP4) inference. B300 and GB300 are the upgraded "Blackwell Ultra".
The generation after Blackwell, pairing Rubin GPUs with Vera CPUs. First shipments began in Q3 2026, with volume ramping in Q4 (report).
AMD's data center GPUs. Large memory makes them strong for big-model inference.
Custom AI chips from Google (TPU) and AWS (Trainium, Inferentia), mostly available only inside those clouds.
Non-GPU chips built for very fast token generation, e.g. Cerebras, Groq's LPU, SambaNova.
High-speed memory on the GPU. Its size decides which models fit; its bandwidth largely sets how fast tokens are generated.
Floating-point operations per second, a measure of raw compute.
A node is one server, usually with 8 GPUs. A cluster is many nodes networked together.
Fast links between GPUs inside a server or rack (NVLink) and between servers (InfiniBand or high-speed Ethernet).
A full rack of GPUs (72 in the NVL72) wired to act like one giant GPU.
Data center capacity is now measured in megawatts. PUE is total facility energy divided by IT energy; closer to 1.0 is more efficient.
How many GPUs are available, and how long it takes to add more. Demand has even pushed up rental prices for older GPUs like the H100 in 2026 (report).
Where your data sits, whose law applies, and how it is protected.
Where data is physically stored and processed, e.g. "EU only".
Per-request records showing where each request was processed, with any exception flagged.
Data falls only under the laws and control of a chosen jurisdiction, not just stored there.
Infrastructure and models run under the legal and operational control of one jurisdiction, by entities based there.
A 2018 US law that lets US authorities require US-based companies to hand over data they control, even when it's stored abroad.
A 2020 ruling by the EU Court of Justice that struck down the EU-US Privacy Shield over US surveillance concerns.
The 2023 adequacy decision allowing personal data transfers to certified US companies. The EU General Court upheld it in September 2025; an appeal to the Court of Justice is pending (tracker).
Standard Contractual Clauses are EU-approved contract terms for transfers outside the EU; a transfer impact assessment checks the risks in the destination country.
The controller decides why and how personal data is processed (the customer). The processor handles it on their behalf (us). Sub-processors are the processor's own suppliers.
The GDPR-required contract between controller and processor setting how personal data is handled.
The provider stores no prompts or outputs once a request has been served.
A commitment never to use customer inputs or outputs to train or improve models.
What request data is recorded (content or only metadata), for how long, and where.
Records of who did what and when: logins, key creation, config changes, deployments.
Permissions assigned by role, e.g. admin, member, read-only.
Single sign-on lets staff log in with company accounts, often via the SAML standard. SCIM adds and removes users automatically.
Encryption while data moves over networks (TLS) and while it is stored.
Customers control the encryption keys for their stored data and can revoke them. In AI gateways, BYOK can also mean bringing your own model-provider API key.
Hardware protection that keeps data encrypted even while it is processed, so not even the operator can see it. Recent NVIDIA GPUs support it.
How well one customer's data and workloads are separated from others on shared infrastructure.
Automatically detecting and removing personal data before or after model processing.
Filters that block harmful, off-policy or sensitive inputs and outputs.
The standards and EU rules buyers ask about.
A US-origin security audit. Type I checks that controls are designed properly at one point in time; Type II checks they actually worked over a period, usually 6 to 12 months.
International certification for information security management, audited externally.
Privacy extension to ISO 27001, covering how personal data is handled.
International standard for AI management systems: how an organization governs the AI it builds or uses.
Government-backed cloud security frameworks in Germany (C5), France (SecNumCloud) and Spain (ENS). SecNumCloud also requires protection from non-EU laws.
The European Commission's method for scoring cloud providers on eight sovereignty objectives, from SEAL-0 (no sovereignty) to SEAL-4 (full EU supply chain, chips to software). Used in its EUR 180 million sovereign cloud tender awarded in April 2026 (Commission).
EU cybersecurity directive for essential and important entities across many sectors, including duties on supply-chain security.
EU regulation, applying since 17 January 2025, on how financial firms manage ICT risk, including risk from third-party providers (DNB).
EU law regulating AI by risk level: banned practices, high-risk systems, transparency duties and rules for general-purpose models. The 2026 AI Omnibus moved high-risk obligations to 2 December 2027, or 2 August 2028 for AI inside regulated products (K&L Gates).
AI Act term for models that can do a wide range of tasks, such as large language models. Obligations on their providers already apply; the Omnibus did not delay them.
The provider develops an AI system or model and puts it on the market; the deployer uses it in its own operations.
EU regulation, applying since 12 September 2025, that gives customers the right to switch cloud providers. Switching charges are banned from 12 January 2027 (Alston & Bird).
US health-data law. A BAA (business associate agreement) is the contract a vendor signs to handle US health data.
What keeps a model API dependable once it is in production.
SLA: the contractual promise (e.g. 99.9% uptime) with a remedy, usually service credits. SLO: the internal target. SLI: what is actually measured.
Availability as a percentage. 99.9% allows about 43 minutes of downtime a month; 99.99% about 4 minutes.
Switching automatically to a backup region, deployment or provider when one fails.
A layer in front of models that handles routing, failover, rate limits, caching, logging and access control across one or many providers.
A provider rejecting requests because limits or capacity are exceeded. 429 is the HTTP error code.
Metrics, logs and traces showing latency, errors, token usage and cost per request.
Locking an application to one model version so its behavior doesn't change unexpectedly.
When a provider retires a model version and customers must migrate.
Tests a customer runs on their own data to check a model is good enough for their use case.
A model producing confident but false information.
A public page showing service health; an incident is any outage or degradation.
Who provides what, and the words used to describe the market.
The largest clouds: AWS, Microsoft Azure and Google Cloud, sometimes Oracle. They sell models through platforms such as Amazon Bedrock and Google Vertex AI.
A cloud built on US technology but operated by EU companies, e.g. S3NS, the Thales and Google Cloud joint venture.
EU-headquartered clouds and AI platforms, e.g. OVHcloud, Scaleway, STACKIT and IONOS.
GPU-focused clouds that rent compute mainly to AI companies, e.g. CoreWeave, Nebius, Lambda, Crusoe.
Companies specializing in serving models through APIs and dedicated deployments, e.g. Together AI, Fireworks AI, DeepInfra.
Companies that build models, e.g. OpenAI, Anthropic, Google DeepMind, Meta, Mistral AI, DeepSeek, Alibaba (Qwen). Most also sell inference on their own models.
Services offering one API or catalog across many models and providers, e.g. OpenRouter, Hugging Face.
Data centers purpose-built for AI. In the EU, AI Factories and AI Gigafactories are publicly backed programs to expand European compute.
How hard it is to move to another provider: proprietary APIs, custom formats, contracts, egress.
Using several models and providers for resilience, cost and the best fit per task.
Getting better answers by spending more compute at inference, e.g. with reasoning models, rather than only by training bigger models.
When something gets cheaper, usage can grow so much that total spend rises.
One key, one endpoint. Your first call takes minutes.