Ship a Full-Stack App with One Prompt

Copy this prompt into your AI coding agent, or open it in one below.

Give this to your AI Create a to-do list app using Puter.js

Coding manually? see the guide

Blog

GPT-6.2 Astra and Sol Review: Fewer Tokens, Less Reasoning

On this page

GPT-6.2 Astra and GPT-6.2 Sol are OpenAI's new frontier and everyday models, the successors to GPT-6 Astra and GPT-6.1 Sol. Most of the launch post covers professional documents, science, and coding, but it opens with a claim about every request. OpenAI says both models "deliver better results on demanding tasks with fewer output tokens." We tested the token part against the predecessors with the same prompts.

In our tests, GPT-6.2 Astra used 34% fewer output tokens than GPT-6 Astra and cost 47% less, and GPT-6.2 Sol used 25% fewer tokens than GPT-6.1 Sol and cost 25% less. Both new models used fewer tokens on all five prompts. About two-thirds of Astra's saving came from reasoning. At default settings, GPT-6.2 Astra used no reasoning on the code and article prompts, where GPT-6 Astra used several hundred reasoning tokens per answer. All four models were correct on every answer we could check.

What OpenAI Claims

The post gives one token figure. On GDPval v2, OpenAI's internal benchmark of long knowledge-work assignments, it reports that GPT-6.2 Astra scored 6.2 points higher than GPT-6 Astra while using 22% fewer output tokens. For Sol, it says GPT-6.2 Sol is more efficient than GPT-6.1 Sol and fits more tasks into the same paid plan, without giving a token figure.

Astra also got a price cut. Its input and output prices are 20% lower than GPT-6 Astra's, and cached input is 60% lower. GPT-6.2 Sol keeps GPT-6.1 Sol's prices.

Per million tokens GPT-6 Astra GPT-6.2 Astra GPT-6.1 Sol GPT-6.2 Sol
Input $10.00 $8.00 $2.00 $2.00
Cached input $1.00 $0.40 $0.10 $0.10
Output $50.00 $40.00 $10.00 $10.00

Prices are from OpenAI's model pages for GPT-6.2 Astra, GPT-6.2 Sol, and GPT-6 Astra, and from the launch post for GPT-6.1 Sol.

OpenAI combines the price cut and the token savings in its cost-per-task figures. On Agents' Last Exam, a benchmark of multistep professional work, it reports GPT-6.2 Astra at under a third of GPT-6 Astra's cost per task.

The model pages also say the API rejects requests that set reasoning effort to none for either GPT-6.2 model, and they don't list a default effort level. We left effort at the default.

How We Tested

We used five prompts with short, medium, and long expected answers:

  • Bug fix. Find the bug in a binary search function.
  • Invoice to JSON. Pull the vendor, date, line items, and total from a short invoice.
  • Tank word problem. Three pipes fill and drain a tank, one closes partway through, find when the tank is full.
  • Debounce function. Write a TypeScript debounce with AbortSignal cancellation and a flush() method.
  • Technical article. Write a 1,000-word post comparing WebSockets and Server-Sent Events, with code examples.

Each model ran each prompt three times on default settings with no system prompt, for 60 runs in total. Each round sent the same prompt to all four models at once. For every answer, we recorded the wait for the first word, the total time, the billed output tokens, which include reasoning, and the cost at list price.

Reasoning isn't shown in the response, so we estimated it as the billed output tokens minus the tokens in the visible answer.

Three of the prompts have a single correct answer, and all 36 of those answers were correct. Every model changed hi = arr.length to hi = arr.length - 1, totaled the invoice to $373.00 with the right line totals, and found the tank full at 12:12 p.m.

Output Tokens

Average output tokens GPT-6.2 Astra GPT-6 Astra Change GPT-6.2 Sol GPT-6.1 Sol Change
Bug fix 152 182 −16% 170 190 −10%
Invoice to JSON 200 202 −1% 176 225 −22%
Tank word problem 203 231 −12% 224 236 −5%
Debounce function 379 1,106 −66% 572 1,023 −44%
Technical article 1,515 1,985 −24% 1,541 1,928 −20%
All 15 answers 7,348 11,119 −34% 8,053 10,803 −25%

Both new models used fewer tokens than their predecessors on every prompt. The largest drop was on the debounce function, where GPT-6.2 Astra used about a third of GPT-6 Astra's tokens. The smallest was GPT-6.2 Astra on the invoice, at 1%.

Across all answers, GPT-6.2 Astra's 34% is above the 22% OpenAI reports for GDPval v2. GDPval v2 is made of long multistep assignments and our prompts are short single requests, so the two figures measure different work.

Where the Savings Came From

Across 15 answers GPT-6.2 Astra GPT-6 Astra GPT-6.2 Sol GPT-6.1 Sol
Reasoning tokens (estimated) 200 2,750 940 2,500
Answer tokens (estimated) 7,150 8,370 7,120 8,300
Words in answers 4,101 4,756 4,175 4,665

