What an AI agent at OpenAI is made of and where it runs.
An agent takes on a task, fetches knowledge and tools and acts in your systems; at OpenAI it runs as a dot, in the Agents SDK, on the Agents API or as Codex.
Click through the parts, the security rings and real cases, and watch an agent check an invoice, prepare a new starter or fend off an attack. This is how we design workflows AI-native: the agent does the work, and a person decides before every step with consequences.
Agent
Head · Reads, plans, writes
The model reads the request and plans the steps.
The language model understands the request, decides which tool comes next and writes the answer. We choose the model per task: a small one for sorting and summarising, a large one when the agent works with business systems and has to weigh options.
agent.yaml
model: claude-opus-5-5
fallback: smaller model, same tools
effort: medium
max_output: 2000 tokens
data: no training, per contract
region: per data sheet for each platform
How it is secured: Where the model runs is recorded per platform and model in the data sheet. Inputs and outputs pass through content filters, and the enterprise contract rules out training on your data.
On the platforms: Copilot Studio lets you pick the model per agent, Microsoft Foundry offers it from the model catalogue, and OpenAI and Anthropic provide their models through their own APIs.
Microsoft Foundry
Copilot Studio
OpenAI
Claude
01
Head, hands, memory and operations make up the agent.
An invoice arrives in the mailbox. The agent reads it, fetches the order from the ERP through an MCP server, compares items and amounts, proposes the account assignment and puts the discrepancy in front of a person for approval. For that it needs a head made of model, instructions and a soul file that records tone and limits; hands made of skills, tools and MCP servers with which it reads and writes; a memory in the session and for what it has learned about your workflows; and operations made of triggers that start it and evaluation that measures every version against the test set. The Agent Explorer above shows these parts, the security stations around them and four cases step by step, including the one in which a hidden instruction in a document is stopped. Before every step with consequences a person decides; that is the same for every type.
02
Dots and workspace agents work in the workspace.
A team builds a workspace agent for the weekly report in ChatGPT from instructions, apps and files and shares it in the workspace; it is maintained in the interface by the people who know the task, and in apps it sees only what the person using it may open there. A dot goes further: it works on a goal with its own cloud computer even when nobody is watching, gathers documents, prepares drafts and reports by chat, voice, Slack or Teams when it needs something or is done. What it may see and do follows the apps and roles of the workspace, actions with consequences are confirmed by the person, and where dots are enabled is set in the admin console; in Switzerland they come through Business Premium and as an Enterprise beta.
03
The Agents SDK runs in your application, the Agents API at OpenAI.
With the Agents SDK your application runs the loop of model call, tool call and handoff to further agents itself, with guardrails for inputs and outputs, traces for every step and an approval by a person before tools with consequences; since April 2026 it brings a sandbox for working with files and tools, first in Python, and the agent is operated wherever your application runs, for instance in Azure Container Apps. The Agents API, by contrast, provides the runtime OpenAI itself runs Codex on: sessions that persist, sandboxes hosted by the vendor or by you, context compaction and collaboration between several agents, since 29 September 2026 also a browser the agent operates. For the single model call with tools the Responses API remains, ChatKit provides the chat window in your application, and the Decisions API picks the next step from a fixed set.
04
Codex works as an agent in the repository.
A development team gives Codex a ticket, and Codex reads the code, writes the change and the tests, shows what it executed and opens a pull request that a person reviews; locally in the desktop app, in the terminal and in the IDE, or in Codex Cloud on the connected repository. Rules and skills for the repository live in the .codex or .agents folders, the sandbox knows the modes read-only, workspace-write and danger-full-access, and the approval policy decides when Codex asks. Through requirements.toml and the agent security settings your IT prescribes which profiles, policies and MCP servers are allowed, and the repository cannot widen these limits. In Enterprise workspaces Codex Cloud starts switched off, and it respects the repository permissions of the source system.
05
Several agents share the work, the test set the approval.
Beyond a certain size the task splits: an orchestrator hands out subtasks to specialists, a handover passes the case from one agent to the next, a checker reviews another agent's work before a person sees it, and parallel agents work on parts at the same time. In the Agents SDK the handover is called a handoff, on the Agents API several agents collaborate in one session, and Codex starts runs of its own for subtasks. Which type fits is shown by the weighting in the explorer: a Teams agent reaches Teams through a dot, a process agent runs in the SDK or on the Agents API, a personal agent is a dot, a coding agent is Codex. The same route from task to operations applies to all of them: a pilot with one group, the test set as the approval, a named person who can stop the agent, and versions that go through the evaluation, which since the end of the Evals platform lives in your own pipeline.
What you decide.
Agents SDK or Agents API for this agent?
Options
1The Agents SDK in your own application
2The Agents API with sessions and sandboxes at OpenAI
3The Responses API for a workflow with a single call
Our recommendation: The SDK when operation, memory, approvals and logs should stay in your environment, for instance in Azure with Entra ID and Purview; most process agents with personal data belong there. The Agents API when a task runs long, needs a sandbox and persistent sessions and gets by with development or test data, as long as region and retention are not settled there. The Responses API when one call with tools and a schema already carries the workflow.
What we advise against: Choosing the Agents API because it is the runtime of Codex. What your application needs in approvals and logs it first has to rebuild there.
What may the agent do without approval?
Options
1Only read and propose
2Read, propose and write in test systems
3Write with an approval per action with consequences
Our recommendation: Read and propose from day one; write with an approval before every action with consequences, that is before sending, posting, ordering and deleting. In the SDK the tool demands the approval, with Codex the approval policy decides, a dot confirms with the person. Which actions run without approval after a quarter without complaints is decided by the business team from the log, and deleting always stays with a person.
What we advise against: Approvals nobody reads. If every approval is waved through, a sample from the log replaces it better.
Workspace agent or agent on the platform?
Options
1A workspace agent in ChatGPT, maintained by the team
2An agent in the Agents SDK or on the Agents API
3Both: the workspace agent as the interface, the work on the platform
Our recommendation: The workspace agent when the people who know the task should maintain it themselves and the work happens in ChatGPT with apps and files. An agent on the platform as soon as the workflow runs without a chat, is built into your process, calls tools with consequences or needs a test set in the pipeline. Often the team stays in the workspace and the work behind it runs on the platform.
What we advise against: A workspace agent for a workflow with postings and deadlines. Without approvals per tool and without a test set in the pipeline it remains a draft.
Who maintains instructions, tools and the test set?
Options
1The business team in the ChatGPT workspace
2The development team in the agent's repository
3A partner who maintains both
Our recommendation: The business team maintains instructions and the test set, because it knows the cases; the development team maintains tools, MCP servers and the code in the repository, where the rules for Codex live too. Every change produces a version that goes through the evaluation in your pipeline, and a named person may stop the agent at any time. We maintain both until your team takes over.
What we advise against: Instructions that exist only in a session of the Agents API. What is not in the repository leaves with the session.
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.
The Agents API is in public beta, since 29 September 2026 with computer use.
OpenAI has run the Agents API as a public beta since 10 September 2026: sessions that persist, sandboxes, context compaction and collaboration between several agents on the runtime OpenAI itself runs Codex on. Since 29 September 2026 an agent also operates a browser hosted by OpenAI through it.
The Agents SDK brings a harness and a sandbox, first in Python.
The Agents SDK runs the loop of model call, tool call and handoff to further agents inside your application, with guardrails for inputs and outputs and traces for every step. Since April 2026 it brings a sandbox for working with files and tools, first in Python.
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.
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.
This is how we put it into practice: workflows designed for agents from the start, with the first agent on real cases from your business team and a point where a person decides. Agentic AI
What does it mean that the Agents API is the runtime of Codex?
That your agent runs on the same infrastructure OpenAI runs Codex on: sessions that persist, a sandbox per session, context compaction when the history fills the window, and collaboration between several agents. You supply instructions, tools and skills, the vendor the operation. The API has been in public beta since 10 September 2026 and is not listed for the Europe region; that is why it stays with development and test data until both are settled.
Where does an agent's sandbox run?
On the Agents API at OpenAI, at your place or not at all; in the Agents SDK inside your application, since April 2026 with a sandbox of its own for files and tools; with Codex on the developer's machine in the modes read-only, workspace-write and danger-full-access, or in Codex Cloud. Which sandbox an agent gets is recorded in its data sheet, because it determines what a mistake or an attack can reach.
How do we build the approval before an action with consequences?
In the Agents SDK a tool with consequences demands the approval by a person before the call continues, and the trace records the decision. With Codex the approval policy decides when it asks, prescribed centrally through requirements.toml. A dot confirms actions with the person, a workspace agent sees in apps only what the person may. The approval is part of the workflow in every case, not a note at the end.
Can several agents work together?
Yes, in four patterns: an orchestrator distributes, a handover passes the case on, a checker reviews, parallel agents share the work. In the Agents SDK the handover is a handoff between agents with their own instructions and tools, on the Agents API several agents collaborate in one session. Every agent needs a narrow brief, and the checker gets the references, not the first agent's opinion.
What replaces Agent Builder and the Evals platform?
For the agents themselves the Agents SDK, the Agents API or a workspace agent in ChatGPT; ChatKit remains as the interface. For evaluation a test set in your own pipeline: real cases with the expected answer that run with every change to instructions, tools or model, with the SDK traces as the basis. Existing evals become read-only from 31 October 2026, and the platform shuts down on 30 November 2026.
Do we need ChatKit?
Only when your application needs a chat window with history, attachments, streaming and approvals and nobody wants to build it themselves. ChatKit delivers that surface as a building block for web and mobile, connected to an agent on the platform or to your backend, with your branding; sign-in runs through your application. An agent in a process without a chat does not need it.
Can a dot work for a whole team?
A dot belongs to one person and works with that person's access on that person's goals; for workflows a team shares, the team builds a workspace agent from instructions, apps and files and shares it in the workspace. Roles and groups in the admin console control who may use dots and share agents, and in Enterprise the Compliance API delivers the evidence for it.
Next chapter · Chapter 4
How AI reaches your data at OpenAI and what it sees.
How does AI reach our data at OpenAI, and what does it see?