OpenAI: public beta
OpenAI launched the public beta on September 10, 2026. Developers who want to evaluate it today can start with OpenAI’s documentation and access requirements.
OpenAI Agents API
The Codex harness for long-running application tasks.
OpenAIManaged agent runtimeEvoLink integration in progress
Persistent sessionsContext compactionSubagentsTools & files
OpenAI status
Public beta
EvoLink integration
In progress
Workloads
Code · Research · Files
Get ready
Choose your first workflow
Status reviewed October 2, 2026
Build workflows that investigate a problem, work with files and deliver a result across many steps. OpenAI Agents API brings the Codex harness to your application, with managed sessions, context compaction and parallel subagents. EvoLink integration is in progress and is not open for calls yet. Subscribe for the launch update, including access instructions, supported features and pricing.
EvoLink integration in progress
Get notified when access opens
Get the EvoLink launch update with the access instructions, supported capabilities and pricing you need to plan your first integration.
Join the Agents API launch alert
By submitting, you request email updates about this integration.
Have a workload in mind? Talk with us on Discord
What the launch update includes
Access documentation, the initially supported capabilities and pricing to help you plan integration with your application.
Choose how to get started with Agents API
Your application: business rules and delivery
Your application authenticates users, authorizes business tools and checks the final result. For a report, it decides who can download it; for a ticket, it records approval and the created ticket ID.
EvoLink: integration in progress
Prefer to connect through EvoLink? Follow the launch update while preparing your first task, business tools and acceptance criteria.
Read the official source
OpenAI’s announcement and upstream availability.
OpenAI Agents API documentation
Official session, tool, environment and service-limit documentation.
Status reviewed October 2, 2026
What you can build with OpenAI Agents API
The capabilities below describe OpenAI’s service. Use them to plan a workflow that fits your application.
Long work with context compaction
Managed sessions and automatic context compaction support work across many steps. For repository maintenance, an agent can inspect code, make changes and continue from review feedback within a continuing task.
Parallel subagents
Delegate independent research questions or document reviews to subagents with separate contexts. The main agent brings their findings together, making this useful for investigations with several independent lines of work.
Tool search and programmatic calling
Tool search loads relevant definitions when needed. Programmatic calling can filter and combine results in code—for example, aggregate CRM records before returning a concise analysis to the agent.
Execution where the workload fits
Consider hosted compute for file analysis, self-hosted compute for specialized dependencies, or no sandbox for external-tool tasks. Choose from the work, not from a default container.
Files that become deliverables
Use a sandbox to process source files and produce artifacts your application can retrieve. A reconciliation workflow can turn CSV exports into a workbook with totals, exceptions and records for review.
Execution evidence and trace export
OpenAI documents OTLP JSON trace export. Connect execution evidence to a business job to investigate tool calls, find where a task stalled and compare successful runs with failed attempts.
Start with the task you need to ship
Three suggested pilot tasks, each with a concrete deliverable and acceptance criteria.
Repository maintenance
For developer-tool teams: provide a repository, a reproducible pagination bug and the existing tests. The proposed workflow investigates the cause, produces a patch and runs targeted tests. Accept the patch when the bug is fixed while authentication and the public response shape remain intact, including after follow-up instructions.
File reconciliation
For finance and operations software: provide two CSV exports and matching rules. The proposed workflow groups records, calculates totals and prepares a workbook with matched rows, exceptions and a summary. Accept it when totals match an independent calculation and duplicate IDs or missing currencies are sent to review rather than silently resolved.
Investigation and ticket creation
For support-tool teams: provide an issue, read access to relevant records and an approval rule. The proposed workflow gathers evidence and drafts a ticket; application code creates it after approval. Test an interruption after creation: the application must recover the existing ticket ID and show the result without creating a duplicate.
Prepare your first Agents API workflow
Use this planning checklist before a pilot. Save the inputs and expected outcomes so you can compare the new workflow with your current implementation.
| Your workflow | What to prepare |
|---|---|
| Sessions & events | Define a business job ID, when a session begins, and what a user should see when returning to the task. |
| Files & artifacts | Save representative input files, the expected output format and which users may download the result. |
| Execution environments | List package dependencies, storage needs and how long working files need to remain available. |
| Tools & MCP | List the systems the agent may read or change; identify actions that require a person’s approval. |
| Tracing & usage | Record today’s cost per accepted result and the execution details you need for troubleshooting. |
| Recovery & cancellation | Choose a safe retry policy and a way to find completed actions, such as a ticket already created. |
Understand what runs where
Plan who owns each part of the workflow: the agent loop, compute, business rules and the connection from your application.
OpenAI: agent runtime
The managed service operates the agent loop and session context. This is distinct from running the Agents SDK in your application.
Sandbox: task execution
Code and file work run in an execution environment. Choosing your own sandbox does not mean self-hosting the entire managed service.
Your application: business rules and delivery
Your application authenticates users, authorizes business tools and checks the final result. For a report, it decides who can download it; for a ticket, it records approval and the created ticket ID.
EvoLink: integration in progress
EvoLink is preparing the gateway connection. Keep your business tools separate from the API adapter so you can adopt the published integration path without rewriting the workflow.
Budget for the whole task
OpenAI states that Agents API adds no separate API fee; model, tool and hosted-environment charges still apply. Compare total direct charges divided by accepted results, including failures and rescue attempts. Track environment lifetime separately from the user conversation, and record engineering effort separately from usage charges.
Prepare a cost baseline
EvoLink pricing will be included in the launch details. For now, record your current cost per accepted task as a comparison baseline.
Decide what to prepare—and when to keep your current path
Choose the next step from runtime control, business constraints and data requirements. Evaluate model calls separately from managed-session access.
Prepare a bounded pilot
A team spending substantial effort on long-task execution can prepare a read-only investigation or file-report workload. Save its inputs, acceptance rules and current completion cost before evaluating a new runtime.
Keep existing orchestration when it already fits
A fixed sequence with established approval and recovery rules may not benefit from another runtime. Separate reusable business tools from session adapters so the evaluation does not require rewriting the product.
Resolve data requirements before the pilot
As of October 2, OpenAI documents US-only data residency and no Zero Data Retention support for Agents API, including self-hosted sandboxes. An incompatible requirement blocks this candidate; a private executor does not remove the managed-service boundary.
Plan your next step
Release guide: what changed and what to evaluate
Review the harness, tool mechanisms, cost boundaries and acceptance fixtures.
Agents API vs Agents SDK vs Responses API
Compare runtime control, recovery, migration costs and workload fit.
Explore currently listed models
Compare models by task and choose a suitable route for your existing application.
Questions before you integrate
Can I call Agents API through EvoLink now?
Not yet. Integration is in progress. This page will change when the supported operations and access requirements have been verified.
Is this the OpenAI Agents SDK?
No. Agents API is a managed runtime. With the Agents SDK, your application runs the orchestration. Choose based on where you need runtime control.
Will my existing EvoLink key work?
Use the Agents API integration instructions when EvoLink launches. Managed sessions have their own API operations, so an existing model-call example is not the setup guide for this service.
When will it launch, and what will it cost?
There is no announced EvoLink launch date or price yet. The launch update will include availability, access instructions and pricing so you can decide when to integrate.
Will my own sandbox be supported?
OpenAI supports self-hosted execution environments while operating the managed agent runtime. If you need a specific sandbox, prepare its dependencies and network requirements; consult the EvoLink launch documentation for supported connections.
What can I prepare while integration is underway?
Choose a representative task, define successful output, identify tool permissions, and record your current task cost. Use the release guide and runtime comparison to plan an evaluation.