GPT-6.1 Sol vs GPT-6 Luna Copilot: Which to Pick

GitHub deprecated GPT-5.5 and GPT-5 mini across Copilot on October 19, 2026, and the official replacements are GPT-6.1 Sol and GPT-6 Luna. If you had GPT-5.5 or GPT-5.4 selected anywhere in Copilot, GitHub now points you to GPT-6.1 Sol; if you were on GPT-5 mini or GPT-5.4 mini, the replacement is GPT-6 Luna. Copilot Enterprise administrators may need to enable them through model policies first.

The short version: GPT-6.1 Sol is the heavier reasoning model for complex coding work, and GPT-6 Luna is the cost-sensitive, high-volume model. Sol costs $2.00 per million input tokens and $10.00 per million output tokens at standard rates; Luna costs $0.10 per million input and $0.50 per million output. That is a 20× difference on both input and output. Pick Sol when the work is hard and you want fewer iterations; pick Luna when the work is repetitive and token volume matters more than per-turn quality.

What GitHub deprecated on October 19, 2026#

GitHub deprecated the following models across most Copilot experiences, including Copilot Chat, inline edits, ask and agent modes, and code completions:

The deprecations were announced on September 18, 2026, giving about a month of warning. GitHub says no action is required to remove the deprecated models; they simply stop being selectable. The GitHub changelog post has the official wording.

GPT-6.1 Sol vs GPT-6 Luna at a glance#

Both models share a 1.05M token context window, 128K max output, and the same tool set. The differences are in reasoning effort levels, price, and knowledge cutoff:

Pricing is from OpenAI's pricing page and model specs from OpenAI's models page, both as of October 20, 2026.

A few things stand out:

1. Luna supports the none reasoning effort level; Sol does not. If your workload is mostly retrieval or formatting and you want the model to skip reasoning tokens, Luna is the only one of the two that allows it.

2. Luna's knowledge cutoff is slightly later (May 18, 2026 versus April 30, 2026 for Sol). Not a huge factor for code work, but worth knowing if you lean on the model for general knowledge.

3. Both support the same tools: Functions, Web search, File search, and Computer use.

Cost in practice#

Standard short-context pricing (up to 272K input tokens) tells most of the story, but there are more tiers:

Luna does not have an Ultrafast row on the pricing page. If you need Ultrafast, Sol is the only option of the two, at 6× the standard rate.

Long-context pricing (above 272K input tokens) doubles the standard rate on both models: Sol goes to $4.00 input and $15.00 output; Luna goes to $0.20 input and $0.75 output. With Copilot's 1.05M context window, long-context pricing is realistic for large-repo agent runs.

Here is a quick cost estimator for standard short-context pricing:

def estimate_cost(input_tokens, output_tokens, model):
    rates = {
        "gpt-6.1-sol": {"input": 2.00, "output": 10.00},
        "gpt-6-luna": {"input": 0.10, "output": 0.50},
    }
    r = rates[model]
    cost = (input_tokens / 1_000_000) * r["input"] + (output_tokens / 1_000_000) * r["output"]
    return round(cost, 6)

# A typical Copilot Chat turn: 8k input, 1.5k output
for model in ("gpt-6.1-sol", "gpt-6-luna"):
    print(f"{model}: ${estimate_cost(8_000, 1_500, model)} per turn")

Reasoning effort and when it matters#

Both models accept a reasoning effort parameter, but the allowed values differ:

• gpt-6.1-sol: low, medium, high, xhigh, max
• gpt-6-luna: none, low, medium, high, xhigh, max

Sol cannot be set to none. If you want a model to act as a non-reasoning completions engine, similar to the old GPT-5 mini behavior for fast inline work, Luna with reasoning: none is the closer match. Sol is better when you want the model to think through a multi-file refactor or an agent loop.

For Copilot Chat, reasoning effort is managed by Copilot itself, so you will not be setting it directly in the IDE. But if you also call the same models through the OpenAI Responses API for adjacent tooling, the Responses API previous_response_id guide covers chaining turns there, and the reasoning effort is something you control per request.

