What other models does OpenAI offer?

OpenAI's current lineup runs from a flagship reasoning tier down to lightweight, high-volume models built for cost-sensitive traffic. Here are some other models OpenAI supports:

• GPT-5.6 Sol: the flagship of the GPT-5.6 family, built for complex reasoning, coding, and long-horizon agentic work, with a 1.05 million token context window and pricing of $5 input and $30 output per million tokens

• GPT-5.6 Terra: the balanced, default tier in the same family, priced at $2.50 input and $15 output per million tokens, aimed at everyday production traffic that doesn't need Sol's peak reasoning depth

• GPT-5.5: OpenAI's prior-generation flagship, released in April 2026 and now positioned below the GPT-5.6 family, still available for teams running workloads validated against it

• GPT-5.4 mini: a lower-cost general-purpose model from the GPT-5.4 generation, available on OpenAI's free tier and suited to everyday tasks that don't require frontier-level reasoning

• GPT-5.4 nano: the smallest and cheapest model in the GPT-5.4 line, priced at $0.20 input and $1.25 output per million tokens, built for extremely high-volume, low-complexity work like classification and short-form extraction

How does GPT-5.6 Luna differ from OpenAI's other models?

Luna sits at the bottom of the GPT-5.6 family's cost and latency curve, trading peak reasoning depth for speed and price.

• Benchmark scores: On the Artificial Analysis Intelligence Index, Sol scores 59 (rank #4 of 189 tracked models), Terra scores 55 (#11), and Luna scores 51 (#20). Luna trails its siblings on raw intelligence but still lands well above the field median

• Pricing: Luna costs $1 input and $6 output per million tokens, with cached input at $0.10, versus $2.50/$15 for Terra and $5/$30 for Sol, roughly a fifth of Sol's rate

• Speed: Luna is the fastest of the three in Artificial Analysis testing, generating output at roughly 197 tokens per second versus 144 for Terra and 69 for Sol. The tradeoff runs opposite to price: Luna is both the cheapest and the fastest

• Context window and capabilities: All three models share the same 1.05 million token context window, 128,000 token max output, image input support, and function-calling and reasoning-token support. The tiers differ in reasoning depth applied per request, not in raw capability surface

Luna is the right pick when a product needs to process a high volume of requests at low latency and low per-token cost, and where Sol's or Terra's extra reasoning depth wouldn't change the outcome of most individual requests.

What models should I consider using alongside GPT-5.6 Luna?

No single model is optimal for every task. Here are models worth pairing with GPT-5.6 Luna depending on what your product needs:

• Gemini 3.5 Flash (Google): for workloads that lean on retrieval across very large documents or long multi-turn context, Gemini 3.5 Flash's long-context handling and Google-ecosystem integration cover ground Luna alone can't

• Grok 4.1 Fast (xAI): for latency-critical agentic workflows with heavy tool-calling, Grok 4.1 Fast's non-reasoning speed profile complements Luna for requests where even a lightweight reasoning pass adds too much delay

• DeepSeek V4 Flash (DeepSeek): for high-volume code generation where cost per request matters more than peak coding benchmark scores, DeepSeek V4 Flash gives you a cheaper option to route routine code tasks to

• Mistral Small (Mistral): for use cases that need an open-weight or self-hostable option, such as strict data residency requirements, Mistral Small covers simple classification and generation tasks without routing traffic through OpenAI at all

What are the challenges of using GPT-5.6 Luna in my product?

Like any production LLM, GPT-5.6 Luna comes with tradeoffs worth planning for:

• Provider dependency: Luna runs exclusively on OpenAI's infrastructure. An OpenAI outage, rate-limit change, or deprecation of the Luna checkpoint directly disrupts any product that hasn't built in a fallback

• Cost at scale: Even at $1/$6 per million tokens, Luna is a reasoning model that generates chain-of-thought tokens before its final answer. Those reasoning tokens bill as output, so verbose responses compound cost faster than the sticker price suggests without active monitoring

• Long-context price cliff: Pricing roughly doubles once a request crosses OpenAI's long-context threshold, moving Luna from $1/$6 to $2/$9 per million tokens. Workloads with unpredictable document lengths need to account for that jump, not just the standard rate

• Rapid version churn: OpenAI shipped GPT-5.4, GPT-5.5, and GPT-5.6 within roughly a year. Pinning to a specific model string carries real deprecation risk, and teams need a plan for migrating to newer tiers as older ones sunset

• Text-only output: Luna accepts image input but only returns text. Products that need generated images, audio, or video have to route those request types to a different model entirely, adding a second integration to maintain

Why should I use Merge Gateway to route LLM requests with GPT-5.6 Luna and every other model?

Using GPT-5.6 Luna through Merge Gateway gives you access to the model itself and the infrastructure layer around it:

• One API, every provider: Call GPT-5.6 Luna and every other major LLM through the same endpoint and API key. Switching providers means swapping a model string, not rewriting application code

• Intelligent routing and automatic failover: Merge automatically routes around OpenAI outages. Routing policies built on cost, latency, or quality signals can cut spend 40-60% without any changes to your application

• Cost governance: Set hard or soft budgets per project so Luna spend stays predictable. Every request rolls up to a model, project, and tag in one billing dashboard spanning every provider

• Build Your Own Router: Decide what "best" means for your traffic using curated ML benchmarks or your own eval scores. The router weighs each candidate model against those criteria and picks a winner per request, with a plain-language explanation attached

• Security and compliance controls: DLP rules and prompt injection protection run before any request reaches OpenAI. Per-project model and region policies get enforced centrally, without adding that logic into your product

How can I start routing requests to GPT-5.6 Luna via Merge Gateway?

Getting GPT-5.6 Luna running through Merge Gateway takes a few minutes:

1. Create an account and get your API key from the dashboard.

2. Install the Merge Gateway SDK: run pip install merge-gateway-sdk (Python) or npm install merge-gateway-sdk (Node). Alternatively, if you're already using the OpenAI SDK, set base_url = "https://api-gateway.merge.dev/v1/openai" and your existing code works as-is.

3. Make your first request using the provider/model format. For GPT-5.6 Luna, the model string is openai/gpt-5.6-luna. Swap the model string to route to any other provider without changing anything else.

4. Configure a routing policy in the dashboard to set failover behavior, cost limits, and optimization strategy. Your first policy can be as simple as naming GPT-5.6 Luna as primary with one fallback.

Full setup instructions and SDK references are in the Merge Gateway docs.