DAGE Security Architecture Model

Executive Summary

Das DAGE Security Architecture Model beschreibt eine lokale Security-by-Design-Sicherheitsarchitektur für KI-Agentensysteme mit strikt deterministischer Rechte- und Tool-Kontrolle (Weiche).

Der Ansatz verfolgt nicht das Ziel, probabilistische Sprachmodelle vollständig kontrollierbar zu machen. Stattdessen werden sicherheitskritische Entscheidungen konsequent aus dem Modell ausgelagert und ausschließlich durch kontrollierte Systemlogik verarbeitet.

Der Ansatz eignet sich insbesondere für:

• lokale Unternehmenssysteme
• technische Informationssysteme
• datenschutzkritische Umgebungen
• kontrollierte KI-Assistenten
• lokale Offline-KI-Systeme
• agentische Unternehmensanwendungen mit erhöhten Sicherheitsanforderungen

Architekturübersicht

Überblick über das DAGE Security Architecture Model mit deterministischer Kontrollinstanz, isoliertem Sprachmodell und kontrollierter Ressourcenfreigabe.

Zusammenfassung

Moderne KI-Agentensysteme basieren häufig auf großen Sprachmodellen mit erweiterten Fähigkeiten zum Zugriff auf Dateien, Datenbanken, APIs, Unternehmensdaten und externe Werkzeuge.

Die Durchsetzung von Sicherheitsgrenzen erfolgt dabei in vielen aktuellen Systemen primär auf Prompt- und Instruktionsebene innerhalb des Sprachmodells selbst. Dadurch entstehen grundlegende Risiken hinsichtlich Prompt Injection, Kontextmanipulation, unzulässiger Datenzugriffe sowie unkontrollierter Tool-Ausführungen.

Zusätzlich können insbesondere agentische Systeme mit gemeinsam genutzten Kontexten oder unzureichender Sitzungsisolation potenziell anfällig für unbeabsichtigte Offenlegung vertraulicher Benutzer- oder Unternehmensinformationen sein.

Unklare Kontexttrennungen, gemeinsam genutzte Speicherstrukturen oder nicht deterministisch kontrollierte Agentenkommunikation können hierbei dazu führen, dass Informationen zwischen unterschiedlichen Benutzern, Projekten oder Berechtigungsbereichen unzulässig übertragen werden.

Das DAGE Security Architecture Model verfolgt einen alternativen Architekturansatz, bei dem das Sprachmodell keinerlei direkte Systemrechte besitzt. Sämtliche Zugriffe auf Dateien, APIs, Prozesse oder externe Ressourcen erfolgen ausschließlich über ein deterministisches Gateway-System mit expliziter Rechteprüfung und kontrollierter Tool-Ausführung.

Das Sprachmodell kann innerhalb der Architektur ausschließlich textbasierte Tool-Anfragen formulieren. Die tatsächliche Autorisierung und Ausführung verbleibt vollständig außerhalb des LLM.

Problemdefinition

Große Sprachmodelle und autonome KI-Agenten ermöglichen zunehmend komplexe Interaktionen mit Unternehmensdaten, lokalen Dateisystemen, externen Diensten und automatisierten Werkzeugketten.

Gleichzeitig entsteht ein grundlegendes Sicherheitsproblem: Die Durchsetzung von Zugriffsgrenzen, Datenschutzregeln und Handlungsbeschränkungen erfolgt in vielen aktuellen Systemen primär auf Prompt- und Instruktionsebene innerhalb des Sprachmodells selbst.

Da große Sprachmodelle probabilistische Systeme darstellen, kann die zuverlässige Einhaltung definierter Sicherheitsregeln innerhalb des Modells nicht deterministisch garantiert werden.

Insbesondere agentische Systeme mit erweiterten Werkzeug- und Datenzugriffen sind dadurch potenziell anfällig für:

• Prompt Injection
• indirekte Kontextmanipulation
• unzulässige Datenoffenlegung
• Überschreitung definierter Berechtigungen
• unkontrollierte Systemaktionen
• unzureichende Benutzer- und Kontextisolation
• unbeabsichtigte Vermischung von Informationen aus unterschiedlichen Kontexten

Ein weiteres Risiko besteht in der unbeabsichtigten Vermischung von Informationen aus unterschiedlichen Benutzern, Projekten, Datenquellen oder Berechtigungskontexten. Solche Kontextvermischungen können dazu führen, dass Inhalte in Antworten erscheinen, die aus Sicht der jeweiligen Benutzer- oder Projektberechtigung irrelevant oder nicht zugänglich sein dürften.

Das DAGE Security Architecture Model verfolgt daher einen alternativen Sicherheitsansatz, bei dem sicherheitskritische Entscheidungen vollständig außerhalb des Sprachmodells in eine deterministische Kontrollinstanz ausgelagert werden, während sämtliche Kontextdaten benutzerbezogen isoliert gespeichert und ausschließlich nach deterministischen Berechtigungsregeln angereichert werden.

Architekturprinzip

Das DAGE Security Architecture Model trennt die semantische Verarbeitung durch das Sprachmodell strikt von sämtlichen sicherheitskritischen Systemfunktionen.

Das Sprachmodell dient innerhalb der Architektur ausschließlich als probabilistische Verarbeitungs- und Entscheidungsinstanz für natürliche Sprache.

Direkte Zugriffe auf folgende Ressourcen sind für das Modell zu keinem Zeitpunkt möglich:

• Dateien
• Datenbanken
• APIs
• Netzwerkressourcen
• Betriebssystemfunktionen
• externe Prozesse

Sämtliche Kommunikation zwischen Benutzer und Sprachmodell erfolgt ausschließlich über das DAGE-System als deterministische Vermittlungsinstanz.

Das DAGE-System übernimmt insbesondere:

• Benutzeridentifikation
• Sitzungsverwaltung
• Verwaltung des Chat-Kontexts
• Berechtigungsprüfung
• Tool-Validierung
• Parameterprüfung
• Ressourcenbegrenzung
• Protokollierung
• deterministische Ausführung erlaubter Aktionen

Das Sprachmodell selbst besitzt keinerlei direkte Ausführungsrechte. Es kann ausschließlich textbasierte Tool-Anfragen formulieren, deren Ausführung vollständig durch das DAGE-System kontrolliert wird.

Nicht erlaubte oder unbekannte Tool-Aufrufe werden deterministisch zurückgewiesen und nicht ausgeführt.

Dadurch entsteht eine klare Trennung zwischen probabilistischer Sprachverarbeitung innerhalb des LLM und deterministischer Sicherheits- und Rechtekontrolle innerhalb des DAGE-Systems.

Architekturdiagramm

+-------------------+
|       User        |
+-------------------+
          |
          v
+-------------------+
|    DAGE-System    |
|-------------------|
| - User-ID         |
| - Rechteprüfung   |
| - Kontextkontrolle|
| - Tool-Kontrolle  |
| - Logging         |
| - Human Approval  |
+-------------------+
          |
          v
+-------------------+
|        LLM        |
|    nur Text       |
+-------------------+
          |
          v
 Tool-Request als Text
          |
          v
+-------------------+
|    DAGE-System    |
|-------------------|
| deterministische  |
| Tool-Prüfung      |
+-------------------+
          |
          v
+-------------------+
| Tools / Ressourcen|
|-------------------|
| Dateien           |
| Datenbanken       |
| APIs              |
| OCR               |
| Prozesse          |
| UI-Steuerung      |
+-------------------+
          |
          v
+-------------------+
|    DAGE-System    |
|-------------------|
| Tool-Ergebnis     |
|Kontextanreicherung|
+-------------------+
          |
          v
+-------------------+
|        LLM        |
| formuliert Antwort|
+-------------------+
          |
          v