Enabling the new models in Copilot Enterprise#

If you are on Copilot Enterprise, the new models may not appear in your selector until an administrator enables them. The GitHub changelog says Copilot Enterprise administrators may need to enable access to alternative models through their model policies in Copilot settings. As an administrator, you verify availability by checking your individual Copilot settings and confirming that the policy is enabled for the specific model. Once enabled, you see the model in the Copilot Chat model selector in VS Code and on github.com.

The changelog does not mention other IDEs for this verification step. If you use a JetBrains IDE or another editor, check your model selector after the policy is enabled.

No action is required to remove the deprecated models. They simply stop being selectable.

Choosing between Sol and Luna for Copilot work#

GitHub's mapping is straightforward: GPT-5.5 and GPT-5.4 map to Sol, and GPT-5 mini and GPT-5.4 mini map to Luna. That mapping is a reasonable default. Here is how I would think about it per workload:

Use GPT-6.1 Sol for: - Agent mode tasks that span multiple files or require planning - Ask mode questions where you want a thorough answer - Complex refactors, architecture questions, and debugging sessions - Inline edits that touch several related functions

Use GPT-6 Luna for: - Code completions (the autocomplete you get while typing) - High-volume chat where you are asking many small, independent questions - Workloads where token cost is the primary constraint - Cases where you want reasoning: none for the fastest possible response

If you were happy with GPT-5 mini for completions and lightweight chat, Luna is the direct successor and you will likely not notice a quality drop for routine work. If you were using GPT-5.5 for agent and ask mode, Sol is the closer match.

Gotchas and common mistakes#

Mixing up GPT-6 Sol and GPT-6.1 Sol. OpenAI released GPT-6 Sol (gpt-6-sol) on September 22, 2026 and GPT-6.1 Sol (gpt-6.1-sol) on September 29, 2026. They are different model IDs. GitHub's suggested alternative for GPT-5.5 is specifically GPT-6.1 Sol. If you call the API directly in adjacent tooling, use gpt-6.1-sol to match what Copilot is now using.

Expecting Luna in Ultrafast mode. The pricing page lists Ultrafast pricing for gpt-6-astra and gpt-6.1-sol only. Luna does not have an Ultrafast row. If you need Ultrafast, move up to Sol.

Assuming the model shows up in every IDE. The changelog says the model appears in the Copilot Chat model selector in VS Code and on github.com after the enterprise policy is enabled. It does not mention JetBrains or other editors. Verify in your specific IDE after enabling the policy.

Forgetting that Sol does not support none reasoning. If you were using GPT-5 mini with no reasoning for fast completions and you switch to gpt-6.1-sol expecting the same behavior, Sol will still reason at low minimum. Use gpt-6-luna with reasoning: none if you need the no-reasoning mode.

Long-context pricing catches you off guard. Above 272K input tokens, standard pricing doubles. For a 500K-token agent run on Sol, you pay $4.00 per million input tokens, not $2.00. With Copilot's 1.05M context window, this is real.

Not updating workflows and integrations. GitHub asks you to update your workflows and integrations to use supported models. If you have anything that references the old model names by string, update those references to gpt-6.1-sol and gpt-6-luna.

Quick reference#

Checklist: - Confirm your Copilot Chat model selector in VS Code or github.com shows GPT-6.1 Sol and GPT-6 Luna - If on Copilot Enterprise, ask your admin to enable the new models in Copilot settings under model policies - Update any references to gpt-5.5, gpt-5.4, gpt-5.4 mini, or gpt-5 mini to the new model IDs - If you call the Responses API directly, use gpt-6.1-sol for Sol and gpt-6-luna for Luna - If you relied on none reasoning effort, use Luna, since Sol does not support none - Budget for long-context pricing (2× standard) if your agent runs exceed 272K input tokens - If you need Ultrafast mode, use Sol, since Luna does not have an Ultrafast tier

Quick answers