Each directory contains a complete example with its own README for detailed instructions:

- **[Basic Examples](./basic/README.md)** - Simple agent examples including a hello world agent and a tools-enabled agent that can access external APIs like weather services.

- **[Agent Patterns](./agent_patterns/README.md)** - Advanced patterns for agent composition, including using agents as tools within other agents.

- **[Research Bot](./research_bot/README.md)** - Multi-agent research system with specialized roles: a planner agent, search agent, and writer agent working together to conduct comprehensive research.

- **[Customer Service](./customer_service/README.md)** - Interactive customer service agent with escalation capabilities, demonstrating conversational workflows.

Common agentic patterns extended with Temporal's durable execution capabilities.

*Adapted from [OpenAI Agents SDK agent patterns](https://github.com/openai/openai-agents-python/tree/main/examples/agent_patterns)*

First, start the worker (supports all patterns):

uv run openai_agents/agent_patterns/run_worker.py

Then run individual examples in separate terminals:

**TODO**

A common tactic is to break down a task into a series of smaller steps. Each task can be performed by an agent, and the output of one agent is used as input to the next. For example, if your task was to generate a story, you could break it down into the following steps:

1. Generate an outline

2. Generate the story

3. Generate the ending

Each of these steps can be performed by an agent. The output of one agent is used as input to the next.

**TODO**

In many situations, you have specialized sub-agents that handle specific tasks. You can use handoffs to route the task to the right agent.

For example, you might have a frontline agent that receives a request, and then hands off to a specialized agent based on the language of the request.

The mental model for handoffs is that the new agent "takes over". It sees the previous conversation history, and owns the conversation from that point onwards. However, this is not the only way to use agents. You can also use agents as a tool - the tool agent goes off and runs on its own, and then returns the result to the original agent.

For example, you could model a translation task as tool calls instead: rather than handing over to the language-specific agent, you could call the agent as a tool, and then use the result in the next step. This enables things like translating multiple languages at once.

uv run openai_agents/agent_patterns/run_agents_as_tools_workflow.py

**TODO**

LLMs can often improve the quality of their output if given feedback. A common pattern is to generate a response using a model, and then use a second model to provide feedback. You can even use a small model for the initial generation and a larger model for the feedback, to optimize cost.

For example, you could use an LLM to generate an outline for a story, and then use a second LLM to evaluate the outline and provide feedback. You can then use the feedback to improve the outline, and repeat until the LLM is satisfied with the outline.

**TODO**

Running multiple agents in parallel is a common pattern. This can be useful for both latency (e.g. if you have multiple steps that don't depend on each other) and also for other reasons e.g. generating multiple responses and picking the best one.

**TODO**

Related to parallelization, you often want to run input guardrails to make sure the inputs to your agents are valid. For example, if you have a customer support agent, you might want to make sure that the user isn't trying to ask for help with a math problem.

You can definitely do this without any special Agents SDK features by using parallelization, but we support a special guardrail primitive. Guardrails can have a "tripwire" - if the tripwire is triggered, the agent execution will immediately stop and a `GuardrailTripwireTriggered` exception will be raised.

This is really useful for latency: for example, you might have a very fast model that runs the guardrail and a slow model that runs the actual agent. You wouldn't want to wait for the slow model to finish, so guardrails let you quickly reject invalid inputs.

from openai_agents.agent_patterns.workflows.agents_as_tools_workflow import (

AgentsAsToolsWorkflow,

)

from __future__ import annotations

import asyncio

from datetime import timedelta

from temporalio.client import Client

from temporalio.contrib.openai_agents import ModelActivityParameters, OpenAIAgentsPlugin

from temporalio.worker import Worker

from openai_agents.agent_patterns.workflows.agents_as_tools_workflow import (

AgentsAsToolsWorkflow,

)

async def main():

# Create client connected to server at the given address

client = await Client.connect(

"localhost:7233",

plugins=[

OpenAIAgentsPlugin(

model_params=ModelActivityParameters(

start_to_close_timeout=timedelta(seconds=30)

)

),

],

)

worker = Worker(

client,

task_queue="openai-agents-task-queue",

workflows=[

AgentsAsToolsWorkflow,

],

)

await worker.run()

if __name__ == "__main__":

asyncio.run(main())

Simple examples to get started with OpenAI Agents SDK integrated with Temporal workflows.

*Adapted from [OpenAI Agents SDK basic examples](https://github.com/openai/openai-agents-python/tree/main/examples/basic)*

First, start the worker (supports all basic examples):

uv run openai_agents/basic/run_worker.py

Then run individual examples in separate terminals:

uv run openai_agents/basic/run_hello_world_workflow.py

Agent with access to external tools (weather API):

uv run openai_agents/basic/run_tools_workflow.py

from openai_agents.basic.workflows.hello_world_workflow import HelloWorldAgent

from openai_agents.basic.workflows.tools_workflow import ToolsWorkflow

from openai_agents.basic.activities.get_weather_activity import get_weather

from openai_agents.basic.workflows.hello_world_workflow import HelloWorldAgent

from openai_agents.basic.workflows.tools_workflow import ToolsWorkflow

start_to_close_timeout=timedelta(seconds=30)