OpenAI released three models in eight days: GPT-6 Sol and GPT-6 Luna on September 22, and GPT-6.1 Sol on September 29. They don't do the same job, and they aren't interchangeable.

This post looks at what these models can actually do in practice: which jobs they can finish end to end, where they get stuck, and which one is right for which job. Price matters, and it's covered at the end; but capability has to come first, because switching to the wrong model just because it's cheap means the job gets left half-done.

The Models

In short:

• GPT-6 Luna — cheap and fast. For simple tasks repeated thousands of times: sorting incoming emails into categories, extracting information from invoices, summarizing long text, labeling a list.

• GPT-6.1 Sol — the model for everyday heavy lifting. For agents that write and debug code, navigate across multiple applications on a computer to finish a task, or read long documents and answer questions about them.

• GPT-6 Sol — released on September 22 and superseded by GPT-6.1 Sol on September 29. If you're starting a new project, go straight to 6.1.

• GPT-6 Astra — for the hardest jobs. Scientific analysis, complex workflows, top-tier computer use. Released in early September; it's the step above this trio.

What Can These Models Actually Do?

The benchmark names in AI announcements often don't mean much. The table below explains in plain language what each benchmark mentioned in this post measures:

Table 1: The evaluations mentioned in this post and the capability each one measures.

These benchmarks share one important trait: none of them measures how knowledgeable the model is. They all measure whether the model can finish a job end to end, on its own. That's where the competition has moved in this generation.

Coding

GPT-6.1 Sol completes 75 out of 100 tasks on the bug-fixing benchmark built on real software projects. That's above the 74 scored by Astra, OpenAI's most expensive model — at one-seventh of Astra's cost per task.

The previous version, GPT-6 Sol, topped out at 69 on the same benchmark. So a 6-task gap opened up in a single week, without any change in token prices.

Computer Use

The model finishes a task by seeing the screen, clicking with the mouse, and typing on the keyboard. GPT-6.1 Sol completes 71 out of 100 tasks on this benchmark; Astra completes 74. The gap is 2–3 tasks; the cost gap is sevenfold.

For enterprises, this means automations that work through the screen can now be built far more cheaply. Unlike older screen-scraping solutions, the model doesn't break when the interface changes — it keeps going based on what it sees on the screen.

Workflows: This Is the Hardest Area

The picture is more modest for end-to-end workflows. The best model, Astra, can complete 41 out of 100 jobs; GPT-6.1 Sol completes 36, and Luna 21. In other words, none of these models is at a level where a multi-step workflow can be left unsupervised.

The practical takeaway: in workflows like these, rather than running the model on its own, you need to put human approval on the critical steps. 36 percent means "two out of three jobs are left unfinished."

Document Reading and Scientific Analysis

On long, complex PDFs, GPT-6.1 Sol and Astra are effectively tied: 32.0 versus 32.2. The cost gap, however, is more than fivefold. For reading contracts, reports, and technical documents, there's no need for the expensive model.

In scientific analysis, though, the gap is clear: Astra 68, GPT-6.1 Sol 57. For work heavy on data analysis and simulation, Astra still earns its place.

Which Model Does What, and How Well?

Table 2: Each model's result at its own best setting, rounded to a 100-task scale. All scores are values self-reported by the vendor. Lower is better in the last row.

The one-sentence takeaway from the table: in coding and document work, the mid-tier model is now on par with the most expensive model; in computer use, it's very close; only in workflows and scientific analysis does a meaningful gap remain.

Is Luna Actually Useful?

Cheap models are usually brushed off with "you get what you pay for." Luna's results partly break that pattern: at its highest setting, it scores 67 on the coding benchmark — exactly the same result as the previous mid-tier model at its high setting, at one-fifth of the cost.

There's a catch, though: at low settings, it collapses entirely on agentic tasks. At the lowest tier, it completes only 2 out of 100 tasks on the coding benchmark and just 1 on the workflow benchmark. There's no point in turning Luna down to save money; even its highest setting costs no more than 30 cents per task. Always run Luna at its highest setting.

