OpenAI Agents SDK vs Claude API: Which to Use for Building AI Agents in 2026

from openai import OpenAI
from agents import Agent, Runner, function_tool

client = OpenAI(api_key="your-openai-api-key")

@function_tool
def search_knowledge_base(query: str) -> str:
    """Search the internal knowledge base for relevant information."""
    # In production: call your vector database
    return f"Found articles about: {query}"

@function_tool
def send_email(to: str, subject: str, body: str) -> str:
    """Send an email to the specified recipient."""
    # In production: call your email service
    return f"Email sent to {to} with subject '{subject}'"

# Define the agent
support_agent = Agent(
    name="Customer Support Agent",
    model="gpt-4o",
    instructions="""You are a helpful customer support agent.
    Search the knowledge base before responding.
    Only send emails when explicitly requested by the user.""",
    tools=[search_knowledge_base, send_email]
)

# Run the agent
runner = Runner()
result = runner.run_sync(
    support_agent,
    "Can you look up our refund policy and send it to customer@example.com?"
)
print(result.final_output)

from agents import Agent, Runner, handoff

triage_agent = Agent(
    name="Triage",
    model="gpt-4o-mini",  # Cheaper model for routing
    instructions="Route user requests to the appropriate specialist.",
    handoffs=[]  # Will be set after creating specialists
)

billing_agent = Agent(
    name="Billing Specialist",
    model="gpt-4o",
    instructions="Handle billing and payment questions with precision.",
    tools=[search_knowledge_base]
)

technical_agent = Agent(
    name="Technical Specialist",
    model="gpt-4o",
    instructions="Handle technical issues and debugging assistance.",
    tools=[search_knowledge_base]
)

# Set up handoffs
triage_agent.handoffs = [
    handoff(billing_agent, tool_name_override="escalate_to_billing"),
    handoff(technical_agent, tool_name_override="escalate_to_technical")
]

runner = Runner()
result = runner.run_sync(
    triage_agent,
    "My invoice shows the wrong amount charged."
)
print(result.final_output)

import anthropic
import json

client = anthropic.Anthropic(api_key="your-anthropic-api-key")

# Define tools using JSON schema
tools = [
    {
        "name": "search_knowledge_base",
        "description": "Search the internal knowledge base for relevant information.",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "The search query"
                }
            },
            "required": ["query"]
        }
    },
    {
        "name": "send_email",
        "description": "Send an email to a recipient.",
        "input_schema": {
            "type": "object",
            "properties": {
                "to": {"type": "string", "description": "Recipient email address"},
                "subject": {"type": "string", "description": "Email subject"},
                "body": {"type": "string", "description": "Email body content"}
            },
            "required": ["to", "subject", "body"]
        }
    }
]

def execute_tool(tool_name: str, tool_input: dict) -> str:
    """Execute the named tool and return the result."""
    if tool_name == "search_knowledge_base":
        return f"Knowledge base results for '{tool_input['query']}': refund policy allows 30-day returns."
    elif tool_name == "send_email":
        return f"Email sent successfully to {tool_input['to']}."
    return "Tool not found."

def run_agent(user_message: str) -> str:
    """Run the Claude agent loop until completion."""
    messages = [{"role": "user", "content": user_message}]

    while True:
        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=4096,
            system="You are a helpful customer support agent. Search the knowledge base before responding.",
            tools=tools,
            messages=messages
        )

        # If Claude is done (no more tool calls)
        if response.stop_reason == "end_turn":
            # Extract text from response
            for block in response.content:
                if hasattr(block, "text"):
                    return block.text

        # Process tool calls
        messages.append({"role": "assistant", "content": response.content})

        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                result = execute_tool(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result
                })

        messages.append({"role": "user", "content": tool_results})

# Run it
output = run_agent("Can you look up our refund policy and send it to customer@example.com?")
print(output)

# Claude tends to use tools deliberately
# To encourage tool use, be explicit in the system prompt:
system = """You MUST search the knowledge base before answering any factual question.
Do not answer from memory—always verify with a search first."""

# OpenAI: tool_choice controls this behavior
response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    tools=tools,
    tool_choice="auto"  # or "required" to force tool use
)

from agents import Agent, GuardrailFunctionOutput, RunContextWrapper, input_guardrail
from pydantic import BaseModel

class EmailValidationOutput(BaseModel):
    is_valid_request: bool
    reasoning: str

@input_guardrail
async def validate_email_request(
    ctx: RunContextWrapper,
    agent: Agent,
    input: str
) -> GuardrailFunctionOutput:
    """Ensure email requests include a valid recipient."""
    has_email = "@" in input and "." in input.split("@")[-1]
    return GuardrailFunctionOutput(
        output_info=EmailValidationOutput(
            is_valid_request=has_email,
            reasoning="Valid email address found" if has_email else "No valid email address in request"
        ),
        tripwire_triggered=not has_email
    )