1
LLM
The reasoning engine
Intuition for transformers and attention, latent space, scaling laws, non-determinism, system vs. user prompts.
OST – Eastern Switzerland University of Applied Sciences
Generative AI &
Agentic Systems
From prompt to production-ready agent – in two compact days.
A hands-on intensive course for software developers, IT architects, data scientists, ML engineers and technical project leads who want to design and operate agentic systems – not just understand them.
2 days · 16 sessions8 modules · 4 pillarsHands-on · Code first
Overview
Why this course – why now?
Agentic AI is the next major step after the chatbot era. Systems that plan, use tools, remember and reflect are already changing how software is built, knowledge is unlocked and business processes are automated.
If you use LLM APIs today only as text generators, you are tapping a fraction of their potential. The real leverage lies in the architecture around them: how do you connect models to tools, give them reliable memory, let them plan and reflect – and run the whole thing securely, observably and cost-effectively in production?
That is exactly where this course comes in. We deliberately skip academic deep-learning theory and focus on what you actually need: system architecture, clean code and best practices from current enterprise AI deployments.
After two days you not only understand how an agent works – you have built, evaluated and hardened one yourself.
What you gain
Architectural clarity
Make informed decisions instead of throwing tools blindly into a ReAct loop – and know when a single agent is enough and when multi-agent makes sense.
Code you can ship
Every hands-on module delivers production-near notebooks: Function Calling, MCP, hybrid-search RAG, LangGraph topologies and an eval harness.
Production readiness & security
Learn to harden agentic systems along OWASP Top 10 for LLM Apps and evaluate them systematically with LLM-as-a-Judge.
A strategic edge
Become your team's go-to person for agentic AI – and guide use-cases from idea to stable production deployment.
Our common thread
The four pillars of agentic systems
“An agent is more than a chatbot.” We examine and build systems along these four building blocks – each gets its own module, and at the end they come together as one working system.
2
Tool Use
The agent's hands
Function calling, structured outputs with pydantic / instructor, the Model Context Protocol (MCP) as the new industry standard.
3
Memory
Long-term recall
Context engineering, token budgeting, prefix caching, rolling summarization, vector DBs and production RAG.
4
Planning
Autonomy
Task decomposition, plan-and-execute vs. ReAct, self-reflection, multi-agent orchestration with LangGraph.
Who is this course for?
This course is designed for everyone who works with hosted LLMs and APIs day-to-day and wants to design or operate production-grade agentic systems.
- Software developers
- IT architects
- Data scientists
- ML engineers
- Technical project leads
Prerequisites
- Solid Python basics (functions, classes, packages, async)
- First experience with Jupyter notebooks, REST APIs and JSON
- Basic understanding of modern LLM APIs (OpenAI, Anthropic or open source)
- Your own laptop with Python ≥ 3.10, Git, VS Code/Jupyter, optionally Docker
Optional pre-read: If you want to brush up on the math behind transformers, attention and tokenization, you'll receive a compact pre-read package (PDF + notebooks) before the course.
Program
Two days, eight modules, one clear arc
Every module follows the same rhythm: a short architecture discussion, a live demo, an extended hands-on phase in the notebook and a shared reflection.
Day 1
The foundation
LLMs, tools & long-term memory
Module 1 Pillar 1
LLMs as a reasoning engine
- Intuition for transformers and attention – without the math
- Latent space, scaling laws, non-determinism
- System vs. user prompts in practice
Module 2 Pillar 2 Hands-on
Tool use, structured outputs & MCP
- Function calling and structured outputs (pydantic / instructor)
- Model Context Protocol (MCP) as the new standard
- Hands-on: your own arXiv MCP server, wired into Claude
Module 3 Pillar 3a
Context engineering & memory management
- Token budgeting as a core architecture decision
- Prefix caching and rolling summarization
- Embeddings and vector databases (Qdrant, Pinecone)
Module 4 Memory Hands-on
Advanced RAG in production
- Hybrid search (BM25 + vector) and re-ranking
- RAG as a callable tool for the LLM
- Hands-on: production-grade RAG pipeline · outlook on GraphRAG
Day 2
Autonomy
Planning, state & multi-agent orchestration
Module 5 Pillar 4
Planning, reasoning & reflection
- Task decomposition – how AI breaks down problems
- Plan-and-execute vs. adaptive planning / ReAct
- Self-reflection & self-correction against endless loops
Module 6 Integration Hands-on
Single-agent build
- All four pillars united in one loop
- Build an autonomous research agent
- Web search + RAG from day 1 + planning / reflection
Module 7 Pillar 3b
Multi-agent teams & state management
- “Single-agent first” – avoiding premature complexity
- LangGraph topologies: sequential, concurrent, debate
- Global state, checkpointing, human-in-the-loop
Module 8 AgentOps Hands-on
Automated evaluation & security
- Eval harness along 4 metric quadrants
- LLM-as-a-Judge, context drift in long-running sessions
- OWASP Top 10 for LLM/Agentic Apps, prompt injection
What you'll be able to do
01
Cleanly separate and architecturally combine the four pillars of an agentic system
02
Design and implement your own tool integrations with function calling, structured outputs and MCP
03
Practice deliberate context engineering – keeping cost and latency under control
04
Build production-grade RAG pipelines with hybrid search and re-ranking
05
Choose deliberately between plan-and-execute and ReAct and integrate self-reflection loops
06
Model multi-agent topologies with LangGraph and avoid premature complexity
07
Evaluate agents systematically and harden them along OWASP Top 10 standards
Instructors
Experience from teaching and industry
Christoph Würsch
Professor of Physics, Mathematics and Machine Learning
OST – Eastern Switzerland University of Applied Sciences
Combines scientific depth with years of practical experience in industrial ML projects and AI-driven system development.
Shao Jü Woo
Lecturer in Data Analytics and Machine Learning
OST – Eastern Switzerland University of Applied Sciences
Focuses on pragmatic data architectures, LLM-powered applications and production-ready ML engineering workflows.
What you take home
Slide decks for all 8 modules
In PDF/beamer format – with diagrams, architecture sketches and sources.
Comprehensive course script
In German, textbook-style, with explicit mapping to the 4 pillars.
Jupyter notebooks with solutions
MCP lab, RAG lab, single-agent build, AgentOps lab – each with coach solutions.
Code repository
Configurations for local and cloud LLMs, MCP server templates, LangGraph examples.
Optional pre-read
Transformer math, attention and tokenization as PDF + notebooks.
Curated reading list
Industry and community sources that shape the enterprise agentic focus.
Registration
Invest in your AI competence
Seats are limited to guarantee intensive coaching during the hands-on phases.
Questions about the course?
Get in touch – we're happy to discuss suitability, content or in-house delivery for your team.
christoph.wuersch@ost.ch