Most AI agents are deaf. You type, they respond. You stop typing, they stop existing. That's not an agent — that's a very expensive autocomplete.

Real agents react to the world. A new customer signs up: the agent enriches their profile, drafts an onboarding sequence, and flags edge cases to you. A competitor publishes a post: the agent summarizes it, tags it, and routes it to the right Slack channel. No prompt required. No babysitting needed.

This is the architecture most tutorials skip. Let me walk you through how to actually build it.

Why "Prompt → Response" Is the Wrong Mental Model

When LangChain and ChatGPT exploded, everyone built chatbots. The interaction model was synchronous: human sends message, model replies, loop ends. Clean, understandable — and completely wrong for automation.

The problem is that most valuable work happens between conversations. Your CRM gets a new lead at 2am. A webhook fires when a payment fails. A cron job finds a broken link on your site. None of these start with a human typing something.

Event-driven agents flip the model: instead of waiting to be asked, they listen for signals and act autonomously. The LLM becomes a reasoning engine inside a larger reactive system, not the entry point.

Think of it like this — your agent is a team member who stays logged in. They watch the queue, process what comes in, and only escalate when genuinely stuck.

The Three Primitives You Actually Need

You don't need a full orchestration framework to start. You need three things:

1. A trigger layer — something that produces events. This can be a webhook endpoint, a cron job, a file watcher, or a queue consumer. In Python, a minimal FastAPI webhook listener is 15 lines.

2. A routing layer — logic that decides which agent (or which tool) handles which event. This is just a dispatcher, not magic.

3. An action layer — the agent itself: LLM call + tools + optional output (API call, database write, Slack message).

# Minimal event-driven agent skeleton
from fastapi import FastAPI, Request
import asyncio

app = FastAPI()

async def run_agent(event: dict):
    event_type = event.get("type")
    if event_type == "new_lead":
        await enrich_and_score(event["data"])
    elif event_type == "payment_failed":
        await draft_recovery_email(event["data"])

@app.post("/webhook")
async def handle_webhook(request: Request):
    payload = await request.json()
    asyncio.create_task(run_agent(payload))  # non-blocking
    return {"status": "accepted"}

Notice the create_task — we return 200 immediately and process async. If your webhook receiver blocks, upstream services will time out and retry. That's how you get duplicate agent runs at 3am.

Multi-Agent Routing Without the Framework Tax

The moment you have more than one agent, you need routing. Most frameworks solve this with abstractions that cost you flexibility. Here's what works without vendor lock-in:

Use a simple event schema with a type field and route to specialized agents:

AGENT_REGISTRY = {
    "new_lead":       LeadEnrichmentAgent(),
    "payment_failed": RecoveryAgent(),
    "mention":        MonitoringAgent(),
    "form_submit":    OnboardingAgent(),
}

async def dispatch(event: dict):
    agent = AGENT_REGISTRY.get(event["type"])
    if agent:
        await agent.run(event["data"])
    else:
        await fallback_agent.run(event)

Each agent is just a class with a run() method. No inheritance chains, no magic decorators. You can test each one in isolation with pytest and a mock event dict.

For higher volume, swap the dict dispatch for a proper queue (Redis Streams, SQS, even SQLite with polling). The agent code doesn't change — only what feeds it does.

Handling Failures Like a Production System

Here's what tutorials always skip: agents fail. The API times out. The LLM hallucinates a tool call. The downstream webhook is down.

Build for failure from day one:

Idempotency keys — store processed event IDs. If the same webhook fires twice (it will), skip the duplicate.

import sqlite3

def already_processed(event_id: str) -> bool:
    conn = sqlite3.connect("agent_state.db")
    row = conn.execute(
        "SELECT 1 FROM processed_events WHERE id = ?", (event_id,)
    ).fetchone()
    return row is not None

def mark_processed(event_id: str):
    conn = sqlite3.connect("agent_state.db")
    conn.execute(
        "INSERT OR IGNORE INTO processed_events VALUES (?)", (event_id,)
    )
    conn.commit()

Dead letter queues — if an event fails 3 times, route it to a failed_events table for human review. Don't silently swallow errors.

Timeouts on LLM calls — wrap every client.messages.create() with a timeout. An agent that hangs forever blocks your entire queue.

These three patterns alone will make your agent ten times more reliable than anything built in a weekend hackathon.

Passive Monitoring: Agents That Watch Without Being Asked

The most powerful use case is monitoring — agents that continuously observe a data source and act when conditions are met.

Example: an agent that watches your product's Subreddit and drafts a response whenever your brand is mentioned with a negative sentiment.

import asyncio

async def reddit_monitor_loop():
    seen = set()
    while True:
        mentions = fetch_recent_mentions(subreddit="yourproduct")
        for post in mentions:
            if post["id"] not in seen:
                seen.add(post["id"])
                sentiment = await classify_sentiment(post["text"])
                if sentiment == "negative":
                    draft = await draft_response(post)
                    await notify_slack(draft, post["url"])
        await asyncio.sleep(300)  # poll every 5 minutes

This runs forever as a background task. No human triggers it. It just... works. You wake up in the morning with a Slack message showing every negative mention and a ready-to-post response draft.

That's the promise of event-driven agents — not AI that answers questions, but AI that does work.

Deploying Without Overengineering

You don't need Kubernetes. For most indie projects and early-stage startups, a single VPS with nohup and a process watchdog is enough:

nohup python3 -u agent_worker.py > logs/agent.log 2>&1 &

Run a watchdog cron that restarts it if it crashes. Log everything to a file you can tail. Add a /health endpoint that returns the last event processed timestamp — if it's stale, you know the loop is stuck.

Only add infrastructure complexity when you actually hit the limits of this setup. Most teams never do.

The trap is building for scale you don't have. An event-driven agent that runs on a $6/month VPS and reliably processes 1,000 events a day is worth infinitely more than an orchestration monstrosity that takes three sprints to deploy.

Start boring. Automate the trigger. Ship the agent. Scale if the problem demands it.

I compiled everything into a practical guide — patterns, production pitfalls, and complete code examples: Event-Driven AI Agents: Give Your LLM Ears