OpenAI Agents SDK (Python)

Introduction

OpenAI Agents SDK enables the development of complex AI agents with tools, planning, and memory capabilities. Obiguard enhances OpenAI Agents with observability, reliability, and production-readiness features.

Obiguard turns your experimental OpenAI Agents into production-ready systems by providing:

Complete observability of every agent step, tool use, and interaction
Cost tracking and optimization to manage your AI spend
Access to 200+ LLMs through a single integration
Guardrails to keep agent behavior safe and compliant

OpenAI Agents SDK Official Documentation

Learn more about OpenAI Agents SDK’s core concepts

Installation & Setup

Install the required packages

pip install -U openai-agents obiguard

Generate API Key

Create a Obiguard API key

Connect to OpenAI Agents

There are 3 ways to integrate Obiguard with OpenAI Agents:

Set a client that applies to all agents in your application
Use a custom provider for selective Obiguard integration
Configure each agent individually

See the Integration Approaches section for more details.

Configure Obiguard Client

For a simple setup, we’ll use the global client approach:

from agents import (
  set_default_openai_client,
  set_default_openai_api,
  Agent, Runner
)
from openai import AsyncOpenAI
from obiguard import OBIGUARD_GATEWAY_URL, createHeaders
import os

# Set up Obiguard as the global client
client = AsyncOpenAI(
  base_url=OBIGUARD_GATEWAY_URL,
  obiguard_api_key=os.environ["OBIGUARD_API_KEY"],
  default_headers=createHeaders(
    obiguard_api_key="vk-obg***",  # Your Obiguard virtual key
  )
)

# Register as the SDK-wide default
set_default_openai_client(client, use_for_tracing=False)
set_default_openai_api("chat_completions") # Responses API → Chat

What are Virtual Keys? Virtual keys in Obiguard securely store your LLM provider API keys (OpenAI, Anthropic, etc.) in an encrypted vault. They allow for easier key rotation and budget management. Learn more about virtual keys here.

Getting Started

Let’s create a simple question-answering agent with OpenAI Agents SDK and Obiguard. This agent will respond directly to user messages using a language model:

from agents import (
    set_default_openai_client,
    set_default_openai_api,
    Agent, Runner
)
from openai import AsyncOpenAI
from obiguard import OBIGUARD_GATEWAY_URL, createHeaders
import os

# Set up Obiguard as the global client
client = AsyncOpenAI(
    base_url=OBIGUARD_GATEWAY_URL,
    default_headers=createHeaders(
        obiguard_api_key="vk-obg***",  # Your Obiguard virtual key
    )
)

# Register as the SDK-wide default
set_default_openai_client(client, use_for_tracing=False)
set_default_openai_api("chat_completions")  # Responses API → Chat

# Create agent with any supported model
agent = Agent(
    name="Assistant",
    instructions="You are a helpful assistant.",
    model="gpt-4o"  # Using Anthropic Claude through Obiguard
)

# Run the agent
result = Runner.run_sync(agent, "Tell me about quantum computing.")
print(result.final_output)

In this example:

We set up Obiguard as the global client for OpenAI Agents SDK
We create a simple agent with instructions and a model
We run the agent synchronously with a user query
We print the final output

Visit your Obiguard dashboard to see detailed logs of this agent’s execution!

Integration Approaches

There are three ways to integrate Obiguard with OpenAI Agents SDK, each suited for different scenarios:

Set a global client that affects all agents in your application:

from agents import (
  set_default_openai_client,
  set_default_openai_api,
  set_tracing_disabled,
  Agent, Runner
)
from openai import AsyncOpenAI
from obiguard import OBIGUARD_GATEWAY_URL, createHeaders
import os

# Set up Obiguard as the global client
client = AsyncOpenAI(
  base_url=OBIGUARD_GATEWAY_URL,
  obiguard_api_key=os.environ["OBIGUARD_API_KEY"],
  default_headers=createHeaders(
    virtual_key="YOUR_OPENAI_VIRTUAL_KEY"
  )
)

# Register it as the SDK-wide default
set_default_openai_client(client, use_for_tracing=False) # skip OpenAI tracing
set_default_openai_api("chat_completions") # Responses API → Chat
set_tracing_disabled(True) # optional

# Regular agent code—just a model name
agent = Agent(
  name="Haiku Writer",
  instructions="Respond only in haikus.",
  model="claude-3-7-sonnet-latest"
)

print(Runner.run_sync(agent, "Write a haiku on recursion.").final_output)

Best for: Whole application migration to Obiguard with minimal code changes