GPT-6.2 Astra used about 2,550 fewer reasoning tokens and 1,220 fewer answer tokens than GPT-6 Astra, so reasoning accounts for about two-thirds of its drop. For GPT-6.2 Sol, reasoning accounts for a little over half. Both new models also wrote shorter answers, with 14% to 15% fewer answer tokens and 11% to 14% fewer words.

Most of the reasoning went to the two longer prompts:

Reasoning tokens per answer (estimated) GPT-6.2 Astra GPT-6 Astra GPT-6.2 Sol GPT-6.1 Sol
Debounce function 0 552 135 462
Technical article 0 274 125 254
Other three prompts 0 to 43 0 to 59 0 to 44 20 to 57

GPT-6.2 Astra skipped reasoning on the debounce and article prompts in all six of its runs, and its billed tokens matched the visible answer each time. GPT-6 Astra used reasoning in all six. On the three short prompts, all four models used little or no reasoning.

The debounce answers show the difference in the output too. All 12 included AbortSignal cancellation, a flush() method, and TypeScript types (we didn't run the code). GPT-6.2 Astra wrote a short explanation and one code block, averaging 198 words. GPT-6 Astra added a usage example in all three runs and averaged 297 words.

To see how a higher setting changes this, we ran the debounce prompt once more on GPT-6.2 Astra with reasoning effort set to high. It used about 710 reasoning tokens and 1,157 output tokens in total, close to GPT-6 Astra's average of 1,106 at default.

Time and Cost per Answer

Across 15 answers GPT-6.2 Astra GPT-6 Astra GPT-6.2 Sol GPT-6.1 Sol
Median wait for the first word 3.4 s 7.0 s 1.5 s 2.7 s
Median time per answer 5.8 s 8.8 s 3.6 s 3.9 s
Total cost at list price $0.303 $0.568 $0.083 $0.110

GPT-6.2 Astra cost 47% less than GPT-6 Astra for the same 15 requests. At GPT-6 Astra's token counts, the new prices alone would have brought the total to $0.454, a 20% saving, and the fewer tokens account for the rest. GPT-6.2 Sol has the same prices as GPT-6.1 Sol, so its cost fell by the same 25% as its tokens.

OpenAI's Agents' Last Exam figure, under a third of the cost per task, is for multistep agent work. On our single requests, GPT-6.2 Astra cost 53% of what GPT-6 Astra did. Our prompts had no cached input, so the 60% cut on cached input, which applies when long sessions resend the same context, isn't part of our numbers.

Average cost per answer GPT-6.2 Astra GPT-6 Astra GPT-6.2 Sol GPT-6.1 Sol
Bug fix 0.72¢ 1.05¢ 0.20¢ 0.22¢
Invoice to JSON 0.88¢ 1.12¢ 0.20¢ 0.25¢
Tank word problem 0.87¢ 1.23¢ 0.24¢ 0.25¢
Debounce function 1.55¢ 5.58¢ 0.58¢ 1.03¢
Technical article 6.09¢ 9.96¢ 1.55¢ 1.93¢

Wait times varied between runs more than token counts did. GPT-6.2 Astra's first word on the debounce prompt came after 33 seconds in two runs and after 1.8 seconds in the third, with nearly the same token count. In one round, GPT-6.2 Astra and GPT-6.1 Sol both waited 95 to 100 seconds before the first word of the article. The billed tokens didn't rise with these waits, so they weren't reasoning. We report medians and don't draw conclusions about speed from these runs.

What to Expect

  • Fewer output tokens. GPT-6.2 Astra used 34% fewer output tokens than GPT-6 Astra across our prompts, and GPT-6.2 Sol used 25% fewer than GPT-6.1 Sol. Both were lower on every prompt.
  • Less reasoning at default settings. Most of the drop came from reasoning on the code and long-writing prompts, where GPT-6.2 Astra skipped reasoning entirely. Answers were also about 14% shorter.
  • Lower cost per answer. GPT-6.2 Astra cost 47% less than GPT-6 Astra, with the price cut alone worth 20%. GPT-6.2 Sol cost 25% less at the same prices.
  • Smaller gap at higher effort. With reasoning effort set to high, GPT-6.2 Astra used about as many tokens on the debounce prompt as GPT-6 Astra at default, in our one run. Compare the models at the effort level you plan to use.
  • Same results on checkable answers. All four models were correct on every bug fix, invoice, and tank answer.
  • Ask for blockers explicitly. OpenAI's launch post says both models were more likely to leave out obstacles that blocked their work, such as a missing file, and that it added instructions in Codex to reduce this. Those instructions aren't part of a direct API call. We didn't test this behavior.

We ran three runs per prompt per model, at default settings, on November 19. Wait times varied with load, and our prompts are short, single-turn requests. We didn't test long agentic sessions, cached input, or the benchmark tasks behind OpenAI's figures.

Try It Yourself

Puter.js gives you free access to GPT-6.2 Astra and Sol without an API key, straight from the browser. Users cover their own usage costs under the User-Pays Model. This example sends the debounce prompt, then prints the answer, the wait for the first word, the total time, and the billed output tokens.

Script tag:

<html>
<body>
    <script src="https://js.puter.com/v2/"></script>
    <script>
        const prompt = `Write a debounce function in TypeScript. It should support cancellation through an AbortSignal, and the returned function should have a flush() method that immediately runs any pending call. Include full types.`;

        (async () => {
            const start = performance.now();
            let firstWord;
            const response = await puter.ai.chat(prompt, { model: "gpt-6.2-astra", stream: true });
            for await (const part of response) {
                if (part.type === "text") {
                    firstWord ??= performance.now() - start;
                    puter.print(part.text);
                }
                if (part.type === "usage") {
                    const total = performance.now() - start;
                    puter.print(`<br><br>First word: ${(firstWord / 1000).toFixed(1)} s, total: ${(total / 1000).toFixed(1)} s, output tokens: ${part.usageDetails.outputTokens}`);
                }
            }
        })();
    </script>
</body>
</html>

npm:

// npm install @heyputer/puter.js
import { puter } from "@heyputer/puter.js";

const prompt = `Write a debounce function in TypeScript. It should support cancellation through an AbortSignal, and the returned function should have a flush() method that immediately runs any pending call. Include full types.`;

const start = performance.now();
let firstWord;
const response = await puter.ai.chat(prompt, { model: "gpt-6.2-astra", stream: true });
for await (const part of response) {
    if (part.type === "text") {
        firstWord ??= performance.now() - start;
        process.stdout.write(part.text);
    }
    if (part.type === "usage") {
        const total = performance.now() - start;
        console.log(`\n\nFirst word: ${(firstWord / 1000).toFixed(1)} s, total: ${(total / 1000).toFixed(1)} s, output tokens: ${part.usageDetails.outputTokens}`);
    }
}

To compare, run the same prompt with gpt-6-astra, gpt-6.2-sol, or gpt-6.1-sol. To try a higher setting, add reasoning_effort: "high" to the options. Run it a few times, since timing and token counts vary between runs.

FAQ

What is GPT-6.2?

GPT-6.2 is OpenAI's model family made up of GPT-6.2 Astra, its frontier model for the hardest projects, and GPT-6.2 Sol, its efficient model for everyday work, according to the launch post. They succeed GPT-6 Astra and GPT-6.1 Sol. Both accept text and image input and return text.

How much does GPT-6.2 cost?

GPT-6.2 Astra costs $8 per million input tokens, $0.40 per million cached input tokens, and $40 per million output tokens. GPT-6.2 Sol costs $2, $0.10, and $10. Batch requests cost half, fast mode costs twice the standard rate, and requests over 272,000 input tokens cost double for input and 1.5 times for output, per OpenAI's model pages. In our tests, GPT-6.2 Astra cost 47% less per answer than GPT-6 Astra, and GPT-6.2 Sol cost 25% less than GPT-6.1 Sol.

Is GPT-6.2 Astra better than GPT-6 Astra?

GPT-6.2 Astra scores higher than GPT-6 Astra on OpenAI's benchmarks, by 5.2 points on Agents' Last Exam, 9 points on Terminal-Bench-Science 0.1, and 6.2 points on GDPval v2, according to the launch post. In our tests, both models were correct on every answer we could check, and GPT-6.2 Astra used 34% fewer output tokens and cost 47% less.

What is the difference between GPT-6.2 Astra and GPT-6.2 Sol?

GPT-6.2 Astra is OpenAI's frontier model for complex professional work, and GPT-6.2 Sol is its lower-cost model for everyday work, at a quarter of Astra's per-token prices. OpenAI reports that on Cognition's FrontierCode 2.0, Sol comes within 0.5 points of Astra at about one-fifth of the cost, with both at max effort. In our tests, GPT-6.2 Sol cost $0.083 across 15 answers against $0.303 for Astra, and its median wait for the first word was 1.5 seconds against 3.4.

Where can I use GPT-6.2?

GPT-6.2 Astra and GPT-6.2 Sol are available in ChatGPT Work and Codex for Plus, Pro, Enterprise, and Edu users, and in the OpenAI API as gpt-6.2-astra and gpt-6.2-sol, according to the launch post. Developers can also call both through Puter.js with the same model IDs.

What is the GPT-6.2 context window?

GPT-6.2 Astra and GPT-6.2 Sol both have a 1,050,000-token context window, with up to 922,000 input tokens and 128,000 output tokens, according to OpenAI's model pages for Astra and Sol. Astra's knowledge cutoff is May 18, 2026, and Sol's is June 1, 2026.

How fast is GPT-6.2?

GPT-6.2 Sol had a median wait for the first word of 1.5 seconds in our tests, and GPT-6.2 Astra had 3.4 seconds, both shorter than their predecessors, though wait times varied between runs. OpenAI also offers fast mode at twice the standard rate, and Ultrafast at three times the standard rate through February 28, 2027 and six times after, per the model pages.

Ship a Full-Stack App with One Prompt

Give this to your AI Create a to-do list app using Puter.js

Coding manually? see the guide