Python asyncio Fundamentals for AI Engineers: Coroutines, Tasks, and Event Loops

Why AI Engineers Need asyncio

AI agent systems spend most of their time waiting. Waiting for LLM API responses, waiting for database queries, waiting for tool call results. A synchronous agent that makes five sequential LLM calls taking two seconds each wastes eight seconds doing nothing. With asyncio, those same five calls complete in roughly two seconds total.

asyncio is Python's built-in library for writing concurrent code using the async/await syntax. It uses a single-threaded event loop to multiplex I/O-bound operations, making it the ideal foundation for AI agent architectures where network latency dominates execution time.

Coroutines: The Building Blocks

A coroutine is a function defined with async def. When called, it returns a coroutine object that must be awaited to produce a result.

import asyncio

async def call_llm(prompt: str) -> str:
    """Simulate an LLM API call with network latency."""
    print(f"Sending prompt: {prompt[:40]}...")
    await asyncio.sleep(1.5)  # Simulates network round-trip
    return f"Response to: {prompt[:20]}"

async def main():
    # Awaiting a single coroutine
    result = await call_llm("Explain quantum computing in one sentence")
    print(result)

asyncio.run(main())

The await keyword suspends the current coroutine, yields control back to the event loop, and resumes once the awaited operation completes. This is the mechanism that allows other work to happen during I/O waits.

The Event Loop

The event loop is the scheduler at the heart of asyncio. It maintains a queue of ready tasks and switches between them whenever one yields control via await.

import asyncio
import time

async def agent_step(step_name: str, delay: float) -> str:
    print(f"[{time.monotonic():.2f}] Starting {step_name}")
    await asyncio.sleep(delay)
    print(f"[{time.monotonic():.2f}] Completed {step_name}")
    return f"{step_name} done"

async def main():
    start = time.monotonic()

    # Sequential execution — total time is sum of delays
    r1 = await agent_step("retrieve_context", 1.0)
    r2 = await agent_step("call_llm", 2.0)
    print(f"Sequential: {time.monotonic() - start:.2f}s")

asyncio.run(main())
# Output: Sequential: ~3.00s

Tasks: Running Coroutines Concurrently

Tasks wrap coroutines and schedule them on the event loop immediately. Use asyncio.create_task() to run multiple operations concurrently.

async def main():
    start = time.monotonic()

    # Concurrent execution — total time is max of delays
    task1 = asyncio.create_task(agent_step("retrieve_context", 1.0))
    task2 = asyncio.create_task(agent_step("call_llm", 2.0))
    task3 = asyncio.create_task(agent_step("fetch_tools", 1.5))

    # Wait for all tasks to complete
    r1 = await task1
    r2 = await task2
    r3 = await task3

    print(f"Concurrent: {time.monotonic() - start:.2f}s")

asyncio.run(main())
# Output: Concurrent: ~2.00s (limited by slowest task)

Gathering Results

asyncio.gather() is the most common pattern for running multiple coroutines concurrently and collecting their results in order.

async def process_agent_batch(prompts: list[str]) -> list[str]:
    """Process a batch of prompts concurrently."""
    results = await asyncio.gather(
        *[call_llm(prompt) for prompt in prompts]
    )
    return results

async def main():
    prompts = [
        "Summarize this document",
        "Extract key entities",
        "Generate follow-up questions",
        "Classify sentiment",
    ]
    results = await process_agent_batch(prompts)
    for prompt, result in zip(prompts, results):
        print(f"{prompt[:30]} -> {result}")

asyncio.run(main())

The results list preserves the same order as the input coroutines, regardless of which completes first.

Practical Pattern: Agent Initialization

A real-world pattern is initializing an agent's subsystems concurrently at startup.

async def load_vector_store() -> dict:
    await asyncio.sleep(0.5)  # Simulate loading embeddings
    return {"type": "vector_store", "docs": 15000}

async def connect_database() -> dict:
    await asyncio.sleep(0.3)  # Simulate DB connection
    return {"type": "db", "connected": True}

async def load_tool_registry() -> dict:
    await asyncio.sleep(0.2)  # Simulate tool loading
    return {"type": "tools", "count": 12}

async def initialize_agent():
    """Initialize all agent subsystems concurrently."""
    vector_store, db, tools = await asyncio.gather(
        load_vector_store(),
        connect_database(),
        load_tool_registry(),
    )
    print(f"Agent ready: {vector_store['docs']} docs, "
          f"{tools['count']} tools, db={db['connected']}")
    return {"vector_store": vector_store, "db": db, "tools": tools}

asyncio.run(initialize_agent())
# Total startup: ~0.5s instead of ~1.0s sequential

Key Rules for AI Engineers

1. Never call blocking I/O inside async code — use await with async libraries like httpx, aiohttp, or asyncpg instead of requests or psycopg2.
2. Use asyncio.run() as your single entry point — do not create event loops manually.
3. Prefer create_task() over raw await when you want concurrency within a single function.
4. Every await is a potential context switch — the event loop may run other tasks at that point.

FAQ

When should I use asyncio instead of threading for AI agents?

Use asyncio for I/O-bound workloads like LLM API calls, database queries, and HTTP requests. asyncio is more lightweight than threads (no GIL contention, lower memory per task) and scales to thousands of concurrent operations. Use threading only when you must call blocking libraries that have no async equivalent.

Can I mix synchronous and asynchronous code in the same agent?

Yes, but carefully. Use asyncio.to_thread() to run blocking functions without freezing the event loop. For example, result = await asyncio.to_thread(some_blocking_function, arg1) offloads the blocking call to a thread pool while keeping the event loop responsive.

How many concurrent tasks can asyncio handle?

asyncio tasks are extremely lightweight — a single process can manage tens of thousands of concurrent tasks. The practical limit is usually the external resource (API rate limits, database connection pools), not the event loop itself.

---

#Python #Asyncio #Concurrency #AIAgents #EventLoop #AgenticAI #LearnAI #AIEngineering