Which GitHub Copilot model fits which task? A practical selection guide

There is no single “best model” in GitHub Copilot. Start with GPT-5.6 Luna when the task is small and cheap to verify; GPT-5.6 Terra or Claude Sonnet 5 for everyday features and multi-file work; GPT-5.6 Sol or Claude Opus for ambiguous debugging and architecture review; and GPT-6 Astra or Claude Fable 5.1 when an agent must work independently for a long stretch.[1] This is not my benchmark result. It is a routing rule derived from GitHub’s current task categories and pricing table.[1][4]

The task-based decision table

• Small fix, docstring, regex, utility function: GPT-5.6 Luna. Alternatives: Claude Haiku 4.5 or Gemini Flash.[1]
• Everyday feature, test generation, reversible multi-file refactor: GPT-5.6 Terra or Claude Sonnet 5.[1]
• Unknown root cause, architecture trade-off, large-codebase analysis: GPT-5.6 Sol or Claude Opus.[1]
• Long repository research, end-to-end feature work, multi-stage agent task: GPT-6 Astra or Claude Fable 5.1.[1]
• Screenshot, diagram, or UI bug: choose a model with visual input in a Copilot client that supports it.[1][2]

GitHub places Luna in small, fast work; Terra in balanced everyday coding; Sol in hard reasoning over large codebases; and Astra in long-horizon tasks with continued planning and independent verification.[1] Its table puts Haiku in fast work, Sonnet in general coding and agent tasks, Opus in deep reasoning, and Fable 5.1 in substantial long-running agent workflows.[1] Those are vendor and GitHub product claims, not a quality guarantee for your repository.

1. Small and reversible work: Luna, Haiku, or Flash

A name change, short test, explanation, or utility function rarely deserves the slowest model in the menu. GitHub maps its fast-model group to quick edits, syntax help, small prototypes, and one-off code suggestions.[1] It calls GPT-5.6 Luna the lowest-cost member of the GPT-5.6 family.[1] GitHub’s task examples also route a simple list transformation to a lightweight model and test generation to Haiku.[3] Start here when you can state the boundary in one sentence and verify the result with lint, a test, or a short diff.

The published rates show how wide the gap can be. In GitHub’s table checked on September 8, 2026, Luna’s standard tier costs $0.20 per million input tokens and $1.20 per million output tokens.[4] Astra is listed at $10 and $50.[4] These are the current token rates used for Copilot AI credit calculations, not a separate API bill, and they can change.[4] On a tiny task, a heavy model may buy expensive waiting rather than useful accuracy.

2. Everyday development: Terra or Sonnet

A balanced model is the saner default for a new endpoint, a test that follows existing patterns, or a reversible refactor across several files. GitHub describes Terra as a balanced all-round choice for interactive and agentic coding, while Sonnet 5 sits in its general coding and agent-task category.[1] Asking for a short plan, the files to be changed, and the test commands usually adds more control than blindly moving up a model tier.

My routing choice would be to start on Terra, then move to Sonnet or Sol if the model misreads the existing architecture twice. You can route work downward too. Once the ambiguity is gone and only implementation remains, there is little reason to leave the heavyweight model on for the rest of the session. Treat model switching like queue management, not brand loyalty.

3. Ambiguous bugs and architecture: Sol or Opus

When several services, old abstractions, or incomplete logs are involved, the fastest answer may not be the cheapest one. GitHub’s deep reasoning group covers multi-file debugging, large refactors, cross-layer planning, and library trade-offs.[1] It describes Sol as the highest reasoning ceiling in the GPT-5.6 family.[1] Opus also sits in the deep reasoning category.[1]

Do not ask for code first. Ask for candidate root causes, the evidence that would separate them, affected files, and a rollback plan. Then test the smallest hypothesis. A persuasive explanation from a stronger model is still not verification.

4. Long autonomous work: Astra or Fable 5.1

An agent-tier model makes sense when repository research, feature work, and repeated tool calls will genuinely run for a long stretch. GitHub positions Astra for long-horizon coding with continuous planning, batched diagnosis, and independent confirmation.[1] It positions Fable 5.1 for deep codebase research and complex agent workflows.[1] Both appear as generally available in GitHub’s supported-model list, although access can still depend on plan, client, and organization policy.[2]

Tokens are only part of the cost. You also pay in review time for a large diff, wasted agent time, and unrelated edits. Before launching the agent, write the acceptance criteria, forbidden areas, test command, and stop condition. Without those boundaries, a stronger model can travel farther in the wrong direction.

The Copilot surface matters too

Copilot does not expose every model in every client or feature.[2] GitHub maintains separate client and feature availability tables, plus minimum IDE versions for recent models.[2] If a model is missing, check your Copilot plan, organization policy, client support, and extension version before treating it as a model-quality problem.

For the mechanics of Auto and the point where manual selection becomes useful, read the GitHub Copilot Auto vs manual guide. This article answers a different question: where to route a task after you open the manual model menu.

A three-stage route for solo builders

• Start: write the cost of a wrong result and how you will verify it. Use Luna/Haiku/Flash for cheap-to-reverse work and Terra/Sonnet for ordinary development.
• Escalate: move to Sol/Opus if the plan misses a dependency, two attempts fail in the same place, or ambiguity expands. Consider Astra/Fable when the task becomes genuinely long-horizon.
• Close: read the changed-file list and diff; run the relevant test, lint, and build; then check the product behavior yourself. The agent’s “done” message is not evidence.

For the depth, speed, and cost split inside the GPT-5.6 family, use the Sol–Terra–Luna pillar guide. This Copilot route does not repeat that guide; it adds the cross-vendor menu and task queue around it.

If the selected model also exposes a thinking control, the low-vs-high reasoning task guide covers the next decision.

Before merge, run the seven-step agent-output verification checklist. The model tier can change. Your responsibility for the result does not.

Singrey note

My rule is plain: fast model for small work, balanced model for daily work, deep reasoning for ambiguity, and an agent model for long autonomous jobs. Leaving the “most powerful” option on all day does not create trust. It hides the cost of the decision. Routing each job is less exciting, but it protects both the budget and the attention I still need for review.