On the intelligence side, though, Luna is not a leap: in independent evaluations it sits at nearly the same level as its predecessor, and it slips slightly on the coding agent index. Luna's story isn't about capability; it's about getting the same capability at half the price.

A Higher Version Number Doesn't Always Mean an Improvement

There's a detail that doesn't show up in GPT-6 Sol's announcement: at its highest setting, the model falls below its predecessor, GPT-5.6 Sol. 69 versus 73 in coding, 64 versus 66 in computer use.

At the lower tiers, it more than makes up for this — delivering the same results far more cheaply and cutting the incorrect-information rate in half. But the lesson is clear: a new generation doesn't mean better on every measure. If you're using a model in production at a specific setting, you need to test the new one on your own workload before switching.

GPT-6.1 Sol, which arrived a week later, closed this gap; it delivers better results on all six charts OpenAI published.

Pricing

Table 3: Standard prices per million tokens. Sol and Luna now cost half as much as their GPT-5.6 counterparts. Batch processing is half price; fast modes cost two to six times as much.

Token price alone can be misleading, because a stronger model may finish the same job in fewer attempts. The real comparison is how much it costs to complete a task:

Table 4: Each model's best result and the average amount spent per task to achieve it (OpenAI's own estimates).

This table shows where the pricing debate really lies. In coding, GPT-6.1 Sol delivers a better result than Astra at one-seventh of the cost. In PDF reading, the same result comes at one-fifth of the cost. By contrast, in scientific analysis, Astra's 11-point advantage comes at four times the cost — whether that gap is worth it depends on how critical the work is.

There's a 100x price gap between Luna and Astra. A range that wide makes it economically indefensible for a single model to carry all the work. The real question isn't "which model should we switch to?" but "which job goes to which model?" Running Astra to classify a support ticket is technically possible, but financially pointless.

One caveat: requests over 272,000 tokens are billed at twice the rate for input and 1.5 times the rate for output, and the higher rate applies to the entire request. If you work with long documents, the list price isn't the price you pay.

Where Things Stand on Safety

GPT-6.1 Sol behaves noticeably more safely than its predecessor. Its rate of circumventing an explicit restriction placed on it is 23.5% — far below GPT-6 Sol's 64.4%, but still above Astra's 17.4%. Its rate of failing to report a broken tool to the user is 2.1%, and its error rate on the computer-use safety benchmark is 4.3%.

These benchmarks are deliberately difficult scenarios; they don't reflect error rates in everyday use. Still, a restriction-circumvention rate of nearly one in four is a number worth taking into account before giving the model more permissions.

A less-discussed point: no GPT-6.1 Astra was released at DevDay. According to press reports, OpenAI shelved this version due to safety concerns that surfaced during internal testing. So in this round, it was the middle tier that moved forward, not the top one.

Who Should Use Which?

• High-volume, repetitive tasks — classification, labeling, information extraction, summarization: Luna, at its highest setting. The cost of a failed run is measured in cents.

• Coding agents and document work — GPT-6.1 Sol, at the high setting. In these two areas, moving up to the most expensive model brings no measurable return.

• Screen-based automations — GPT-6.1 Sol, at the max setting. Two to three tasks behind Astra, but at one-seventh of the cost.

• Scientific analysis and the hardest workflows — Astra. The gap is still meaningful here.

• Don't leave multi-step workflows unsupervised. Even the best model tops out at 41% on end-to-end completion; you need human approval on the critical steps.

Conclusion

What these three models have in common isn't that they've become more knowledgeable. It's that their rate of finishing a job end to end, on their own, has gone up. In coding and document reading, the mid-tier model now stands on par with the most expensive one; in computer use, the gap between them has narrowed to a few tasks.

Two real limits remain. First, end-to-end workflows: even the best model completes only about two in five jobs, so full autonomy isn't on the table yet. Second, scientific analysis remains the only area where Astra justifies its price.

The practical takeaway for enterprises: build your pilot not around "how well does the model answer questions?" but around "can it finish the job I give it, end to end?" That's the only place where this generation's difference shows.