Guide OpenAI · Chapter 2

    Which OpenAI model does which work.

    The GPT-6 family works in ChatGPT, through the API and under Copilot, Codex models in the repository. Which model takes on a task is decided by your test set.

    As of: October 2026 · Editor: Marcel Haas

    • GPT-6
    • Codex
    • Responses API
    • Decisions API
    • Data region
    • Assistants API

    Model data sheets

    One data sheet per model family.

    For every family: who offers it, where it is available, where it computes, what we test it on first, and the Stand with the vendor's page where one exists.

    • OpenAI

      GPT-6 Astra

      Where it is available
      ChatGPT by plan, the API per project, Microsoft Foundry as Azure OpenAI
      Where it computes
      Data region per project; the Europe region for the listed endpoints, with an approved retention option
      What we test it on first
      Planning long workflows, operating software, researching on the web, running code; only once Sol fails on the test set
    • OpenAI

      GPT-6 Sol

      Where it is available
      ChatGPT by plan, the API per project, Microsoft Foundry as Azure OpenAI, under Copilot through the router
      Where it computes
      Data region per project; the Europe region for the listed endpoints, with an approved retention option
      What we test it on first
      Office work, drafts, coding and computer use in daily routine; the main model of most applications
    • OpenAI

      GPT-6 Luna

      Where it is available
      The API per project, as the basis of the Decisions API, Microsoft Foundry as Azure OpenAI
      Where it computes
      Data region per project; the Europe region for the listed endpoints, with an approved retention option
      What we test it on first
      Classification, extraction and short texts at volume, routing in the inbox, the next step of an agent
    • OpenAI, aligned to the work in the repository

      Codex models

      As of October 2026

      Where it is available
      Codex in the desktop app, the terminal, the IDE and Codex Cloud, included in ChatGPT Business and Enterprise
      Where it computes
      Locally on the developer's machine or in Codex Cloud on the connected repository; switched off at first in Enterprise workspaces
      What we test it on first
      Working through tickets in the repository, writing code and tests, submitting changes as a pull request; measured on real tickets

    The models we test with first; your test set decides. The cards name the models as the catalogue lists them until the vendor's page is in the index.

    01

    A model reads the context and returns an answer, a tool call or a structure.

    An association sends the minutes of its assembly to the Responses API and asks for the resolutions with owner and deadline as a table. The call carries everything the model should see: the instruction, the minutes, the description of the tools and the schema of the output, counted in tokens, and back comes an answer, a tool call or an output in exactly the prescribed shape. How long the model thinks first you set per call; more thinking time costs tokens and seconds and pays off for analyses, rarely for classification at volume. Context, reasoning, tool calls and structured output decide whether a model carries a task, and all four can be measured on your cases.

    02

    The GPT-6 family is graded, and Codex has models of its own.

    OpenAI assigns Astra to the most demanding work: planning long workflows, operating software, researching on the web, running code. Sol carries office work, coding and computer use in daily routine, and Luna takes on classification, extraction and short texts at volume; the Decisions API, which picks one answer from a fixed set, builds on Luna. Codex works with models aligned to the work in the repository: long tasks, tool calls, tests, changes for review. The same family is available in the ChatGPT workspace, through the API per project and as Azure OpenAI in Microsoft Foundry; what changes with the route are place, sign-in and billing, not the model.

    03

    The task picks the model, the test set confirms it.

    An inbox with hundreds of requests a day needs a model that classifies in seconds and costs almost nothing; a forty-page contract needs one that holds long contexts and names passages; an agent preparing a posting needs reliable tool calls and outputs that keep to a schema. That is why two models often work in one application: a small one for pre-sorting and extraction, a large one for the answer, and where a wrong answer is expensive, a third as a checker. For steps with a fixed set of answers, post, query, reject, the Decisions API takes the context as text or image and picks one answer. Two candidates work through the same set of real cases, and the proposal records why one won.

    04

    The data region of the project decides where a model computes.

    A model alone is not yet a place. Only the project you call it in sets one: you choose the data region when creating the project, together with keys that expire and hard spending limits. The Europe region, which the vendor labels EEA and Switzerland, stores and processes in the region for the listed endpoints and requires an approved retention option; the Agents API is not listed there, and which models and features a Europe project covers we check per application against the list. We do not commit to processing in Switzerland for these models; we name the region as the vendor names it. The data sheet of every project therefore carries model, version, region and retention option, and the data boundaries chapter says which data class may go in.

    05

    Retirements are planning facts.

    On 26 August 2026 OpenAI removed the Assistants API; integrations have run on the Responses API since then, and the Conversations API keeps the history. Agent Builder and the Evals platform shut down on 30 November 2026, existing evals become read-only from 31 October 2026, ChatKit remains. Model versions follow the same pattern: the deprecations page names for every version the date on which it is replaced and the successor. Every data sheet carries that date, a quarter before it the successor competes on the test set, and because the Evals platform is going, the test set lives in your own pipeline, where nobody can switch it off.

    What you decide.

    Astra, Sol or Luna for the first case?

    Options

    1. 1Luna for classification, extraction and short texts at volume
    2. 2Sol for office work, drafts and coding
    3. 3Astra for long, multi-step work with tools

    Our recommendation: Luna when the bulk of the calls consists of classification, extraction and routing; Sol for drafts, summaries and coding in daily routine; Astra only when Sol fails a long, multi-step task on the test set. In every case two candidates compete on the test set, and the cheaper one wins as soon as it solves the cases equally well.

    What we advise against: Astra for everything because it is the strongest model. Every call costs more tokens and time, and a test set that never tried a smaller model does not know the saving.

    One model per application or one per step?

    Options

    1. 1One model for every step
    2. 2A small model for pre-sorting and extraction, a large one for the answer
    3. 3Plus a second model as a checker

    Our recommendation: Per step. A small model takes pre-sorting and extraction, because the bulk of the calls happens there, a large one the answer, and where a wrong answer is expensive, a second model checks references and completeness before a person decides. Which combination holds is shown by the test set with the cost per case.

    What we advise against: Several models because it is possible. Every additional model needs a slot in the data sheet, in the test set and in the cost calculation.

    Decisions API or a model call with a schema?

    Options

    1. 1A model call with an output schema
    2. 2The Decisions API for fixed sets of answers
    3. 3Both, depending on the step

    Our recommendation: The Decisions API where a step needs exactly one answer from a fixed set, for instance routing in the inbox or the next step of an agent, and a test set with your cases measures the hit rate. A model call with a schema where the output carries several fields, for instance the list of resolutions. In an agent both often occur, and decisions with consequences for a person fall back to a human.

    What we advise against: Hanging a decision with consequences for a person on the hit rate. The rate from the test set stands next to every approval, it does not replace it.

    When do we switch the model?

    Options

    1. 1When the deprecations page names a date
    2. 2When a new model scores better on the test set
    3. 3At a fixed date every quarter

    Our recommendation: When the test set shows it or the retirement date demands it, and never unnoticed. Every project data sheet carries the date of replacement; a quarter before, the successor competes on the test set, instructions are adjusted where the answers differ, and the switch goes through approval as a new version like every other change.

    What we advise against: Moving to the newest version because it is there. A new version answers differently, and what has proven itself in instructions and schemas must be measured again.

    Status and sources.

    As of: October 2026

    • Since 26 August 2026

      Assistants API shut down, Agent Builder next.

      OpenAI removed the Assistants API on 26 August 2026; the successors are the Responses API and the Conversations API. Agent Builder and the Evals platform shut down on 30 November 2026, and existing evals become read-only from 31 October 2026. ChatKit remains.

      Source: OpenAI: Deprecations
    • As of October 2026

      The data region of the project decides where a model computes.

      You set the data region per project when creating it, together with keys that expire and hard spending limits. The Europe region, which OpenAI labels EEA and Switzerland, stores and processes in the region for the listed endpoints and requires a retention option approved by OpenAI; the Agents API is not listed there.

      Source: OpenAI: Data controls in the OpenAI platform
    • As of October 2026

      Codex Cloud starts switched off in Enterprise workspaces.

      Administrators enable use through roles, define environments, secrets and internet access, and distribute rules for local runs in a requirements.toml file. Codex Cloud respects the repository permissions of the source system.

      Source: OpenAI: Codex admin rollout guide

    Frequently asked questions.

    How do Astra, Sol and Luna differ?

    In the work they are built for and in the price per token. Astra carries the most demanding work: planning long workflows, operating software, researching, running code. Sol takes on office work, drafts, coding and computer use in daily routine. Luna classifies, extracts and writes short texts at volume and is the basis of the Decisions API. Which model gets a task is shown by the test set, and often two of them work in one application.

    Are the models in ChatGPT and in the API the same?

    The same family, on different routes. In the workspace ChatGPT chooses per plan and task, through the API you choose model, thinking time and schema per call, and as Azure OpenAI the same family runs in Microsoft Foundry with Entra ID and Purview. Place, sign-in and billing hang on the route, which is why the data sheet of every application records which route it calls through.

    Does Codex need a model of its own?

    Codex runs on models the vendor aligns to the work in the repository: long tasks, many tool calls, tests, changes for review. Which model a run uses is set in the Codex configuration and can be prescribed centrally for the development team; quality and consumption you measure, as with any model, on real tickets from your repository.

    When do we use the Decisions API?

    When a step needs exactly one answer from a fixed set: assigning inbox items, invoices or tickets to a category, routing a case to the person responsible, choosing the next step of an agent. It gets the context as text or image and the possible answers, picks one, and a test set with your cases measures the hit rate before the workflow follows it. Decisions with consequences for a person fall back to a human.

    How do we notice that a model is being retired?

    On the deprecations page, which names the date of replacement and the successor for every version; that date sits in the data sheet of every project, and one person per application checks the page with its status date every quarter. A quarter before the date the successor competes on the test set, and the switch goes through approval as a new version.

    Does a Europe project compute with every model?

    With the models and endpoints the vendor lists for the region; the Agents API is not among them, and an approved retention option is a prerequisite. That is why we check the list per application before the project is created, because the region cannot be changed afterwards. We do not commit to processing in Switzerland for these models; we name the region as the vendor names it.

    Next chapter · Chapter 3

    What an AI agent at OpenAI is made of and where it runs.

    What is an agent made of at OpenAI, and how does it run safely?