Model Library

GPT-5.4 nano is the smallest model in the GPT-5.4 family, built for the tasks where speed and cost decide whether a design is possible at all: classification, data extraction, ranking, and subagents. It answers immediately by default, with no reasoning pass, and exposes the same five effort levels as the tiers above it should a particular path need more. It accepts text and images across a 400,000-token context window and supports schema-constrained output, so structured extraction needs no parsing layer behind it. On DEVUP AI it is the model to reach for when the same operation runs thousands of times and the cost of each one is what you are actually optimising.

GPT-5.4 Mini brings the strengths of the full GPT-5.4 model into a faster, more efficient form built for high-volume workloads. OpenAI positions it as its strongest mini model yet for coding, computer use, and subagents — the roles where a model runs many times rather than once, and where latency and cost per call decide whether a design is viable at all. It shares the same five reasoning effort levels as the tier above it, defaults to no reasoning for speed, and adds a verbosity control that shapes answer length independently of thinking depth. Text and images in, text out, across a 400,000-token context window.

GPT-5.4 is OpenAI's more affordable model for coding and professional work, and it differs from the tier above it in one way that shapes every integration: it defaults to no reasoning at all. Where the flagship deliberates unless told otherwise, this model answers immediately unless you ask it to think — which makes it fast and cheap by default, and easy to under-configure by accident. It brings dedicated coding-model capabilities into a general model: production-quality code, multi-file changes with fewer retries, and stronger document and spreadsheet work. It carries a context window slightly beyond a million tokens, accepts text and images, and adds a verbosity control that shapes answer length independently of reasoning depth.

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.

DeepSeek V4.1 Flash is a multimodal Mixture-of-Experts model built around one goal: making the memory cost of long context collapse. It carries 552 billion backbone parameters but activates only 8 billion per token while reading your input and 16 billion while writing its answer — an asymmetry made possible by a causal encoder-decoder design where the decoder's key-value cache is projected from the encoder's final states rather than rebuilt layer by layer. The result is 890 bytes of cache per token, roughly a quarter of the previous generation and a fraction of a percent of where the series began. Reasoning effort is a continuous integer from 1 to 100 rather than a handful of preset levels, so cost and accuracy can be tuned rather than chosen from a menu.

GPT-5.6 Sol is the flagship of OpenAI's GPT-5.6 family and the model the bare gpt-5.6 alias resolves to. What separates it from the two tiers below is not the envelope — all three share the same context window, output ceiling, input types, and six reasoning levels — but persistence. It is built to stay coherent through multi-hour agent sessions rather than stopping early, and it reaches frontier results while emitting fewer output tokens than its predecessors needed. It reasons across six effort levels, carries its chain of thought between turns when you let it, and offers a separate pro execution mode for work where reliability outweighs latency. Text and images in, text out, against a context window slightly beyond a million tokens.

GPT-5.6 Terra is the balanced tier of OpenAI's GPT-5.6 family: more capability than the efficiency model, at a fraction of the flagship's cost, on an interface identical to both. All three tiers share the same context window, output ceiling, input types, and six reasoning effort levels — so routing between them is a change to one field, not a re-integration. Terra is positioned as the practical default for everyday production traffic: application features, internal tooling, support automation, and the routine steps of a longer agent run. It reasons across six levels from none through maximum, accepts text and images, supports structured outputs and function calling, and can carry its reasoning across turns to improve both multi-turn quality and cache efficiency.

GPT-5.6 Luna is the efficiency tier of OpenAI's GPT-5.6 family, built for workloads measured in volume rather than difficulty. Its distinguishing feature is the range of control it gives you over deliberation: six reasoning effort levels, from none at all through to maximum, selectable per request. That span is unusually wide — the same model identifier serves a real-time chat endpoint that must answer instantly and a batch analysis job that can afford to think for minutes. It accepts text and images against a context window slightly beyond a million tokens, supports structured outputs and function calling, and works through both the standard chat interface and OpenAI's newer Responses API.

Ling-3.0-flash-VL adds image and video understanding to Ling-3.0-flash, and the interesting part is that vision did not sit alongside the language model — it raised it. On the Artificial Analysis intelligence index the visual model scores 42 against 38 for the text model it was built from, on the same 124-billion-parameter foundation with only 5.5 billion active per inference step. A vision encoder feeds a two-layer projector that aligns visual features with text, while a space-and-time positional encoding handles video. What it was built to do is act on what it sees: read a design reference and write the interface, render the result and compare it against the original, identify elements on a screen and operate them.

DeepSeek V4 Flash Vision Exp is an experimental vision-enabled build of V4 Flash, and it takes an unusual approach to image cost: every image is capped at 384 tokens regardless of its resolution. A two-megapixel scan and a twenty-five-megapixel one bill identically, because both are resized to the same working size before inference. That turns document processing from an open-ended cost into arithmetic you can do before sending the request. It accepts up to six hundred images per call, matches the text model it is built on across agents, reasoning, and world knowledge, and holds the same million-token context. On DEVUP AI it is the choice when the workload is pages rather than paragraphs.

