GPT-6.2 Sol vs Claude Opus 5.5: Release & Pricing

GPT-6.2 Sol is OpenAI's new model for everyday coding and agent work. Released on November 17, 2026, it succeeds GPT-6.1 Sol and keeps the same standard API prices. The upgrade gives existing Sol users a reason to revisit tasks that still needed a more expensive model. OpenAI's release announcement explains the changes.
Claude Opus 5.5 is a useful comparison because its standard input and output rates are twice Sol's. Opus scores higher on the Intelligence Index in the evaluated configurations below and on the selected coding benchmark; Sol leads several of OpenAI's reported workflow evaluations. For an application that makes thousands of requests, the question is whether Opus produces enough additional accepted work to justify that difference.
You can access both through AI/ML API. This guide explains the release, compares the published evidence and works through the pricing conditions before showing a complete API example. Our Python and animated-city outputs provide a smaller, inspectable coding check along the way.
What is GPT-6.2 Sol?
GPT-6.2 is a family with two models. Astra is the more expensive option for demanding professional work; Sol has lower rates and serves everyday development workflows.
These are Sol's specifications from its API model documentation, with the current Opus specifications alongside them:
| Specification | GPT-6.2 Sol | Claude Opus 5.5 |
|---|---|---|
| AI/ML API model ID | openai/gpt-6.2-sol |
anthropic/claude-opus-5-5 |
| Context window | 1,050,000 tokens | 1,000,000 tokens |
| Maximum output | 128,000 tokens | 128,000 tokens |
| Input | Text and images | Text and images |
| Output | Text | Text |
The context window covers the material the model can work with in a request. Input includes your instructions and supplied content, such as source files or earlier messages. The output limit caps what it can generate. You cannot send 1.05 million input tokens to Sol and then ask for another 128,000: its separate input ceiling is 922,000.
For a code review, this lets you supply relevant files together with the conventions the change must follow. Images let you include a screenshot of the interface you are fixing. Choose those inputs around the task. Sending an entire archive adds cost and can obscure the file that contains the problem; a large context limit gives you room when the work requires it.
What's new in GPT-6.2 Sol?
More capability at GPT-6.1 Sol's price
OpenAI reports a 5.3 percentage point improvement over GPT-6.1 Sol on its internal GDPval v2 evaluation of extended professional assignments. It also reports Sol close to Astra on FrontierCode 2.0: the displayed max-effort scores are 43.8% and 44.2%. That is one coding evaluation, rather than evidence that the two models perform alike across all work. Source: OpenAI.
For an existing Sol integration, the useful upgrade question is which rejected outputs now pass your checks. Keep a sample of tasks that previously needed manual repair and run the new model against the same acceptance criteria. A higher success rate at unchanged token prices could reduce the number of requests you send to a more expensive fallback. You still need to measure how many tokens each completed task consumes.
Applying the upgrade in an existing workflow
Use a dashboard change to check the upgrade with Sol's documented text and image inputs. Supply the current screenshot with the source code and describe the behavior you need. Check the rendered page as well as the generated source: a correct event handler does not establish that the button remains usable on a phone.
In an agent, the conversation prefix is the earlier history before a retained reasoning item. Where the selected API route preserves reasoning, the model can reuse that state across requests. OpenAI's integration guidance explains that rewriting an earlier instruction or shortening an old tool result can discard subsequent reasoning items. The model may then repeat that work, increasing token usage and latency. Cache reuse also depends on matching the beginning of the request, so changing the prefix can reduce eligible cache hits. Append a correction or new instruction when possible, and check whether an existing agent rewrites its history after each tool call.
GPT-6.2 Sol vs Claude Opus 5.5: benchmarks
OpenAI's launch results
The following rows come from OpenAI's release evaluation. Both models use the reported max-effort configuration. Scores are percentages, with higher values better.
FrontierCode checks whether codebase changes meet a maintainer's standards for merging. Agents' Last Exam tests multistep professional work, while GDPval v2 Internal covers extended knowledge-work assignments. Harvey LAB-AA tests legal deliverables grounded in supplied sources.
| Benchmark | GPT-6.2 Sol | Claude Opus 5.5 |
|---|---|---|
| FrontierCode 2.0 | 43.8 | 45.5 |
| Agents' Last Exam v1.1 | 73.0 | 71.6 |
| GDPval v2 Internal | 46.9 | 43.5 |
| Harvey LAB-AA v1.1, hallucination-gated all-pass | 11.1 | 4.2 |
Opus leads the selected repository-coding evaluation. Sol's higher scores on the workflow rows support trying it on work that involves producing a deliverable from supplied material. Harvey counts an assignment as successful only when it passes every criterion without a material hallucination. Its all-pass percentage uses a different scoring rule from the other rows.
GDPval v2 Internal belongs to OpenAI's evaluation. It is separate from Artificial Analysis's GDPval-AA, so results from the two should not be combined.
Artificial Analysis's independent comparison
Artificial Analysis reports the following results for Sol at max and Opus at its configuration labeled Max, Default Fallback. Its Intelligence Index aggregates performance across several evaluations.
| Artificial Analysis metric | GPT-6.2 Sol | Claude Opus 5.5 |
|---|---|---|
| Intelligence Index v5.0.1, rounded | 57 | 59 |
| Cost per Intelligence Index task | $1.01 | $10.04 |
| Time per Intelligence Index task | 7.9 minutes | 24.6 minutes |
Opus has the higher aggregate score, while Sol has lower evaluated task cost and time. AA calculates task cost from weighted evaluation usage, including reasoning and caching. The dollar values describe those tasks; you should not use their ratio to forecast an application's savings. These results compare the named configurations, and matching effort labels does not establish equal computing budgets.
If you need a model to make difficult code changes, Opus's FrontierCode and Intelligence Index leads justify including it in your trial. If you are choosing a default for a queue of smaller jobs, Sol's lower evaluated cost and time give you a reason to start there and examine the failures before adding a fallback.
GPT-6.2 Sol pricing
We checked AI/ML API's interactive Chat Completions model cards on November 18, 2026. Their standard rates matched the direct-provider rates below. Use the complete model catalog to check the route you intend to call; batch and other processing options have separate cards.
| Standard rate per 1 million tokens | GPT-6.2 Sol | Claude Opus 5.5 |
|---|---|---|
| Uncached input | $2 | $4 |
| Cached input read | $0.10 | $0.20 |
| Output | $10 | $20 |
For matching counts of 100,000 uncached input tokens and 10,000 billable output tokens, Sol costs $0.30 and Opus costs $0.60. That is a useful starting estimate for a request below Sol's long-input threshold. Reasoning contributes to billable output, so count it alongside the answer you see. OpenAI pricing and Claude pricing explain the billing categories.
Sol's rates increase when input exceeds 272,000 tokens. The higher prices apply to the whole request: $4 for input, $0.20 for cached input and $15 for output per million tokens. At that point Sol matches Opus's input and cache-read rates; its output remains 25% cheaper. With 300,000 uncached input tokens and 10,000 output tokens, the totals are $1.35 for Sol and $1.40 for Opus. Source: Sol model documentation.
Caching can help a workflow that repeatedly sends the same instructions or reference files, provided the request qualifies for a cache hit. The read price applies to eligible reused content; cache writes have their own charges. For budgeting, log actual usage and include failed attempts. A model that costs half as much per token can lose that advantage if it requires enough extra reasoning or retries to finish the job.
How did GPT-6.2 Sol do in our coding tests?
We asked each model for a Python module and an animated city in one combined request. The pair makes two kinds of output inspectable: Python behavior has exact checks, while the browser scene lets you judge the implementation alongside its appearance. The prompt restricted the answer to two code blocks and about 1,800 visible tokens.
Sol ran through Codex CLI on November 17; Opus ran through the regular Claude web interface on November 18, Moscow dates. Both used high effort, with no observed tool use or repair turn in the successful request. These different subscription clients give us no comparable API timing or measured AI/ML API bill. Each model completed one successful combined request.
Python duration parsing and interval merging
Both implementations passed all 61 checks. The duration parser had to accept values such as 1h30m while rejecting duplicate units and incorrect ordering. The interval function had to merge touching ranges, reject boolean and nonfinite endpoints, and leave the original input unchanged.
Both produced the requested behavior on those checks. Their source differs in details: Sol converts long digit strings in chunks, while Opus uses direct integer conversion and separates endpoint validation into a helper. You can inspect the Sol module and Opus module to decide which implementation you would maintain. The passing score does not grade readability.
Python test details and full logs
The same frozen runner checked both modules. These counts come from the saved reports for the original runs.
| Check group | GPT-6.2 Sol | Claude Opus 5.5 |
|---|---|---|
| Valid duration inputs | 12/12 | 12/12 |
| Rejected duration inputs | 20/20 | 20/20 |
| Interval results and unchanged input | 12/12 | 12/12 |
| Rejected interval inputs | 17/17 | 17/17 |
| Total | 61/61 | 61/61 |
Each valid interval case also checks that the function returns a new list of tuples and leaves the input unchanged. An invalid-input pass means the runner caught the required ValueError.
Selected cases from those reports:
| Input | GPT-6.2 Sol | Claude Opus 5.5 |
|---|---|---|
parse_duration("1h30m") |
5400 |
5400 |
parse_duration(" 1H 2M 3S ") |
3723 |
3723 |
parse_duration("1s1m") |
ValueError |
ValueError |
merge_intervals([[3,5],[1,3],[8,8]]) |
[(1, 5), (8, 8)] |
[(1, 5), (8, 8)] |
merge_intervals([[True,2]]) |
ValueError |
ValueError |
merge_intervals([[0,float("inf")]]) |
ValueError |
ValueError |
GPT-6.2 Sol full log (JSON) · Claude Opus 5.5 full log (JSON) · Frozen test runner.
Download the runner and one module, save them in the same folder, then run:
python3 test_runner.py candidate.py
The runner prints the case-by-case JSON report and applies an eight-second execution timeout.
GPT-6.2 Sol: original Python module
import math
import re
_DURATION = re.compile(
r"\s*(?:([0-9]+)[hH]\s*)?(?:([0-9]+)[mM]\s*)?(?:([0-9]+)[sS]\s*)?"
)
def parse_duration(value):
match = _DURATION.fullmatch(value) if isinstance(value, str) else None
if match is None or not any(match.groups()):
raise ValueError("Invalid duration")
total = 0
for digits, multiplier in zip(match.groups(), (3600, 60, 1)):
if digits is None:
continue
number = 0
for offset in range(0, len(digits), 500):
chunk = digits[offset:offset + 500]
number = number * 10 ** len(chunk) + int(chunk)
total += number * multiplier
return total
def merge_intervals(intervals):
if not isinstance(intervals, list):
raise ValueError("Expected a list of intervals")
pairs = []
for pair in intervals:
if not isinstance(pair, (list, tuple)) or len(pair) != 2:
raise ValueError("Expected a pair of endpoints")
for endpoint in pair:
if (
isinstance(endpoint, bool)
or not isinstance(endpoint, (int, float))
or (isinstance(endpoint, float) and not math.isfinite(endpoint))
):
raise ValueError("Expected a finite numeric endpoint")
start, end = pair
if start > end:
raise ValueError("Interval start exceeds its end")
pairs.append((start, end))
pairs.sort(key=lambda pair: pair[0])
merged = []
for start, end in pairs:
if merged and start <= merged[-1][1]:
previous_start, previous_end = merged[-1]
merged[-1] = (previous_start, max(previous_end, end))
else:
merged.append((start, end))
return merged
GPT-6.2 Sol: full recorded test log
{
"passed": 61,
"total": 61,
"cases": [
{
"case": "parse_valid_0",
"passed": true,
"detail": "3600"
},
{
"case": "parse_valid_1",
"passed": true,
"detail": "5400"
},
{
"case": "parse_valid_2",
"passed": true,
"detail": "125"
},
{
"case": "parse_valid_3",
"passed": true,
"detail": "0"
},
{
"case": "parse_valid_4",
"passed": true,
"detail": "3723"
},
{
"case": "parse_valid_5",
"passed": true,
"detail": "5400"
},
{
"case": "parse_valid_6",
"passed": true,
"detail": "120"
},
{
"case": "parse_valid_7",
"passed": true,
"detail": "3723"
},
{
"case": "parse_valid_8",
"passed": true,
"detail": "7200"
},
{
"case": "parse_valid_9",
"passed": true,
"detail": "11040"
},
{
"case": "parse_valid_10",
"passed": true,
"detail": "62"
},
{
"case": "parse_valid_11",
"passed": true,
"detail": "2"
},
{
"case": "parse_invalid_0",
"passed": true
},
{
"case": "parse_invalid_1",
"passed": true
},
{
"case": "parse_invalid_2",
"passed": true
},
{
"case": "parse_invalid_3",
"passed": true
},
{
"case": "parse_invalid_4",
"passed": true
},
{
"case": "parse_invalid_5",
"passed": true
},
{
"case": "parse_invalid_6",
"passed": true
},
{
"case": "parse_invalid_7",
"passed": true
},
{
"case": "parse_invalid_8",
"passed": true
},
{
"case": "parse_invalid_9",
"passed": true
},
{
"case": "parse_invalid_10",
"passed": true
},
{
"case": "parse_invalid_11",
"passed": true
},
{
"case": "parse_invalid_12",
"passed": true
},
{
"case": "parse_invalid_13",
"passed": true
},
{
"case": "parse_invalid_14",
"passed": true
},
{
"case": "parse_invalid_15",
"passed": true
},
{
"case": "parse_invalid_16",
"passed": true
},
{
"case": "parse_invalid_17",
"passed": true
},
{
"case": "parse_invalid_18",
"passed": true
},
{
"case": "parse_invalid_19",
"passed": true
},
{
"case": "merge_valid_nonmutation_0",
"passed": true,
"detail": "[]"
},
{
"case": "merge_valid_nonmutation_1",
"passed": true,
"detail": "[(1, 5), (8, 8)]"
},
{
"case": "merge_valid_nonmutation_2",
"passed": true,
"detail": "[(1, 2), (5, 6)]"
},
{
"case": "merge_valid_nonmutation_3",
"passed": true,
"detail": "[(1, 10)]"
},
{
"case": "merge_valid_nonmutation_4",
"passed": true,
"detail": "[(1, 2)]"
},
{
"case": "merge_valid_nonmutation_5",
"passed": true,
"detail": "[(0, 1)]"
},
{
"case": "merge_valid_nonmutation_6",
"passed": true,
"detail": "[(-4, 0)]"
},
{
"case": "merge_valid_nonmutation_7",
"passed": true,
"detail": "[(1.5, 3.5)]"
},
{
"case": "merge_valid_nonmutation_8",
"passed": true,
"detail": "[(1, 5)]"
},
{
"case": "merge_valid_nonmutation_9",
"passed": true,
"detail": "[(7, 7)]"
},
{
"case": "merge_valid_nonmutation_10",
"passed": true,
"detail": "[(1, 4), (6, 7), (9, 10)]"
},
{
"case": "merge_valid_nonmutation_11",
"passed": true,
"detail": "[(0, 1), (1.0001, 2)]"
},
{
"case": "merge_invalid_0",
"passed": true
},
{
"case": "merge_invalid_1",
"passed": true
},
{
"case": "merge_invalid_2",
"passed": true
},
{
"case": "merge_invalid_3",
"passed": true
},
{
"case": "merge_invalid_4",
"passed": true
},
{
"case": "merge_invalid_5",
"passed": true
},
{
"case": "merge_invalid_6",
"passed": true
},
{
"case": "merge_invalid_7",
"passed": true
},
{
"case": "merge_invalid_8",
"passed": true
},
{
"case": "merge_invalid_9",
"passed": true
},
{
"case": "merge_invalid_10",
"passed": true
},
{
"case": "merge_invalid_11",
"passed": true
},
{
"case": "merge_invalid_12",
"passed": true
},
{
"case": "merge_invalid_13",
"passed": true
},
{
"case": "merge_invalid_14",
"passed": true
},
{
"case": "merge_invalid_15",
"passed": true
},
{
"case": "merge_invalid_16",
"passed": true
}
],
"harness_sha256": "09f0bb2751cc62d5947e85b3e1293d0fa480e46011be7c782c961e49dbded563"
}Claude Opus 5.5: original Python module
"""Duration parsing and interval merging utilities (standard library only)."""
import math
import re
__all__ = ["parse_duration", "merge_intervals"]
_DURATION_RE = re.compile(
r"\s*(?:([0-9]+)[hH])?\s*(?:([0-9]+)[mM])?\s*(?:([0-9]+)[sS])?\s*"
)
def parse_duration(value):
"""Return total seconds for strings like '1h30m', '2m 5s', ' 1H 2M 3S '."""
if not isinstance(value, str) or isinstance(value, bool):
raise ValueError("duration must be a string")
match = _DURATION_RE.fullmatch(value)
if match is None:
raise ValueError(f"invalid duration: {value!r}")
hours, minutes, seconds = match.groups()
if hours is None and minutes is None and seconds is None:
raise ValueError(f"invalid duration: {value!r}")
total = 0
for part, factor in ((hours, 3600), (minutes, 60), (seconds, 1)):
if part is not None:
total += int(part) * factor
return total
def _endpoint(value):
if isinstance(value, bool) or not isinstance(value, (int, float)):
raise ValueError(f"invalid endpoint: {value!r}")
if isinstance(value, float) and not math.isfinite(value):
raise ValueError(f"non-finite endpoint: {value!r}")
return value
def merge_intervals(intervals):
"""Merge overlapping or touching intervals; return a new sorted list of tuples."""
if not isinstance(intervals, list):
raise ValueError("intervals must be a list")
pairs = []
for pair in intervals:
if not isinstance(pair, (list, tuple)) or len(pair) != 2:
raise ValueError(f"malformed pair: {pair!r}")
start, end = _endpoint(pair[0]), _endpoint(pair[1])
if start > end:
raise ValueError(f"reversed pair: {pair!r}")
pairs.append((start, end))
pairs.sort(key=lambda p: (p[0], p[1]))
merged = []
for start, end in pairs:
if merged and start <= merged[-1][1]:
last_start, last_end = merged[-1]
merged[-1] = (last_start, max(last_end, end))
else:
merged.append((start, end))
return merged
Claude Opus 5.5: full recorded test log
{
"passed": 61,
"total": 61,
"cases": [
{
"case": "parse_valid_0",
"passed": true,
"detail": "3600"
},
{
"case": "parse_valid_1",
"passed": true,
"detail": "5400"
},
{
"case": "parse_valid_2",
"passed": true,
"detail": "125"
},
{
"case": "parse_valid_3",
"passed": true,
"detail": "0"
},
{
"case": "parse_valid_4",
"passed": true,
"detail": "3723"
},
{
"case": "parse_valid_5",
"passed": true,
"detail": "5400"
},
{
"case": "parse_valid_6",
"passed": true,
"detail": "120"
},
{
"case": "parse_valid_7",
"passed": true,
"detail": "3723"
},
{
"case": "parse_valid_8",
"passed": true,
"detail": "7200"
},
{
"case": "parse_valid_9",
"passed": true,
"detail": "11040"
},
{
"case": "parse_valid_10",
"passed": true,
"detail": "62"
},
{
"case": "parse_valid_11",
"passed": true,
"detail": "2"
},
{
"case": "parse_invalid_0",
"passed": true
},
{
"case": "parse_invalid_1",
"passed": true
},
{
"case": "parse_invalid_2",
"passed": true
},
{
"case": "parse_invalid_3",
"passed": true
},
{
"case": "parse_invalid_4",
"passed": true
},
{
"case": "parse_invalid_5",
"passed": true
},
{
"case": "parse_invalid_6",
"passed": true
},
{
"case": "parse_invalid_7",
"passed": true
},
{
"case": "parse_invalid_8",
"passed": true
},
{
"case": "parse_invalid_9",
"passed": true
},
{
"case": "parse_invalid_10",
"passed": true
},
{
"case": "parse_invalid_11",
"passed": true
},
{
"case": "parse_invalid_12",
"passed": true
},
{
"case": "parse_invalid_13",
"passed": true
},
{
"case": "parse_invalid_14",
"passed": true
},
{
"case": "parse_invalid_15",
"passed": true
},
{
"case": "parse_invalid_16",
"passed": true
},
{
"case": "parse_invalid_17",
"passed": true
},
{
"case": "parse_invalid_18",
"passed": true
},
{
"case": "parse_invalid_19",
"passed": true
},
{
"case": "merge_valid_nonmutation_0",
"passed": true,
"detail": "[]"
},
{
"case": "merge_valid_nonmutation_1",
"passed": true,
"detail": "[(1, 5), (8, 8)]"
},
{
"case": "merge_valid_nonmutation_2",
"passed": true,
"detail": "[(1, 2), (5, 6)]"
},
{
"case": "merge_valid_nonmutation_3",
"passed": true,
"detail": "[(1, 10)]"
},
{
"case": "merge_valid_nonmutation_4",
"passed": true,
"detail": "[(1, 2)]"
},
{
"case": "merge_valid_nonmutation_5",
"passed": true,
"detail": "[(0, 1)]"
},
{
"case": "merge_valid_nonmutation_6",
"passed": true,
"detail": "[(-4, 0)]"
},
{
"case": "merge_valid_nonmutation_7",
"passed": true,
"detail": "[(1.5, 3.5)]"
},
{
"case": "merge_valid_nonmutation_8",
"passed": true,
"detail": "[(1, 5)]"
},
{
"case": "merge_valid_nonmutation_9",
"passed": true,
"detail": "[(7, 7)]"
},
{
"case": "merge_valid_nonmutation_10",
"passed": true,
"detail": "[(1, 4), (6, 7), (9, 10)]"
},
{
"case": "merge_valid_nonmutation_11",
"passed": true,
"detail": "[(0, 1), (1.0001, 2)]"
},
{
"case": "merge_invalid_0",
"passed": true
},
{
"case": "merge_invalid_1",
"passed": true
},
{
"case": "merge_invalid_2",
"passed": true
},
{
"case": "merge_invalid_3",
"passed": true
},
{
"case": "merge_invalid_4",
"passed": true
},
{
"case": "merge_invalid_5",
"passed": true
},
{
"case": "merge_invalid_6",
"passed": true
},
{
"case": "merge_invalid_7",
"passed": true
},
{
"case": "merge_invalid_8",
"passed": true
},
{
"case": "merge_invalid_9",
"passed": true
},
{
"case": "merge_invalid_10",
"passed": true
},
{
"case": "merge_invalid_11",
"passed": true
},
{
"case": "merge_invalid_12",
"passed": true
},
{
"case": "merge_invalid_13",
"passed": true
},
{
"case": "merge_invalid_14",
"passed": true
},
{
"case": "merge_invalid_15",
"passed": true
},
{
"case": "merge_invalid_16",
"passed": true
}
],
"harness_sha256": "09f0bb2751cc62d5947e85b3e1293d0fa480e46011be7c782c961e49dbded563"
}Frozen Python test runner
#!/usr/bin/env python3
"""Frozen behavior checks. Runs model Python in a child interpreter, timeout 8s."""
import argparse
import copy
import hashlib
import importlib.util
import json
import math
import pathlib
import subprocess
import sys
PARSE_OK = [
('1h',3600), ('1h30m',5400), ('2m 5s',125), ('0s',0),
(' 1H 2M 3S ',3723), ('90m',5400), ('120s',120),
('01h02m03s',3723), ('2h0s',7200), ('3h 4m',11040),
('1m\t2s',62), ('2s',2),
]
PARSE_BAD = ['', ' ', '123', '-1s', '+1s', '1.5h', '1s1m', '1m1h',
'1h1h', '1m2m', '1s2s', '1d', '1 h', '1h nope', 'NaNs',
None, True, 30, [], b'1s']
MERGE_OK = [
([], []), ([[3,5],[1,3],[8,8]],[(1,5),(8,8)]),
([[5,6],[1,2]],[(1,2),(5,6)]), ([[1,10],[2,3]],[(1,10)]),
([[1,2],[1,2]],[(1,2)]), ([[0,0],[0,1]],[(0,1)]),
([[-4,-2],[-2,0]], [(-4,0)]), ([[1.5,2.5],[2.5,3.5]],[(1.5,3.5)]),
([(1,2),(4,5),(2,4)],[(1,5)]), ([[7,7]],[(7,7)]),
([[9,10],[2,4],[1,3],[6,7]],[(1,4),(6,7),(9,10)]),
([[0,1],[1.0001,2]],[(0,1),(1.0001,2)]),
]
MERGE_BAD = [None, (), {}, 'ab', [1], [[1]], [[1,2,3]], [[2,1]],
[[True,2]], [[0,False]], [['1',2]], [[None,2]], [[0,float('inf')]],
[[float('-inf'),0]], [[0,float('nan')]], [{1,2}], [[0,complex(1,0)]]]
def child(module_path):
spec = importlib.util.spec_from_file_location('candidate', module_path)
module = importlib.util.module_from_spec(spec)
try:
spec.loader.exec_module(module)
except BaseException as exc:
return {'passed':0,'total':len(PARSE_OK)+len(PARSE_BAD)+len(MERGE_OK)+len(MERGE_BAD),'import_error':repr(exc)}
records=[]
def add(name, ok, detail=None):
records.append({'case':name,'passed':bool(ok),**({'detail':detail} if detail else {})})
for i,(value, expected) in enumerate(PARSE_OK):
try:
actual=module.parse_duration(value)
add(f'parse_valid_{i}', type(actual) is int and actual==expected, repr(actual))
except BaseException as exc: add(f'parse_valid_{i}',False,repr(exc))
for i,value in enumerate(PARSE_BAD):
try:
actual=module.parse_duration(value)
add(f'parse_invalid_{i}',False,repr(actual))
except ValueError: add(f'parse_invalid_{i}',True)
except BaseException as exc: add(f'parse_invalid_{i}',False,repr(exc))
for i,(value, expected) in enumerate(MERGE_OK):
inp=copy.deepcopy(value); before=copy.deepcopy(inp)
try:
actual=module.merge_intervals(inp)
ok=type(actual) is list and all(type(p) is tuple for p in actual) and actual==expected and inp==before and actual is not inp
add(f'merge_valid_nonmutation_{i}',ok,repr(actual))
except BaseException as exc: add(f'merge_valid_nonmutation_{i}',False,repr(exc))
for i,value in enumerate(MERGE_BAD):
try:
actual=module.merge_intervals(copy.deepcopy(value))
add(f'merge_invalid_{i}',False,repr(actual))
except ValueError: add(f'merge_invalid_{i}',True)
except BaseException as exc: add(f'merge_invalid_{i}',False,repr(exc))
return {'passed':sum(r['passed'] for r in records),'total':len(records),'cases':records}
if __name__=='__main__':
parser=argparse.ArgumentParser(); parser.add_argument('module'); parser.add_argument('--child',action='store_true'); parser.add_argument('--output')
args=parser.parse_args()
if args.child:
print(json.dumps(child(args.module)))
else:
try:
result=subprocess.run([sys.executable,'-I',__file__,args.module,'--child'],capture_output=True,text=True,timeout=8)
data=json.loads(result.stdout.strip().splitlines()[-1])
except BaseException as exc: data={'runner_error':repr(exc)}
data['harness_sha256']=hashlib.sha256(pathlib.Path(__file__).read_bytes()).hexdigest()
out=json.dumps(data,indent=2)
if args.output: pathlib.Path(args.output).write_text(out)
print(out)
Animated city in one HTML file
Both scenes filled the viewport and animated without external requests or recorded browser errors in the desktop and mobile checks. Their day/night buttons changed the scene and remained usable after resizing.
Sol used a denser skyline with blue and amber windows, small flat cars and a purple night gradient. Opus used larger cars with visible wheels, yellow windows and a darker blue sky. These are visible design differences; the requested functionality passed in both. Open the demos to inspect motion, since a still image cannot show how the animation behaves.

