How well does GPT-6.2 Astra handle problems where one overlooked detail can change the answer? We put OpenAI’s new flagship through four tasks: reading a circuit, repairing Python, checking a database deployment and choosing the best project portfolio.
Astra got the substantive answers right, but one response still missed an explicit instruction. In this article, we examine its reasoning, accuracy and instruction-following at High effort to see how closely its answers match the complete brief.
TLDR: GPT-6.2 Astra got all four tasks right at Ultra effort, but its first database response included citations despite instructions to omit them.

What Is GPT-6.2 Astra?
GPT-6.2 Astra is OpenAI’s model for demanding professional projects, including coding, reasoning and document analysis. It accepts text and images and produces text, with a 1,050,000-token context window and up to 128,000 output tokens. Browsing, reading files and creating deliverables depend on the tools available around the model.
| Standard API pricing | Cost per million tokens |
|---|---|
| Uncached input | $8 |
| Cached input | $0.40 |
| Output | $40 |
To match our setup, start a fresh Work chat, select GPT-6.2 Astra and choose Ultra effort before submitting your prompt. how LLMs connect to external tools is useful here: generating an answer about a spreadsheet and creating a working spreadsheet are different capabilities to check.

The same principle matters in our earlier GPT-6.1 Terra vs Sol comparison: compare matching inputs, then check the result rather than the confidence of the answer.
Reading the circuit, including what changes when a branch disappears
This image looks straightforward until you ask what happens after disconnecting R3. Lower total current does not mean that every remaining resistor must carry less current. Astra first had to read the connections correctly, then reason about the changed circuit.

Prompt
Read the attached circuit diagram using ideal resistors and an ideal 12 V source. First identify which resistors are in series and parallel. Then give a compact table with equivalent resistance, total current, voltage across the parallel branch, and the currents through R2 and R3. Round to three decimals and include units. Finally, disconnect R3 only: calculate the new total current and R2 current, and explain whether each rises or falls. Show enough arithmetic to check the result. Keep the whole response under 160 words. Use only the image and basic circuit laws; do not browse or use tools. Keep the output anonymous: no personal names, organisations, account details, contact information, personal references or signature.
GPT-6.2 Astra:

The reading and all requested rounded results matched an independent calculation. Astra placed R2 and R3 in parallel, with R1 in series, and correctly separated the falling source current from the rising R2 current after R3 was removed. That last distinction made the answer useful as an explanation, rather than just a table of plausible numbers.
Repairing Python without breaking nested intervals or the input
The attached function counted covered minutes across intervals. Its merge step could shrink an existing interval when it encountered a smaller nested one. It also sorted the caller’s list in place and lacked the requested validation.
Input file: coverage.py
def covered_minutes(spans):
spans.sort()
if not spans:
return 0
start, end = spans[0]
total = 0
for next_start, next_end in spans[1:]:
if next_start <= end:
end = next_end
else:
total += end - start
start, end = next_start, next_end
return total + end - start
Prompt
Fix
covered_minutesin the attached Python file. It must return the union length of half-open integer intervals, so overlaps aren't counted twice. Ignore zero-length intervals. Accept negative endpoints. Reject reversed intervals, malformed pairs and non-integer endpoints (including booleans) with ValueError. Don't mutate the input or any pair inside it. Use only the standard library and O(n log n) time. Return one complete replacement function and five short asserts, including a nested interval and an immutability check. Keep the code under 45 lines. Don't browse or run tools. Keep the answer anonymous: no names, account details, organisations or signatures.
GPT-6.2 Astra:

Astra built a separate list of valid intervals, sorted that copy and kept the furthest covered endpoint when intervals overlapped. That avoids both the nesting bug and the input mutation. It also rejected booleans explicitly, a necessary detail because Python otherwise treats them as integers.
The five supplied assertions passed. We then ran the unchanged function against 11,736 independent cases: 9,724 exhaustive valid cases, 2,000 fixed-seed randomized cases and 12 invalid-input cases. All passed, including checks that the original list and its inner pairs remained unchanged. Inspection also supported the requested O(n log n) approach.
One distinction is worth keeping: Astra’s own five assertions did not cover every validation rule. The broader check was ours. This was a strong repair of the supplied function, not evidence that a short model-written test block proves every property of the code.
Checking SQLite documentation before choosing a deployment
For the research task, the proposed app put one SQLite file on a network-mounted filesystem, with processes on two machines writing to it. WAL mode is often discussed as a concurrency improvement, so the useful answer had to identify the condition that makes it unsuitable here.
Prompt
I need a short deployment decision for a small app whose SQLite database file would sit on a network-mounted filesystem and be written by processes on two different machines. Browse the current official SQLite documentation. Is switching to WAL mode an appropriate fix for concurrency here? Explain the locking or shared-memory condition that changes the answer, and suggest one practical architecture that avoids it. Also say whether WAL allows multiple simultaneous writers. Keep the answer under 170 words, without links, citations or quotations in the response. Use only official documentation to research it. Keep everything anonymous: no names, account details, organisations or signature.
GPT-6.2 Astra:

