How to Use ChatGPT Agents: ChatGPT Work, Workspace Agents, and the API

How to use ChatGPT agents: choose your route

For an individual multi-step task in ChatGPT, use ChatGPT Work. For a repeatable workflow shared with a team, consider a workspace agent if it’s available in your workspace. If you’re building an agent into your own application, use a developer tool such as the OpenAI Agents SDK. These are separate workflows: having ChatGPT access does not by itself configure an API integration. (ChatGPT Work; workspace agents; Agents SDK)

OpenAI’s ChatGPT agent Help Center page says that ChatGPT agent is no longer available and directs readers to ChatGPT Work for longer, multi-step tasks and finished deliverables. For current instructions, use the documentation for the route you intend to take rather than relying on older /agent directions. (ChatGPT agent Help Center)

Use ChatGPT Work for a task

1. Open ChatGPT on web or mobile and start a task in Work.
2. State the result you want, the information or sites it may use, and any constraints.
3. Follow its progress in the conversation. Respond if it asks for input, sign-in, or confirmation.
4. Review the result and its sources. Check important claims and proposed changes before relying on them.

For tasks that use the cloud browser, OpenAI says to describe the desired outcome and website, approve access if asked, and review the result and sources. Cloud-browser availability depends on plan, region, rollout, and workspace permissions; OpenAI’s current help article says it is available on paid ChatGPT plans in supported regions, excluding Free and Go. You don’t need to select the browser separately. (Using cloud browser in ChatGPT)

A prompt pattern that makes results easier to check

Specify the goal, allowed inputs, output format, constraints, success checks, and what to do if information is missing. For example:

Using only the three documents I uploaded, summarize the project’s open decisions and list five action items. For each item, include the document and page or section that supports it. Separate explicit facts from your inferences. If the documents don’t answer a question, say so. Return a table with columns for decision or action, evidence, owner if stated, and open question. Do not send messages or change any files.

After the response, check whether each item is supported by the cited material, whether the agent followed your source limits, and whether it flagged missing information. This is a practical prompt pattern, not required syntax.

Create a workspace agent for repeatable team work

OpenAI’s Help Center guide covers creating, using, sharing, and managing workspace agents in ChatGPT and Slack for Business and Enterprise workspaces. Feature access and permissions can still depend on workspace configuration. (Workspace Agents Help Center)

If you have access, follow the agent builder in your workspace. The Help Center guidance describes testing with Preview and a sample prompt, then reviewing the output. Check the controls and setup steps shown in your workspace rather than assuming every account has the same options. (Workspace Agents Help Center)

Choose Work for an individual task and a workspace agent when a team needs a reusable workflow. Start with a narrow task and only the resources it needs; broaden access only if testing shows it is necessary.

Build an agent with the OpenAI Agents SDK

For a custom Python application, the official Agents SDK quickstart documents a simple Agent and Runner pattern. The SDK uses the Responses API by default for OpenAI models. This is one documented developer route; OpenAI also announced a separate Agents API in public beta. (Agents SDK quickstart; Agents SDK overview; Agents API announcement)

Prerequisites and version note

• Python 3.10 or later.
• An OpenAI API key, kept out of source code and set as an environment variable.
• The openai-agents package.

The official repository metadata currently lists SDK version 0.24.0 and Python >=3.10. SDK documentation and releases can change; this example follows the published quickstart pattern and has not been executed for this article. Record the installed package version when you test it, and pin the version you validate for your project. The example does not set a model explicitly: current SDK documentation lists gpt-5.6-luna as the built-in default. For repeatable deployments, select a supported model explicitly and confirm API access for your account. (SDK repository metadata; SDK model documentation)

Create and activate a virtual environment, then install the SDK:

mkdir my_project
cd my_project
python -m venv .venv

# macOS or Linux
source .venv/bin/activate

# Windows PowerShell: use this instead
# .venv\Scripts\Activate.ps1

pip install openai-agents

Set your API key in the current terminal session:

# macOS or Linux
export OPENAI_API_KEY="your-api-key"

# Windows PowerShell: use this instead
# $env:OPENAI_API_KEY = "your-api-key"

Save this as agent_example.py:

import asyncio
from agents import Agent, Runner

agent = Agent(
    name="Test agent",
    instructions="For this test, reply with exactly: Agent run succeeded.",
)

async def main():
    result = await Runner.run(agent, "Run the test.")
    print(result.final_output)

if __name__ == "__main__":
    asyncio.run(main())

Run it with python agent_example.py. The intended smoke-test output is Agent run succeeded.; check the actual final_output rather than assuming the model returned that exact text. If setup fails, check the Python version, API-key environment variable, API access, and installed SDK version (pip show openai-agents). The constructor, asynchronous Runner.run call, and result.final_output handling follow the official quickstart. (Agents SDK quickstart)

This is a minimal text-agent example, not a complete production service and not an agent with external-action tools. Before deployment, handle API errors, validate inputs and outputs for your use case, and keep secrets out of source control. If you add tools that can change external data or take consequential actions, restrict their permissions and require appropriate human review. The example itself does not configure those tools or approvals.

The supplied competitor article included client.agents.create and client.agents.run snippets but labeled them conceptual and incomplete. They are not the SDK calls used here; follow the documented Agent and Runner pattern instead.

Check the result and reduce risk

Before relying on an agent’s work:

1. Test a small, harmless task first. Use sample documents or synthetic data where possible.
2. Limit access. Provide only the files, apps, and tools needed for the task.
3. Check evidence. Verify important factual claims against cited sources or original files.
4. Review consequential changes. Keep a person involved before sending, publishing, purchasing, or changing records.
5. Ask it to flag uncertainty. Request that it identify missing inputs, failed steps, and unsupported conclusions.

For cloud-browser work, OpenAI’s help article says the task may pause for sign-in or confirmation and advises reviewing the result and sources. Workspace agents can be tested in Preview with a sample prompt, according to the Help Center. Those descriptions do not guarantee identical tools or controls for every task or workspace, so check what is available in your own account. (Cloud browser help; Workspace Agents Help Center)

In short: use Work to delegate an individual multi-step task in ChatGPT, workspace agents for repeatable team workflows where available, and the Agents SDK when building an agent into software. Give it checkable instructions, test the output, and review consequential results.

Sources

ChatGPT is now a partner for your most ambitious work

Introducing workspace agents in ChatGPT

ChatGPT agent

ChatGPT Workspace Agents for Enterprise and Business

Using cloud browser in ChatGPT

OpenAI Agents SDK Quickstart

OpenAI Agents SDK

OpenAI Agents SDK pyproject.toml

Models - OpenAI Agents SDK

Introducing the Agents API