GPT-6.2 Sol's output. Open the city demo.
Interactive city: GPT-6.2 Sol

Claude Opus 5.5's output. Open the city demo.
Interactive city: Claude Opus 5.5
Exact prompt used for both models
Respond directly without calling tools.
Return exactly two fenced code blocks, first python then html. No explanations. Keep the combined visible answer within about 1800 tokens. Use Python standard library only and no external resources in the HTML.
Task 1. Implement two functions in one Python module:
parse_duration(value): return total integer seconds. Accept strings containing one or more unsigned integer terms with units h, m, s, each unit at most once and in that order. Units are case-insensitive. Allow whitespace around the string and between terms, but not between a number and its unit. Examples: '1h30m', '2m 5s', '0s', ' 1H 2M 3S '. Minutes and seconds may exceed 59. Reject empty/whitespace-only values, bare numbers, signs, decimals, duplicate/out-of-order units, unknown units and non-string values, including bool. Raise ValueError for every invalid input.
merge_intervals(intervals): accept a list of pairs (each pair a list or tuple of length 2) of finite int/float endpoints; bool is invalid. Require start <= end. Return a new list of tuples sorted by start, merging overlapping or touching intervals. Do not mutate the input or its pairs. Accept zero-length and negative intervals. Empty list returns []. Invalid outer types, malformed pairs, invalid/nonfinite endpoints or reversed pairs must raise ValueError. Example: [[3,5],[1,3],[8,8]] -> [(1,5),(8,8)].
Task 2. Write one self-contained HTML file showing an animated night city on a canvas that fills the viewport and resizes with the window. Include a skyline with lit windows that slowly turn on and off, a road with at least five moving cars traveling in both directions with headlights, a moon, and a visible button at the top-left that switches between night and day. The button must remain usable after resizing. Use no external libraries, assets or network requests.
How to use GPT-6.2 Sol through AI/ML API
AI/ML API supports the OpenAI Python SDK. You can use one client to call Sol and Opus, then keep the input and your acceptance checks constant as you compare their outputs.
Step 1: Create a key and prepare Python
Create an AI/ML API account and generate an enabled key on the API keys page. You need an AI/ML API key for this endpoint. Follow the quickstart to configure your account, then install the SDK in your Python environment:
python3 -m pip install openai
export AIMLAPI_API_KEY="your-aimlapi-key"
The environment command above is for macOS or Linux. In PowerShell, set $env:AIMLAPI_API_KEY="your-aimlapi-key" instead. Keep the real key in your environment rather than the example file.
Step 2: Send a small, checkable task
Save this as sol_example.py. It asks Sol to group incident reports by service and calculate their total downtime. The local checks verify the returned data against the supplied records. This is an integration example; running it sends a billable request.
import json
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["AIMLAPI_API_KEY"],
base_url="https://api.aimlapi.com/v1",
)
response = client.chat.completions.create(
model="openai/gpt-6.2-sol",
messages=[{
"role": "user",
"content": (
"Group these incident records by service and sum downtime_minutes. "
"Return only a JSON object mapping each service to its integer total. "
"Do not include Markdown fences or commentary. Records: "
'[{"service":"checkout","downtime_minutes":12},'
'{"service":"search","downtime_minutes":4},'
'{"service":"checkout","downtime_minutes":7}]'
),
}],
max_tokens=16000,
)
choice = response.choices[0]
text = choice.message.content
if choice.finish_reason == "length" or not text:
raise RuntimeError(f"Incomplete answer: {choice.finish_reason}")
print(text)
print("Usage:", response.usage)
result = json.loads(text)
if result != {"checkout": 19, "search": 4}:
raise ValueError(f"Unexpected incident totals: {result}")
print("Incident totals passed the check.")
Run it with python3 sol_example.py. The code prints the answer and usage before checking the totals. If the answer includes extra prose, JSON parsing will fail, which gives you a concrete formatting failure to record. A production integration can use a supported structured-output option after you check its route schema.
Step 3: Compare Opus and check the controls
Change only the model ID to anthropic/claude-opus-5-5 for an initial Opus comparison. Record the result and usage for each request, then review the usage logs for the account charges. Keep the local check unchanged.
The example leaves thinking controls at route defaults. OpenAI rejects reasoning effort none; Opus uses adaptive thinking. Consult each model's supported request schema before setting effort, because a shared SDK does not give the two models identical parameters or budgets. OpenAI's hosted tools use the Responses API. This text-only Chat Completions example supplies no browsing or computer-use tools.
Frequently asked questions
Is GPT-6.2 Sol a price cut from GPT-6.1 Sol?
No. Standard input, cached-input and output rates remain the same.
Should I replace Opus 5.5 with Sol for coding?
Try Sol on a representative set of your coding tasks first. Opus leads FrontierCode 2.0 in the comparison above, while both models passed our smaller Python task. Keep Opus available for tasks where it produces an accepted change that Sol fails to deliver, and measure how often that happens.
Can I send a million-token document to Sol?
Sol's maximum input is 922,000 tokens, and instructions or other request content also use that allowance. Input above 272,000 tokens triggers higher rates for the whole request. Check the encoded request size before budgeting a large-document workflow.
Can I turn thinking off to get a cheaper response?
Sol rejects reasoning effort none, and Opus's adaptive thinking is always on. The available effort controls depend on the selected API route. See the Sol and Opus documentation.
Does my ChatGPT or Claude subscription cover AI/ML API?
AI/ML API uses its own key and account balance. Your chat subscription does not fund requests sent to this gateway.
Which model should you use?
Start with GPT-6.2 Sol when you need a default for repeated coding or document tasks that you can check. Its unchanged rates make it a straightforward upgrade candidate for GPT-6.1 Sol users, and its lower standard rates make it worth trying on tasks you currently send to Opus.
Keep Opus 5.5 for tasks where its output earns the extra cost. Opus's higher FrontierCode and Intelligence Index scores make it worth keeping in the comparison for difficult code changes. For very long inputs, compare the actual bill because Sol's input-rate advantage disappears above 272,000 tokens. Use the AI/ML API example to send your first checkable request, then expand the trial to work your application needs to complete.
For the other model in this release, see our GPT-6.2 Astra vs Claude Fable 5.2 guide.