Qwen3.8-27B is a dense vision-language model that thinks before it answers — and by default, it thinks a great deal. Reasoning runs at the deepest of three settings unless you change it, which on long-form work can consume an entire output budget before a single word of the answer appears. The three levels turn out to be three system prompts rather than three capability tiers: one asks the model to deliberate, one says nothing, one asks for brevity. Independent measurement across ninety-six runs found no quality difference on short verifiable tasks. Sixty-four layers, three quarters of them linear attention, with a 262,144-token window and hour-scale video understanding.

Muse Glimmer 30B is Meta Superintelligence Lab's first open-weight release, and it was designed around a single constraint: an agent that runs on the machine in front of you. Roughly 29.6 billion dense parameters including a dedicated vision encoder, distilled from a larger model, and quantized to fit under 20 GB — small enough to run on one consumer GPU while still holding a 131K context and reading screenshots, charts, and documents. What sets it apart is what it was trained for rather than what it knows: sustained tool use across long workflows, and diagnosing a failed tool call and retrying rather than stopping. It ships with published prompt-injection and privacy evaluations, which few models of any size do. Apache 2.0.

Kimi K3 is the first open model in the three-trillion-parameter class — 2.8 trillion total, 104 billion active, a million tokens of context, and native vision. Two architectural bets carry it: Kimi Delta Attention paired with Attention Residuals, and a sparsity framework that selects sixteen experts from eight hundred and ninety-six, together delivering roughly two and a half times the scaling efficiency of the previous generation. Thinking is permanently on with three effort levels, and the model was trained in preserved-thinking-history mode — meaning your client must send its reasoning back on every turn, not as an optimisation but as a requirement.

Inkling-Small is a Mixture-of-Experts transformer with 276B total parameters, 12B active, trained on NVIDIA GB300 NVL72 systems. Like Inkling, it features native reasoning over audio and images, variable thinking effort

Gemma 4 31B is the largest dense model in Google DeepMind's open family, and its defining quality is how little it spends to think. Running a full intelligence evaluation consumed roughly 39 million output tokens — a fraction of what comparably-scoring reasoning models needed, because it reaches its conclusion rather than circling it. A 131,072-token context window takes entire codebases or large image sets in one prompt, with a vision encoder that accepts variable aspect ratios rather than forcing everything square. Thinking is configurable, function calling is native, and it runs on a workstation under Apache 2.0.

Claude Opus 5 is Anthropic's model for complex agentic coding and enterprise work, and it thinks by default. Adaptive thinking means the model decides when and how much to reason on each turn rather than waiting to be told, with effort selectable across five levels. Its million-token context window is both the default and the maximum — there is no smaller variant and no long-context surcharge — and instruction following, tool calling, and reasoning stay consistent across the full window. The largest gains over the previous generation are in sustained multi-step analysis, long-horizon agentic work that completes features rather than leaving stubs, and converting additional effort into measurably better results.

Inkling is a general-purpose multimodal model that accepts text, image and audio inputs and generates text outputs.

Claude Fable 5 was Anthropic's most capable widely released model, built for demanding reasoning and long-horizon agentic work. Two things set it apart from everything else in this catalogue. Thinking is permanently on — there is no parameter that disables it, only an effort dial that sets how deep it goes. And it ships with safety classifiers that can decline a request, returning a successful response carrying a refusal rather than an error, which means any integration must inspect why a response ended rather than assuming a 200 means an answer. It holds a million-token context with a 128,000-token output ceiling, and reads text and images.

Claude Sonnet 5 pairs a million-token context window with the fastest comparative latency in its generation, which is what makes it the working default rather than an economy option. It matches the Opus tier on window size and output ceiling while answering noticeably quicker, and adaptive thinking is on by default with five effort levels controlling how deep it goes. One integration detail separates it from most models in this catalogue: sampling parameters are rejected outright. Send a temperature, a top-p, or a top-k at anything other than its default and the request returns an error rather than quietly ignoring it — so output variation is shaped through effort and prompting instead.

MiniMax-M3 is built around one component: a sparse attention operator that MiniMax published as a standalone project with its own technical report. The numbers it produces are measured against the previous generation at a million tokens — nine times faster prefill, fifteen times faster decode, and per-token compute cut to one twentieth. Multimodality was not added afterwards; mixed-modality training ran from the first step across text, image, and video. Four hundred and twenty-eight billion parameters with twenty-three active, sixty layers, a 524,288-token window, and a thinking parameter that can let the model decide for itself when deliberation is worth it.

Nemotron 3.5 Content Safety is a four-billion-parameter moderator that can explain itself. It classifies a prompt, an optional image, and an optional response across a twenty-three-category taxonomy — and in think mode it emits an auditable reasoning trace before the verdict, which is what makes a blocked decision defensible rather than merely enforced. It also accepts your own safety policy in place of the default taxonomy. Its twelve languages were not translated but culturally adapted, addressing a measured problem: models produce more unsafe content in non-English languages because safety training data lacks cultural nuance. It runs on a single L4.

Built for the Agent era, it delivers stable performance in complex reasoning and long-horizon tasks, including multi-step planning, visual-text reasoning, video understanding, and advanced analysis.

Built for low-latency, high-concurrency, cost-sensitive use cases, with flexible deployment, four-tier thinking, and multimodal

A coding model optimized for real-world development environments, with reliable tool use in common IDEs such as Claude Code. It delivers strong front-end performance and supports Skills.