Set a global client that affects all agents in your application:

from agents import (
  set_default_openai_client,
  set_default_openai_api,
  set_tracing_disabled,
  Agent, Runner
)
from openai import AsyncOpenAI
from obiguard import OBIGUARD_GATEWAY_URL, createHeaders
import os

# Set up Obiguard as the global client
client = AsyncOpenAI(
  base_url=OBIGUARD_GATEWAY_URL,
  obiguard_api_key=os.environ["OBIGUARD_API_KEY"],
  default_headers=createHeaders(
    virtual_key="YOUR_OPENAI_VIRTUAL_KEY"
  )
)

# Register it as the SDK-wide default
set_default_openai_client(client, use_for_tracing=False) # skip OpenAI tracing
set_default_openai_api("chat_completions") # Responses API → Chat
set_tracing_disabled(True) # optional

# Regular agent code—just a model name
agent = Agent(
  name="Haiku Writer",
  instructions="Respond only in haikus.",
  model="claude-3-7-sonnet-latest"
)

print(Runner.run_sync(agent, "Write a haiku on recursion.").final_output)

Best for: Whole application migration to Obiguard with minimal code changes

Use a custom ModelProvider to control which runs use Obiguard:

from agents import (
  Model,
  ModelProvider,
  RunConfig,
  Runner,
  Agent
)
from agents import OpenAIChatCompletionsModel # concrete Model
from openai import AsyncOpenAI
from obiguard import OBIGUARD_GATEWAY_URL, createHeaders
import os, asyncio


client = AsyncOpenAI(
  base_url=OBIGUARD_GATEWAY_URL,
  default_headers=createHeaders(
    obiguard_api_key="vk-obg***",  # Your Obiguard virtual key
  )
)

class ObiguardProvider(ModelProvider):
  def get_model(self, model_name: str | None) -> Model:
    return OpenAIChatCompletionsModel(
      model=model_name or "claude-3-7-sonnet-latest",
      openai_client=client
    )

provider = ObiguardProvider() # singleton is fine

async def main():
  agent = Agent(name="Assistant", instructions="Haikus only.")
  run_cfg = RunConfig(model_provider=provider)

  # Only this call uses Obiguard
  out = await Runner.run(agent, "Weather in Tokyo?", run_config=run_cfg)
  print(out.final_output)

asyncio.run(main())

Best for: A/B testing, staged rollouts, or toggling between providers at runtime

Attach a specific Model object to each Agent:

from agents import Agent, Runner, OpenAIChatCompletionsModel
from openai import AsyncOpenAI
from obiguard import OBIGUARD_GATEWAY_URL, createHeaders
import os

client = AsyncOpenAI(
  base_url=OBIGUARD_GATEWAY_URL,
  default_headers=createHeaders(
    obiguard_api_key="vk-obg***",  # Your Obiguard virtual key
  )
)


agent = Agent(
  name="Haiku Writer",
  instructions="Classic Japanese form.",
  model=OpenAIChatCompletionsModel( # concrete Model
    model="claude-3-7-sonnet-latest",
    openai_client=client
  ),
)

print(Runner.run_sync(agent, "Recursion haiku.").final_output)

Best for: Mixed agent environments where different agents need different providers or configurations

Comparing the 3 approaches

Strategy	Code Touchpoints	Best For
Global Client via `set_default_openai_client`	One-time setup; agents need only model names	Whole app uses Obiguard; simplest migration
ModelProvider in RunConfig	Add a provider + pass `run_config`	Toggle Obiguard per run; A/B tests, staged rollouts
Explicit Model per Agent	Specify `OpenAIChatCompletionsModel` in agent	Mixed fleet: each agent can talk to a different provider

End-to-End Example

Research Agent with Tools: Here’s a more comprehensive agent that can use tools to perform tasks.

from agents import Agent, Runner, Tool, set_default_openai_client
from openai import AsyncOpenAI
from obiguard import OBIGUARD_GATEWAY_URL, createHeaders
import os

# Configure Obiguard client
client = AsyncOpenAI(
    base_url=OBIGUARD_GATEWAY_URL,
    default_headers=createHeaders(
        obiguard_api_key="vk-obg***",  # Your Obiguard virtual key
    )
)
set_default_openai_client(client)

# Define agent tools
def get_weather(location: str) -> str:
    """Get the current weather for a location."""
    return f"It's 72°F and sunny in {location}."

def search_web(query: str) -> str:
    """Search the web for information."""
    return f"Found information about: {query}"

