AI Agents – Grundlagen, Architektur und Praxis
Agentische KI-Systeme verstehen, entwickeln und kontrolliert einsetzen
01 Intro
AI Agents erweitern Sprachmodelle um die Fähigkeit, selbstständig
Arbeitsschritte zu planen, Werkzeuge aufzurufen, Informationen aus externen
Systemen zu beschaffen und auf Ergebnisse ihrer Aktionen zu reagieren. Aus
einem Modell, das Antworten erzeugt, wird damit ein System, das innerhalb
definierter Grenzen Aufgaben bearbeiten und Aktionen ausführen kann.
Der Kurs vermittelt die grundlegenden Konzepte, Architekturen und
Engineering-Prinzipien agentischer KI-Systeme. Die Teilnehmer entwickeln
eigene Agenten, statten sie mit Werkzeugen und externem Wissen aus und
untersuchen unterschiedliche Formen von Planung, Zustandsverwaltung und
Zusammenarbeit mehrerer Agenten. Ebenso wichtig sind die Grenzen agentischer
Autonomie: Berechtigungen, technische Guardrails, Beobachtbarkeit und
kontrollierte Eskalation werden deshalb von Beginn an als Bestandteil der
Architektur behandelt.
Kurs-ID
AI-007
Dauer
3 Tage
Format
Präsenz · Live Online · Inhouse
Vorkenntnisse
Grundkenntnisse generativer KI und praktische Programmiererfahrung, vorzugsweise mit Python
02 Trainingsprogramm
Inhalte
Vom Sprachmodell zum Agenten
- Sprachmodell und AI Agent
- Antworten und Handlungen
- Ziel und Aufgabe
- Kontext
- Zustand
- mehrstufige Bearbeitung
Agent oder Workflow?
- deterministische Workflows
- LLM-gestützte Workflows
- agentische Entscheidungen
- feste und dynamische Abläufe
- kontrollierbare Prozessketten
- einfachste geeignete Architektur wählen
Architektur und Agent Loop
- Aufgabe entgegennehmen
- aktuellen Zustand bewerten
- nächsten Schritt bestimmen
- Tool auswählen
- Aktion ausführen
- Abschluss oder Fortsetzung
Aufgaben, Ziele und Planung
- Zielzustand
- Randbedingungen
- verfügbare Informationen
- erlaubte Aktionen
- Erfolgskriterien
- Eskalationsbedingungen
Tools und strukturierte Schnittstellen
- Fähigkeiten eines Agenten erweitern
- Funktionen als Werkzeuge
- Tool-Beschreibungen
- Parameter
- strukturierte Ein- und Ausgaben
- Tool-Auswahl durch das Modell
Model Context Protocol
- Zweck von MCP
- MCP Server und Client
- Tools
- Resources
- zusätzliche Kontextquellen
- MCP als Integrationsschicht
Zustand, Memory und externes Wissen
- Modellwissen und Anwendungswissen
- Dokumente
- Datenbanken
- Suchsysteme
- Retrieval
- Aktualität
RAG und Kontextmanagement
- begrenztes Kontextfenster
- relevante Informationen auswählen
- Tool-Ergebnisse
- Gesprächsverlauf
- Dokumente
- Kontext nicht unkontrolliert wachsen lassen
Subagents und Multi-Agent-Systeme
- koordinierender Agent
- spezialisierte Rollen
- Übergabe von Aufgaben
- parallele Bearbeitung
- gemeinsame und getrennte Zustände
- Fehlerfortpflanzung
Orchestrierung und Human in the Loop
- Mensch als Informationsquelle
- Mensch als Entscheider
- Freigaben
- Rückfragen
- Eskalationen
- unnötige Unterbrechungen vermeiden
Autonomie, Berechtigungen und Trust Boundaries
- Modell
- Agent Runtime
- Tools
- externe Daten
- Benutzer
- vertrauenswürdige und nicht vertrauenswürdige Komponenten
Technische Guardrails
- Regeln außerhalb des Sprachmodells
- Eingabevalidierung
- Tool Policies
- Allow- und Deny-Listen
- Wrapper
- Freigabemechanismen
Prompt Injection und untrusted Content
- direkte Prompt Injection
- indirekte Prompt Injection
- externe Dokumente
- Webseiten
- E-Mails
- Instruktionen allein sind keine Sicherheitsgrenze
Fehlerbehandlung und Abbruchbedingungen
- Tool nicht verfügbar
- ungültige Parameter
- Timeout
- externe Fehler
- widersprüchliche Informationen
- Eskalation
Verifikation, Tests und Evaluation
- Agent behauptet Erfolg
- tatsächlichen Zustand prüfen
- deterministische Prüfungen
- Regeln und Invarianten
- externe Referenzen
- Verifikation als eigener Prozessschritt
Observability und Audit
- Agentenlauf nachvollziehen
- Modellaufrufe
- Tool Calls
- Parameter
- Ergebnisse
- Laufzeiten und Kosten
Kosten und Performance
- Anzahl der Modellaufrufe
- Modellwahl
- Kontextgröße
- Tool-Aufrufe
- Retries
- Kosten und Nutzen messen
Produktionsarchitektur
- Agent Runtime
- Model Provider
- Tool Layer
- State Store
- Knowledge Layer
- klare Verantwortlichkeiten zwischen den Komponenten
Praxis: einen belastbaren Agenten entwerfen
- Anwendungsfall auswählen
- Ziel definieren
- Umgebung bestimmen
- benötigte Informationen
- benötigte Tools
- Sicherheits- und Qualitätsgrenzen
03 Durchführung
Rahmen und Organisation
Dauer
3 Tage
Durchführung
Präsenz oder Live Online, vorzugsweise als Inhouse-Schulung
Schwerpunkt
Inhouse-Schulungen für Unternehmen und Teams
Sprache
Deutsch, englische Fachbegriffe und Dokumentation
Unterlagen
Kursunterlagen, Beispiele und Übungsaufgaben
Technik
Eigener Rechner mit Entwicklungsumgebung und Zugang zu einem aktuellen Sprachmodell
Inhouse-Schulungen
Interne APIs, Datenquellen, MCP-Server oder typische Geschäftsprozesse
können als Grundlage für die praktischen Agenten verwendet werden.
04 Zielgruppe
Für wen ist der Kurs gedacht?
Der Kurs richtet sich an Softwareentwickler, Softwarearchitekten, AI Engineers und technische Consultants, die agentische KI-Systeme verstehen, entwickeln oder in bestehende Anwendungen und Prozesse integrieren möchten.
Er eignet sich sowohl für Teilnehmer, die erste eigene Agenten entwickeln wollen, als auch für Teams, die bereits mit agentischen Frameworks oder Produkten experimentieren und die zugrunde liegenden Architektur- und Engineering-Prinzipien systematisch verstehen möchten.
Voraussetzungen
Praktische Programmiererfahrung wird vorausgesetzt; die Übungen können
vorzugsweise mit Python durchgeführt werden. Grundkenntnisse über
generative KI und Sprachmodelle werden erwartet. Spezielle Kenntnisse
eines Agentenframeworks oder eines bestimmten Modellanbieters sind nicht
erforderlich.
05 Lernziele
Was Sie nach dem Kurs können
Nach dem Kurs können die Teilnehmer:
- AI Agents von Sprachmodellen, Assistenten und klassischen Workflows abgrenzen
- den Aufbau eines agentischen Systems erklären
- geeignete Anwendungsfälle für Agenten identifizieren
- Agent Loops und Planungsmechanismen entwickeln
- Tools für Agenten entwerfen und implementieren
- strukturierte Tool-Aufrufe validieren
- MCP zur Integration externer Fähigkeiten einsetzen
- Zustand, Kontext und Memory unterscheiden und gestalten
- externes Wissen und Retrieval integrieren
- Single- und Multi-Agent-Architekturen einordnen
- Human-in-the-Loop und unterschiedliche Autonomiegrade gestalten
- Berechtigungen und Trust Boundaries definieren
- technische Guardrails außerhalb des Modells implementieren
- Prompt-Injection- und Tool-Risiken berücksichtigen
- Fehler- und Abbruchstrategien entwickeln
- Agenten beobachtbar und auditierbar machen
- agentische Systeme systematisch testen und evaluieren
- Kosten und Performance berücksichtigen
- einen Agenten vom Prototyp zu einer belastbaren Architektur weiterentwickeln
06 FAQ
Häufige Fragen
Was unterscheidet diesen Kurs von Agentic Software Development?
Dieser Kurs behandelt AI Agents als allgemeine Systemarchitektur. Die Beispiele können aus unterschiedlichen Anwendungsgebieten stammen; behandelt werden Agent Loops, Tools, Zustand, Memory, Retrieval, MCP, Multi-Agent-Systeme, Sicherheit, Evaluation und Produktionsarchitektur.
Agentic Software Development konzentriert sich ausschließlich auf den Einsatz solcher Konzepte in der Softwareentwicklung: Coding Agents, Repositories, Entwicklungswerkzeuge, Git, Tests und Quality Gates stehen dort im Mittelpunkt.
Was unterscheidet einen Agenten von einem normalen LLM-Chat?
Ein Chat erzeugt zunächst Antworten auf Eingaben. Ein Agent kann darüber hinaus innerhalb eines mehrstufigen Ablaufs seinen nächsten Arbeitsschritt bestimmen, Werkzeuge verwenden, deren Ergebnisse auswerten und weitere Aktionen auslösen.
Muss ein Agent autonom arbeiten?
Nein. Autonomie ist kein Selbstzweck. Je nach Aufgabe kann ein Agent lediglich Vorschläge machen, einzelne Aktionen nach Freigabe durchführen oder innerhalb klarer Grenzen selbstständig arbeiten.
Brauche ich ein Agentenframework?
Nein. Gerade für das Verständnis der grundlegenden Mechanismen ist es hilfreich, zunächst einen einfachen Agent Loop und die Tool-Anbindung selbst zu entwickeln. Frameworks können anschließend dort eingesetzt werden, wo sie tatsächlich einen Vorteil bieten.
Wird MCP behandelt?
Ja. MCP wird als standardisierte Möglichkeit behandelt, Agenten mit Werkzeugen und zusätzlichen Informationsquellen zu verbinden. Dabei geht es sowohl um die Nutzung als auch um die Gestaltung geeigneter Tool-Schnittstellen.
Wird RAG behandelt?
Ja, aber aus Sicht eines Agentensystems: Retrieval ist eine mögliche Fähigkeit eines Agenten. Aufbau und Optimierung komplexer RAG-Systeme sind nicht Schwerpunkt dieses Kurses.
Werden Multi-Agent-Systeme behandelt?
Ja. Der Kurs behandelt Subagents, spezialisierte Rollen, Orchestrierung und parallele Bearbeitung. Ebenso wichtig ist die Frage, wann mehrere Agenten gegenüber einem einzelnen Agenten überhaupt einen Vorteil bieten.
Wird Sicherheit praktisch behandelt?
Ja. Berechtigungen, Trust Boundaries, Prompt Injection, Tool Policies und technische Guardrails sind Bestandteile der Übungen. Sicherheitsgrenzen sollen dabei nicht ausschließlich durch Instruktionen an das Sprachmodell entstehen.
Wird ein bestimmtes LLM vorausgesetzt?
Nein. Die vermittelten Konzepte sind grundsätzlich modell- und anbieterunabhängig. Für die praktischen Übungen wird ein geeignetes aktuelles Modell verwendet.
Was unterscheidet den Kurs von einer Framework-Schulung?
Der Kurs vermittelt Agent Engineering und keine Framework-API. Frameworks ändern sich vergleichsweise schnell; Agent Loops, Tool-Schnittstellen, Zustandsmanagement, Trust Boundaries, Verifikation und Evaluation bleiben dagegen grundlegende Architekturthemen.
Warum dauert der Kurs drei Tage?
Der Kurs umfasst sowohl die Entwicklung eines funktionsfähigen Agenten als auch die wesentlichen Architekturthemen für einen kontrollierten Einsatz: Tools, Zustand, MCP, Multi-Agent-Konzepte, Sicherheit, Verifikation und Evaluation. Drei Tage ermöglichen, diese Themen praktisch zu erarbeiten, ohne in die Spezialisierungen der weiterführenden Kurse auszuweichen.
Kann der Kurs an einen konkreten Anwendungsfall angepasst werden?
Ja. Bei Inhouse-Schulungen können beispielsweise interne APIs, Datenquellen, MCP-Server oder typische Geschäftsprozesse als Grundlage für die praktischen Agenten verwendet werden.