Series / Learning path
Agent Engineering
A practical path through agent patterns, asynchronous execution, state, streaming, and production runtimes.
Learning Path
From control flow to production contracts
A field-tested learning path for designing agent backends that remain understandable and recoverable in production.
Where should I start?
Choose your entry point
Stage 1
Design and overall structure
Map agent control patterns and the backend’s boundaries of responsibility before implementation details.
What should the agent own, and what belongs to the backend?
- 01→
Agent Pattern Design: From Tool Use to Planning, Parallelism, HITL, and Reflection
Compose bounded control flows instead of building one giant autonomous loop
- 02→
Agent Backend Architecture at a Glance: How APIs, Queues, Workers, State, and SSE Fit Together
Execution architecture boundaries — mental model, failure modes, optional deep dives
Stage 2
Execution and orchestration
Separate and coordinate work with async, threads, workers, and parent-child runs.
How should long-running work be separated and parallelized?
- 03→
Why Agent Systems Need Async: Making Waiting Time Useful
Turn time spent waiting on LLMs, databases, and search APIs into concurrency
- 04→
Async, Threads, and Processes: What to Know Before Agent Workers
Waiting, blocking SDKs, and CPU-bound computation require different execution tools
- 05→
A Worker Is Not a Thread: Why Agent Execution Should Leave the API Server
Separate concurrency primitives from ownership of the execution lifecycle
- 06→
Multi-Agent Is Not Multiple Agents: Parent Runs, Fan-out, and Fan-in
Model child lifecycles, isolated state, and partial failure as one execution tree
Stage 3
State and durability
Separate durable state, live projections, events, and session ownership.
Where does execution state live, and who owns it?
- 06→
Where Does Agent State Live? Redis, PostgreSQL, and Checkpoints
Durable records, hot projections, and resumable snapshots survive different failures
- 07→
State Is Not an Event: Designing Real-Time Agent UIs
Restore the screen from a snapshot, then keep its timeline complete with cursors
Stage 4
Safe execution and recovery
Connect approval, idempotency, retries, cancellation, checkpoints, and permissions into a recovery contract.
How does the system survive duplicates, failures, cancellation, and permission errors?
- 08→
Can an Agent Tool Execute Exactly Once? Approval, Idempotency, and Retries
Linking user intent to side effects so a transfer tool does not run twice
Stage 5
Delivery and operational boundaries
Unify streaming, runtimes, deployment, observability, and overload control as the production delivery layer.
How should execution facts be delivered, observed, and operated?
- 09→
Let the Agent Speak While It Works: SSE, Generators, and Redis Streams
Safely stream snapshots and events over an HTTP connection with async generators
- 10→
LangGraph Is Not Architecture: Where the Runtime Actually Belongs
Separate graph state from application state to assign responsibility across workers, Redis, databases, and browsers
Applied Track
Inference Serving · vLLM
A focused path on internal vLLM serving, tuning under GPU limits, and troubleshooting slowdowns
Applied Track · 3 ARTICLES
Inference Serving · vLLM
Choose, tune, and troubleshoot models served on internal GPUs.
- 01
Why Serve Open-Source LLMs with vLLM on Internal GPUs?
Deciding internal open-model serving for security, data control, cost, and performance
- 02
What is vLLM tuning?
Serving LLMs when GPUs are scarce
- 03
Why Is vLLM Slow?
Diagnosing bottlenecks with TTFT, TPOT, and KV cache