Skip to content

Bottom-Up Agent Architecture & Mechanics, Generative AI ​

A large language model cannot act by itself. You give it a context, it works over that context, and it returns text. Building an agent on top of such a model, one that can plan, call tools, keep state, and act safely, is an engineering problem. That is what this course covers.

This manual is the architecture reference for the course. It is organized bottom-up: it starts with the model engine and moves up through the layers that shape agent behavior, ending with the practices that keep agents reliable in production. Each layer is presented as the solution to the problem of the layer above it, with its own details hidden, so you can read the architecture cleanly from the bottom.

I give this course at ESISAR (Grenoble INP UGA) in the fall of 2026. The chapters below are the supporting material for it.

Use it in three ways:

  1. First read: read it top to bottom to build the full mental model.
  2. Design reference: use the layer chapters as a reference when you design an agent.
  3. Debugging reference: use the failure-mode and observability chapters when an agent misbehaves.

When you implement, look at mature frameworks such as LangGraph and smolagents to see how these ideas show up in real systems. This manual intentionally leaves out implementation code. The goal is to understand the architecture first.

Chapters ​

  1. Objectives
  2. Core Mental Model
  3. Layered Architecture Map
  4. What Is an Agent?
  5. Layer 0: Model Engine
  6. Layer 1: Context & Messages
  7. Layer 2: Structured Output
  8. Layer 3: Tools & Actions
  9. Layer 4: Control Loop
  10. Layer 5: Memory & State
  11. Layer 6: Guardrails & Safety
  12. Layer 7: Observability & Evaluation
  13. Building a Simple Agent: Architecture Procedure
  14. How Performance Is Determined
  15. From One Agent to Many
  16. Production Deployment Checklist

Appendices ​