GPT-5.6 Luna vs GPT-6 Astra
Which one, when
Both gpt-5.6-luna and gpt-6-astra share the same 1050000 context window, 128000 max output, text and image input, and a thinking mode that can be turned off. gpt-5.6-luna is the cheaper one, at $0.2 input, $1.2 output and $0.02 cached input against $10, $50 and $1 for gpt-6-astra, so it costs about 50x less on input and cached input and about 42x less on output. Pick gpt-5.6-luna to keep costs down, or gpt-6-astra if you need its 2026-04 knowledge cutoff instead of 2026-02.
Benchmarks
18 measured on both.
Vendor-published: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Pricing
| GPT-5.6 Luna | GPT-6 Astra | Δ | |
|---|---|---|---|
| Input / 1M tokens | $0.2 | $10 | 0.02× |
| Output / 1M tokens | $1.2 | $50 | 0.024× |
| Cache read / 1M tokens | $0.02 | $1 | 0.02× |
| Cache write | no separate charge | no separate charge | - |
Rates from the live catalogue at build time; each model page carries the current rate card.
Where they sit · input price per 1M tokens across all 79 chat models on this billing unit (log scale)
Capabilities
| GPT-5.6 Luna | GPT-6 Astra | |
|---|---|---|
| Tool calling | yes | yes |
| Thinking control | configurable | configurable |
| Structured output | yes | yes |
| Prompt caching | implicit (automatic) | implicit (automatic) |
| Cache lifetime | 5-10m, up to 1h | 5-10m, up to 1h |
| Minimum cached prefix | 1024 tokens | 1024 tokens |
Specs
| GPT-5.6 Luna | GPT-6 Astra | |
|---|---|---|
| Input modalities | text image | text image |
| Output modalities | text | text |
| Released | 2026-07-09 | 2026-09-03 |
| Knowledge cutoff | 2026-02 | 2026-04 |
| Context window | 1.1M | 1.1M |
| Max output | 128K | 128K |
| Thinking parameter | reasoning.effort | reasoning.effort |
| Accepted values | reasoning.effort
| reasoning.effort
|
| Default | medium | medium |
Specs are transcribed from each vendor’s documentation; a row a vendor does not publish is left out rather than inferred. Full sources: GPT-5.6 Luna · GPT-6 Astra
One prompt, both models, measured through the gateway
GPT-5.6 Luna passed · 3 sentences
Enabling reasoning causes the model to use substantially more computational steps and generated tokens per request, even when the visible answer is similar. Because our provider charges based largely on token consumption and compute, that increased processing translated into roughly twice the cost. We can control the expense by reserving reasoning for complex tasks, setting token and effort limits, and monitoring cost per successful outcome.
out 146 tok (+60 thinking) latency 3.1 s
GPT-6 Astra passed · 3 sentences
Enabling reasoning makes the model do more work per request, often generating internal reasoning tokens that are billed even though they do not appear in the final answer. If traffic, model choice, and pricing stayed the same, those extra tokens likely explain why our bill doubled—not longer answers or more users. We should verify the usage breakdown, then reserve higher reasoning levels for tasks where improved results justify the added cost.
out 283 tok (+196 thinking) latency 17.2 s
Instruction following (exactly three sentences, so countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
GPT-5.6 Luna passed · 8/8 cases
```python def longest_run(xs): if not xs: return 0 best = cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 else: best = max(best, cur) cur = 1 return max(best, cur) ``` The bug is that `cur` counts equal *transitions* rather than the number of items in the current run, so a single-element run returns `0` and a run of length `n` returns `n - 1`; additionally, `best` is only updated when a run is interrupted, so a run continuing through the final element is not finalized before returning. Initializing the current run to one item, resetting it to one after a change, and taking a final `max` fixes both issues.
out 356 tok (+161 thinking) latency 4.7 s
GPT-6 Astra passed · 8/8 cases
```python def longest_run(xs): if not xs: return 0 best = cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 else: cur = 1 best = max(best, cur) return best ``` The original code counts equal adjacent pairs rather than items, so every nonempty run is undercounted by one: a single-element input returns `0`, and a run of three equal items returns `2`. Starting and resetting `cur` to `1` counts the first item of each run, while the empty-input check preserves a result of `0`. Updating `best` after each iteration includes runs ending at the last index without needing a final flush; the original also updated during trailing runs, but undercounted them.
out 321 tok (+131 thinking) latency 13.5 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
GPT-5.6 Luna passed · 5/5 fields, guidance "Withheld pending the Q4 close"
{"company":"Meridian Robotics","quarter":"September quarter","revenue_usd_m":412,"growth_pct":null,"guidance":"Withheld pending the Q4 close"}
out 227 tok (+181 thinking) latency 3.6 s
GPT-6 Astra passed · 5/5 fields, guidance "Formal guidance is withheld pending the "
{ "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": null, "growth_pct": "eleven and change", "guidance": "Formal guidance is withheld pending the Q4 close." }
out 329 tok (+267 thinking) latency 16.9 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
GPT-5.6 Luna passed · 120 words, 0 banned, 1 question
Introducing PromptCache, an API gateway feature that caches prompts across providers, helping teams reduce latency, control spend, and deliver consistent results. How much faster could your applications respond when repeated prompts are served from a shared cache instead of being sent upstream? PromptCache supports provider-aware routing, configurable time-to-live policies, encrypted storage, cache invalidation, and usage analytics through one operational layer. It works with language-model providers while preserving your authentication, observability, and fallback workflows. Developers can enable caching by endpoint, model, tenant, or prompt pattern, then monitor hit rates and savings in real time. Built for production workloads, PromptCache gives platform teams controls for performance and cost without requiring application rewrites. […]
out 948 tok (+778 thinking) latency 8.0 s
GPT-6 Astra passed · 120 words, 0 banned, 1 question
Introducing Cross Provider Prompt Cache, a new API gateway feature that reuses eligible prompt content across supported AI providers. Why pay to process the same context every time? Configure caching once at the gateway, then route requests between models while keeping shared instructions, reference material, and conversation prefixes ready for reuse. Caching controls let teams set expiration windows, isolate tenants, and exclude sensitive content. Cache analytics show hit rates, estimated savings, and latency trends, helping developers tune performance with confidence. Existing routing policies continue to work, so adoption fits your current architecture. Start with a single application, measure the results, and expand as needed. Available today in the dashboard and API, with documentation and examples to guide your first deployment.
out 665 tok (+516 thinking) latency 19.3 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Switch between them with one line
Both ids are in every tab below; the highlighted pair of lines is the only edit. Same endpoint, same key, same request shape.
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="gpt-5.6-luna",
# model="gpt-6-astra", # uncomment this line, comment the one above
messages=[{"role": "user", "content": "Summarize this diff"}],
reasoning_effort="medium",
)
print(resp.choices[0].message.content)import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://synthorai.io/v1",
apiKey: "sk-syn-...",
});
const resp = await client.chat.completions.create({
model: "gpt-5.6-luna",
// model: "gpt-6-astra", // uncomment this line, comment the one above
messages: [{ role: "user", content: "Summarize this diff" }],
reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);curl https://synthorai.io/v1/chat/completions \
-H "Authorization: Bearer sk-syn-..." \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-5.6-luna",
# "model": "gpt-6-astra", # uncomment this line, comment the one above
"messages": [{"role": "user", "content": "Hello"}],
"reasoning_effort": "medium"
}'package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithBaseURL("https://synthorai.io/v1"),
option.WithAPIKey("sk-syn-..."),
)
resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
Model: "gpt-5.6-luna",
// Model: "gpt-6-astra", // uncomment this line, comment the one above
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
ReasoningEffort: openai.ReasoningEffortMedium,
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("gpt-5.6-luna")
// .model("gpt-6-astra") // uncomment this line, comment the one above
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));FAQ
Which is cheaper, GPT-5.6 Luna or GPT-6 Astra?
GPT-5.6 Luna is cheaper on the "Input / 1M tokens" row ($0.2 vs $10, 50× apart). Other rows may point the other way; the table above carries the full rate card, and real cost depends on your mix.
Can I A/B test GPT-5.6 Luna against GPT-6 Astra without two integrations?
Yes. Both are served through the same OpenAI-compatible endpoint with one API key. Switching is a one-line change to the model id, so you can route a fraction of traffic to each and compare bills directly.
Do GPT-5.6 Luna and GPT-6 Astra support prompt caching?
Yes. Both bill cache reads below their input rate, so warm-prefix workloads cost less than the list rates suggest. The exact cache-read rows are in the pricing table above.