Choosing model and effort in ChatGPT/Codex

After upgrading to ChatGPT Pro, my most natural reaction was:

since I have Pro and Extra High now, important questions obviously get the top setting. Same in Codex: pick the strongest model, and push effort as high as it goes.

But after using it for a while, I found that isn’t the best approach.

Pro often does mean waiting longer; with Codex on high settings, the allowance also drains fast. Once, I used nearly a week’s usage in a single morning. More importantly, spending more time and allowance didn’t necessarily produce results that fit the current task better.

Some answers are more thorough, but also wordier; some simple questions get over-analyzed; for tasks like writing titles or tweaking wording, a lower setting may actually be more direct and natural.

The problem isn’t that the high settings are useless, but that:

model and effort don’t solve the same problem, and the top setting isn’t the standard answer for every task.

The product information below is as of July 2026.

1. What do model and effort each affect?

You can think of an AI task as asking someone to do a job.

The model is choosing who does it.

Different models don’t only differ in “strength”; they’re good at different things:

• some suit complex, open-ended tasks that need judgment;
• some suit everyday work, balancing capability, speed and cost;
• some suit clear, repetitive tasks that are easy to check.

Effort is deciding how much reasoning it puts in this time.

Higher effort usually means the model spends more compute breaking the problem down, comparing options, checking constraints and correcting results.

That doesn’t mean the answer will be longer.

High effort may think for a long time and end up giving just a few sentences; low effort may write something very long that hasn’t really been thought through.

Two other variables can’t be ignored either:

the prompt and context decide whether the task was explained clearly; tools and data decide whether the model has the material it needs to do the task.

So a poor answer isn’t necessarily because the model isn’t strong enough, or the effort isn’t high enough.

It may just be that:

• the goal wasn’t clear;
• a key file was missing;
• it didn’t search for the latest information;
• the acceptance criteria were unclear;
• or a task that should have been split up was crammed into one request.

Higher effort mainly solves “not enough reasoning”; it can’t solve every quality problem.

2. Why are high settings sometimes worse than low ones?

“Worse” here doesn’t necessarily mean less capable, but a result that suits the current task less well.

1. A simple task gets made complicated

For example:

make this sentence sound a bit more natural.

A low setting may just give you a usable version.

A high setting may start analyzing the relationship between the people, the strength of the tone and cultural differences, then offer five versions. None of it is necessarily wrong, but the time and reading cost of finishing this small thing has gone up.

2. The goal is wrong, but the model works on it harder

Say you want AI to cut the padding out of an article, but it reads the goal as “make it more professional.” Higher effort may make the article more fully structured, with more explanation, more like a report.

It isn’t that it didn’t try; it tried in the wrong direction.

In that case you should restate the goal and the definition of done, not keep turning the setting up.

3. What’s really missing is information

When asking about the latest policies, product prices, job status or the current state of code, what the model needs is search, files, a database or the real code.

No amount of thinking turns old information into new information.

4. Creativity and expression have no single answer

Titles, copy, personal messages and emotional conversations don’t always have an “optimal answer” you can approach through more and more reasoning.

Higher effort sometimes makes the writing more complete and safer, but also more average and less natural.

What high settings are really good at, on the other hand:

• multi-step problems;
• trade-offs between several conditions;
• long context;
• audits where details are easily missed;
• tasks that need verification and repeated checking.

OpenAI’s advice for Codex is actually very direct too: start with the lowest reasoning effort that produces the result you need, and raise it only when the task really requires more planning, analysis or checking.

3. How to choose among ChatGPT’s settings?

As of now, in ChatGPT:

• Instant uses GPT-5.5 Instant;
• Medium, High and Extra High all use GPT-5.6 Sol, differing mainly in reasoning effort;
• Pro uses GPT-5.6 Sol Pro, aimed at harder, longer-running tasks.