# Create agent with tools
agent = Agent(
    name="Research Assistant",
    instructions="You are a helpful assistant that can search for information and check the weather.",
    model="claude-3-opus-20240229",
    tools=[
        Tool(
            name="get_weather",
            description="Get current weather for a location",
            input_schema={
                "location": {
                    "type": "string",
                    "description": "City and state, e.g. San Francisco, CA"
                }
            },
            callback=get_weather
        ),
        Tool(
            name="search_web",
            description="Search the web for information",
            input_schema={
                "query": {
                    "type": "string",
                    "description": "Search query"
                }
            },
            callback=search_web
        )
    ]
)

# Run the agent
result = Runner.run_sync(
    agent,
    "What's the weather in San Francisco and find information about Golden Gate Bridge?"
)
print(result.final_output)

Visit your Obiguard dashboard to see the complete execution flow visualized!

Production Features

1. Enhanced Observability

Obiguard provides comprehensive observability for your OpenAI Agents, helping you understand exactly what’s happening during each execution.

Traces provide a hierarchical view of your agent’s execution, showing the sequence of LLM calls, tool invocations, and state transitions.

# Add tracing to your OpenAI Agents
client = AsyncOpenAI(
  base_url=OBIGUARD_GATEWAY_URL,
  default_headers=createHeaders(
    obiguard_api_key="vk-obg***",  # Your Obiguard virtual key
  )
)
set_default_openai_client(client)

Traces provide a hierarchical view of your agent’s execution, showing the sequence of LLM calls, tool invocations, and state transitions.

# Add tracing to your OpenAI Agents
client = AsyncOpenAI(
  base_url=OBIGUARD_GATEWAY_URL,
  default_headers=createHeaders(
    obiguard_api_key="vk-obg***",  # Your Obiguard virtual key
  )
)
set_default_openai_client(client)

Obiguard logs every interaction with LLMs, including:

Complete request and response payloads
Latency and token usage metrics
Cost calculations
Tool calls and function executions

All logs can be filtered by metadata, trace IDs, models, and more, making it easy to debug specific agent runs.

Obiguard provides built-in dashboards that help you:

Track cost and token usage across all agent runs
Analyze performance metrics like latency and success rates
Identify bottlenecks in your agent workflows
Compare different agent configurations and LLMs

You can filter and segment all metrics by custom metadata to analyze specific agent types, user groups, or use cases.

2. Guardrails for Safe Agents

Guardrails ensure your OpenAI Agents operate safely and respond appropriately in all situations.

Why Use Guardrails?

OpenAI Agents can experience various failure modes:

Generating harmful or inappropriate content
Leaking sensitive information like PII
Hallucinating incorrect information
Generating outputs in incorrect formats

Obiguard’s guardrails protect against these issues by validating both inputs and outputs.

Obiguard’s guardrails can:

Detect and redact PII in both inputs and outputs
Filter harmful or inappropriate content
Validate response formats against schemas
Check for hallucinations against ground truth
Apply custom business logic and rules

Learn More About Guardrails

Explore Obiguard’s guardrail features to enhance agent safety

3. Tracing

Obiguard provides an opentelemetry compatible backend to store and query your traces.

You can trace your OpenAI Agents using any OpenTelemetry compatible tracing library.

Tool Use in OpenAI Agents

OpenAI Agents SDK natively supports tools that enable your agents to interact with external systems and APIs. Obiguard provides full observability for tool usage in your agents:

from agents import Agent, Runner, Tool, set_default_openai_client
from openai import AsyncOpenAI
from obiguard import OBIGUARD_GATEWAY_URL, createHeaders
import os

# Configure Obiguard client with tracing
client = AsyncOpenAI(
    base_url=OBIGUARD_GATEWAY_URL,
    default_headers=createHeaders(
        obiguard_api_key="vk-obg***",  # Your Obiguard virtual key
        trace_id="tools_example",
        metadata={"agent_type": "research"}
    )
)
set_default_openai_client(client)

# Define tools
def get_weather(location: str, unit: str = "fahrenheit") -> str:
    """Get the current weather in a given location"""
    return f"The weather in {location} is 72 degrees {unit}"

def get_population(city: str, country: str) -> str:
    """Get the population of a city"""
    return f"The population of {city}, {country} is 1,000,000"

