Warum Schichtenmodelle wichtig sind

Agenten ohne Framework zu bauen ist wie ein Haus ohne Bauplaene zu bauen -- moeglich, aber Sie werden es bereuen.

Schichtenmodelle helfen Ihnen:

• Verantwortlichkeiten trennen (Routing vs. Reasoning vs. Aktion)
• Identifizieren, was selbst gebaut vs. eingekauft wird
• Einzelne Komponenten unabhaengig skalieren
• Probleme durch Isolierung der fehlerhaften Schicht debuggen
• Architekturentscheidungen an Stakeholder kommunizieren

Die Branche hat sich auf mehrere komplementaere Modelle geeinigt. Sie zu verstehen hilft Ihnen, die richtige Architektur fuer Ihren Anwendungsfall zu waehlen.

Die Boomi-Agenten-Architektur

Boomis Modell konzentriert sich auf Enterprise-Integration:

+----------------------------------+
|  Schicht 5: Benutzeroberflaeche  |  Chat, API, Trigger
+----------------------------------+
|  Schicht 4: Orchestrierung       |  Aufgabenplanung, Routing
+----------------------------------+
|  Schicht 3: Agent-Runtime        |  LLM-Aufrufe, Tool-Nutzung, Speicher
+----------------------------------+
|  Schicht 2: Integration          |  APIs, Datenbanken, Dateisysteme
+----------------------------------+
|  Schicht 1: Fundament            |  Auth, Logging, Monitoring
+----------------------------------+

Zentrale Erkenntnis: Die Integrationsschicht (Schicht 2) ist dort, wo die meiste Enterprise-Komplexitaet liegt. Agenten mit ERP-Systemen, CRMs und Legacy-Datenbanken zu verbinden ist schwerer als der KI-Teil.

Der Vendia LAMP-Stack

Vendia schlaegt den LAMP-Stack fuer agentische KI vor (eine Anspielung auf den klassischen Linux-Apache-MySQL-PHP):

Buchstabe	Komponente	Zweck
L	LLM	Die Reasoning-Engine
A	Agents	Aufgabenausfuehrung und Tool-Nutzung
M	Memory	Kontextpersistenz ueber Sitzungen hinweg
P	Platform	Infrastruktur, Sicherheit, Compliance

Memory ist das Unterscheidungsmerkmal. Ohne persistenten Speicher:

• Agent vergisst alles zwischen Sitzungen
• Kein Lernen aus vergangenen Fehlern
• Kann kein institutionelles Wissen aufbauen
• Jede Interaktion beginnt bei Null

Speichertypen:

• Kurzzeitgedaechtnis: Aktueller Konversationskontext (Kontextfenster)
• Langzeitgedaechtnis: Vektordatenbanken, Wissensgraphen, AGENTS.md
• Episodisch: Protokolle vergangener Interaktionen und Entscheidungen

Das Mezmo AURA-Framework

Mezmos AURA-Modell (Agent Understanding and Reasoning Architecture):

+---------------------------------------+
|  A -- Awareness                        |
|  Welche Datenquellen und Tools gibt es?|
|  Erkennung, Registry, Faehigkeiten    |
+---------------------------------------+
|  U -- Understanding                    |
|  Was braucht der Nutzer?               |
|  Intent-Parsing, Kontextaufbau         |
+---------------------------------------+
|  R -- Reasoning                        |
|  Wie sollen wir das loesen?            |
|  Planung, Zerlegung, Strategie         |
+---------------------------------------+
|  A -- Action                           |
|  Den Plan ausfuehren                   |
|  Tool-Aufrufe, API-Anfragen, Ausgaben  |
+---------------------------------------+

AURA betont die "Vorher"-Phase -- verstehen, was verfuegbar ist und was benoetigt wird, bevor gehandelt wird. Viele Agenten-Fehler passieren, weil der Agent handelt, ohne ausreichend zu verstehen.

Workshop-5-Schichten-Modell

Ein praktisches Modell, das auf Implementierung ausgelegt ist:

Schicht 1 -- Interface

• Wie Nutzer interagieren: Chat, API, CLI, Event-Trigger
• Authentifizierung und Autorisierung

Schicht 2 -- Routing

• Aufgabenklassifikation: Welcher Agent bearbeitet das?
• Modellauswahl: Welches LLM fuer diese Aufgabe?
• Prioritaets- und Warteschlangenmanagement

Schicht 3 -- Reasoning

• LLM-Aufrufe mit System-Prompts und Kontext
• Chain-of-Thought, Planung, Zerlegung
• Entscheidungsfindung: handeln oder Klaerung anfragen?