So moving from Medium to High mainly increases the same model’s reasoning effort; moving from Extra High to Pro isn’t just one more notch of effort, but switching to the Pro path.

Instant: small things done directly

Good for:

• simple Q&A;
• translation and wording;
• summarizing short texts;
• quick brainstorming;
• clear, low-risk small tasks.

To fix one English sentence, tidy up a message or explain a simple concept, there’s no need to start with Pro.

Medium: the starting point for most serious questions

Good for:

• explaining a new concept;
• a first pass at organizing content;
• ordinary product discussions;
• laying out the main pros and cons of a question;
• tasks with some reasoning that don’t need a complex audit.

For most everyday questions, Medium is already enough.

High: the workhorse for serious work

Good for:

• comparing and choosing between several options;
• product design;
• restructuring an article;
• job-search materials and job fit;
• tasks that need a clear judgment rather than a simple list of information.

For me, High suits everyday serious work better than Pro.

It usually has enough analytical depth without making me wait a long time every time.

Extra High: final review and audits

Good for:

• very long context;
• cross-checking several documents against each other;
• checking for conflicts and omissions;
• reviewing technical proposals;
• checking a long piece for facts, structure and repetition;
• a final review before submitting something important.

I’d rather use Extra High once the content is basically done, not from the first draft.

Pro: the few truly hard tasks

Good for:

• high-value, long-chain tasks;
• synthesizing large amounts of evidence;
• cases where the ordinary settings have clearly missed things;
• where mistakes are costly;
• where spending more time for more reliability is worth it.

For example, a repo-level architecture audit, diagnosing a system across code and docs, or a comprehensive check before submitting an important proposal.

Pro usually means a longer wait, but not all of that time is “thinking”: searching, reading files, calling tools, running code and generating results all take time.

So seeing it spin for a long time doesn’t simply mean “it must be thinking more deeply, and will definitely answer better.”

4. Does ChatGPT Pro have limits?

Yes.

Buying a Pro subscription doesn’t mean every model and setting is unlimited. OpenAI says some models in the Pro plan have their own usage allowances; once reached, the model may be temporarily unavailable until the allowance resets.

But there’s currently no fixed conversion table for individual users telling you how much one High, one Extra High and one Pro request each cost.

One more practical detail:

when Instant automatically decides to switch to Medium, it doesn’t count against the allowance for manually chosen reasoning.

So for daily use, turning on Instant’s automatic switching is less hassle than manually choosing High or Pro for every question.

5. In Codex, choose the model first, then the effort

Codex currently offers three main GPT-5.6 models:

• Sol;
• Terra;
• Luna.

The default Power setting is Sol + Medium. It’s a reliable general starting point, but that doesn’t mean every task should stay on Sol.

Luna: the task is already clear

Good for:

• extracting and categorizing information;
• converting JSON, CSV or other formats;
• generating files from a template;
• bulk-editing copy;
• renaming variables;
• other repetitive, clear, easily checked work.

Whether Luna fits isn’t about whether the task is “small,” but:

whether you already know what correctly done looks like.

Terra: the everyday development workhorse

Good for:

• implementing features with a clear scope;
• fixing ordinary bugs;
• adding tests;
• changing existing components;
• adding an API within the existing architecture;
• work that needs some reasoning and tool calls but no complex architectural judgment.

For example, adding export to an existing list, adding form validation, or fixing a mobile layout usually don’t all need to go to Sol.

Sol: complex, ambiguous, high-value tasks

Good for:

• complex bugs with unclear causes;
• refactors spanning several modules;
• architecture design for a new module;
• checking consistency between code and docs;
• trade-offs between several technical approaches;
• deep review of important PRs.

Sol’s value isn’t only better code, but that it suits tasks that can’t be done mechanically by following clear steps.

OpenAI positions the three models the same way: Sol for complex, open-ended work that needs judgment and polish; Terra as the everyday workhorse; Luna for clear, repetitive, high-frequency tasks.

