Building AI Agents From Scratch using OpenAI Agents SDK

from agents import Agent, Runner

# Two specialist agents — each speaks only one language
spanish_agent = Agent(
    name="Spanish agent",
    instructions="You only speak Spanish.",
)

english_agent = Agent(
    name="English agent",
    instructions="You only speak English.",
)

# The triage agent routes to the correct specialist
triage_agent = Agent(
    name="Triage agent",
    instructions="Handoff to the appropriate agent based on the language of the request.",
    handoffs=[spanish_agent, english_agent],
)

async def main():
    # Spanish input → goes to spanish_agent
    result = await Runner.run(triage_agent, input="Hola, ¿cómo estás?")
    print(result.final_output)

    # English input → goes to english_agent
    result = await Runner.run(triage_agent, input="Hello, how are you?")
    print(result.final_output)

    # Directly calling spanish_agent with English input
    result = await Runner.run(spanish_agent, input="Hello, how are you?")
    print(result.final_output)

await main()

from agents import Agent, Runner, function_tool
import datetime

# ── Define tools ──────────────────────────────────────────

@function_tool
def get_current_time(city: str) -> str:
    """Return the current UTC time. City is accepted but we use UTC for simplicity."""
    now = datetime.datetime.utcnow().strftime("%H:%M:%S UTC")
    return f"The current time (UTC) is {now}."

@function_tool
def calculate(expression: str) -> str:
    """Evaluate a simple arithmetic expression and return the result."""
    try:
        result = eval(expression, {"__builtins__": {}})
        return f"{expression} = {result}"
    except Exception as e:
        return f"Error: {e}"

# ── Create the agent with tools ───────────────────────────
assistant = Agent(
    name="Assistant",
    instructions="You are a helpful assistant. Use your tools whenever a question requires live data or calculation.",
    tools=[get_current_time, calculate],
)

async def main():
    result = await Runner.run(assistant, input="What time is it in London?")
    print(result.final_output)

    result = await Runner.run(assistant, input="What is 1492 multiplied by 33?")
    print(result.final_output)

await main()

from agents import Agent, Runner

tutor = Agent(
    name="Tutor",
    instructions=(
        "You are a patient Python tutor. Remember what the student has already learned "
        "in this session and build on it. Keep explanations short and encouraging."
    ),
)

async def chat(history: list, user_message: str) -> str:
    # Add the new user message to history
    history.append({"role": "user", "content": user_message})

    # Run the agent with the full conversation history as input
    result = await Runner.run(tutor, input=history)
    reply = result.final_output

    # Append the agent's reply so the next call has full context
    history.append({"role": "assistant", "content": reply})
    return reply

async def main():
    history = []   # Start with an empty conversation

    reply1 = await chat(history, "Hi! I'm new to Python. What's a variable?")
    print(f"Tutor: {reply1}\n")

    reply2 = await chat(history, "Got it. Now, what's a list and how is it different?")
    print(f"Tutor: {reply2}\n")

    # The tutor remembers we started with variables
    reply3 = await chat(history, "Can I store a list inside a variable?")
    print(f"Tutor: {reply3}\n")

await main()

from agents import Agent, Runner

# ── Stage 1: Drafter ──────────────────────────────────────
drafter = Agent(
    name="Drafter",
    instructions=(
        "You are a blog writer. Given a topic, write a short 3-paragraph blog post. "
        "Be informative but conversational. Do not polish — this is a rough draft."
    ),
)

# ── Stage 2: Critic ───────────────────────────────────────
critic = Agent(
    name="Critic",
    instructions=(
        "You are a sharp editor. Review the given draft and list exactly 3 specific, "
        "actionable improvements. Be concise — use bullet points."
    ),
)

# ── Stage 3: Editor ───────────────────────────────────────
editor = Agent(
    name="Editor",
    instructions=(
        "You are a professional editor. You will receive a draft and a list of critique points. "
        "Rewrite the draft addressing all critique points. Output only the final polished post."
    ),
)

async def run_pipeline(topic: str) -> str:
    # Stage 1 — Generate draft
    draft_result = await Runner.run(drafter, input=topic)
    draft = draft_result.final_output
    print("Draft complete\n")

    # Stage 2 — Critique the draft
    critique_result = await Runner.run(critic, input=draft)
    critique = critique_result.final_output
    print("Critique complete\n")

    # Stage 3 — Edit using the draft + critique together
    combined = f"DRAFT:\n{draft}\n\nCRITIQUE:\n{critique}"
    final_result = await Runner.run(editor, input=combined)
    print("Final edit complete\n")

    return final_result.final_output

async def main():
    final_post = await run_pipeline("Why learning to code is still valuable in the age of AI")
    print("── FINAL Result ──────────────────────────────────────\n")
    print(final_post)

await main()

Pattern           When to use
────────────────────────────────────────────────────────────
Triage Agent      Route different request types to specialists
Tool-Use Agent    Need live data, APIs, math, or external actions
Memory Agent      Multi-turn conversations that need context
Pipeline Agent    Complex tasks that benefit from staged processing