Guide OpenAI · Chapter 5

    Which OpenAI tool fits which task.

    Whether people work in the workspace, Codex writes code or an agent runs in your workflow decides the tool. The platform finder gets you there in a few questions.

    As of: October 2026 · Editor: Marcel Haas

    • ChatGPT Enterprise
    • Workspace agents
    • Codex
    • Responses API
    • Agents SDK
    • Agents API

    Platform finder

    The questions that lead to the layer.

    Every answer points at one or two layers. The layer with the most hits is the starting point; what to check there is listed below.

    1. 01

      Where does the work happen?

      • A person works with documents in the workspaceleads toChatGPT in the workspace
      • The same task runs the same way for a teamleads toWorkspace agent
      • In a workflow or line-of-business system of your ownleads toResponses API and Agents SDKAgents API
      • In the repository, as code with testsleads toCodex
    2. 02

      How long does a task run?

      • One dialogue, then it is doneleads toChatGPT in the workspaceWorkspace agentResponses API and Agents SDK
      • For hours or days, with sessions and restartsleads toAgents API
      • Until the pull request is readyleads toCodex
    3. 03

      Who runs the agent loop?

      • OpenAI, in the workspaceleads toChatGPT in the workspaceWorkspace agent
      • Your application, with your logs and approvalsleads toResponses API and Agents SDK
      • OpenAI as the runtime; your application sets the task and approvalsleads toAgents API
    4. 04

      Which data region does the task need?

      • The rules of the workspaceleads toChatGPT in the workspaceWorkspace agentCodex
      • A project in the Europe region for the listed endpointsleads toResponses API and Agents SDK
      • Global, only with data without personal referenceleads toAgents API
    5. 05

      Where should identities, networks and logs live?

      • At OpenAI, with sign-in through Entra ID and the Compliance APIleads toChatGPT in the workspaceWorkspace agentResponses API and Agents SDKAgents API
      • In Microsoft 365 or Azure, with Purview and private networksleads toMicrosoft 365 or Azure
    6. 06

      Who maintains the result?

      • Nobody has to maintain anythingleads toChatGPT in the workspace
      • The team in the workspaceleads toWorkspace agent
      • A development team with a pipelineleads toCodexResponses API and Agents SDKAgents API

    Where the answers lead.

    ChatGPT in the workspace

    What that means: People work with projects, apps and Deep Research; they use the result themselves.

    What you check: Plan, sign-in through Entra ID, approved apps and connectors, the directive on data classes.

    Open page

    Workspace agent

    What that means: The same task runs the same way for a team, from instructions, apps and files, maintained in the interface.

    What you check: Who shares the agent, which apps it uses, the test set from the team's cases.

    Open page

    Codex

    What that means: Software work in the repository, locally or in Codex Cloud, every change as a pull request with tests.

    What you check: Roles and environments, requirements.toml, secrets and internet access, the review of every change.

    Open page

    Responses API and Agents SDK

    What that means: A model call with tools or an agent loop inside your own application, with your logs and approvals.

    What you check: Project with data region, keys and usage limits, guardrails and traces, the test set.

    Open page

    Agents API

    What that means: OpenAI runs the agent with sessions, sandboxes and context compaction; your application sets the task, tools and approvals.

    What you check: Data region per project, the Agents API is not listed for Europe; approvals before actions with consequences; cost per run.

    Open page

    Microsoft 365 or Azure

    What that means: The agent lives in Teams or the application runs with Entra, Purview and private networks in Azure; the Microsoft AI/SI guide takes it from here.

    What you check: Copilot Studio or Foundry, deployment type and region; see platform choice in the Microsoft AI/SI guide.

    Open page
    01

    The task determines the tool.

    A fiduciary team wants to check the annual accounts of its clients against a checklist. If that happens by hand with the documents, ChatGPT helps in the workspace, with the checklist as a file and an app on the document store. If the check should run the same way for every new set of accounts, it becomes a workspace agent the team maintains itself. If it should run without a chat in the line-of-business system and file its findings there, it takes an application on the Responses API or an agent on the Agents SDK or the Agents API. These questions separate the cases: Does a person work in the workspace, or does the task run in a workflow? Is it software work in the repository? Does the agent need sessions that persist for days? Who runs the loop, you or OpenAI? Which data region does the project need? Who maintains the result?

    02

    In the workspace: ChatGPT, apps, workspace agents, dots.

    ChatGPT helps where people write, research and analyse, and apps bring SharePoint, Outlook, GitHub and your own systems to it; as long as a person triggers the task and uses the result, nothing more is needed. A workspace agent takes over as soon as the same task should run the same way every time and several people use it; the team maintains it in the interface. A dot keeps working towards goals on its own cloud computer and reports by chat, voice, Slack or Teams, in Switzerland through Business Premium and as an Enterprise beta.

    03

    In the repository: Codex locally or in the cloud.

    Codex reads the code, changes it with tests and opens a pull request. Locally in the desktop app, terminal or IDE it works with the sandbox profile your workspace's rules allow; in Codex Cloud on a connected repository with environments, secrets and internet access that administrators define. Repository rules, tests and the review of every change apply in both cases, and Codex Cloud respects the permissions of the source system.

    04

    On the platform: Responses API, Agents SDK or Agents API.

    OpenAI matches the tools like this: the Responses API to direct model calls or an agent built from scratch; the Agents SDK to agents with their own tools and workflows inside your application, whose loop, memory and approvals you run; the Agents API to long-running tasks where OpenAI runs the agent with sessions, sandboxes and context compaction. ChatKit provides the embedded interface for it. Since 26 August 2026 the Assistants API has been shut down; existing integrations move to the Responses API and the Conversations API.

    05

    The test set decides.

    Two candidates work through the same set of real cases: correct, incomplete and prohibited requests, missing sources, failures. We compare answer quality, access boundaries, failure handling, the review effort for people and the cost per case, and the proposal records why one tool won. A pilot with one group then shows what holds up in daily work; after every change to model, tools or instructions, the test set runs again.

    What you decide.

    ChatGPT or an agent?

    Options

    1. 1ChatGPT with apps in the workspace
    2. 2A workspace agent the team maintains itself
    3. 3An agent on the platform in your workflow

    Our recommendation: ChatGPT, as long as a person triggers the task and uses the result themselves. A workspace agent, as soon as the same task should run the same way every time and several people use it, with instructions, apps and files the team maintains. An agent on the platform when the task runs without a chat in a workflow, writes to line-of-business systems or must wait for an approval before actions with consequences.

    What we advise against: An agent for a task nobody has yet described cleanly by hand. Without sources, permitted actions and a point where a person decides, the test set measures nothing.

    Agents SDK or Agents API?

    Options

    1. 1Agents SDK: the loop runs in your application, you run memory and approvals
    2. 2Agents API: OpenAI runs the runtime with sessions, sandboxes and context compaction

    Our recommendation: The SDK when the agent lives in your application, uses your identities and logs and you want to keep the operation in your own hands, for instance in Azure Container Apps. The Agents API when tasks run for hours or days, several agents collaborate or a browser should be operated and OpenAI may provide the runtime; the data region has to be checked per project there, because the Agents API is not listed for the Europe region.

    What we advise against: The Agents API for personal data as long as the Europe region does not cover it, or the SDK for a task that needs only one model call with tools.

    Codex locally or in Codex Cloud?

    Options

    1. 1Locally in the desktop app, terminal or IDE
    2. 2In Codex Cloud on the connected repository
    3. 3Both, with the same rules from requirements.toml

    Our recommendation: Locally when developers use Codex in their IDE alongside their own work and see every change at once; the rules come centrally from requirements.toml. Codex Cloud when tasks run in parallel, security scans run overnight or teams should share an environment with the same secrets and tests; administrators enable it and define internet access.

    What we advise against: Codex Cloud with full internet access and secrets before roles and environments are defined.

    Status and sources.

    As of: October 2026

    • As of October 2026

      Agents API, Agents SDK or Responses API.

      OpenAI matches the Agents API to long-running tasks where OpenAI runs the agent, the Agents SDK to agents with their own tools and workflows inside your application, and the Responses API to direct model calls or an agent built from scratch. ChatKit provides an embedded chat interface.

      Source: OpenAI: Agents
    • 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

      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
    • Since 29 September 2026

      OpenAI brings dots.

      Dots keep working towards goals in ChatGPT on their own cloud computer and are reachable by chat, voice, Slack or Teams. In Switzerland through Business Premium and as an Enterprise beta, not for Pro accounts at launch.

      Source: OpenAI Help Center: Getting started with your dot

    Frequently asked questions.

    Can we start with ChatGPT and build an agent later?

    Yes. Projects, apps and files from the workspace show which tasks repeat; they become workspace agents, and what belongs in a workflow moves to the platform with instructions and test set. Sign-in, roles and the Compliance API stay the same.

    What became of Agent Builder and the evals?

    OpenAI shuts down Agent Builder and the Evals platform on 30 November 2026; existing evals become read-only from 31 October 2026, ChatKit remains. Workflows from Agent Builder we rebuild with the Agents SDK or the Agents API, and the test set carries on in your own evaluation.

    Do we have to program for workspace agents?

    No; instructions, apps and files are enough, and the team maintains the agent in the interface. Code comes into play when a tool of your own is built as an MCP server or the agent belongs in a workflow outside the workspace.

    Can agents at OpenAI work together with agents in Microsoft 365?

    Through tools, yes: an agent on the Agents API calls a Foundry application or an MCP server in your environment, and an agent in Copilot Studio reaches an application on the OpenAI API as an action. Each side keeps its identity and its log; how it continues on the Microsoft side is in the Microsoft AI/SI guide.

    When is the API worth it if we already have Azure?

    When you need something that exists only there: Codex in cloud environments, the Agents API with the Codex runtime, the ChatGPT workspace with apps and workspace agents. For calling GPT models, Foundry remains the shorter route, because identities, networks and Purview are already there.

    Who decides on the tool in the end: IT or the business?

    Both, with distinct roles. The business team describes the task, sources, permitted actions and the point where a person decides; your IT sets the frame of plan, roles, data region and usage limits. The proposal names the tool with the reasoning, and the test set checks it before anything is opened to everyone.

    Next chapter · Chapter 6

    Data boundaries: where ChatGPT, Codex and the API process.

    Where do ChatGPT, Codex and the API process our data, and what may we send there?