Get in touch
← All courses

Building AI Agents in Practice

or how to integrate AI into your applications

From a hand-written agent loop to a complex, multi-agent, production-ready system: MCP, memory, observability, evals, durable execution and multi-agent coordination. We dive into the code in the very first session.

Get in touch Syllabus

AI isn't just changing how we build software, it's changing the software itself. Agents are spreading fast: software whose capabilities you extend with an AI model and the tools it can use, so it can carry out certain tasks on its own.

Putting an AI agent together isn't hard anymore. A thousand tutorials show you how to write one in twenty lines of code. Building an agent that doesn't fall over at step ten in production, doesn't forget everything after two messages, and that you actually understand, is a different game entirely.

That's what this hands-on course is about. We cover every important aspect of building AI agents, starting from a simple, hand-written agent loop and working step by step towards a complex, multi-agent, production-ready system.

8 modules

Syllabus

  1. The agent loop and tool use from scratch

    • When is a system an "agent", and when is it just a prompted LLM?
    • Defining an AI agent: LLM + loop + tools + stop condition
    • Building the Reason → Act → Observe cycle by hand, without a framework
    • Introducing tools: parameters, JSON schema, error handling
    • Conversation memory in its simplest form: context as state

  2. Agent frameworks

    • Replacing the hand-written loop with Pydantic AI: the same agent with a fraction of the code
    • When does a framework add real value, and when is it just abstraction overhead?
    • A quick comparison with the alternatives: LangGraph, CrewAI, smolagents
    • Vendor SDKs

  3. MCP servers

    • What is the Model Context Protocol, and why did it become the de facto standard?
    • The Host–Client–Server architecture in practice
    • When is MCP worth it, and when is it an unnecessary layer?
    • Building your own MCP server: exposing tools, resources and prompts
    • Connecting external, third-party MCP servers

  4. Memory and knowledge

    • Short-term and long-term memory in agents: what each one is for
    • Managing the context window at runtime: compaction, summarization and the "context rot" problem
    • Persistent memory: when you need it and how to design it
    • RAG as the long-term memory layer

  5. Observability

    • Why are agentic systems especially hard to debug?
    • Tracing in practice: following nested agent calls, tool chains and LLM calls
    • Diagnosing a real bug live: from the trace to the root cause
    • Cost and latency: how much does your system cost to run?
    • A production debugging workflow you can try at home

  6. Evals – making quality measurable

    • How do you turn "I think it got better" into a number?
    • Building a test set from three sources: hand-written cases, production traces, synthetic generation
    • Programmatic evals vs. LLM-as-judge: when to use which
    • Adversarial cases: how to test for known failure modes
    • Eval-as-CI: building evaluation into your development process

  7. Production deployment and durable agents

    • What "durable" execution means: long-running agents with checkpointing
    • What happens when the agent fails at step 60: rewind vs. restart
    • Running agents in the background and headless
    • Cost optimization: model routing (when to use a cheaper or a pricier model), prompt caching
    • Latency optimization: parallelism, early responses, speculative execution

  8. Multi-agent coordination

    • Why split an agent into parts at all, and when does it do more harm than good?
    • Subagents-as-tools
    • The orchestrator pattern: a planner-coordinator and specialist agents
    • Cross-service coordination

Interested in this course?

Drop us a line and we'll figure out how to tailor the course to your team.

Get in touch