OpenAI agents SDK Core features:
· Introduction to Co-routines and other agents information:
o Co-routines Versus Functions: when using 'async def' in Python, the resulting object is a coroutine, not a traditional function, and calling a coroutine returns a coroutine object rather than executing the code immediately.
o Event Loop Mechanism: the event loop in the async IO library is a loop that schedules and executes coroutines, pausing them when they are waiting for IO and resuming others, enabling concurrency without traditional multithreading.
o Awaiting Coroutines: to execute a coroutine, it must be awaited using the 'await' keyword, which schedules it for execution in the event loop and blocks until the coroutine completes.
o Concurrent Execution with Gather: 'asyncio.gather' as a construct that allows multiple coroutines to be scheduled concurrently, with the event loop managing their execution and collecting their results as a list.
· Introduction to OpenAI Agents SDK:
o Framework Characteristics: the OpenAI Agents SDK is lightweight, flexible, and not prescriptive, allowing users to choose their preferred working style while abstracting away repetitive tasks such as JSON handling.
o Key Terminology in OpenAI Agents SDK- Agents Terminology: three core terms in the OpenAI Agents SDK—agents, handoffs, and guardrails.
§ Agents - agents as wrappers around LLMs with specific roles,
§ Handoffs - 'handoffs' as interactions between agents,
§ Guardrails - 'guardrails' as checks and controls to ensure agents behave within defined Guardrails.
· Steps to Run an Agent in OpenAI Agents SDK: three steps required to run an agent using the OpenAI Agents SDK:
o Agent Instance Creation: Create an instance of an agent, which will represent a role in the solution.
o Interaction Logging with Trace: using 'with trace' is recommended for logging all interactions with the agent, enabling monitoring through OpenAI's tools. Trace to track the agent.
o Running the Agent Coroutine: the agent is executed by calling 'runner.run', which is a coroutine and must be awaited to actually run the agent. Call runner.run to run the agent.
asyncio:
asyncio is Python’s built‑in asynchronous programming
framework. It performed multiple things at the same time without
using threads or processes. asyncio will offer:
- While
task A is waiting, Python can run task B
- While
task B is waiting, Python can run task C
Asyncio, Python run many waiting tasks at the same time,
making I/O-heavy programs dramatically faster. This makes the program much faster and more
efficient. Use asyncio when the program does a lot of waiting.
Don’t
use for CPU-heavy tasks (math, ML, image processing). All methods and functions should start with async as
keyword. During the calling of methods or functions, use await keyword
import asyncio
async def fetch_data():
await asyncio.sleep(2)
return "data"
async def main():
results = await
asyncio.gather(
fetch_data(),
fetch_data(),
fetch_data()
)
print(results)
result = await Runner.run(main())
INSTRUCTIONS = " some instruction as prompt."
first_agent = Agent(
name="First
agent",
instructions=INSTRUCTIONS,
tools=toolname,
model="gpt-4o-mini",
)
message = "Welcome AI Agent frameworks in 2025"
with trace("Welcome"):
result = await
Runner.run(first_agent, message)
with trace("multiple
agents"):
results = await
asyncio.gather(
Runner.run(agent1,
message),
Runner.run(agent2,
message),
Runner.run(agent3,
message),
)Key concepts in asyncio
|
Concept
|
Meaning
|
|
async def
|
Defines an asynchronous function
|
|
await
|
Pauses the function until the awaited task completes
|
|
event loop
|
The engine that schedules async tasks
|
|
asyncio.gather()
|
Runs multiple tasks at the same time
|
|
asyncio.sleep()
|
Non-blocking sleep (example of async I/O)
|
Agent frameworks need to:
- run
multiple agents at the same time
- handle
many I/O operations (LLM calls, tools, APIs)
- wait
for responses without blocking the whole system
- coordinate
tasks, messages, and events
- rely on asyncio.
Agent frameworks use asyncio, and the frameworks below are built around async
execution:
1.
LangChain
a. Tool
calls are async
b. LLM
calls can be async
c. Agents
run async loops
d. Many
integrations require async def
2.
LangGraph
a. Entire
architecture is async-first
b. Nodes,
edges, and tool calls run concurrently
c. Event-driven
execution uses asyncio tasks
3.
CrewAI
a. Uses
asyncio for parallel task execution
b. Agents
can run concurrently
c. Async
tool calls supported
4.
Microsoft Autogen (new version)
a. Fully
async
b. Agents
communicate via async message passing
5.
MCP (Model Context Protocol)
a. Server
and client interactions use async
b. Streaming
responses require async
c. Tool
execution often async
Learning during this journey
- Agent workflow
- Use of tools to call functions
- Agent collaboration via Tools and Handoffs
Example: Multi Agents
Steps1: Define instruction, trying to run multiple agent as parallel. Define instruction, description, and tools
instructions1 = "You are a agent1 working for ComplAI,
define the action."
instructions2 = "You are a agent2 working for ComplAI, define
the action."
instructions3 = "You are a agent3 working for ComplAI define
the action."
description = "specific actions"
# Agent definition
agent1 = Agent(name="DeepSeek Sales Agent",
instructions=instructions1, model=deepseek_model)
agent2 = Agent(name="Gemini
Sales Agent", instructions=instructions2, model=gemini_model)
agent3 = Agent(name="Llama3.3
Sales Agent",instructions=instructions3,model=llama3_3_model)
# tool definition
tool1 = agent1.as_tool(tool_name="agent1",
tool_description=description)
tool2 = agent2.as_tool(tool_name="agent2",
tool_description=description)
tool3 = agent3.as_tool(tool_name="agent3",
tool_description=description)
Steps2: Define the decorator function
@function_tool
def do_action(sub: str,
des: str) -> Dict[str, str]:
""" Action
definition"""
return
{"status": "success"}
Instruction to agent:
sub1_instructions = "write a detail for action perform
by agent."
sub2_instructions = "write a detail for action perform
by agent."
Define agents and convert them into tools:
agent4 = Agent(name="new_agent1",
instructions= sub1_instructions, model="gpt-4o-mini")
subject1_tool = Agent4.as_tool(tool_name="
Agent4", tool_description="tool description as action")
agent5 = Agent(name="new_agent2",
instructions= sub2, model="gpt-4o-mini")
subject2_tool = html_converter.as_tool(tool_name="
Agent5",tool_description=" tool description as action")
listOf_tools = [subject1_tool, Subject2_tool, do_action]
referencing a handoff agent:
agent5 = Agent(
name="new_agent3",
instructions=instructions,
tools= listOf_tools,
model="gpt-4o-mini",
handoff_description="handoff agent will
take care as instructed")
tools = [tool1, tool2, tool3]
handoffs = [handoff_agent]
Runs the entire multi‑agent system:
Role is ComplAI and goal is to do ….. using the agent_name
tools.
Follow these steps carefully:
1. Generate Drafts: Use all agents agent_name tools ….
2. Handoff for
Sending: Pass…. to the Handoff Manager' agent. The Handoff Manager will do….. """
instructions=main_instructions,
message = "add some message"
with
trace("Automated SDR"):
result = await Runner.run(agent_manager,
message)
