Model Library
Browse and deploy state-of-the-art AI models through the DEVUP Gateway.
Browse and deploy state-of-the-art AI models through the DEVUP Gateway.
GPT-5.5 was OpenAI's flagship for complex professional work, and it earned that position on persistence rather than raw capability. Where earlier models answered a hard question, this one was built to stay in the loop — find information, judge what matters, use tools, check its own output, and keep going. It carries a context window slightly beyond a million tokens with a 128,000-token output ceiling, accepts text and images, and reasons across five effort levels from none through extended analysis. It also knows more than almost anything measured against it, and answers confidently more often than it should. That combination is the single most important thing to understand before deploying it.
OpenAI's flagship model for complex professional work. Fully available, with newer generations also in the catalogue.
GPT-5.5 is a current, supported model. Newer OpenAI generations exist alongside it, and the difference that matters in practice is knowledge recency: this model's training data stops at 1 December 2025. The newest generation reaches five months further.
For anything touching recent events, library versions, or evolving standards, that gap shows. For grounded work — where the model reads material you supply rather than answering from memory — it does not.
All these models share the same interface, so comparing them on your own workload is a change to one field rather than a re-integration.
Accepted values: none, low, medium (default), high, .
xhighmax is not valid. It appears in documentation for some models in this lineage, but sending it
returns HTTP 400.
{
"model": "openai/gpt-5.5",
"messages": [{ "role": "user", "content": "..." }],
"reasoning_effort": "medium"
}The gateway does not validate the value. An invalid effort level is forwarded upstream, rejected there, and returned as a generic invalid-parameter error — the upstream text naming the accepted values is masked. Validate client-side, per model.
Do not assume the ladder is monotonic. On a later model in this lineage, low was measured as
both more expensive than none and less accurate — the model deliberated for hundreds of tokens and
reached the wrong answer where zero deliberation reached the right one. Accuracy became reliable at
medium. That measurement was taken on a different generation, so treat it as a reason to test
rather than a rule — but test rather than assume.
This is the most important thing on this page.
Independent evaluation by Artificial Analysis measured a hallucination rate of 86% on their AA-Omniscience benchmark — against roughly 36% for the strongest competitor in the same test, and 50% for the next.
Read that alongside the other finding from the same evaluation: this model knows more than anything else tested. Both are true simultaneously. It has unusually broad knowledge, and it will confidently answer a question outside that knowledge at close to two and a half times the rate of the best-calibrated model available.
What this means in practice.
Never present raw output as fact in a user-facing product. The failure mode is not obvious nonsense — it is a fluent, confident, specific answer that happens to be wrong. Those are the hardest errors to catch downstream, because nothing about the response signals uncertainty.
Ground it. Retrieval, tool calls, and supplied source material shift the model from recalling to reading. Its measured strength is persistence through a research loop; its measured weakness is answering from memory. Design around that split.
Instruct it to decline. A system prompt that explicitly permits "I don't know" and forbids inference from absent data does real work here. It will not eliminate the behaviour, but stating the expectation is cheaper than catching the result.
Require citations on anything factual. A claim with a source is a claim you can check. A claim without one, from this model, is a coin flip you cannot see.
| Model ID | openai/gpt-5.5 |
| Context window | 1,050,000 tokens |
| Max output | 128,000 tokens |
| Knowledge cutoff | 1 December 2025 |
| Input | Text, image |
| Output | Text |
| Reasoning effort | none · low · medium · high · xhigh |
| Released | April 2026 |
Context, output, and cutoff figures are as published by OpenAI and have not been independently verified here. Architecture is not published — no parameter counts, no layer structure, no training details, no weights.
Note on visual input. OpenAI's guidance states this model preserves more visual detail by default than its predecessors, which helps on screenshots, charts, UI review, and visual document analysis.
| Capability | Value |
|---|---|
input_types | text, image |
output_types | text |
audio_input | Not supported |
video_input | Not supported |
context_window | 1050000 |
max_output_tokens | 128000 |
reasoning | none, low, medium, high, xhigh — no max |
streaming | Supported |
tool_calling | Supported |
structured_output | Supported — JSON schema |
requires_prompt | Yes — text prompt required, image optional |
OpenAI's framing at release was persistence through a full loop of knowledge work — finding information, judging what matters, using tools, checking the output, and deciding what to do next. Not answering a hard question, but staying with a task across many steps.
That shows in what it leads on. Broad professional work across occupations, desktop computer use, and financial modelling are where it was strongest at release. Software engineering and web browsing were competitive rather than category-leading.
It is also more token-efficient than its predecessors on the same tasks, which matters on long agentic runs where the same work is done repeatedly.
Base URL: https://api.devupai.com/v1 · Model ID: openai/gpt-5.5
curl https://api.devupai.com/v1/chat/completions \
-H "Authorization: Bearer $DEVUP_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "openai/gpt-5.5",
"messages": [
{
"role": "user",
"content": "Two services write to the same row without a transaction. Walk through the failure modes in order of likelihood and propose the smallest fix for each."
}
],
"reasoning_effort": "high",
"max_tokens": 32768
}'Given the calibration profile above, this is not optional boilerplate.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["DEVUP_API_KEY"],
base_url="https://api.devupai.com/v1",
)
GROUNDED = (
"Answer only from the material provided in this conversation. "
"If the material does not contain the answer, say so explicitly and stop — "
"do not infer, estimate, or fill the gap from general knowledge. "
"Cite the source for every factual claim. "
"An answer of 'the provided material does not say' is a correct and complete response."
)
response = client.chat.completions.create(
model="openai/gpt-5.5",
messages=[
{"role": "system", "content": GROUNDED},
{"role": "user", "content": f"{source_documents}\n\nQuestion: {question}"},
],
max_tokens=16384,
extra_body={"reasoning_effort": "medium"},
)
print(response.choices[0].message.content)Permitting "I don't know" explicitly matters more on this model than on most. Without it, the default behaviour is to produce something.
Effort vocabularies differ across models in this catalogue, and the gateway forwards without checking.
# Measured against the live API. `max` is rejected across this lineage.
EFFORT_LEVELS = {
"openai/gpt-5.5": {"none", "low", "medium", "high", "xhigh"},
"openai/gpt-5.6-luna": {"none", "low", "medium", "high", "xhigh"},
"openai/gpt-5.6-terra": {"none", "low", "medium", "high", "xhigh"},
"openai/gpt-5.6-sol": {"none", "low", "medium", "high", "xhigh"},
"openai/gpt-6-astra": {"low", "medium", "high", "xhigh"}, # no `none`
}
def ask(model: str, prompt: str, *, effort: str, max_tokens: int = 16384) -> str:
"""Send a request, refusing an effort level the target model does not accept."""
allowed = EFFORT_LEVELS.get(model)
if allowed is not None and effort not in allowed:
raise ValueError(
f"{model} does not accept reasoning_effort={effort!r}. Allowed: {sorted(allowed)}"
)
response = client.chat.completions.create(
model=model,
messages=[{"role": "user", "content": prompt}],
max_tokens=max_tokens,
extra_body={"reasoning_effort": effort},
)
return response.choices[0].message.contentresponse = client.chat.completions.create(
model="openai/gpt-5.5",
messages=[
{"role": "system", "content": "Extract only fields present in the source. Use null for anything absent — never infer."},
{"role": "user", "content": document},
],
response_format={
"type": "json_schema",
"json_schema": {
"name": "invoice",
"strict": True,
"schema": {
"type": "object",
"properties": {
"invoice_number": {"type": ["string", "null"]},
"total": {"type": ["number", "null"]},
"currency": {"type": ["string", "null"]},
"due_date": {"type": ["string", "null"]},
},
"required": ["invoice_number", "total", "currency", "due_date"],
"additionalProperties": False,
},
},
},
max_tokens=4096,
extra_body={"reasoning_effort": "low"},
)Nullable types throughout, and an instruction never to infer. On a model with this calibration profile, a schema that forbids null is an invitation to invent a value.
import base64
with open("dashboard.png", "rb") as handle:
encoded = base64.b64encode(handle.read()).decode("utf-8")
response = client.chat.completions.create(
model="openai/gpt-5.5",
messages=[
{
"role": "user",
"content": [
{
"type": "image_url",
"image_url": {"url": f"data:image/png;base64,{encoded}"},
},
{
"type": "text",
"text": (
"Read every numeric value visible in this dashboard and report it with its "
"label. Report nothing you cannot actually read — if a value is cut off or "
"illegible, say so rather than guessing."
),
},
],
}
],
max_tokens=8192,
extra_body={"reasoning_effort": "medium"},
)npm install devupaiimport DevupAI from "devupai";
const client = new DevupAI({
apiKey: process.env.DEVUP_API_KEY,
});
const response = await client.chat.completions.create({
model: "openai/gpt-5.5",
messages: [
{
role: "system",
content:
"You are a staff engineer reviewing a migration. Report only defects that would " +
"cause data loss or downtime, each with a severity and the smallest safe fix. " +
"If the plan does not contain enough information to judge, say so.",
},
{ role: "user", content: migrationPlan },
],
max_tokens: 32768,
reasoning_effort: "high",
});
console.log(response.choices[0]?.message?.content);stream = client.chat.completions.create(
model="openai/gpt-5.5",
messages=[{"role": "user", "content": "Design a retry policy for a webhook delivery system."}],
max_tokens=32768,
stream=True,
extra_body={"reasoning_effort": "high"},
)
for chunk in stream:
if not chunk.choices:
if getattr(chunk, "usage", None):
print(f"\n\nTokens — in: {chunk.usage.prompt_tokens}, out: {chunk.usage.completion_tokens}")
continue
delta = chunk.choices[0].delta
if getattr(delta, "content", None):
print(delta.content, end="", flush=True)Streamed responses carry a real usage object in the final chunk, but no platform metadata — so
any request parameter the gateway drops is invisible on a streamed call. Test parameter handling on
a non-streamed request first.
for _ in range(30): # bounded loop — never let an agent iterate without a ceiling
...The iteration ceiling is the only bound you have. There is no per-request spending limit on this platform, so an unbounded loop runs against your full balance.
From OpenAI's announcement and independent evaluation. OpenAI's evaluations were run at xhigh
effort. None of these figures were verified here.
| Benchmark | Score |
|---|---|
| GDPval (44 occupations) | 84.9% |
| Internal investment-banking modeling | 88.5% |
| OSWorld-Verified (desktop computer use) | 78.7% |
| BrowseComp | 84.4% |
| FinanceAgent | 60.0% |
| SWE-bench Pro | 58.6% |
| OfficeQA Pro | 54.1% |
| AA-Omniscience hallucination rate | 86% |
The last row is not a typo and not a minor caveat. It is measured by a third party, it is the highest figure on this list, and it is the one that should determine how this model is deployed.
Note also that the coding and browsing figures were not category-leading at release — competing models were ahead on software engineering and on browsing. This model's distinguishing claim was persistence through a full knowledge-work loop, not a top score on any single axis.
Strong fit for grounded work: retrieval-augmented answering, document analysis, screenshot and dashboard reading, multi-step agentic tasks with tools, and long professional workflows where the model reads rather than recalls.
Weaker fit for open-domain factual questions answered from the model's own knowledge and shown directly to a user. The calibration profile makes that pattern risky without a verification layer.
Compare against newer generations if your workload depends on recent knowledge. The interface is identical, so the test costs one changed string.
max is not a valid reasoning level.low measured worse
than none at higher cost. Test rather than assume.