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.3-Codex is OpenAI's most capable agentic coding model, and it is built for a narrower job than a general assistant: writing, debugging, and shipping software inside a coding agent. It merges the software-engineering strength of the previous Codex model with the broader professional reasoning of the general tier, and the result works autonomously for hours rather than turns. Compaction support lets a session run past what a context window would normally allow, and you can steer it mid-execution rather than waiting for it to finish and starting over. Reasoning is always on, across four depth levels, with the middle setting recommended for everyday interactive work.
OpenAI's most capable agentic coding model. It is tuned for one environment — a coding agent — and that focus is visible in every design choice on this page.
Most models in this family are general. This one is not. It is optimised for Codex and Codex-shaped environments: a model given a repository, a terminal, a set of tools, and a task it is expected to finish on its own.
It combines two lineages. The software-engineering capability comes from the previous Codex-tuned model; the broader professional reasoning and world knowledge come from the general tier of the same generation. Coding models often lose the second when they specialise. This one kept it.
The practical effect is on the tasks that are not purely code — reading a specification, judging which of three approaches fits an existing architecture, deciding that a failing test is wrong rather than the implementation.
| Level | When to use it |
|---|---|
low |
| Small, well-specified edits where the path is already clear |
medium | OpenAI's recommendation for interactive coding — the everyday balance of intelligence and speed |
high | Harder problems that need real analysis |
xhigh | The hardest tasks, and long autonomous runs |
Unlike the general-purpose models in this family, there is no zero-reasoning setting. That is deliberate. A model that writes code into a repository without deliberating is not a feature anyone asked for.
Start at medium and move only when you have a reason. OpenAI's own framing is that high and
xhigh are for your hardest tasks — not for everything, and not as a default.
One operational note: this model is more token-efficient than its predecessors at the same effort level. It reaches the same result with fewer thinking tokens, which means a level that felt expensive on an earlier model may not be here. Re-measure rather than carrying over an old setting.
Check the level against the four accepted values in your own code before the request goes out.
This is the capability that changes what is possible rather than what is faster.
Compaction lets a session continue past the point where the context window would normally end it. A long agent run accumulates file contents, tool output, test results, and its own reasoning. Ordinarily that growth has a hard stop. Compaction compresses the history as the session runs, so the work continues.
Two things follow.
Multi-hour autonomous work becomes practical. OpenAI describes this model as working independently for hours on hard tasks, and compaction is the mechanism that makes it possible rather than a claim about stamina.
Long conversations do not need restarting. A session that would have hit a wall and forced a fresh start can simply keep going — which matters because a restarted session has lost everything it learned.
You can redirect this model while it is working, rather than waiting for a wrong answer and starting again.
That changes the shape of the interaction. On a conventional model, noticing at minute three that the agent is solving the wrong problem means cancelling, rewriting the prompt, and paying for the whole run again. Here it means saying so.
Build for it: surface the model's progress as it works, and give whoever is watching a way to intervene. A steering channel that exists but is invisible gets used by nobody.
An unusually specific note from OpenAI's own guidance: this model is substantially better in PowerShell and Windows environments than its predecessors.
That is worth flagging because coding agents have historically been tuned against Unix-shaped assumptions — POSIX paths, bash idioms, Unix tooling. If your team develops on Windows, or your agent operates against Windows infrastructure, this is a concrete reason to prefer this model over an older one in the same family.
| Model ID | openai/gpt-5.3-codex |
| Context window | 400,000 tokens |
| Max output | 128,000 tokens |
| Input | Text, images, files |
| Output | Text |
| Reasoning effort | low · medium · high · xhigh |
| Compaction | Supported |
| Interactive steering | Supported |
Specifications as published by OpenAI. The model's internals — parameter count, layer structure, training method — are not made public, and no weights are distributed.
| Capability | Value |
|---|---|
input_types | text, image, file |
output_types | text |
audio_input | Not supported |
video_input | Not supported |
context_window | 400000 |
max_output_tokens | 128000 |
reasoning | low, medium, high, xhigh — no none |
streaming | Supported |
tool_calling | Supported |
structured_output | Supported — JSON schema |
requires_prompt | Yes — text prompt required |
Base URL: https://api.devupai.com/v1 · Model ID: openai/gpt-5.3-codex
curl https://api.devupai.com/v1/chat/completions \
-H "Authorization: Bearer $DEVUP_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "openai/gpt-5.3-codex",
"messages": [
{
"role": "user",
"content": "This Postgres query returns duplicate rows after I added the join. Explain why, then give the corrected query.\n\nSELECT o.id, o.total, p.name FROM orders o JOIN payments p ON p.order_id = o.id WHERE o.status = 3;"
}
],
"reasoning_effort": "medium",
"max_tokens": 16384
}'medium is the recommended interactive setting. It is also the one most people skip past on the way
to high, and usually did not need to.
The environment this model was tuned for.
import os
import json
import subprocess
from pathlib import Path
from openai import OpenAI
client = OpenAI(
api_key=os.environ["DEVUP_API_KEY"],
base_url="https://api.devupai.com/v1",
)
REPO = Path("/srv/workspace/project")
TOOLS = [
{
"type": "function",
"function": {
"name": "read_file",
"description": "Read a file relative to the repository root.",
"parameters": {
"type": "object",
"properties": {"path": {Two details carry weight here.
The _resolve guard refuses paths that escape the workspace. A model writing files is a model that
can write them anywhere your process can, and the sandbox is yours to build.
Errors return as JSON rather than propagating. This model is trained on trajectories where actions fail and the agent adapts; a raised exception throws away that capability along with the run.
Where xhigh and compaction belong together.
response = client.chat.completions.create(
model="openai/gpt-5.3-codex",
messages=[
{
"role": "system",
"content": (
"Work autonomously. Before each irreversible action, state what you are about to "
"do and why. Report progress as you go. Stop and ask if a requirement is ambiguous "
"rather than choosing for me."
),
},
{"role": "user", "content": "Migrate this service from raw SQL to the query builder, one module at a time. Keep tests green throughout."},
],
tools=TOOLS,
max_tokens=65536,
extra_body={"reasoning_effort": "xhigh"},
)"Stop and ask rather than choosing for me" is the line that makes a multi-hour run recoverable. An autonomous model that guesses at an ambiguous requirement will guess consistently, and you will find out at the end.
import base64
with open("failing_ci_run.png", "rb") as handle:
encoded = base64.b64encode(handle.read()).decode("utf-8")
response = client.chat.completions.create(
model="openai/gpt-5.3-codex",
messages=[
{
"role": "user",
"content": [
{"type": "image_url", "image_url": {"url": f"data:image/png;base64,{encoded}"}},
{
"type": "text",
"text": "This is a failing CI run. Identify the first real failure — ignore cascading errors downstream of it — and tell me which file to look at.",
},
],
}
],
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.3-codex",
messages: [
{
role: "system",
content:
"Review this pull request. Report only changes that would break in production, " +
"each with the file, the line, and the smallest correct fix.",
},
{ role: "user", content: diff },
],
max_tokens: 32768,
reasoning_effort: "high",
});
console.log(response.choices[0]?.message?.content);stream = client.chat.completions.create(
model="openai/gpt-5.3-codex",
messages=messages,
tools=TOOLS,
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\nin {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)Streaming is what makes mid-execution steering usable. If the operator cannot see what the model is doing until it stops, there is nothing to steer.
Drawn from OpenAI's own guidance for this model.
Start at medium. It is the recommended interactive setting, and this model reaches results at
that level that earlier ones needed more effort for.
Expect fewer thinking tokens than before. Token efficiency improved meaningfully. A budget that was right for a previous Codex model may now be oversized, or a level that was too slow may now be affordable.
Give it the whole task, not a decomposed one. This model is designed to work through a multi-hour problem on its own. Breaking the work into small instructions and feeding them one at a time discards the capability you are paying for.
Re-tune prompts written for other models. OpenAI notes that an existing Codex implementation usually needs only minor updates, but a prompt and toolset optimised for a general GPT-series model or a third-party model needs more substantial changes.
Ask for a plan before the edits on anything large. A stated plan is reviewable; a completed refactor is not.
Reach for it when the work is software engineering inside an agent: repository-scale changes, debugging sessions that run long, terminal automation, and CI or deployment workflows. It is also the better choice for Windows and PowerShell environments than earlier models in this family.
Reach elsewhere for general assistance, conversation, writing, or high-volume classification. This model carries capability you would be paying for and not using, and it cannot switch deliberation off for the cheap paths.
Check the context ceiling against your repository. 400,000 tokens is generous but not unlimited; compaction extends a session rather than the window itself.