Free to read

Architect your agent as seven composable layers

Stop debugging monolithic agents by guessing. Build a FastAPI service where every request flows through transport, orchestrator, tools, memory, retrieval, guardrails, and observability, with a per-layer trace you can replay.

Start readingPreview curriculum

Still deciding? Ask first.

Message a mentor about fit, prerequisites, or where to start. Replies come on WhatsApp, usually within a day.

  • Curriculum fit, prerequisites, or where to start
  • Honest answer, no pressure to enroll

Taught by an engineer who has shipped this

  • ISO 27001

    Led the engineering work behind the certification of a regulated EU platform.

  • Series A platform

    Architected the case-management product that became the business a €11.6M round was raised on.

  • 3x faster deploys

    Cut time-to-deploy by migrating to Kubernetes on GCP with deploy-on-merge.

Build an LLM agent as seven composable layers with clear contracts, per-layer tracing, and graceful failure modes. Transport, orchestrator, tools, memory, retrieval, guardrails, observability.

Architect an agent as seven composable layers with per-request traces.

What you'll ship

Real projects, not toy demos.

  • A FastAPI agent service where every request flows through seven named layers
  • A transport layer with Pydantic contracts, size limits, and a tiny rate limit sketch
  • A state-machine orchestrator that picks tool use, retrieval, or direct reply
  • A tool registry with whitelist validation and a structured error envelope
  • A bounded per-thread memory store with summarization hooks
  • A ChromaDB retrieval layer with citations and a re-rank extension point
  • PII guardrails that run on both input and output, with a refusal policy
  • Per-request traces with per-layer timings and a replay endpoint for debugging

What you'll learn

You finish able to:

  • Design an agent as a graph of small, testable layers instead of one monolithic function
  • Enforce request contracts at the transport layer before anything reaches the model
  • Route intents with a tiny state machine with explicit cycle-break conditions
  • Register and dispatch tools safely with schema validation and a shared error envelope
  • Keep bounded per-thread memory with a summarization path for long sessions
  • Ground answers in ChromaDB with citations and a pluggable re-rank hook
  • Scrub PII on both sides of the model and apply a refusal policy for unsafe outputs
  • Emit structured per-layer traces you can replay to debug any production request

Curriculum

Seven layers wired into one FastAPI service with replayable traces.

  1. 01

    Transport layer

    Validate every request at the door with Pydantic contracts, size caps, and versioned routes

  2. 02

    Orchestrator layer

    Build a state machine that picks tool use, retrieval, or reply, with explicit cycle-break conditions

  3. 03

    Tools layer

    Register tools behind a dispatch table with schema validation and a shared error envelope

  4. 04

    Thread memory layer

    Store per-thread conversation history with hard bounds and a summarization hook

  5. 05

    Retrieval layer

    Ground replies in ChromaDB with citations and a re-rank hook for later upgrades

  6. 06

    I/O guardrails layer

    Scrub PII on both sides of the model and apply a refusal policy for unsafe outputs

  7. 07

    Observability layer

    Emit structured per-layer traces, capture timings, and expose a replay endpoint for debugging

Who it's for

Is this for you?

AI engineers shipping agents to production

who keep finding new failure modes at 2am because their agent is one big function with no layer boundaries

Backend engineers adopting LLMs

who already know how to build clean services but have not mapped those patterns onto agent pipelines

Tech leads reviewing agent code

who need a shared vocabulary for transport, orchestration, tools, memory, retrieval, guardrails, and observability

FAQ

Common questions.

  • Do I need LangGraph or LangChain?

    No. The orchestrator is a plain Python state machine that mirrors the graph-of-nodes pattern. You will understand LangGraph better after, but the course does not depend on it.

  • Will the retrieval layer run without a vector DB?

    Yes. ChromaDB runs embedded with local Sentence Transformers. The retrieval layer also degrades gracefully if embeddings are unavailable, so the rest of the pipeline keeps serving traffic.

  • Is this about a specific LLM provider?

    No. The service uses an LLM provider pattern that works with OpenRouter, Fireworks, Gemini, or OpenAI. Any provider with async text generation works.

  • How is this different from the design patterns course?

    Design patterns teach individual building blocks. This course wires them into a single running service where every request flows through all seven layers and emits a trace. It is the production assembly of those patterns.