Production Runtimes: Queue, Event, Cron

A notebook hides the failures that production exposes: a network timeout at step 37, a user who hangs up mid-voice call, a cron job that dies when the machine reboots, a background worker that runs out of memory. Which of those you survive depends on the runtime shape you chose.

A runtime shape is the outer shell around the agent loop: how work arrives, how long it runs, and how results get back out. The agent logic stays the same. The shell decides what a failure costs you. There are six shapes.

Request-response

Synchronous HTTP. The user waits for the task to finish, so this only works for short tasks (<30s).

• Stacks: Agno (Python + FastAPI), Mastra (TypeScript + Express/Hono/Fastify/Koa).
• Observability: standard HTTP access logs plus OTel spans.

Streaming

SSE or WebSocket carries progressive output to the client. LiveKit extends the idea to WebRTC for voice and video (Lesson 22).

• Stacks: any framework with streaming support, paired with a frontend that handles SSE or WS.
• Observability: per-chunk timing, first-token latency, tail latency.

Durable execution

State is checkpointed after every step, and the run resumes automatically on failure. Reach for it when the step count is unknown and recovery is expensive.

• LangGraph's core differentiator (Lesson 13).
• The AutoGen v0.4 actor model takes a different angle and isolates failures to one agent (Lesson 14).

Queue-based / background

A job enters a queue, workers pick it up, and results flow back through webhooks or pub/sub. This is the shape for long-horizon agents, which run dozens to hundreds of steps per task according to Anthropic's computer use announcement.

• Stacks: Celery (Python), BullMQ (Node), SQS + Lambda (AWS), or custom.
• Observability: queue depth, per-job latency distribution, DLQ size.

Event-driven

Agents subscribe to triggers: a new email, an opened PR, a cron fire.

• Claude Managed Agents covers this out of the box (Lesson 17).
• CrewAI Flows structures event-driven deterministic workflows (Lesson 15).
• Observability: trigger source, event-to-start latency, agent latency.

Scheduled

Cron-shaped agents that run on a period. Pair them with durable execution so a failing nightly run resumes on the next tick.

• Stacks: Kubernetes CronJob plus a durable framework, or hosted cron (Render, Vercel).

2026 deployment patterns

• CrewAI Flows for event-driven production.
• Agno stateless FastAPI for Python microservices.
• Mastra server adapters (Express, Hono, Fastify, Koa) for embedding.
• Pipecat Cloud / LiveKit Cloud for managed voice (Lesson 22).
• Claude Managed Agents for hosted long-running async.

Observability is load-bearing

If you don't have OpenTelemetry GenAI spans (Lesson 23) feeding a Langfuse, Phoenix, or Opik backend (Lesson 24), you can't debug a multi-step agent that failed at step 40. Treat it as a production requirement. It's what separates "we debug fast" from "we replay from scratch with more logging."

Where production runtimes fail

• Wrong shape choice. Request-response on a 5-minute task: users hang up, workers pile up, retries compound.
• No DLQ. Queue workers without a dead-letter queue lose failed jobs without a trace.
• Opaque background work. A background agent with no trace export fails invisibly until a user reports it.
• Skipping durable state. Any run over 30 seconds that you can't afford to restart needs durable execution.

code/main.py is a stdlib demo that wraps one task in five of the six shells:

• Request-response endpoint (a plain function).
• Streaming handler (a generator).
• Queue-based worker with a DLQ.
• Event trigger registry.
• Cron-shaped scheduler.

Run it:

python3 code/main.py

You get five traces, one per shape, from the same agent logic in different outer shells. Durable execution, the sixth shape, is intentionally left to Lesson 13, where LangGraph checkpointing covers it.

Match the shape to the product surface:

• Request-response for chat-style UX.
• Streaming for progressive responses.
• Durable for long-horizon tasks.
• Queue for batch, async, and long-running work.
• Event for agent reactivity.
• Cron for housekeeping: memory consolidation, evals, cost reports.

outputs/skill-runtime-shape.md picks a runtime shape for a task and wires in its observability requirements.

1. Port your Lesson 01 ReAct loop to all six shapes in your stack. Which shape fits which product surface?
2. Add a DLQ to the queue-based demo. Simulate 10% job failure and surface the DLQ size.
3. Write a cron-triggered eval agent that runs nightly against your top 20 traces from the day.
4. Implement streaming with backpressure: if the client is slow, pause the agent. How does this interact with a turn budget?
5. Read the Claude Managed Agents docs. When would you move a self-hosted long-horizon agent to managed?

• LangGraph overview: durable execution details
• Claude Managed Agents overview: hosted long-running async
• Anthropic, Introducing computer use: "dozens-to-hundreds of steps per task"
• AutoGen v0.4 (Microsoft Research): actor-model fault isolation