This isn’t a launch recap. The OpenAI Agents SDK is a Python framework for building agent workflows: official docs describe agents as language models equipped with instructions, tools, guardrails, and handoffs. Here’s what the current official docs and README say.

The repo, checked on November 20
The public GitHub API, fetched on November 20, 2026, at 1:20 p.m. America/Phoenix, showed openai/openai-agents-python as public, not archived, and MIT-licensed, with 30,786 stars. The latest release was v0.25.0, published 2026-11-18T00:22:25Z, which is 5:22 p.m. America/Phoenix on November 17, 2026. The default branch had last been pushed 2026-11-20T20:18:06Z, which is 1:18 p.m. America/Phoenix on November 20. The README on main and at the v0.25.0 tag was byte-identical. Repo security advisories on that fetch were none. The official docs at openai.github.io/openai-agents-python, including the quickstart, guardrails, configuration, and tracing pages, returned HTTP 200.
The README calls the SDK “a lightweight yet powerful framework for building multi-agent workflows” and says it is provider-agnostic, “supporting the OpenAI Responses and Chat Completions APIs, as well as 100+ other LLMs.” The docs also call it “a production-ready upgrade” of OpenAI’s earlier Swarm experiment. Those are the project’s descriptions, not a benchmark.
Install and the first text agent
The README says you need Python 3.10 or newer. The official quickstart starts by creating a project directory and a virtual environment, then activating it:
mkdir my_project
cd my_project
python -m venv .venv
source .venv/bin/activate # On Windows: .venv\Scripts\activate
Then it installs the package with pip install openai-agents. The README shows the same install, and also an uv add openai-agents path if you already use uv. The docs say to set the OPENAI_API_KEY environment variable for your current terminal session before you run an example. Keep that key out of source control. The configuration page adds that, by default, the SDK uses OPENAI_API_KEY for both LLM requests and tracing, and that the key is resolved when the SDK first creates an OpenAI client, so the variable needs to be set before the first model call.
The README and the docs site use the same first text-agent example: a plain Agent and Runner.run_sync, with a prompt about recursion in programming:
from agents import Agent, Runner
agent = Agent(name="Assistant", instructions="You are a helpful assistant")
result = Runner.run_sync(agent, "Write a haiku about recursion in programming.")
print(result.final_output)
The README presents a sample haiku in a comment under that snippet. The docs add: “If running this, ensure you set the OPENAI_API_KEY environment variable.” The official quickstart then shows an async Runner.run version of the same pattern, and tells you to start with a plain agent plus runner “when the task mainly lives in prompts, tools, and conversation state.”
Tools, handoffs, and guardrails
The docs describe function tools as a way to “turn any Python function into a tool with automatic schema generation and Pydantic-powered validation.” The quickstart’s first tool example marks a Python function with the SDK’s tool decorator from agents.decorators:
from agents.decorators import tool
def history_fun_fact() -> str:
"""Return a short history fact."""
return "Sharks are older than trees."
In the official snippet the decorator is applied to that function, which is then passed into Agent(..., tools=[history_fun_fact]). The same quickstart also shows handoffs: one triage agent with an inventory of specialist agents it can delegate to, and handoff_description to help with routing. “The runner handles executing individual agents, any handoffs, and any tool calls,” the page says. After a run, it points you to the Trace viewer in the OpenAI Dashboard.
Guardrails, the docs say, “enable you to do checks and validations of user input and agent output.” Input guardrails run on the initial user input; output guardrails run on the final agent output. If a guardrail’s tripwire_triggered flag is true, the SDK raises an exception so the application can stop or respond. The docs are explicit about a timing catch: input guardrails default to parallel execution, which starts the guardrail and the agent at the same time. “If the guardrail’s tripwire is triggered, the agent may have already consumed tokens and executed tools before being cancelled.” For a check that must finish first, they document blocking execution with run_in_parallel=False, so “the agent never executes, preventing token consumption and tool execution.”
Security caveats the docs actually spell out
Treat OPENAI_API_KEY as a secret. The official install path sets it in the environment. The configuration page also documents set_default_openai_key() for cases where the environment variable isn’t available at startup; a key passed in code still needs the same care as any other credential, and it shouldn’t land in a committed file.
Tracing is on by default. The tracing docs say certain spans “may capture potentially sensitive data”: generation_span() stores the inputs and outputs of the LLM generation, and function_span() stores the inputs and outputs of function calls. You can turn that capture off with RunConfig.trace_include_sensitive_data. To disable tracing entirely, the same page lists three official options: the environment variable OPENAI_AGENTS_DISABLE_TRACING=1, a global set_tracing_disabled(True) call, or a per-run setting on RunConfig.
Function tools are your Python functions, running in your process, with whatever permissions that process already has. A tool can read a file, call a service, or do anything else the function is written to do, so the usual rules about tokens, credentials, and reachable systems still apply. Guardrails help you check inputs and outputs, but they are not an isolation boundary, and in the default parallel mode a tool can run before a tripwire fires.
The official docs also describe a human-in-the-loop path that can pause a run so a person can decide on a sensitive tool call. That’s a documented control, not a promise that every tool waits. If a tool isn’t marked that way, the runner can execute it as part of the loop.
Hero photo: Escalier muraille Château Madeleine Chevreuse by Jebulon, via Wikimedia Commons; CC0 1.0; cropped and resized.