Sequence length is how many tokens are in this particular input right now; context window is the model's fixed maximum capacity. One changes with every request and grows with each generated token; the other is baked into the architecture and never moves. A request to GPT-5.5 might use 3,000 tokens of a 1M token window. Cost, KV cache memory, and latency all scale with the live sequence length, not the advertised window size.
Here is the correction: **sequence length** and **context window** describe two different quantities, and confusing them leads to wrong cost estimates and capacity planning.
Sequence length is how many tokens are in this particular request right now. It includes the prompt plus everything the model has generated so far. A request might start at 1,200 tokens (just the prompt) and grow to 1,800 after 600 generated tokens. It changes with every request and grows with every emitted token.
The context window is the model's fixed upper bound, baked into the architecture by the positional encoding and exposed as `model_max_length` or `max_position_embeddings` in the config. GPT-5.5 has a 1M token window, Claude Opus 4.7 has 1M, Gemini 3.1 Pro has 2M, Llama 4 Maverick has 1M. These numbers never change at inference time.
The distinction matters because cost, KV cache memory, and latency all scale with the live sequence length, not the advertised window. A 1M token model used for a 3,000 token request costs the same as a 4K model for that request. When sequence length hits the context window, the runtime must stop, truncate, or fail. The window is the ceiling; the sequence length is where you actually are.
**Sequence length** and **context window** are related but distinct. Sequence length is a property of a single request at a single point in time; context window is a property of the model.
Sequence length is the count of tokens in one specific input at one moment. It includes everything the model is currently attending to: chat template wrappers, system prompt, user message, retrieved chunks, assistant turn so far. During generation it grows by one for every emitted token.
Context window is the maximum sequence length the model can ever handle, set at training time by the positional encoding and fixed across all requests. The HuggingFace surface is `tokenizer.model_max_length` and config's `max_position_embeddings`. 2026 numbers: Llama 3 8B base 8K, Llama 3 long-context 128K, GPT-5.5 1M, Claude Opus 4.7 1M, Gemini 3.1 Pro 2M, Llama 4 Maverick 1M.
The distinction matters in three places. **Cost**: it scales with sequence length, not window, so a 1M model used for 4K requests bills like a 4K workload. **Generation control**: when sequence length hits the window, the runtime stops, truncates, or errors. **Debugging**: context length errors are almost always miscounted sequence length, not a changed window.
Quick reference
TL;DR
Sequence length is the live token count of this request right now; context window is the model's hard ceiling that never changes. Cost and memory scale with the live count, not the advertised maximum.
Think of a parking lot. The context window is how many cars the lot can hold; it is a fixed property of the lot. The sequence length is how many cars are parked right now; it changes as cars arrive and stops going up when the lot is full. The model's context window is the lot capacity. The sequence length of a specific request is the current car count. People confuse the two because vendors quote the lot's capacity and forget that any given request has its own current count.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Quoting a context length for billing purposes. Pricing is per token of sequence length, not per context window. The window is the ceiling, not the price.
Comparing two models on long context capability. Window size alone says nothing about attention quality at long lengths; effective context is what matters, not nominal ceiling.
Sizing KV cache memory for a small batch of short requests. Memory scales with sequence length, so a small request on a 1M model uses no more KV memory than the same request on a 4K model.
Quick scan · 2–4 min
Everything important, quickly.
3 min: define sequence length as a per-request live count, context window as the model's hard ceiling, name the config fields, anchor the 2026 numbers, and close on how cost and KV memory scale with the live count not the advertised window.
Real-world examples
Real products, models, and research that use this idea.
1OpenAI usage responses include prompt_tokens, completion_tokens, and total_tokens; total_tokens is the final sequence length for that request.
2Anthropic's client.messages.count_tokens reports the input sequence length before a Claude call so you can budget against the 1M context.
3vLLM logs max_model_len (context window) at startup and per-request prompt_tokens plus output_tokens (sequence length).
4HuggingFace tokenizer.model_max_length exposes the context window; len(input_ids) is the prompt sequence length.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QIf a model's context window is 128K but my requests average 4K tokens, am I paying for 128K?
Sign in or go Pro to see the approach for this follow-up.
QHow does sequence length interact with prompt caching?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Saying a 128K model means every request uses 128K tokens. The 128K is the ceiling. A specific request might use 800 tokens or 80,000; the sequence length is per request and grows during generation.