# Create agent with tools
agent = Agent(
    name="Research Assistant",
    instructions="You are a helpful assistant that can look up weather and population information.",
    model="gpt-4o-mini",
    tools=[
        Tool(
            name="get_weather",
            description="Get the current weather in a given location",
            input_schema={
                "location": {
                    "type": "string",
                    "description": "City and state, e.g. San Francisco, CA"
                },
                "unit": {
                    "type": "string",
                    "description": "Temperature unit (celsius or fahrenheit)",
                    "default": "fahrenheit"
                }
            },
            callback=get_weather
        ),
        Tool(
            name="get_population",
            description="Get the population of a city",
            input_schema={
                "city": {
                    "type": "string",
                    "description": "City name"
                },
                "country": {
                    "type": "string",
                    "description": "Country name"
                }
            },
            callback=get_population
        )
    ]
)

# Run the agent
result = Runner.run_sync(
    agent,
    "What's the weather in San Francisco and what's the population of Tokyo, Japan?"
)
print(result.final_output)

Set Up Enterprise Governance for OpenAI Agents

Why Enterprise Governance? If you are using OpenAI Agents inside your orgnaization, you need to consider several governance aspects:

Cost Management: Controlling and tracking AI spending across teams
Access Control: Managing which teams can use specific models
Usage Analytics: Understanding how AI is being used across the organization
Security & Compliance: Maintaining enterprise security standards
Reliability: Ensuring consistent service across all users

Obiguard adds a comprehensive governance layer to address these enterprise needs. Let’s implement these controls step by step.

Enterprise Implementation Guide

Obiguard allows you to use 1600+ LLMs with your OpenAI Agents setup, with minimal configuration required. Let’s set up the core components in Obiguard that you’ll need for integration.

Create guardrail policy

You can choose to create a guardrail policy to protect your data and ensure compliance with organizational policies. Add guardrail validators on your LLM inputs and output to govern your LLM usage.

Create Virtual Key

Virtual Keys are Obiguard’s secure way to manage your LLM provider API keys. Think of them like disposable credit cards for your LLM API keys.

To create a virtual key: Go to Virtual Keys in the Obiguard dashboard. Select the guardrail policy and your LLM provider. Save and copy the virtual key ID

Save your virtual key ID - you’ll need it for the next step.

Once you have created your API Key after attaching default config, you can directly pass the API key + base URL in the AsyncOpenAI client. Here’s how:

from obiguard import createHeaders, OBIGUARD_GATEWAY_URL
from openai import AsyncOpenAI

client=AsyncOpenAI(
  obiguard_api_key="vk-obg***",  # Your Obiguard virtual key
  base_url="OBIGUARD_GATEWAY_URL"
)

# your rest of the code remains same

Enterprise Features Now Available

OpenAI Agents now has:

Departmental budget controls
Model access governance
Usage tracking & attribution
Security guardrails
Reliability features

Frequently Asked Questions

How does Obiguard enhance OpenAI Agents?

Can I use Obiguard with existing OpenAI Agents?

Does Obiguard work with all OpenAI Agents features?

How does Obiguard handle streaming in OpenAI Agents?

How do I filter logs and traces for specific agent runs?

Can I use my own API keys with Obiguard?

Resources

OpenAI Agents Docs

Official OpenAI Agents SDK documentation

Agent Examples

Example implementations for various use cases

Book a Demo

Get personalized guidance on implementing this integration

Ecosystem

AI Apps

Agents

LLMs

Vector Databases

OpenAI Agents SDK (Python)

Introduction

OpenAI Agents SDK Official Documentation

Installation & Setup

Getting Started

Integration Approaches

End-to-End Example

Production Features

1. Enhanced Observability

2. Guardrails for Safe Agents

Learn More About Guardrails

3. Tracing

Tool Use in OpenAI Agents

Set Up Enterprise Governance for OpenAI Agents

Enterprise Features Now Available

Frequently Asked Questions

Resources

OpenAI Agents Docs

Agent Examples

Book a Demo

Ecosystem

AI Apps

Agents

LLMs

Vector Databases

​Introduction

OpenAI Agents SDK Official Documentation

​Installation & Setup

​Getting Started

​Integration Approaches

​End-to-End Example

​Production Features

​1. Enhanced Observability

​2. Guardrails for Safe Agents

Learn More About Guardrails

​3. Tracing

​Tool Use in OpenAI Agents

​Set Up Enterprise Governance for OpenAI Agents

​Enterprise Features Now Available

​Frequently Asked Questions

​Resources

OpenAI Agents Docs

Agent Examples

Book a Demo

Introduction

Installation & Setup

Getting Started

Integration Approaches

End-to-End Example

Production Features

1. Enhanced Observability

2. Guardrails for Safe Agents

3. Tracing

Tool Use in OpenAI Agents

Set Up Enterprise Governance for OpenAI Agents

Enterprise Features Now Available

Frequently Asked Questions

Resources