Introduction to Agents SDK

Welcome! Today, we’ll take our first steps with AI agents using the Agents SDK. AI agents are everywhere — from virtual assistants to customer support bots and learning tools. The Agents SDK makes it easy to build, configure, and run your own AI agents in Python. By the end of this lesson, you’ll know what the Agents SDK is, how to create an agent, and how to interact with it using real code. Our goal is to help you get comfortable with the basics so you can start building interactive, intelligent applications.

The Agents SDK is a Python library for creating and running AI agents. Think of it as a toolkit for building agents that can understand instructions, process user input, and generate helpful responses. Why use it? If you want to build a virtual assistant, a chatbot, or a learning companion, the Agents SDK gives you the core components you need.

The two main parts are:

• Agent: Defines your AI agent, including its name and instructions.
• Runner: Runs your agent and manages conversations.

With these, you can quickly add AI-powered features to your apps.

Let’s see how to create an agent. The Agent class lets you define your agent’s personality and behavior. You usually provide a name to identify your agent and instructions to guide how it should respond. Here’s a basic example:

from agents import Agent

# Create a simple agent
my_agent = Agent(
    name="HelperBot",
    instructions="You are a friendly assistant. Answer questions clearly and politely."
)

Instructions are like the agent’s job description. Want a patient teacher, a technical expert, or a playful companion? Just describe it in the instructions.

For example, a math tutor agent:

from agents import Agent

math_tutor = Agent(
    name="MathTutor",
    instructions=(
        "You are a patient math tutor. Explain concepts step by step, "
        "and encourage students to ask questions if they are confused."
    )
)

Clear instructions help your agent respond the way you want.

Once you have an agent, how do you use it? That’s where Runner comes in. The Runner class lets you run your agent and get responses. The most common method is run_sync, which runs the agent and waits for a response. Here’s a simple example:

from agents import Agent, Runner

# Create an agent
agent = Agent(
    name="HelperBot",
    instructions="You are a helpful assistant. Answer questions clearly."
)

# User input
user_input = "What is the capital of France?"

# Run the agent and get the response
result = Runner.run_sync(agent, user_input)
print(result.final_output)  # The capital of France is Paris.

Here’s what happens: you create an agent with instructions, provide user input, use Runner.run_sync to send the input to the agent, and get a response in result.final_output. This is the basic pattern for building interactive AI apps.

Let’s walk through a more complete example. Suppose you want a learning assistant to help students understand complex topics.

from agents import Agent, Runner

def main():
    # Create an agent with instructions
    agent = Agent(
        name="Learning Assistant",
        instructions=(
            "You are a helpful learning assistant designed to help students understand complex topics. "
            "Provide clear, educational responses that break down concepts step by step. "
            "Be encouraging and patient in your explanations."
        )
    )

    # Example input for the agent
    user_input = "Explain how neural networks learn."

    # Run the agent synchronously
    result = Runner.run_sync(agent, user_input)
    print(result.final_output)  # Neural networks learn by adjusting weights through a process called backpropagation...
    # (The actual output will be a detailed, step-by-step explanation of how neural networks learn.)
if __name__ == "__main__":
    main()

Here, the agent is set up as a learning assistant. The instructions specify breaking down concepts and being patient. The user asks, “Explain how neural networks learn.” The agent returns a detailed, step-by-step answer. You can adapt this for customer support, onboarding, or any scenario where an AI agent can help. Just define the agent’s role and instructions, then use Runner for user interactions.

While the Agents SDK is a great starting point, there are several other libraries and frameworks that provide agent capabilities:

• LangChain: A popular Python framework for building applications with language models. It offers tools for chaining together LLM calls, memory, and agent-like behaviors.
• Haystack: An open-source framework focused on building production-ready search and question-answering systems, with support for agent workflows.
• AutoGen: A library for orchestrating multi-agent conversations and workflows, often used for more complex, collaborative agent scenarios.
• Microsoft Semantic Kernel: A framework for integrating AI models, plugins, and memory to build intelligent agents and copilots.
• Rasa: An open-source conversational AI framework, mainly for building chatbots and virtual assistants with dialogue management and custom logic.

Each of these libraries has its own strengths and focus areas, but all aim to make it easier to build interactive, intelligent agents.

You might wonder: why not just use a simple completions API (like OpenAI’s chat.completions or completions endpoint) to generate responses? While completions APIs are great for generating text, agents provide several key advantages:

• Structured Behavior: Agents let you define roles, instructions, and personalities, making responses more consistent and tailored to your use case.
• State and Memory: Agents can manage conversation history, context, and even long-term memory, enabling more coherent and context-aware interactions.
• Multi-step Reasoning: Agents can break down complex tasks, call tools or APIs, and perform multi-step reasoning, which is difficult with a single completion call.
• Extensibility: Agents can be extended with plugins, tools, or custom logic, allowing them to perform actions beyond just generating text.

In short, agents are designed for interactive, stateful, and task-oriented applications, while simple completions APIs are best for one-off text generation. If you want your application to have a persistent, helpful, and intelligent assistant, using an agent framework is the way to go.

In this lesson, you learned what the Agents SDK is and why it’s useful, how to create an agent with the Agent class, and how to interact with your agent using the Runner class and run_sync. You also walked through a real-life example. With these basics, you’re ready to start building your own AI agents for many tasks.

Now it’s your turn! Next, you’ll practice creating and running agents using the Agents SDK. You’ll build agents with different instructions and see how they respond. This hands-on work will help you master the basics and prepare for more advanced topics.