GitHub Copilot Auto: Efficiency, Balance, or Intelligence? Which tier fits each task?

On September 14, GitHub added three preferences to Copilot Auto: Efficiency, Balance, and Intelligence.[1] The choice is no longer limited to Auto versus a manually selected model. You can now tell Auto how to weigh cost, response time, and quality. This is a substantial update to my September 4 Auto-versus-manual guide, not a second URL targeting the same question.

The short answer: start with Efficiency for small work that is cheap to verify, Balance for ordinary development, and Intelligence for ambiguous tasks where a wrong answer is expensive. A tier does not pin one model. GitHub says all three tiers draw from the same model pool, and Auto makes a fresh choice for each prompt.[1]

What do the three settings change?

GitHub describes Efficiency as cost-first, Balance as a trade-off across cost, quality, and latency, and Intelligence as quality-first.[1] These are routing preferences, not new model names.

That distinction matters. Selecting Intelligence does not force the heaviest model on every prompt. In GitHub's example, a simple docstring task may still go to a small model even when Auto is optimizing for intelligence.[1]

The task-based decision table

• File rename, docstring, short test, explanation, small utility: Efficiency.
• Feature across a few files, test addition, well-scoped refactor: Balance.
• Unknown root cause, architecture decision, large-codebase review: Intelligence.
• Reproducible comparison where the exact model must stay fixed: manual selection.
• Work constrained by data policy, organization rules, or client support: check access first, then choose a tier or model.

That routing table is my recommendation, not a GitHub benchmark. The labels tell you what Auto will prioritize. They do not predict the success rate in your repository.

When Efficiency makes sense

Efficiency is a sensible first move when a bad result is easy to reverse and verification takes seconds. Think one function or one tightly bounded edit. Treat it as a cheap first attempt, then run a cheap check.

Move away from Efficiency when the task expands. If the agent touches unrelated files, repeats the same mistake, or misreads the requirement, the small-task assumption has already failed.

When Balance should be the default

Balance is the safest general default for a solo builder. A new endpoint, a UI change across a few files, or a refactor that follows an existing architecture needs both speed and enough reasoning to stay on track. GitHub describes Balance as the everyday option that considers cost, quality, and latency together.[1]

It still needs boundaries. Put the acceptance criteria, allowed files, and test command in the prompt. A tier cannot repair a vague task.

When Intelligence earns the extra weight

Use Intelligence when the root cause is unclear, a bad architecture choice would create a large diff, or the work crosses several services. Quality receives more weight in model selection, but that does not make the first answer true.[1]

Ask for analysis before code: candidate causes, evidence that would separate them, files likely to change, and a rollback plan. Test the smallest hypothesis first. A polished explanation from a costly model is still only an explanation.

Tier or manual model?

Use an Auto tier when you care about the result more than the model brand, the task changes shape during the session, and you do not want to route every prompt yourself.

Choose a model manually when you need a reproducible comparison, a specific context or vision capability, compliance requires a named model, or Auto has failed twice at the same point.

If you switch to manual selection, the task-based Copilot model guide maps jobs to named models. For the speed, cost, and depth split inside GPT-5.6, use the Sol-Terra-Luna pillar guide. This page does not repeat that model comparison. It covers the routing preference above it.

Do not guess what the tier costs

GitHub says usage is charged according to the model Auto actually selects, not the tier label.[1] It also says paid subscribers keep a 10 percent discount on usage billed through Auto.[1] Those are GitHub's product and pricing claims. Check the current table in your own account before making a budget decision because plans, quotas, and rates can change.

Intelligence is not a fixed expensive-model switch. Efficiency does not lock every prompt to one lightweight model either. If cost control matters, combine the tier with a narrow task boundary, a maximum attempt count, and a stop condition.

A three-step solo-builder route

1. Start: write down the cost of a wrong result and how you will verify it. Pick Efficiency for small work, Balance for daily work, and Intelligence for ambiguity.
2. Escalate: move from Balance to Intelligence if the agent misreads the requirement twice. If Intelligence stalls at the same point, stop changing tiers and bring in a named model or better evidence.
3. Close: read the diff, run the relevant test and build, then check the product behavior yourself. The agent-output verification checklist gives you a short closing sequence.

If your selected model also exposes a thinking control, the low-versus-high reasoning guide covers when to raise that second setting.

Where is it available?

GitHub says the feature is rolling out to Visual Studio Code, Copilot CLI, and the GitHub Copilot app.[1] If the options are missing, the rollout may not have reached your account. Check the client version, Copilot plan, and organization policy before treating it as a bug.