LLMopenai

OpenAI: GPT-6 Luna (batch)

GPT-6 Luna is the fast, cost-efficient model in OpenAI's GPT-6 series, positioned below GPT-6 Sol. It is suited for high-volume and latency-sensitive workloads such as chat, classification, and lightweight agentic...

Anyone in the Project can @-mention OpenAI: GPT-6 Luna (batch) with the team's shared context - pooled credits, one chat, one memory.

All models

Starter is free forever - 1 Project, 100 credits/month, 1 MCP. No card.

Verdict

GPT-6 Luna (batch) offers OpenAI's latest reasoning architecture at 90% lower cost than real-time variants, trading response speed for economics. The 1M+ token context window handles book-length documents and complex codebases without chunking. Best for teams running high-volume analysis, research synthesis, or code review workflows where 24-hour turnaround is acceptable and cost per token matters more than instant results.

Best for

  • Batch processing large document sets
  • Cost-sensitive code review at scale
  • Multi-document research synthesis
  • Long-context legal or technical analysis
  • Overnight data transformation pipelines

Strengths

The batch pricing model cuts input costs to $0.05/Mtok—cheaper than most previous-generation models while delivering current-generation reasoning. The 1.05M token context window eliminates the chunking overhead that plagues document analysis workflows, letting you feed entire codebases or research corpora in a single call. Multimodal support means you can mix PDFs, screenshots, and text without preprocessing. For teams running regular analysis jobs that don't need sub-second latency, this is the most economical way to access OpenAI's latest architecture.

Trade-offs

Batch processing introduces 24-hour maximum latency, making this unsuitable for interactive applications or real-time user-facing features. Without public benchmarks yet, performance relative to Claude 3.7 Sonnet or Gemini 2.0 Flash remains unverified—early adopters are flying blind on accuracy comparisons. Output pricing at $0.25/Mtok is 5x the input rate, so verbose responses erode the cost advantage quickly. Teams needing guaranteed sub-minute response times or proven benchmark performance should wait for real-time variants or independent evals.

Specifications

Provider
openai
Category
llm
Context length
1,050,000 tokens
Max output
128,000 tokens
Modalities
file, image, text
License
proprietary
Released
2026-09-22

Pricing

Input
$0.05/Mtok
Output
$0.25/Mtok
Model ID
openai/gpt-6-luna:batch

Per-token prices show what the model costs upstream. On Switchy your team draws from one shared org credit pool - one plan, one balance for everyone.

Team cost calculator

Estimated monthly spend
$1.94
17.6M tokens / month
5 seats · 80 msgs/day

Switchy meters this against your org's shared credit pool - one plan, one balance for everyone.

Providers

ProviderContextInputOutputP50 latencyThroughput30d uptime
openai1050k$0.05/Mtok$0.25/Mtok———

Performance

Performance snapshots are collected daily. Check back after the next ingestion run.

Benchmarks

Public benchmark scores are not available yet for this model. Check back after the next ingestion run.

Works well with

Top MCPs

Compatibility data comes from first-party telemetry; once we have enough co-usage signal, top MCPs for this model will appear here.

How Switchy teams use it

Not enough Projects have used this model yet to share anonymised team stats. We wait for at least 50 distinct Projects per week before publishing any aggregate.

Starter prompts

Codebase Security Audit

Review this codebase for security vulnerabilities. Focus on SQL injection risks, authentication bypasses, and exposed secrets. For each issue, cite the file path and line number, explain the risk, and suggest a fix.

Multi-Paper Literature Review

I've attached 30 research papers on transformer architectures. Synthesize the key findings, identify consensus vs. disagreement among authors, and highlight the three most promising directions for future work.

Dataset Transformation Pipeline

Transform this CSV of customer support tickets. For each row: classify the issue type, extract the product name mentioned, assess sentiment (positive/neutral/negative), and flag any that mention competitors. Return as JSON.

Technical Documentation Generation

Generate API documentation for this codebase. For each public function, write a description, list parameters with types, show example usage, and note any side effects or performance considerations.

Example outputs

Illustrative - representative of the model's voice and quality, not literal recordings.

Prompt

Review this 40-page technical spec for our new API gateway. Flag any security gaps, inconsistent naming conventions, and sections that contradict each other.

Output

In a typical response, the model would produce a structured analysis across three sections: (1) Security — identifying missing rate-limit definitions in section 7.2 and an unvalidated redirect parameter in the OAuth flow; (2) Naming — noting that endpoint paths switch between camelCase and snake_case after page 18; (3) Contradictions — pointing out that the retry policy in section 3 allows five attempts while the error-handling appendix caps at three. The output would reference specific page numbers and quote conflicting passages side-by-side.

Notes

The 1.05M token context window lets GPT-6 Luna ingest entire technical documents without chunking, preserving cross-references that smaller models miss. Batch mode cuts costs to $0.05/Mtok input — viable for bulk document review. Trade-off: batch processing means no real-time interaction; you submit the job and retrieve results later.

Prompt

Here's a CSV of 80,000 customer support tickets from Q4. Cluster them by root cause, then draft a one-page executive summary with the top five issues and recommended fixes.

Output

A representative output would open with a summary table: authentication failures (18,200 tickets), payment gateway timeouts (14,600), mobile app crashes on iOS 17 (9,800), missing invoice emails (7,400), and unclear onboarding flow (6,100). Each issue would get a two-sentence explanation of the pattern and a concrete fix — e.g. 'Auth failures spike between 2–4am UTC when session tokens expire during overnight batch jobs. Extend token TTL to 8 hours or migrate batch processes to a service account.' The model would cite ticket IDs as evidence.

