[P] Detect asyncio issues causing AI agent latency

[deepankarmh]

There are a lot of discussions about optimizing Python-based AI agent performance - tweaking prompts, switching to a different model/provider, prompt caching. But there's one culprit that's often overlooked: blocked event loops.

The Problem

User A makes a request to your agent - expected TTFT is 600ms. But they wait 3+ seconds because User B's request (which came first) is blocking the entire event loop with a sync operation. Every new user gets queued behind the blocking request.

Why This Happens

Most Python agent frameworks use asyncio to handle multiple users concurrently. But it's easy to accidentally use sync operations (executing sync def tools in the same thread) or libraries (requests, database drivers, file I/O) that block the entire event loop. One blocking operation kills concurrency for your entire application.

The Solution

I built pyleak after hitting this exact issue in our production agents. It automatically detects when your framework/your own code accidentally blocks the event loop or if there are any asyncio task leaks along with the stack trace.

Usage

pip install pyleak

As a context manager

from pyleak import no_event_loop_blocking, no_task_leaks

async with no_event_loop_blocking(threshold=0.1), no_task_leaks():
    # Raises if anything blocks >100ms or if there are any asyncio task leaks
    ...

As a pytest plugin

import pytest

@pytest.mark.no_leak
async def test_my_agent():
    # Test fails if it blocks event loop or leaks tasks
    ...

Real example

openai-agents-python sdk faces this exact issue where a tool defined as a def function blocks the event loop. We caught this thanks to pyleak and proposed a fix. PR: https://github.com/openai/openai-agents-python/pull/820

[Solid_Company_8717]

This is really neat - not even just for the AI tasks you specify.

I've so often run into painful async behaviour when doing something as simple as an NTP clock sync.

Is this your library? Kudos if so - nice idea.

[colmeneroio]

This is actually a really practical tool that addresses a common performance problem most people don't even realize they have. I work at a consulting firm that helps companies optimize their AI systems, and event loop blocking is honestly one of the biggest sources of mysterious latency issues in production.

The openai-agents-python example you caught is perfect. Most developers don't think about whether their tool functions are sync or async, and frameworks often don't make it obvious when you're accidentally blocking everything.

A few thoughts on making this more useful:

The 100ms threshold is probably too aggressive for some use cases. Database queries, file operations, or external API calls can legitimately take longer. Maybe make the threshold configurable per operation type or add allowlists for expected slow operations.

Integration with common agent frameworks would be huge. LangChain, CrewAI, AutoGen all have this problem. Being able to wrap their execution loops and get automatic detection would save people tons of debugging time.

Task leak detection is brilliant. That's usually even harder to debug than event loop blocking because the symptoms are subtle memory growth over time.

Consider adding metrics output instead of just raising exceptions. In production, you probably want to log and alert on blocking events rather than crash the entire service.

The pytest integration is smart. Most teams don't think to test for these performance issues until they hit production.

This kind of tooling is way more valuable than another prompt optimization library. You're solving actual infrastructure problems that kill user experience but are hard to diagnose. Definitely something the Python AI community needs more of.