English for OpenRouter Model Routing

OpenRouter’s value proposition is a single API that routes requests across many LLM providers, and teams building on it need vocabulary for describing routing decisions, fallback behavior, and cost that stays precise even as the underlying provider changes request to request. This guide covers the terms.

Key Vocabulary

Provider routing — OpenRouter’s mechanism for selecting which underlying provider (e.g., a specific inference host for an open-weight model) actually serves a given request, which can vary between calls to the same model. “The latency spike wasn’t the model’s fault — provider routing sent that batch of requests to a slower backend than usual.”

Fallback model — a secondary model specified in the request that OpenRouter uses automatically if the primary model is unavailable or rate-limited. “We set a fallback model so that if the primary model’s provider has an outage, the request doesn’t fail outright — it degrades to the backup instead.”

Unified pricing / normalized cost — OpenRouter’s practice of exposing per-token pricing in a consistent format across providers, making cost comparison possible without reading each provider’s own pricing page. “Unified pricing is why we can compare cost per request across three different model providers in one dashboard, instead of reconciling three separate billing formats.”

Rate limit passthrough — the behavior where a rate limit hit at the underlying provider surfaces to the OpenRouter client as a distinguishable error, rather than being silently absorbed or misreported. “Check whether this 429 is a rate limit passthrough from the provider or an OpenRouter-side limit — the retry strategy differs for each.”

Model slug — the string identifier (e.g., provider/model-name) used to specify exactly which model and often which provider variant a request should target. “Double-check the model slug — a typo there silently routes to a different, more expensive model instead of failing loudly.”

Context length negotiation — OpenRouter’s handling of requests that specify a context window larger than a given provider supports, either rejecting or routing to a provider that supports the requested length. “We hit an error because of context length negotiation — the fallback provider for this model has a smaller context window than the primary one.”

Common Phrases

• “Is this a rate limit from OpenRouter itself, or is it a rate limit passthrough from the underlying provider?”
• “Did we set a fallback model for this request, or does a provider outage just fail the call outright?”
• “Are we comparing cost using OpenRouter’s unified pricing, or pulling numbers from the providers directly?”
• “Is the model slug correct here, or is it silently routing to the wrong provider variant?”
• “Does the fallback model support the same context length as the primary, or could that cause a truncation issue?”

Example Sentences

Explaining a fallback strategy in a design doc: “We’re configuring two fallback models behind the primary — if the primary provider is down, requests degrade to a comparable model rather than failing the user-facing feature entirely.”

Reporting an unexpected cost spike: “Our per-request cost jumped because provider routing shifted a chunk of traffic to a provider with different pricing for the same model — we’re now pinning the provider explicitly to keep cost predictable.”

Debugging an intermittent context error: “The failures only happen on the fallback path, which turned out to be a context length negotiation issue — the fallback provider caps context shorter than what we’re sending.”

Professional Tips

• Distinguish an OpenRouter-side rate limit from a provider passthrough rate limit explicitly — the correct retry and escalation path differs between the two.
• Reference the model slug exactly when reporting a routing bug — “the model” is ambiguous when multiple provider variants exist for the same underlying model.
• Use unified pricing when justifying a cost comparison across providers, since it signals you’re using OpenRouter’s normalized figures rather than an apples-to-oranges manual calculation.
• Call out whether a fallback model is configured when discussing reliability — an unhandled provider outage without a fallback is a single point of failure worth flagging explicitly.

Practice Exercise

1. Explain in one sentence the difference between provider routing and a fallback model.
2. Write a bug report describing a cost spike caused by provider routing.
3. Describe, in your own words, what a rate limit passthrough is.