+-------------------+
|    DAGE-System    |
|-------------------|
| Ausgabe an User   |
| Protokollierung   |
+-------------------+
          |
          v
+-------------------+
|       User        |
+-------------------+

Das DAGE-System kann Tool-Ergebnisse an das LLM zurückführen, jedoch ausschließlich als kontrollierten Kontext. Die finale Antwort wird anschließend vom LLM formuliert und wiederum ausschließlich über das DAGE-System an den Benutzer ausgeliefert.

Benutzer- und Kontextisolation

Jede Kommunikation innerhalb des DAGE-Systems erfolgt auf Basis einer eindeutig identifizierten Benutzer-ID.

Die Benutzeridentifikation kann beispielsweise über lokale Benutzerkonten, Anmeldesysteme, Chat-Systeme, E-Mail-Gateways oder andere kontrollierte Zugangskanäle erfolgen.

Sämtliche Dialoge werden strikt benutzerbezogen verarbeitet. Jeder Benutzer besitzt einen isolierten Kommunikationskontext, auf den ausschließlich innerhalb der jeweiligen Sitzung zugegriffen wird.

Das DAGE-System verwaltet den vollständigen Chat-Verlauf deterministisch außerhalb des Sprachmodells.

Das Sprachmodell selbst besitzt keinen direkten Zugriff auf:

• fremde Benutzerkontexte
• gespeicherte Dialogverläufe
• Systemdateien
• Berechtigungsinformationen
• persistente Datenstrukturen

Der vollständige Kontext wird ausschließlich durch das DAGE-System kontrolliert, zusammengesetzt und an das Sprachmodell übergeben.

Hierdurch entsteht eine vollständige Isolation zwischen unterschiedlichen Benutzersitzungen.

Ein unzulässiger Zugriff auf fremde Benutzerkontexte kann weder durch direkte Prompt-Manipulation noch durch Tool-Aufrufe erfolgen, da sämtliche Kontext- und Ressourcenfreigaben ausschließlich deterministisch durch das DAGE-System kontrolliert werden.

Das System-Prompt selbst bleibt dabei außerhalb des Einflussbereichs des Benutzers sowie des Sprachmodells unveränderlich und wird ausschließlich durch das DAGE-System verwaltet.

Deterministische Kontextkontrolle

Das DAGE Security Architecture Model kontrolliert nicht nur die Ausführung von Werkzeugen, sondern bereits den sicherheitsrelevanten Kontext, den das Sprachmodell überhaupt erhält.

Hierzu gehören insbesondere:

• System-Prompts
• Benutzerisolation
• RAG-Abfragen
• Speicher- und Memory-Zugriffe
• Dokumenteneinbindung
• Tool-Ergebnisse
• Kontextzusammenstellung
• Dialogverlauf
• Einbindung externer Wissensquellen

Das Sprachmodell bestimmt, verändert oder autorisiert seinen sicherheitsrelevanten Kontext zu keinem Zeitpunkt selbst.

Die vollständige Kontextbildung und Kontextfilterung erfolgt deterministisch durch das DAGE-System.

Deterministische Tool-Architektur

Das DAGE-System verwendet eine strikt deterministische Tool-Architektur zur kontrollierten Erweiterung der Fähigkeiten des Sprachmodells.

Das Sprachmodell selbst besitzt keinerlei direkte Möglichkeit:

• Dateien zu lesen oder zu verändern
• Datenbankabfragen auszuführen
• Netzwerkzugriffe durchzuführen
• Prozesse zu starten
• Betriebssystemfunktionen aufzurufen
• externe Systeme direkt zu steuern

Stattdessen kann das Sprachmodell ausschließlich textbasierte Tool-Anfragen formulieren.

Die Ausführung eines Tools erfolgt niemals durch das Sprachmodell selbst, sondern ausschließlich durch das DAGE-System nach erfolgreicher deterministischer Prüfung.

Die Tool-Oberfläche des Systems ist vollständig geschlossen. Es können ausschließlich zuvor definierte und explizit implementierte Tools verwendet werden.

Nicht bekannte oder nicht erlaubte Tool-Aufrufe werden deterministisch zurückgewiesen und nicht ausgeführt.

Die Prüfung eines Tool-Aufrufs umfasst insbesondere:

• Existenz des angeforderten Tools
• Berechtigung der aktuellen Benutzer-ID
• Validierung der Parameter
• Begrenzung erlaubter Ressourcenbereiche
• Größen-, Mengen- oder Kontextbeschränkungen

Die eigentliche Rechteprüfung erfolgt dabei unabhängig vom Sprachmodell ausschließlich innerhalb des DAGE-Systems.

Eine erfolgreiche Manipulation des Sprachmodells durch Prompt Injection, Kontextmanipulation oder fehlerhafte Modellentscheidungen führt daher nicht automatisch zu erweiterten Systemrechten oder unzulässigen Datenzugriffen.

Selbst im Worst Case kann ein manipuliertes Sprachmodell ausschließlich versuchen, einen zusätzlichen Tool-Aufruf vorzuschlagen. Die endgültige Autorisierung bleibt jedoch vollständig abhängig von den deterministischen Prüfregeln des DAGE-Systems.

Dadurch werden Sicherheitsgrenzen nicht auf Prompt-Ebene, sondern auf Systemebene durchgesetzt.

Interaktionsbeispiel

Szenario: Ein Mitarbeiter fragt nach Kontaktdaten für ein Bauprojekt.

System: DAGE-Gateway mit isoliertem LLM-Backend.

Status: Demonstration der deterministischen Tool-Kontrolle, Kontextanreicherung und Fehlerkorrektur.

1. Initialisierung und Identifikation

2. Komplexe Anfrage und mehrstufige Tool-Chain

3. Demonstration der DAGE-Sicherheit durch Correction Loop

4. Finale Antwort zur Projektanfrage

5. Separates Sicherheitsbeispiel: unberechtigter Tool-Call

Deterministische Ressourcen- und Parameterkontrolle

Alle Ressourcenoperationen innerhalb des DAGE-Systems erfolgen ausschließlich innerhalb definierter und kontrollierter Grenzen.

Dateioperationen können beispielsweise auf folgende Bereiche beschränkt werden:

• bestimmte Projektbereiche
• definierte Root-Verzeichnisse
• kontrollierte Dateilisten
• begrenzte Rekursionstiefen
• spezifische Datendomänen

Freie Ressourcenzugriffe werden dabei vermieden.

Statt direkter Pfadangaben können Ressourcen ausschließlich über zuvor erzeugte Listenreferenzen oder deterministisch validierte Identifikatoren angesprochen werden.

Hierdurch lassen sich unter anderem folgende Risiken deterministisch begrenzen:

• Pfadmanipulationen
• unerlaubte Verzeichniswechsel
• unkontrollierte Rekursionen
• unbeabsichtigte Massenabfragen

Auch komplexere Werkzeuge wie OCR-Verarbeitung, Visualerkennung, Prozesssteuerung, Benutzeroberflächenautomatisierung, API-Kommunikation oder externe Systemintegrationen unterliegen denselben deterministischen Kontrollmechanismen.

Die Sicherheitsarchitektur bleibt dabei unabhängig von der funktionalen Komplexität einzelner Tools erhalten, da nicht das Sprachmodell, sondern ausschließlich das DAGE-System operative Systemrechte besitzt.

Human-in-the-Loop-Kontrollmechanismen

Für kritische oder externe Aktionen kann das DAGE-System zusätzliche deterministische Freigabemechanismen integrieren.

Insbesondere Aktionen mit Auswirkungen außerhalb des internen Informationskontexts können eine explizite Benutzerfreigabe erfordern, beispielsweise:

• Versand von E-Mails
• externe Kommunikation
• Prozessauslösungen
• irreversible Aktionen

Das Sprachmodell erzeugt hierbei zunächst lediglich einen Vorschlag der auszuführenden Aktion.

Die finale Aktion wird anschließend direkt durch das DAGE-System an den Benutzer zurückgegeben und dort unverändert zur Prüfung dargestellt.

Die eigentliche Ausführung erfolgt erst nach deterministischer Bestätigung durch den Benutzer, beispielsweise über definierte Freigabewörter oder andere kontrollierte Bestätigungsmechanismen.

Zwischen finaler Benutzerfreigabe und tatsächlicher Ausführung ist das Sprachmodell nicht mehr beteiligt.

Hierdurch wird verhindert, dass nachträgliche Modellmanipulationen, zusätzliche Prompt Injection oder kontextabhängige Modellveränderungen die finale Aktion beeinflussen können.

Protokollierung und Nachvollziehbarkeit

Das DAGE-System verwaltet sämtliche Kommunikations- und Systemzustände außerhalb des Sprachmodells.

Alle relevanten Interaktionen können deterministisch protokolliert werden, insbesondere:

• Benutzereingaben
• Modellantworten
• Tool-Aufrufe
• Systemantworten
• Berechtigungsentscheidungen
• Freigabeprozesse

Die Protokollierung kann append-only erfolgen, wodurch bestehende Kommunikationsverläufe ausschließlich erweitert, jedoch nicht nachträglich verändert werden.

Da weder Benutzer noch Sprachmodell direkten Zugriff auf die internen Protokollstrukturen besitzen, bleibt die Integrität des Kommunikationsverlaufs vollständig unter Kontrolle des DAGE-Systems.

Zusätzliche Schutzmaßnahmen wie Verschlüsselung, Signierung, Hash-Verkettungen oder revisionssichere Speicherverfahren können ergänzend integriert werden, sind jedoch nicht grundlegender Bestandteil des eigentlichen Sicherheitsmodells.

Sicherheitsbetrachtung

Das DAGE Security Architecture Model verfolgt keinen Ansatz zur vollständigen Eliminierung fehlerhafter Modellentscheidungen.

Große Sprachmodelle bleiben weiterhin probabilistische Systeme und können fehlerhafte Antworten erzeugen, Informationen falsch interpretieren, ungeeignete Werkzeuge auswählen oder inhaltliche Fehlentscheidungen treffen.

Die Architektur adressiert stattdessen gezielt die Trennung zwischen semantischer Modellverarbeitung und sicherheitskritischer Systemkontrolle.

Dadurch soll verhindert werden, dass fehlerhafte Modellentscheidungen automatisch zu erweiterten Systemrechten, unzulässigen Datenzugriffen oder unkontrollierten Systemaktionen führen.

Das Sicherheitsmodell basiert damit nicht auf dem Vertrauen in die Regelbefolgung des Sprachmodells selbst, sondern auf der vollständigen Auslagerung sicherheitskritischer Entscheidungen in eine deterministische Kontrollinstanz außerhalb des LLM.

Grenzen und sicherheitsrelevante Hinweise

Das DAGE Security Architecture Model adressiert primär die deterministische Begrenzung operativer Systemrechte und autonomer Systemaktionen. Die inhaltliche Vertrauenswürdigkeit der durch das Sprachmodell erzeugten Antworten bleibt hiervon grundsätzlich getrennt zu betrachten.

Auch innerhalb des DAGE-Modells können fehlerhafte Modellentscheidungen, Halluzinationen, semantische Fehlinterpretationen oder indirekte Prompt-Manipulationen dazu führen, dass Antworten sachlich falsch, unvollständig oder irreführend formuliert werden.

Dies kann beispielsweise fehlerhafte Telefonnummern, falsche Projektzuordnungen, unzutreffende Zusammenfassungen, verfälschte Priorisierungen oder andere semantische Fehlentscheidungen umfassen, die Benutzer zu falschen operativen Entscheidungen verleiten können.

Dokumente, OCR-Ergebnisse oder andere externe Datenquellen können Inhalte enthalten, die versuchen, das Verhalten des Sprachmodells semantisch zu beeinflussen. Innerhalb des DAGE-Modells führt dies jedoch nicht automatisch zu erweiterten Systemrechten, da sämtliche Tool-Ausführungen und Ressourcenfreigaben weiterhin ausschließlich deterministisch durch das DAGE-System kontrolliert werden.

Das DAGE-System begrenzt solche Situationen zusätzlich durch geschlossene Tool-Oberflächen, deterministische Parameter- und Rechteprüfungen, kontrollierte Ressourcenbereiche sowie Begrenzungen der maximal erlaubten aufeinanderfolgenden Tool-Aufrufe, um potenzielle Fehlerschleifen oder endlose Agenten-Loops kontrolliert zu unterbrechen.

Die Architektur verhindert jedoch nicht automatisch organisatorische Fehler innerhalb der zugrunde liegenden Datenbestände.

Werden beispielsweise sensible Dokumente versehentlich in einem für bestimmte Benutzer freigegebenen Projektbereich abgelegt, kann das DAGE-System diese Fehlklassifikation nicht semantisch erkennen, sofern die deterministischen Berechtigungsregeln den Zugriff formal erlauben.

DAGE ersetzt daher keine organisatorischen Sicherheitsprozesse, Datenklassifikation oder Berechtigungskonzepte, sondern erzwingt die technische Durchsetzung der definierten Systemgrenzen.

Zusätzlich müssen bereits aufgebaute oder gespeicherte Kontexte berücksichtigt werden. Werden Berechtigungen nachträglich entzogen, können zuvor freigegebene Informationen weiterhin im bestehenden Chatverlauf enthalten sein. Solche Kontexte müssen durch das DAGE-System gegebenenfalls bereinigt, gesperrt oder verworfen werden.

Benutzer müssen daher weiterhin dafür sensibilisiert werden, Ausgaben eines Sprachmodells nicht ungeprüft als verlässliche Faktenbasis zu betrachten. Das DAGE-Modell reduziert primär die Gefahr unkontrollierter Systemaktionen und autonomer Rechteausweitungen, nicht jedoch die grundsätzliche semantische Unsicherheit probabilistischer Sprachmodelle.

Verfasser: MSB Innovation GmbH, 24. Mai 2026

Projekt-Status (Umsetzung)

Das DAGE Security Architecture Model wurde bereits erfolgreich im betrieblichen Umfeld eingeführt.

Aktuelle umgesetzte Beispiele:

- Mitarbeiter-Disposition (Einteilungen, OOF, Urlaubsplanung usw.)

- Fuhrendisposition und Lieferstatus-Abfragen

- Kontaktsuche und Kontaktverwaltung

- Projekt-Informationen (Kontakte, Kundendaten usw.)

- Projekt-Dateizugriffe und Dokumentabfragen (inkl. KI-Vision-Funktionalität für Pläne)

- Projekt-Leistungsverzeichnisse und Positionssuche

- Projekt-Anfahrt und Wetterinformationen

- Geräteverwaltung inkl. Ummeldungen

- API-Zugriffe auf betriebliche Datenbanken

- RAG-Zugriffe auf betriebliche Wissenssammlungen (gezielte Kontextanreicherung)

- E-Mail-Erstellung mit Versandfreigabe und E-Mail-Empfang (kein E-Mail-Client erforderlich)

In Verbindung mit Sprachtranskription entsteht dadurch eine kontrollierbare, mobiltaugliche, weitgehend tastaturfreie Benutzerinteraktion mit betrieblichen Informationssystemen.

Stand:
März 2026 - Einführung abgeschlossen (Go-Live).
April/Mai 2026 - Security-Live-Tests, Analysen und Erweiterungen abgeschlossen.
24.05.2026 - Veröffentlichung der Architektur (Paper/GitHub).