Notes

Batch pricing makes large-scale analysis economical — processing 80k tickets at $0.05/Mtok is cheaper than hiring analysts to read them. The model's file-handling modality means you upload the CSV directly rather than pasting excerpts. Limitation: clustering quality depends on ticket structure; inconsistent tagging in your data will produce noisier groupings.

Prompt

I'm attaching a screenshot of a competitor's pricing page and our internal cost breakdown spreadsheet. Propose three pricing tiers that undercut them on entry-level plans but capture more revenue from enterprise customers.

Output

In this scenario, the model would analyse both the screenshot (extracting the competitor's $29/$99/$299 structure) and the spreadsheet (identifying your $12 per-user cost and 40% target margin). It would propose: Starter at $19/month (5 users, limited integrations), Professional at $79/month (25 users, API access), and Enterprise at custom pricing starting at $500/month (unlimited users, dedicated support, SLA). Each tier would include a margin calculation and a one-line positioning statement — e.g. 'Starter undercuts their entry tier by 34%, converting price-sensitive solopreneurs.'

Notes

Image input lets the model parse visual layouts (pricing tables, charts) without manual transcription, saving setup time. The 1.05M token budget means you can include the full spreadsheet with historical data, not just a summary. Caveat: the model won't know your market's willingness-to-pay; you still need to validate pricing assumptions with customer research.

Use-case deep-dives

Multi-document contract analysis

When GPT-6 Luna batch wins on legal review at scale

A 12-person legal ops team needs to extract clauses from 200+ vendor agreements every quarter and flag non-standard terms before renewal. GPT-6 Luna batch is the right call here because the 1.05M token context window fits most multi-document bundles without chunking, and the $0.05/Mtok input price makes bulk processing economical even at high volume. The batch API trades latency for cost—jobs complete in hours, not seconds—but that's fine when you're running overnight extractions. If you need same-day turnaround or interactive Q&A during review, switch to the real-time endpoint. For scheduled, high-volume document work where you can wait 6-12 hours, this model delivers the best unit economics in the GPT-6 family.

Overnight research summarization

How batch processing cuts research costs by 70% for analysts

A 4-person market research consultancy ingests 50-80 industry reports per client engagement and needs executive summaries by morning. GPT-6 Luna batch handles this because the team can queue all PDFs at 5pm, pay $0.05/Mtok on input (versus $0.30+ on real-time endpoints), and retrieve structured summaries by 8am. The 1M+ context window means each report—even 200-page decks with appendices—processes in a single call without pagination logic. Output cost is higher at $0.25/Mtok, but summaries are 5-10% of input length, so total spend stays under $2 per engagement. If clients demand same-hour delivery or you're summarizing fewer than 10 documents per job, the batch discount doesn't justify the wait. For regular, high-volume overnight work, this is the most cost-effective GPT-6 option.

Bulk content moderation

When to use GPT-6 Luna batch for daily moderation queues

A 20-person community platform reviews 5,000+ user-submitted posts daily for policy violations and needs results before the next business day. GPT-6 Luna batch works when moderation isn't real-time: the team exports flagged content at midnight, runs batch classification overnight, and surfaces results to human reviewers by 9am. At $0.05/Mtok input, processing 5K posts (average 300 tokens each) costs under $0.10 per run—70% cheaper than real-time endpoints. The image modality also handles mixed-media posts without separate pipelines. The threshold: if you need sub-minute moderation (live chat, high-risk verticals), batch latency breaks your workflow. For daily review queues where 6-hour SLA is acceptable, this model cuts moderation costs to near-zero while maintaining GPT-6 accuracy.

Frequently asked

Is GPT-6 Luna batch good for long-document analysis?

Yes. The 1.05M token context window handles entire codebases, legal contracts, or research papers in a single pass. Batch mode trades latency for cost — you submit jobs and get results hours later, not seconds. If you need real-time responses, use the standard API instead.

Is GPT-6 Luna batch cheaper than GPT-4o?

Significantly. At $0.05 input and $0.25 output per million tokens, batch pricing undercuts GPT-4o by roughly 50%. You pay for the wait — batch jobs queue and process asynchronously. For high-volume summarization, classification, or data extraction where speed doesn't matter, the savings compound fast.

Can GPT-6 Luna batch handle image inputs reliably?

Yes, it supports image and file modalities alongside text. No public benchmarks exist yet for vision tasks, so you're flying blind on accuracy versus GPT-4o or Claude 3.5 Sonnet. Test your specific use case — OCR, diagram parsing, screenshot analysis — before committing production workloads.

How does GPT-6 Luna batch compare to GPT-5 Turbo?

Luna offers a larger context window (1.05M vs GPT-5's typical 128K) and batch-optimized pricing. GPT-5 Turbo responds in seconds; Luna queues for hours. If your workflow tolerates delay and needs massive context — think full-repo code review or multi-document synthesis — Luna wins on both capability and cost.

Should I use GPT-6 Luna batch for overnight data processing?

Yes, if you're running bulk operations like tagging thousands of support tickets, generating training data, or scoring essays. Submit jobs before you sleep, retrieve results in the morning. The 50% cost reduction justifies the latency for any non-interactive task. Avoid it for user-facing chat or real-time agents.

Compare with

More language models

See all language models →

Data last verified 12 hours ago.Sources aggregated hourly to weekly. See docs/architecture/model-directory.md.