You may also see Spark in Codex. It’s a research preview focused on low latency and near-real-time coding feedback — more like a dedicated fast-interaction mode than simply “the lowest tier” below Sol, Terra and Luna.

6. Once the model is chosen, decide Codex’s effort

Light / Low

For tasks with a very small scope of change that need almost no exploration.

For example:

change the button text from Continue to Submit, and update the corresponding test.

Medium

For most ordinary development tasks.

It reads the relevant code, does basic planning, makes the change and verifies the result, without spending too much time exploring again and again.

High

Good for tasks that:

• involve several files;
• need the root cause located;
• have several possible implementations;
• easily introduce regressions;
• need systematic verification afterwards.

For example:

users occasionally receive two duplicate emails. Please find the cause, fix it, add a regression test, and check whether similar problems exist.

Extra High

Extra High makes the current model think more deeply about a single task.

It suits highly coupled problems that are hard to split up, such as a complex bug involving caching, concurrency and state recovery all at once.

Ultra

Ultra isn’t “trying harder than Max.”

It calls subagents, splitting the task into several relatively independent parts handled in parallel.

For example, a pre-release audit could check at the same time:

• the front end;
• the API;
• database migrations;
• tests;
• docs;
• security risks.

A task like that suits Ultra.

The difference can simply be remembered as:

Max: one agent digging deep into the same hard problem. Ultra: several agents each handling a part of a task that can be split.

Most ordinary development tasks need neither.

7. Why does Codex usage drain so fast?

What Codex consumes doesn’t depend only on “how many messages you sent.”

The prompt, chat history, files, code, tool results and final output all take up tokens; the model, context size, reasoning and tool use all affect credit consumption too.

According to the current rate card, for the same token usage:

• Sol’s credit rate is about twice Terra’s;
• Sol is about five times Luna’s.

The exact numbers may change, but they show one thing:

choosing a model is itself allocating your development budget.

Long prompts, a huge AGENTS.md, unnecessary MCPs, an ever-growing conversation history and constant high effort all increase consumption. OpenAI’s official advice also includes deleting unnecessary context, keeping AGENTS.md short, and turning off MCPs the current task doesn’t need.

So using a lot of usage in one morning isn’t necessarily because there were too many tasks; it may be that every task took the heaviest path.

8. When an answer is poor, don’t rush to turn up the setting

Now I first judge where the problem lies.

The facts aren’t current or there’s no evidence:

search the web, read official sources, rather than letting the model keep guessing.

It didn’t understand the real goal:

restate the Goal, Context, Constraints and Done when.

Codex keeps making the same mistake in the repo:

improve AGENTS.md, the tests and the way things are verified, rather than switching to Sol + Extra High every time.

The analysis is clearly too shallow and misses several conditions:

that’s when to raise the effort.

The task is too big, and can be split into several independent directions:

split the task, or consider Ultra.

The task itself is simple, but the answers keep getting more complicated:

lower the setting and tighten the output requirements.

My defaults

These days I roughly use them like this:

ChatGPT

• everyday questions: Instant, with automatic switching to Medium on;
• ordinary serious discussion: Medium;
• product, writing, job search and complex decisions: High;
• cross-checking several documents and final review: Extra High;
• the few truly hard, high-value tasks: Pro.

Codex

• clear, repetitive, checkable: Luna;
• everyday features and ordinary bugs: Terra;
• complex bugs, architecture and cross-module tasks: Sol;
• effort starts at Medium, and goes up only if it isn’t enough;
• Max and Ultra only for tasks that genuinely fit how they work.

If you pay for higher tiers, you should of course use them.

But “making full use of them” doesn’t mean picking the highest every time.

First choose the model that fits the task, then the lowest effort that reliably gets it done.

When the answer is poor, first find out whether what’s missing is information, the task definition, context, tools, model capability, or reasoning effort.

Knowing when you need the top setting matters.

Knowing when you don’t matters just as much.