Astra reached the correct decision. WAL requires processes accessing the database concurrently to share the WAL index in memory; making the files visible to two machines does not provide that shared memory. It also correctly said that WAL permits readers alongside a writer, rather than multiple simultaneous writers.
Its proposed architecture was practical: keep SQLite on one machine’s local disk and expose a small API service there, so remote processes send requests to the service instead of opening the file themselves. We checked those claims against the current official documentation. The substance passed; the two source chips missed the requested response format. We asked for a formatting correction without new research.
The follow-up removed the source badges and preserved the deployment advice. That resolved the presentation problem, with one extra turn rather than a first-answer pass on every instruction.
Choosing the best portfolio instead of the most attractive project
The last task used an attached JSON file with six projects. Choosing the highest-impact items first could violate staff limits or miss a dependency, so we asked for the global optimum and a short reason that no better feasible choice existed.
| Project | Budget units | Staff hours | Impact points |
|---|---|---|---|
| A | 8 | 5 | 18 |
| B | 5 | 4 | 11 |
| C | 4 | 6 | 10 |
| D | 6 | 3 | 14 |
| E | 7 | 6 | 20 |
| F | 3 | 5 | 8 |
The file allowed at most 18 budget units, 16 staff hours and three projects. E required B; A and D could not both be selected; at least one of C or F had to be selected. Tied impact favored lower budget, then fewer staff hours, then alphabetically sorted IDs. Projects could only be selected in full.
Prompt
Use the attached JSON to choose a project portfolio. Follow every resource limit, dependency, exclusion and tie-break rule exactly. Find the global optimum rather than a greedy estimate. Return the selected IDs, total budget, staff hours and impact, then a short explanation showing why a higher-impact feasible choice isn't available. You may use a calculation tool. Keep the answer under 140 words. Keep it anonymous: no personal names, account details, organisations or signatures.
GPT-6.2 Astra:

Astra selected B, C and E for 41 impact points, using 16 budget units and all 16 staff hours. Our separate enumeration checked all 64 subsets and found 18 feasible portfolios. The selected set was the unique optimum.
The explanation did more than repeat a total. With E included, B is compulsory and the remaining slot must satisfy the C-or-F rule; without E, the best feasible portfolio reaches only 39 points. That makes the recommendation inspectable. It is still a six-project exercise, so we would not extend the result to large scheduling or optimization problems without further testing.
What the launch benchmarks and pricing add
Our four answers cannot establish how Astra ranks across all professional work. The published launch charts offer broader context, with a crucial detail: the effort setting belongs beside the number.
| Published evaluation | Astra 6.2 at High | Sol 6.2 at High |
|---|---|---|
| Agents’ Last Exam v1.1 | 76.0%; $2.05 per task | 72.0%; $0.69 per task |
| Terminal-Bench-Science 0.1 | 74.9%; $5.20 per task | 67.7%; $1.51 per task |
| FrontierCode 2.0 | 43.6%; $3.95 per task | 39.7%; $0.88 per task |

On FrontierCode at Max, the gap narrows: Astra scores 44.2% at $5.97 per rollout and Sol scores 43.8% at $1.29. Those results support taking Sol seriously for coding. They do not show that the cheaper model will need the same number of attempts on your codebase, or that selecting High reproduces a Max result.
For Standard API requests within the short-context pricing band, Astra costs $8 per million uncached input tokens, $0.40 per million cached input tokens and $40 per million output tokens. Sol’s corresponding rates are $2, $0.10 and $10. Astra’s input and output rates are 20% below the original GPT-6 Astra rates.

Work and Codex subscription usage is separate from API billing. It varies with the task, effort, speed and amount of work, so there is no single reliable message count for every job. API requests above 272,000 input tokens also have higher full-request rates. Our earlier Astra access guide provides historical context; its old usage observations should not be read as a 6.2 quota.
Conclusion
Astra 6.2 earned a positive first impression on these four jobs. It preserved the circuit’s relationships, repaired the interval algorithm, gave the correct SQLite architecture advice and justified the optimal portfolio. The source-chip miss is also part of that result: even a short, technically correct response can need a final edit before it fits the requested format.
Try Astra on a difficult job whose output you can verify: code with awkward inputs, a diagram with a consequential relationship, or a decision with explicit constraints. Compare it with Sol on that same input before paying the higher token rates for routine work. These runs support using Astra as a capable collaborator; they do not settle speed, real session cost or universal superiority.
Frequently Asked Questions
Where can I use GPT-6.2 Astra?
In Work, Codex and the API, subject to rollout, plan and workspace access. This release does not add it to regular Chat.
What setting did these tests use?
Ultra reasoning effort, with each task starting in a fresh Work chat.
Did Astra pass all four tests?
The substantive answers passed. The first SQLite response included citations; one formatting follow-up removed them.
Does Astra cost more than Sol?
Its Standard input and output token rates are four times higher. Completed-task cost also depends on usage, tools and retries.