Moving From GPT-5.6 Sol to GPT-6 Astra: Set It to Medium and Walk Away

Nobody has asked me whether GPT-6 Astra is better than Sol. Everyone has asked me what to set the reasoning effort to. OpenAI’s docs list five levels, tell you none of them is the default any more, and leave it there. The Codex crowd say high. A few people on X say max because you’re paying flagship money anyway so why not. One person on dev.to did the maths and landed on medium.

I’ve spent the weekend reading every benchmark breakdown I could find, and the dev.to post is right. Set it to medium.

Pricing is what’s making people panic, and fair enough. Sol is $4 per million input and $20 out. Astra is $10 and $50. That’s 2.5x across the board and it lands Astra at exactly the same rate as Claude Fable 5.1, which tells you who OpenAI thinks they’re competing with (and who they’re hoping you’ll stop paying). Cached input goes from $0.40 to $1. Anything over 272K input tokens still cops the 2x input and 1.5x output surcharge on the whole request. Fast mode doubles everything again.

So everyone’s first instinct is to drop the effort a notch to claw the money back. Good instinct. It turns out you lose nothing doing it.

Artificial Analysis publishes an Intelligence Index score and a cost per task for every effort level of both models. Here’s the ladder, side by side, on version 4.2 of their index:

Effort	Astra score	Astra cost/task	Sol score	Sol cost/task
low	49	$0.63	41	$0.23
medium	52	$1.16	46	$0.37
high	53	$1.41	48	$0.61
xhigh	54	$1.85	50	$0.89
max	55	$2.57	51	$1.25

Astra at medium scores 52. Sol at max, the most expensive thing you could buy from OpenAI last week, scores 51 and costs nine cents more per task. Sit with that for a second. The cheap-ish setting on the new model beats the everything-on setting on the old one, for less. If you were on Sol at high, Astra at medium is four points ahead for about double the money. If you were on Sol at xhigh or max, you get a better model and a smaller bill.

Then look at what the rungs above medium cost on Astra. Low to medium is three points for 84% more per task, and that’s the only step on the ladder I’d call worth it. Medium to high is one point for 22% more. High to xhigh, one point for 31% more. xhigh to max, one point for 39% more. Pay more than double the price of medium and you get three points. That’s a model that has done most of its thinking by medium and is mostly clearing its throat after that.

It’s quicker too. Astra at medium gets to its first token in about 10 seconds on Artificial Analysis’s measurements. Sol at high took 19 seconds. Sol at xhigh took 73, which I remember, because I used to go and make a coffee.

The dev.to post is the only proper head to head I’ve found on real work rather than a benchmark, so it’s worth the detail. The author ran one broad coding task through Sol at high and then Astra at low, medium and high. Sol high cost $31.79 and took 75 minutes. Astra medium cost $25.67, took 51 minutes and produced comparable work. Astra high cost $37.23 and took 77 minutes. It did handle some tricky state better, and then its review pass missed a startup bug that the medium run caught. So the expensive run was slower, dearer, and blind to the bug that mattered. More thinking didn’t buy more coverage.

There is one place where the arithmetic flips, and it’s why the Codex people aren’t wrong to say high. ARC Prize ran Astra through ARC-AGI-3 on their standard harness at every effort level. Max was the highest scoring run. It was also the cheapest one in total, $26,098 against $48,090 for medium, even though every individual max turn costs more. At higher effort the model needed fewer actions to finish each game. Medium poked around, tried things, backtracked. Max looked at the board and did the thing.

People read that as high being for hard tasks, or for browsers, or for code. The task type is irrelevant. What matters is how many turns the model takes before it’s done, because in a long agentic loop the number of turns is the bill. The length of any one turn is a rounding error next to it. A cheaper turn that wastes three more turns is not a cheaper turn.

So here’s how I’d split it. Medium for anything that’s one request in, one answer out: extraction, classification, drafting, reviewing a diff, a chat turn. That was most of your Sol traffic and it’s where the table above does all the work. High for anything that runs on its own for twenty minutes, whether that’s Codex driving a shell, an agent clicking through a website, or a pipeline that calls tools forty times before it reports back. A wasted step there costs you a whole round trip, and the retries add up faster than the thinking does. xhigh and max are for the handful of things where you’ve measured a failure rate at high and can point at it. If you can’t point at it, you’re paying for a feeling.

Now the boring stuff that will page you at 2am.

The none effort is gone. Send it and Astra returns a 400. OpenAI’s guidance is to move none and minimal to low and evaluate, which sounds fine until you remember why half of us were on none in the first place. Sol on Chat Completions refused to combine function tools with any reasoning effort at all. The error told you to either use the Responses API or set effort to none. With Astra that escape hatch is closed, so if you were calling tools through Chat Completions, you’re moving to the Responses API whether you planned to or not. Structured outputs go through text.format instead of response_format, and conversation state goes through previous_response_id.

temperature, top_p and top_logprobs are rejected. logprobs too on Chat Completions. If you’ve got a config layer that sprays those onto every request, it’ll start throwing before it ever reaches the model.

If you were using prompt_cache_retention, it’s now prompt_cache_options.ttl with a value like "30m". Worth checking your cache hit rate for a day after the swap rather than assuming.

Sol’s pro mode, the reasoning.mode: "pro" setting, doesn’t carry across in the same form. In ChatGPT it’s GPT-6 Astra Pro on the Pro, Business and Enterprise plans. Plus users get plain Astra. Enterprise admins have to turn it on, because it’s off by default at launch.

The one new thing I like is configuration_update. On Sol, effort was a request-level setting, so bumping it for one hard turn changed the request prefix and blew away your prompt cache for the whole conversation. Astra lets you drop an update item in front of a single user turn, and it applies from that point on without touching anything before it. Keep medium as the request-level baseline, insert a high update before the turn that needs it, and the cached prefix keeps matching. Two constraints: don’t put two updates back to back, and don’t combine it with automatic truncation, because the truncation can silently drop the update. It also only works in standard mode, not Pro, and not through the Batch API.

Astra loves a table. If you want prose out of it you have to say so, or a two-line answer comes back as a bulleted changelog. And it asks permission more than Sol did. OpenAI’s own prompting guide suggests telling it that user approval is the final step, so it finishes the authorised work before checking in rather than pausing at every fork.

Sol isn’t going anywhere yet, and its promotional pricing runs until at least the 21st of November. If your workload is cost bound and Sol at medium was already fine, staying put for a couple more months is a perfectly good answer and nobody on X gets to make you feel bad about it. The Artificial Analysis numbers say Astra at max is about 75% more expensive per task than Sol at max for the same intelligence score on their old index, and OpenAI’s response to that is to say price per task matters more than price per token, which is true right up until you look at the price per task.

If you’re moving, don’t overthink the dial. Set it to medium and only go up on the tasks where you can show medium failing.

Sources: