Architektur-Referenzmodelle für Agentic AI
Wissen
Es gibt kein einheitliches Architekturmodell für Agentic AI — aber mehrere Referenzmodelle, die in der Community häufig zitiert werden. Alle beschreiben im Kern dieselben Bausteine, nur unterschiedlich geschichtet.
Die gemeinsamen Bausteine
Unabhängig vom Modell tauchen immer dieselben Schichten auf:
- Interface — Wie der Nutzer (oder Trigger) mit dem System interagiert: CLI, Chat-UI, Webhook, Cron
- Orchestration / Framework — Die Steuerungslogik: Welcher Agent wird wann aufgerufen? (LangChain, CrewAI, Claude Code)
- LLM / Model — Das Sprachmodell das denkt: Claude, GPT, Gemini, Ollama
- Context / Memory — agents.md, Vektor-Datenbanken, Session-Speicher
- Tools / MCP — Die Werkzeuge: Shell, Filesystem, Git, APIs, Datenbanken
- Output — Was am Ende entsteht: Code, PR, Chat-Antwort, Doku, Tickets
Referenzmodell 1: 6-Schichten-Modell
Ein detailliertes Modell, das jede Schicht explizit trennt:
| Schicht | Funktion | Beispiel |
|---|---|---|
| Application | Benutzeroberfläche, Trigger | IDE, Chat-UI, Webhook |
| Orchestration | Workflow-Steuerung, Agent-Koordination | LangGraph, CrewAI |
| Agent | Reasoning, Planung, Entscheidungen | ReAct-Loop, Plan-and-Execute |
| Context | Kontext-Management, Memory | agents.md, Vektor-DB, RAG |
| Data | Datenzugriff, Persistenz | PostgreSQL, Pinecone, S3 |
| Model | LLM-Inferenz | Claude Opus, GPT-5, Ollama |
Stärke: Macht die Context- und Data-Schicht explizit — wichtig für RAG-basierte Systeme und Enterprise-Setups mit Session-Management.
Referenzmodell 2: LAMP-Stack für AI (4 Schichten)
Angelehnt an den klassischen LAMP-Stack (Linux, Apache, MySQL, PHP) — eine kompaktere Variante:
| Schicht | Analogie zu LAMP | Funktion |
|---|---|---|
| LLM | Linux (Basis) | Das Fundament: Sprachmodell |
| Agent/App-Logik | Apache (Verarbeitung) | Orchestration, Routing, Business-Logik |
| MCP-Gateway | MySQL (Daten) | Werkzeugzugriff über MCP-Protokoll |
| Persistenz | PHP (Interface) | Datenhaltung, Memory, State |
Stärke: Kompakt und leicht verständlich. Frontend ist Teil der App-Logik. Kein separater Output-Layer.
Referenzmodell 3: Pragmatischer Flow
Das einfachste Modell — ein linearer Flow:
Chat-Frontend → Agent → LLM-Provider (austauschbar) → MCP-Tools → Output
Stärke: Zeigt das Wesentliche: Provider und Tools sind austauschbar. Der Agent ist die zentrale Koordinationsinstanz.
Verstehen
Wann welches Modell passt
| Use Case | Empfohlenes Modell | Warum |
|---|---|---|
| Einfacher Coding-Agent | Pragmatischer Flow | Wenige Komponenten, kein aufwendiges Context-Management |
| RAG-basierter Wissens-Agent | 6-Schichten | Context- und Data-Schicht müssen explizit geplant werden |
| Enterprise CI/CD-Agent | LAMP-Stack | Klare Trennung, MCP-Gateway als zentrale Tool-Schicht |
| Multi-Agent-Orchestrierung | 6-Schichten | Orchestration-Schicht muss explizit sein |
Zwei Betriebsmodi
Jedes dieser Modelle kann in zwei Modi betrieben werden:
Mit User Input: Ein Mensch löst den Prozess aus (CLI, Chat, IDE). Der Agent arbeitet interaktiv, fragt bei Unsicherheiten nach, präsentiert Ergebnisse.
Vollautomatisch: Ein Trigger (Cron, Webhook, Event-Stream) startet den Prozess. Der Agent arbeitet autonom — Code Review bei jedem MR, Doku bei jedem Deploy, Monitoring rund um die Uhr.
iKein 'richtiges' Modell
Diese Referenzmodelle sind Denkwerkzeuge, keine Standards. In der Praxis vermischen sie sich. Wichtig ist, dass du die Bausteine verstehst — die Schichtung ist zweitrangig.
Anwenden
Wenn du eine Agentic-AI-Architektur entwirfst, starte mit diesen Fragen:
- Wer löst aus? Mensch oder Trigger? → bestimmt das Interface
- Wie viele Agents? Einer oder mehrere? → bestimmt die Orchestration
- Welcher Kontext? Nur Prompt oder auch RAG/Memory? → bestimmt die Context-Schicht
- Welche Tools? Nur Filesystem oder auch APIs/DBs? → bestimmt die MCP-Schicht
- Welches Modell? Brauche ich Opus oder reicht Haiku? → bestimmt die Kosten
Reflektieren
Architektur-Referenzmodelle geben dir eine gemeinsame Sprache für die Planung von Agentic-AI-Systemen. Die Bausteine sind immer dieselben — Interface, Orchestration, LLM, Context, Tools, Output. Wie du sie schichtest, hängt von deinem Use Case ab.