Schicht 4 -- Execution

• Tool-Nutzung: Datei-I/O, API-Aufrufe, Datenbankabfragen
• MCP-Verbindungen zu externen Systemen
• Fehlerbehandlung und Wiederholungslogik

Schicht 5 -- Observation

• Ergebnisse der Aktionen pruefen
• Mit erwarteten Ergebnissen vergleichen
• Ergebnisse an Schicht 3 zur Iteration zurueckspeisen
• Alles fuer Debugging und Verbesserung protokollieren

Die Feedback-Schleife zwischen Schicht 5 (Observation) und Schicht 3 (Reasoning) ist das, was Agenten selbstkorrigierend macht.

Die Modelle im Vergleich

Jedes Modell betont unterschiedliche Aspekte:

Modell	Staerke	Am besten fuer
Boomi	Enterprise-Integration	Agenten mit Legacy-Systemen verbinden
Vendia LAMP	Speicher und Persistenz	Agenten, die lernen und sich verbessern
Mezmo AURA	Verstehen vor dem Handeln	Komplexe Entscheidungsfindung
Workshop 5-Schichten	Praktische Implementierung	Ihren ersten Agenten bauen

In der Praxis werden Sie Elemente aus allen Modellen mischen. Kein einzelnes Framework deckt jedes Szenario perfekt ab. Nutzen Sie sie als Denkwerkzeuge, nicht als starre Vorlagen.

Ihre Architektur waehlen

Entscheidungsframework fuer Ihr agentisches System:

Ist es ein Einzelaufgaben-Agent? (z.B. Code-Reviewer)
|-- JA -> Einfach 3-Schichten: Interface -> Reasoning -> Execution
+-- NEIN -> Multi-Aufgaben-Agent?
           |-- JA -> Workshop 5-Schichten mit Routing
           +-- NEIN -> Multi-Agent-System?
                      |-- JA -> Orchestrator + spezialisierte Agenten
                      +-- NEIN -> Einfacher beginnen bis Sie mehr brauchen

Haeufiger Fehler: Die Architektur ueberengineeren, bevor man einen funktionierenden Prototyp hat. Beginnen Sie mit der einfachsten Architektur, die funktioniert, und fuegen Sie dann nach Bedarf Schichten hinzu.

Bauen Sie das Einfachste, das funktionieren koennte. Dann iterieren Sie.

---quiz question: Was ist die zentrale Erkenntnis aus dem Vendia LAMP-Modell? options:

• { text: "LLMs sind die wichtigste Komponente", correct: false }
• { text: "Memory (Persistenz ueber Sitzungen hinweg) ist das Unterscheidungsmerkmal -- ohne sie koennen Agenten nicht lernen oder Wissen aufbauen", correct: true }
• { text: "Agenten sollten immer dieselbe Plattform nutzen", correct: false } feedback: Das LAMP-Modell hebt Memory als entscheidendes Unterscheidungsmerkmal hervor. Ohne persistenten Speicher beginnt jede Agenten-Interaktion bei Null -- kein Lernen, keine Verbesserung, kein institutionelles Wissen.

---quiz question: Was erzeugt im Workshop-5-Schichten-Modell das selbstkorrigierende Verhalten von Agenten? options:

• { text: "Die Interface-Schicht, die Nutzer um Korrekturen bittet", correct: false }
• { text: "Die Feedback-Schleife zwischen der Observation-Schicht und der Reasoning-Schicht", correct: true }
• { text: "Die Routing-Schicht, die zu besseren Modellen wechselt", correct: false } feedback: Die Observation-Schicht prueft die Ergebnisse der Aktionen und speist sie zurueck in die Reasoning-Schicht. Diese Schleife ermoeglicht es Agenten, Fehler zu erkennen, ihren Ansatz anzupassen und es erneut zu versuchen -- was sie selbstkorrigierend macht.

---quiz question: Was ist der haeufigste Architekturfehler beim Bauen agentischer Systeme? options:

• { text: "Zu wenige Schichten verwenden", correct: false }
• { text: "Die Architektur ueberengineeren, bevor man einen funktionierenden Prototyp hat", correct: true }
• { text: "Das Boomi-Modell nicht verwenden", correct: false } feedback: Beginnen Sie mit der einfachsten Architektur, die funktioniert, und fuegen Sie dann nach Bedarf Komplexitaet hinzu. Viele Teams verschwenden Wochen mit dem Design aufwaendiger Multi-Agent-Systeme, obwohl ein einzelner Agent mit 3 Schichten ihr Problem loesen wuerde.