Zum Inhalt springen
AggregaAggrega
Sprache wählen: Deutsch
Diese Seite wurde maschinell übersetzt. Das englische Original lesen.

KI-Features

Das KI-Feature-Set von Aggrega

Um den besonderen Anforderungen, der Volatilität und den Sicherheitsbedrohungen moderner KI-Systeme gerecht zu werden, bettet Aggrega spezialisierte Intelligenz direkt in seine quelloffene KI-Standardbibliothek (den Katalog) ein. Sie stellt sicher, dass sowohl generisches Cloud-native-Gerüst als auch hochspezialisierte KI-native Reasoning-Engines sicher nebeneinander bestehen.

Der zentrale Go-Compiler ist ein inhaltsneutraler universeller Router; die gesamte KI-spezifische Intelligenz liegt in einsteckbaren WebAssembly-Policies (Wasm) und in den Deklarationen nach JSON Schema 2020-12, die Plattform-Architekten auf Katalog-Entitäten verfassen.

1. Die operative Cloud-Ontologie und KI-Duck-Typing

Um das generische Open Application Model (OAM) mit den strengen Realitäten moderner Infrastruktur zu verbinden, bildet das Label component.aggrega.ai/type ausschließlich auf eine geschlossene Menge universeller Cloud-native-Primitive ab. Diese semantische Identität ist das, was ein Socket-Selektor, das appliesTo eines Feature und eine Governance-Policy lesen, um zu erfahren, wie eine Komponente Zustand, Netzwerk-Ingress und Lebenszyklen behandelt; der Compiler gleicht sie als opaken String ab und verzweigt nicht danach, und wie eine Komponente gerendert wird, entscheidet das Recipe, das das Manifest für sie zuordnet.

Die Cloud-native-Typen (die Infrastrukturbasis):

  • server: Langlaufende, zustandslose Rechenlast, die eingehenden Anwendungsverkehr erwartet (z. B. ein AI Gateway oder eine Chat-UI).
  • worker: Langlaufende, zustandslose Rechenlast, die aus Warteschlangen liest oder Hintergrundschleifen ausführt, ohne eingehende Anwendungsports (z. B. ein LangGraph-Agent oder ein Celery-Worker).
  • task: Kurzlebige Rechenlast, die bis zum Abschluss läuft und dann endet (z. B. DB-Migrationsskripte).
  • function: Ereignisgesteuerte Rechenlast, die auf null skaliert (z. B. AWS Lambda).
  • stateful-server: Rechenlast im Cluster, die stabile Netzwerkidentitäten und dauerhafte Datenträger benötigt (z. B. eine Qdrant-Vektordatenbank, ein Kafka-Broker).
  • resource: Externe, von der Plattform verwaltete Infrastruktur (z. B. AWS RDS PostgreSQL, S3-Buckets, ein gehosteter Event-Bus).

Die Menge gehört Aggrega und ist geschlossen. Das veröffentlichte Component-Schema zählt diese Werte auf, und ein Dokument mit einem anderen Wert wird beim Laden abgewiesen — E0215 nennt das Label und listet auf, welche Werte es annimmt. Das ist es, was die Achse leistet: Ein Feature oder ein Socket-Selektor, der gegen stateful-server geschrieben ist, bedeutet in jedem Katalog, auf den er trifft, dasselbe.

Was eine Komponente in Ihrem eigenen Vokabular ist, gehört auf Ihren eigenen Schlüssel. Eine Stufe, eine Datenzone, eine Serviceklasse, eine feinere Aufteilung der Primitive — jedes davon ist ein Label-Schlüssel, den Sie neben dem reservierten verfassen, da das Component-Schema jeden weiteren Label-Schlüssel mit einem String-Wert akzeptiert und jede Selektor-Oberfläche ihn identisch liest. Das ist derselbe Mechanismus, den die unten beschriebenen KI-Duck-Typing-Labels bereits verwenden; der reservierte Schlüssel ist die gemeinsame Basis, und alles darüber gehört Ihnen.

Der operative Typ ist nicht die Kategorie zum Durchsuchen, und es sind absichtlich getrennte Achsen. Ein Kafka-Broker liegt in der Kategorie messaging — wo ein Benutzer ihn sucht — und trägt stateful-server als Typ, weil die Infrastruktur genau das für ihn leisten muss. Ein Selektor, der gegen eine Achse geschrieben ist, trifft nie auf der anderen zu.

Siehe entities/component für die Tabellen der Taxonomie semantischer Labels — die Labels Generic Cloud Layer, Specialized AI Layer, Cross-Cutters und Dynamic Business Context, mit denen Architekten eine kognitive Identität über die Basistypen legen.


1.1 Der Standard des Open-Source-Katalogs: „Nackte Basis, spezialisierte Ränder“

Beim Anwenden dieser Labels gibt es einen entscheidenden Unterschied zwischen dem offiziellen Open-Source-Katalog von Aggrega (core/*) und einem privaten Unternehmenskatalog (acme/*).

Damit der offizielle Open-Source-Katalog universell nutzbar bleibt, muss er streng zwischen unveränderlicher technischer Physik und subjektiver kognitiver Absicht unterscheiden. Wenn das universelle core/datastore/postgres fest mit engine: relational versehen ist, hält ein Governance-Verdict-Plugin, das so konfiguriert ist, dass es die Übereinstimmung des Datastore-Typs erzwingt, den Build an, sobald ein Entwickler die Erweiterung pgvector in seinen values aktiviert und versucht, einen KI-Agenten anzubinden, der einen vector-Datastore benötigt.

Um einen meinungslosen Kernkatalog zu erhalten, folgen offizielle Komponenten diesem Standard: Die Basis nackt halten und die Ränder spezialisieren.

  1. Die nackte Basis: Die quelloffene Component auf Wurzelebene legt nur fest, was objektiv für das Produkt gilt und durch nichts, was ein Autor konfiguriert, geändert werden kann — zuerst und immer das operative Primitiv (component.aggrega.ai/type). Eine Postgres-Datenbank ist objektiv ein stateful-server; diese Tatsache kann sich nicht ändern. Derselbe Test lässt ein Fähigkeits-Label zu, wenn die Identität des Produkts diese Fähigkeit ist: core/datastore/qdrant und core/datastore/weaviate sind Vektorsuchmaschinen, und nichts, was ein Autor schreibt, macht sie zu etwas anderem, daher trägt jede datastore.aggrega.ai/engine: vector auf der Basis, genau wie core/datastore/redis kv trägt. Was die nackte Basis ablehnt, ist der umgekehrte Fall — ein Merkmal, das davon abhängt, wie eine Komponente konfiguriert oder verwendet wird, wofür der dritte Mechanismus unten existiert.
  2. Die spezialisierten Schnittstellen (Schema-Vererbung): Eine Component kann extends deklarieren und damit eine andere Component als ihre Basis benennen, und was dabei zusammengesetzt wird, ist die Struktur: Labels, Annotationen, Attachment-Slots, die Self-Inject-Allowlist, Topologie-Sockets und benannte assertions. Die drei Datensäulen werden nicht zusammengesetzt — eine erweiternde Component schreibt den literalen Marker schema: inherited und verfasst keinen eigenen Inhalt für values, infra oder provides, sodass ihr Vertrag mit dem ihrer Basis identisch ist. Deshalb schränkt der Mechanismus ein, statt zu variieren: Weil der Vertrag unverändert bleibt, bedient jedes für die Basis geschriebene Recipe bereits die Spezialisierung, und die Spezialisierung kostet eine Katalog-Entität und eine Mapping-Zeile im Manifest. Was eine Spezialisierung hinzufügt, ist daher Identität, die ein Selektor oder eine Policy liest — eine Audit-Stufe, eine Datenzone, ein Governance-Ansprechpartner oder ein Socket, dessen Selektor weniger zulässt als der der Basis. Sie kann keinen anderen Vertrag hinzufügen, weil sie keine Oberfläche hat, auf der sie einen verfassen könnte. Eine Folge wird leicht übersehen: Die Mapping-Zeile ist trotzdem erforderlich. Die Recipe-Auswahl erfolgt über den exakten Mapping-Schlüssel, daher braucht eine Spezialisierung ihren eigenen mappings.components.type-Eintrag, auch wenn sie kein eigenes Recipe braucht. Siehe examples/extends-wrapper für einen veröffentlichten Wrapper, der ein Label für eine geprüfte Stufe hinzufügt und einen Socket darauf einschränkt, zusammen mit dem Build, der anhält, wenn eine in diesen Socket verdrahtete Kante die Stufe verlässt. Ein Merkmal, das davon abhängt, wie eine Komponente konfiguriert ist, ist nicht Gegenstand dieses Mechanismus: Eine Spezialisierung pinnt das Artefakt ihrer Basis und erbt deren Vertrag, sodass ein Merkmal, das für die Spezialisierung gilt, bereits für die Basis gilt, wo die Regel der nackten Basis es verortet. Ein solches Merkmal gehört zum dynamischen Mutator unten.
  3. Der dynamische Mutator (Wasm-Promotion): Wenn ein Merkmal durch die Nutzdaten des Entwicklers bestimmt wird (z. B. enable_vector: true), verwendet das Unternehmen beim Aufbau der Topologie die Rolle label-transform des Governance-Sockets, um die opaken values dynamisch zu lesen und das Label datastore.aggrega.ai/engine: vector automatisch in den IR-Graphen einzufügen, bevor Policies laufen. Hier wird ein konfigurationsabhängiges Merkmal für die strenge Policy-Auswertung verfügbar — die vom Entwickler deklarierten values sind es, die es befördern, und die Transformation läuft, bevor irgendeine Policy ein Label liest.

Die Unternehmensausnahme: Weil der Compiler meinungslos ist, steht es Unternehmen, die ihre eigenen internen Kataloge verfassen, frei, diese Regel zu brechen. Wenn eine Sicherheitsrichtlinie des Unternehmens vorschreibt, dass alle internen Datenbanken hochsensibel sind, kann und sollte der Plattform-Architekt compliance.aggrega.ai/data-class: restricted (oder ein ähnliches, vom Unternehmen vorgegebenes Label) direkt auf seiner Basiskomponente acme/postgres festlegen, sodass jede ihrer Instanzen die Klasse trägt und eine vom Unternehmen angebundene Policy sie auf jeder liest. Das Label selbst erzwingt nichts: Der Compiler trägt es als String, und die angebundene Policy ist es, die einen Build anhält. Wo nur einige Verwendungen eines Produkts in einer Systemlandschaft diese Daten enthalten, trägt stattdessen eine Spezialisierung über extends die Klasse — siehe examples/policy-data-class-route, dessen Schadensfall-Assistent der LangGraph-Agent der Standardbibliothek plus ein Klassen-Label ist, neben der Policy, die es liest.

1.2 Wie semantische Labels die Compiler-Pipeline antreiben

Um Labels in der Zuständigkeit des Plattform-Architekten zu halten, können Entwickler keine Labels auf ihre Component-Instanzen innerhalb des Aggregate schreiben: Das Aggregate-Schema gibt einer Komponenteninstanz keinen labels-Schlüssel. Die Labels eines Knotens sind die seiner Katalog-Entität, zusammen mit allen, die ein vom Betreiber konfiguriertes label-transform-Governance-Attachment beim Aufbau der Topologie hinzufügt. So treiben diese Labels die Kompilierungs-Pipeline an, ohne eigenen Go-Code zu erfordern:

1. component.aggrega.ai/type (das Basisprimitiv)

  • Wer schreibt es? Der Plattform-Architekt (Domäne 2). Es ist für jede Komponente im Katalog verpflichtend.
  • Wer konsumiert es? Der statische Analysator und die Wasm-Rendering-Plugins.
  • Anwendungsfall im Compiler: Dies ist die zentrale operative Cloud-Ontologie. Der statische Analysator wertet die usesSchema-Selektor-Strings nativ in Go aus, um zu garantieren, dass ein Entwickler keinen Agenten an eine Standarddatenbank anbinden kann, wenn der Socket eine bestimmte KI-Fähigkeit verlangt. Außerdem verwendet DevOps dieses Label, um zustandsbehaftete Primitive (stateful-server, resource) explizit in physische Cluster-Grenzen zu routen, die dauerhafte Datenträger unterstützen, während eine Governance-Verdict-Rolle erzwingen kann, dass zustandsbehaftete Komponenten nie in rein ephemeren Grenzen platziert werden.

2. model.aggrega.ai/capability

  • Wer schreibt es? Der Plattform-Architekt.
  • Wer konsumiert es? Der statische Analysator (über die Label-Selektoren im Kubernetes-Stil von usesSchema-Sockets).
  • Anwendungsfall im Compiler: Wenn ein Architekt einen usesSchema-Selektor verfasst, der das erforderliche Fähigkeits-Label nennt, weist die native Label-Matching-Engine des Compilers jede Verdrahtung, die den Selektor nicht erfüllt, ab, bevor Artefakte erzeugt werden. Der Compiler behandelt diese Labels als opake Strings; die semantische Bedeutung von „text-generation“ gegenüber „embedding“ liegt in der Art, wie der Architekt den Selektor verfasst.

3. component.aggrega.ai/hosting

  • Wer schreibt es? Der Plattform-Architekt.
  • Wer konsumiert es? Die Policy-Engine (eine Governance-Verdict-Rolle), Wasm-Rendering-Plugins und die eigenen Aufrufer eines Modells oder eines Agenten in der Standardbibliothek: ihre Agenten, deren Assertion es auf jeder model-Verbindung liest, core/ai-tool/agent-invocation, dessen Assertion es auf seiner target_agent-Verbindung liest, ebenso wie seine Kubernetes-Realisierung, die einem über http erreichten external-Agenten ein Credential verweigert, das KI-Gateway, dessen Assertion es auf jeder Verbindung zu seinen Sockets models und cache_store liest, sowie core/gateway/kong, core/gateway/kong-enterprise, core/gateway/apisix, core/gateway/envoy-gateway, core/gateway/traefik-hub, core/gateway/agentgateway und core/gateway/higress, deren Assertions es auf jeder Verbindung zu ihren models-Sockets lesen, sowie zum backend der beiden Kongs, zu den cache_store-Sockets von APISIX und Traefik Hub und zu den cache-Sockets von Envoy Gateway, Higress und Traefik Hub — siehe „Der Schlüssel, den ein Aufrufer vorlegt“ unten.
  • Anwendungsfall im Compiler: Es hält fest, wer die zugrunde liegende Ressource der Komponente betreibt, sodass eine von einem Betreiber angebundene Policy das Risiko der Datenexfiltration beurteilen kann; der Compiler liest den Wert als String und beurteilt nichts. Wenn ein Agent, dessen Klassen-Label besagt, dass er internal-Daten enthält, sich mit einem als managed gekennzeichneten Modell verbindet — einem Dienst, der außerhalb der eigenen Grenze des Release betrieben wird —, kann eine solche Policy erkennen, dass die Daten diese Grenze verlassen, und den Build anhalten, sofern die Verbindung nicht über ein KI-Gateway geroutet wird, das core/data-masking trägt, welches den Chat- und Completion-Text maskiert, den das Gateway weiterleitet. Der model-Socket eines Agenten nimmt ein solches Gateway anstelle des Modells an, sodass diese Route eine Kante des Graphen ist, den die Policy liest, und ein Modell, das das Gateway aus seinem models-Socket bedient, ist eine eigene Kante, vom Gateway zur Modellkomponente, deren Labels die Policy liest — sodass der Pfad von einem Agenten durch das Gateway zu einem managed-Modell durchgängig im Graphen liegt. Ein von Hand in die Modell-Map des Gateways eingetragener Upstream ist das nicht: Er ist ein String, den der Compiler nicht auflöst, sodass eine Policy, die den Graphen liest, das Gateway sieht und nichts dahinter. examples/policy-data-class-route ist eine solche Policy: Ihre Einstellungen stufen ein managed-Modell als public ein, und sie hält einen Build an, in dem ein Assistent mit restricted-Daten ein solches Modell ohne maskierendes Gateway auf der Route erreicht. Dies ist ein querschnittliches Merkmal: Dieselben Werte self-hosted | managed | external beschreiben eine verwaltete Datenbank oder einen selbst betriebenen Inferenzserver genauso wie ein Modell, daher liegt das Label im gemeinsamen Namensraum component.aggrega.ai/ statt im modellspezifischen.

4. agent.aggrega.ai/autonomy

  • Wer schreibt es? Der Plattform-Architekt.
  • Wer konsumiert es? Die Policy-Engine (eine Governance-Verdict-Rolle).
  • Anwendungsfall im Compiler: Es kennzeichnet das Ausführungsrisiko der kognitiven Schleife. Wenn ein Agent als autonomous gekennzeichnet ist (das heißt, er führt Hintergrundschleifen ohne Benutzer-Prompts aus) und sich mit einer hochsensiblen Datenbank verbindet, kann die Policy-Engine den Build anhalten, sofern ein Autor nicht dasjenige Genehmigungs- oder Eindämmungs-Feature anbindet, das die eigenen Regeln des Unternehmens verlangen, sodass eine unbeaufsichtigte Schleife diese Daten nicht ungeprüft erreichen kann.
  • Was eine Komponente ohne Label auf dieser Achse bedeutet, denn das Fehlen ist beabsichtigt. Das Label beschreibt das Ausführungsrisiko einer kognitiven Schleife, daher trägt eine Komponente, die keine eigene Schleife enthält, hier keinen Wert statt des niedrigeren der beiden. Eine ganze Reihe von Komponenten in der Agenten-Kategorie ist genau aus diesem Grund ohne Label: Die unterstützenden Teile, die eine Agentenplattform neben ihrem Server ausliefert — eine Browser-Konsole, ein Lauf zur Schema-Migration, ein Task-Worker, eine Code-Sandbox, ein Egress-Proxy —, stehen in dieser Kategorie, weil Sie sie dort suchen, während die Schleife, die sie unterstützen, im Server der Plattform lebt, und dort sitzt das Label. Der deutlichste Fall ist ein einzelnes Produkt, das auf beide Behandlungen aufgeteilt ist: Der Server einer Plattform trägt copilot, und die daneben ausgelieferte Code-Sandbox trägt nichts. Der Test ist, wo die Schleife lebt, nicht welche Form das Teil hat, daher ist auch eine Laufzeitumgebung, die von Ihnen bereitgestellten Agentencode hostet, ohne Label — die Schleife dort ist das, was Sie darin deployen, nicht etwas, das das Produkt behauptet. Ein Selektor, der einen der beiden Werte nennt, trifft daher auf die Komponenten zu, die eine Schleife enthalten, und auf keine anderen, und einer, der auf jede Autonomiehaltung zutreffen soll, überspringt die unterstützenden Teile, statt sie als das am wenigsten autonome Element im Deployment zu behandeln.

5. gateway.aggrega.ai/intelligence

  • Wer schreibt es? Der Plattform-Architekt.
  • Wer konsumiert es? Der statische Analysator und vom Unternehmen verfasste Linter-Wasm-Plugins.
  • Anwendungsfall im Compiler: Es bestimmt, welche Funktionen ein Router physisch unterstützen kann. Das KI-Feature fallback-chain deklariert appliesTo: gateway.aggrega.ai/intelligence=semantic, und der statische Analysator wertet diesen Selektor gegen die Labels der Zielkomponente aus, bevor irgendein Artefakt gerendert wird. Wenn ein Entwickler es an ein Standard-Gateway l4-mesh anbindet, hält der Build mit einer Selektorverletzung an, die das Feature und den nicht erfüllten Selektor nennt, weil der Architekt diesen Selektor in dem Wissen verfasst hat, dass ein Standard-TCP-Mesh keine LLM-JSON-Payloads parsen kann, um das Modell zu lesen, das eine Anfrage nennt. Die Ablehnung beruht auf dem Fehlen von semantic, nicht auf dem Vorhandensein von l4-mesh, und gilt daher ebenso für einen Router, der überhaupt kein Intelligence-Label trägt. Der Compiler behandelt das Label als opaken String, genau wie oben: Was semantic bedeutet, liegt in der Art, wie der Architekt den Selektor verfasst. Auf einem Router, der semantic tatsächlich trägt, besteht die Anbindung den Selektor, und was danach geschieht, ist Sache seiner Realisierung: Die Realisierung der Standardbibliothek schreibt die Kette in die Routing-Konfiguration des KI-Gateways.
  • Was die Standardbibliothek trägt. Diese Komponenten tragen semantic: core/gateway/litellm, dessen Realisierung die Routing-Tabelle des Proxys rendert: eine Modell-Map über mehrere Upstream-Anbieter; core/gateway/cloudflare-ai-gateway, das gehostete Gateway von Cloudflare, das jede weitergeleitete Modellanfrage liest — das Modell, das sie nennt, die Tokens, die dafür abgerechnet werden, und, wo die eigenen Prüfungen des Gateways aktiv sind, ihren Inhalt; core/gateway/azure-api-management, das KI-Gateway von Azure API Management, ein gehosteter Dienst, das jede Modellanfrage auf einer API liest, die ein Modell bereitstellt — den Prompt, den sein semantischer Cache vergleicht, die Tokens, die eine Antwort meldet, und den Inhalt, den seine Sicherheitsprüfung zur Inspektion sendet; core/gateway/apisix, dessen KI-Proxy den Body jeder Anfrage auf einer Route liest, die ein Modell bereitstellt, sowie die Tokens, die die Antwort des Modells meldet; core/gateway/envoy-gateway, dessen Erweiterung Envoy AI Gateway den Body jeder Anfrage auf der Route liest, die die daran angebundenen Modelle bereitstellt, um das genannte Modell zu finden, sowie die Tokens, die jede Antwort meldet; core/gateway/kong-enterprise, Kong Gateway Enterprise, dessen KI-Proxy den Body jeder Anfrage auf einer Route liest, die ein angebundenes Modell bereitstellt — das Modell, das sie nennt, und die Nachrichten, die sie trägt —, sowie die Tokens, die jede Antwort meldet; core/gateway/traefik-hub, Traefik Hub, dessen Chat-Completion-Middleware den Body jeder Anfrage auf der Route liest, die ein angebundenes Modell bereitstellt, ihn gegen das Chat-Completion-Schema prüft und die Tokens liest, die jede Antwort meldet; core/gateway/agentgateway, agentgateway, das den Body jeder Anfrage auf seinen Pfaden zur Modellbereitstellung liest, um das genannte Modell zu finden, was die Art ist, wie es das angebundene Modell auswählt, an das eine Anfrage gesendet wird, sowie die Tokens, die jede Antwort meldet; und core/gateway/higress, Higress, dessen KI-Proxy den Body jeder Anfrage auf einer Route liest, die ein angebundenes Modell bereitstellt — das Modell, das sie nennt, und ob sie streamt —, und dessen Plugins die Tokens lesen, die jede Antwort meldet — sodass die KI-Features, die diesen Wert verlangen, gegen jede davon aufgelöst werden und jede Realisierung angibt, was ihr Gateway umsetzt, oder den Build anhält, wo ihr Gateway nichts davon umsetzt; ein Feature ohne Realisierung für ein Gateway hält den Build dort an und nennt seinen Typ. Keine Komponente trägt l4-mesh, und die übrigen Gateway-Komponenten der Standardbibliothek tragen überhaupt kein Intelligence-Label: Diejenigen, die Datenverkehr routen, terminieren HTTP und routen auf Schicht 7, und eine davon ist eine Control Plane, die gar nichts routet, sodass keiner der beiden Werte sie beschreibt. Ein TCP-Mesh auf Schicht 4 ist wiederum eine andere Produktklasse. Damit bleibt die obige Ablehnung voll in Kraft, denn sie beruht auf dem Fehlen von semantic: Eine Anbindung, die diesen Wert verlangt, hält bei jeder davon an. Ein Architekt, dessen Katalog tatsächlich ein Mesh auf Schicht 4 betreibt, versieht diese Komponente mit l4-mesh, wodurch die Unterscheidung in beide Richtungen selektierbar wird.
  • Diese Achse benennt eine Produktstufe, und das ist eine andere Frage als die, was eine Komponente mit dem Datenverkehr tun kann, und sie im zweiten Sinn zu lesen ist der Fehler, zu dem sie verleitet. semantic besagt, dass der Router den Request-Body parst, und genau das braucht eine Kontrolle, die auf das in einer Anfrage genannte Modell wirkt — für diese Frage ist sie also die richtige Achse. Sie sagt nichts darüber aus, ob ein Router Datenverkehr kopieren, die Identität eines Aufrufers weitergeben, das Zertifikat eines Upstreams prüfen, einen Prompt ablehnen kann, der auf eine Musterliste passt, oder ein Budget über einen Zeitraum führen kann, und ein Feature, das eine dieser Fähigkeiten braucht, hat nach der Stufe nicht zu fragen: Die meisten Komponenten, die sie bieten, sind gewöhnliche Layer-7-Proxys ohne jeden Intelligence-Wert, und wo ein semantic-Router eine davon bietet, bietet er sie aus Gründen, die die Stufe nicht festhält. Die Stufe erreicht also in beide Richtungen die falsche Menge — sie schließt die einfachen Proxys ganz aus und sagt nichts darüber, welche Fähigkeiten das KI-Gateway, das sie erreicht, tatsächlich hat. Diese Frage gehört zur nachfolgend beschriebenen Datenpfad-Achse, und beide lassen sich kombinieren — ein Feature kann einen semantic-Router verlangen, der zusätzlich spiegelt, indem es beide nennt.

6. tool.aggrega.ai/impact

  • Wer schreibt es? Der Plattform-Architekt.
  • Wer verwendet es? Die Policy-Engine und Wasm-Rendering-Plugins.
  • Anwendungsfall im Compiler: Indem dies aus dem veränderlichen values-Block des Entwicklers in die unveränderliche Label-Identität verlagert wird, kann die Policy-Engine strikte Konfigurationen nach dem Prinzip der geringsten Rechte bewerten. Ein Rendering-Plugin könnte für ein read-only-Websuche-Tool standardmäßige invoke-Berechtigungen erzeugen, für den Aufruf eines mutating-SQL-Drop-Tools jedoch strikte Konfigurationen mit kryptografischer Signatur verlangen.

7. compliance.aggrega.ai/data-class

  • Wer schreibt es? Der Plattformarchitekt des eigenen Katalogs einer IT-Landschaft (oder dynamisch über die Governance-Rolle label-transform eingefügt).
  • Wer konsumiert es? Die Policy-Engine (eine Governance-Verdict-Rolle).
  • Anwendungsfall im Compiler: Es gibt den Daten, die eine Komponente hält, eine Governance-Identität, der eine Policy entlang des Graphen folgen kann. Der Compiler überträgt das Label als Zeichenkette in den IR-Graphen und ordnet nichts: Er weiß nicht, dass restricted sensibler ist als public, und auch nicht, dass eines der beiden Wörter überhaupt etwas bedeutet. Eine Policy, die an der Rolle ir-verdict angehängt ist, liefert diese Bedeutung in ihren eigenen Einstellungen — welche Klassen es gibt und wie sie sich ordnen — und liest das Label auf den Komponenten der Routen, die der Compiler über die uses-Kanten aufzählt, sodass sie einen Build anhalten kann, in dem eine Komponente mit restricted-Daten eine Komponente einer anderen Klasse über eine Route erreicht, auf der kein Feature angehängt ist, das die Policy als deklassifizierend wertet, etwa core/data-masking auf dem KI-Gateway, das die Route durchläuft. Die Aufzählung ist pro Startkomponente begrenzt und listet nichts jenseits der Grenze, sodass eine Route, die die Policy liest, real ist, während das Fehlen einer Route kein Beweis dafür ist, dass keine existiert. examples/policy-data-class-route ist diese Policy, geschrieben für die in die CLI kompilierten Engines Rego und CEL sowie für OPA, mit den anhaltenden Builds und dem abgeschlossenen nebeneinander.
  • Was die Standardbibliothek mitbringt. Keine core/-Component trägt dieses Label. Welche Klasse die Daten einer Komponente haben, ist eine Aussage darüber, wie eine IT-Landschaft die Komponente nutzt, keine Eigenschaft des Produkts, die in jedem Release gilt, daher bleibt es nach der Naked-Base-Regel von der Basis fern: Eine IT-Landschaft trägt es auf ihrer eigenen Component — einer Spezialisierung über extends, wie es der Schadensassistent des ausgearbeiteten Beispiels ist, oder einer eigenen Basis unter der oben beschriebenen Enterprise Exception.

8. hardware.aggrega.ai/accelerator

  • Wer schreibt es? Der Plattformarchitekt. Beim Paketieren einer lokalen Modellkomponente weiß er, dass sie grundsätzlich eine GPU benötigt, um zu funktionieren.
  • Wer verwendet es? DevOps (Domäne 4).
  • Anwendungsfall im Compiler: DevOps leitet mit GPU-Label versehene Komponenten im Release über die Map components: {} explizit in die Grenzen physischer Hardware-Pools. Der Entwickler fordert im Aggregate lediglich das kognitive Modell an, und DevOps platziert es in der Grenze des teuren GPU-Clusters, wodurch die Trennung der Zuständigkeiten vollständig gewahrt bleibt. Eine Governance-Verdict-Rolle kann zusätzlich durchsetzen, dass eine Komponente mit diesem Label nie in einer Grenze ohne GPU-Infrastruktur platziert wird.

9. datastore.aggrega.ai/engine

  • Wer schreibt es? Der Plattformarchitekt, auf Komponenten der Kategorie Datastore (statisch, auf einer flavored Spezialisierung oder durch die Rolle label-transform eingefügt, wenn die values des Entwicklers die Rolle hochstufen). Die im Katalog verwendeten Werte sind: relational, document, kv, vector, graph, semantic-memory, search. Jeder Wert benennt eine Speicher-Engine, die ein Produkt ist — search benennt eine Such- und Analyse-Engine, die auch Vektoren indexiert —, daher ist eine Eigenschaft, die im eigenen Schema und Zugriffsmuster einer Anwendung liegt statt in einem bereitstellbaren Speicher, kein Wert auf dieser Achse.
  • Wer verwendet es? Der statische Analysator (über Selektor-Zeichenketten) und die Policy-Engine.
  • Anwendungsfall im Compiler: Selektoren zielen auf Speichersemantik statt auf Produkte — der Knowledge-Base-Socket eines Agenten wählt datastore.aggrega.ai/engine in (vector, semantic-memory, search) aus, und eine Policy-Engine kann das Routing von SQL-Payloads zu einer Vektor-Engine ablehnen. Die KI-Relevanz von Datastores mit doppeltem Verwendungszweck wird aus diesem Label abgeleitet und nie als separater Boolescher Wert gespeichert.
  • Was die Standardbibliothek mitbringt. core/datastore/qdrant, core/datastore/weaviate, core/datastore/chroma, core/datastore/pgvector und core/datastore/milvus tragen vector, core/datastore/cognee trägt semantic-memory, und core/datastore/opensearch und core/datastore/elasticsearch tragen search, sodass der oben genannte Knowledge-Base-Selektor gegen jede von ihnen aufgelöst wird. core/datastore/redis, core/datastore/valkey und core/datastore/memcached tragen kv. Jedes dieser Labels sitzt auf der eigenen Basis der Komponente, weil die Identität des Produkts diese Engine ist. Bei core/datastore/pgvector ist diese Identität das Artefakt, das sie festlegt: Sie führt das eigene PostgreSQL-Image des pgvector-Projekts aus, das die Erweiterung enthält, und jedes Recipe aktiviert die Erweiterung in der Datenbank, die die Komponente anlegt — ihre Vektor-Eigenschaft hängt also von keiner Einstellung ab, und das unterscheidet sie vom konfigurierten Fall unter „Naked Base, Flavored Edges“ oben, wo ein universelles PostgreSQL die Eigenschaft erst erhält, wenn ein Entwickler eine Erweiterung einschaltet. relational, document und graph haben keine Komponente in der Standardbibliothek, daher passt ein Selektor, der nur Werte unter diesen nennt, hier auf nichts und wird von einem Katalog erfüllt, der eine solche enthält.

10. pipeline.aggrega.ai/mode

  • Wer schreibt es? Der Plattformarchitekt, auf Komponenten der Kategorie Pipeline. Jeder Wert benennt, wie ein Produkt einen mehrstufigen Job ausführt, und die Werte folgen den Komponenten, die sie tragen, statt einer im Voraus festgelegten Liste. Die Standardbibliothek bringt zwei mit: durable auf core/ai-pipeline/temporal, dessen Engine das Ergebnis jedes Schritts als Ereignisverlauf aufzeichnet und erneut abspielt, sodass ein Job, dessen Worker abstürzt, dort weiterläuft, wo er stehen geblieben ist; und reconciled auf core/ai-pipeline/argo-workflows, dessen Controller jeden Schritt als Pod aus einer Workflow-Ressource ausführt, die in der eigenen API des Clusters gehalten wird.
  • Wer verwendet es? Die Policy-Engine und Wasm-Rendering-Plugins.
  • Anwendungsfall im Compiler: Ermöglicht es Policies und Renderern, Pipeline-Engines danach zu unterscheiden, wie ein Lauf einen Ausfall übersteht — ein erneut abgespielter Ereignisverlauf oder eine abgeglichene Cluster-Ressource — statt nach dem Produktnamen.

11. dataplane.aggrega.ai/* (Die Datenpfad-Fähigkeiten)

  • Wer schreibt es? Der Plattformarchitekt, auf jeder Komponente, die im Datenverkehrspfad steht — ein Reverse Proxy, ein Ingress-Gateway, ein Service Mesh, ein KI-Gateway.
  • Wer konsumiert es? Der Static Analyzer, über appliesTo in einem Feature und den usesSchema-Selektor eines Sockets.
  • Anwendungsfall im Compiler: Es beantwortet, was diese Komponente mit dem Datenverkehr tun kann, und genau das muss eine Laufzeitkontrolle tatsächlich wissen, während ein Produktstufen-Label es nicht sagen kann. core/traffic-shadowing, das Live-Anfragen zur Auswertung an einen zweiten Dienst kopiert, deklariert appliesTo: dataplane.aggrega.ai/request-mirroring — nur den Schlüssel —, und der statische Analysator wertet dies gegen die Labels des Ziels aus, bevor irgendetwas gerendert wird, sodass das Anhängen an eine Komponente, die überhaupt nicht spiegeln kann, mit einer Selektorverletzung anhält, die das Feature und den nicht erfüllten Selektor nennt. Der Compiler behandelt jede dieser Zeichenketten als opak, genau wie er die übrigen behandelt.
  • Warum das Präfix den Datenverkehrspfad statt einer Art von Komponente benennt. Spiegelung, Aufruferidentität und Upstream-Prüfung sind keine Gateway-Eigenschaften — sie sind Eigenschaften von allem, was im Anfragepfad steht, und ein Service Mesh, das einem Katalog hinzugefügt wird, hat alle drei. Die Familie nach der Komponentenart zu benennen, die sie zufällig zuerst trug, würde jede spätere Art zwingen, dasselbe Vokabular unter ihrem eigenen Präfix erneut anzugeben, sodass eine Fähigkeit mehrere Namen hätte und kein Selektor sie alle umspannen könnte.
  • Warum die Genauigkeit im Wert steckt. Zwei Komponenten können beide Anfragen spiegeln und sich dennoch in der Weise unterscheiden, auf die es einem Feature ankommt: Die eine kopiert jede passende Anfrage, die andere einen einstellbaren Anteil davon. Ein Schlüssel, der nur sagte, ob eine Komponente spiegelt, ließe beide zu und überließe es der Zeit nach dem Rendern, den Unterschied zu entdecken. Die Genauigkeit in den Wert zu legen, erlaubt es, sie auf diejenige von zwei Arten anzufordern, die zum Feature passt. Ein Feature, das ohne eine bestimmte Genauigkeit überhaupt nicht funktionieren kann, nennt diesen Wert in seinem Selektor. Ein Feature, das auch mit der geringeren Genauigkeit funktioniert, wählt nur über den Schlüssel aus, und seine Realisierung lehnt die Einstellung ab, die die Komponente nicht erfüllen kann: Den gesamten Strom zu kopieren funktioniert auf jeder Komponente, die spiegelt, daher lässt sich core/traffic-shadowing an alle anhängen, und die Realisierung für eine Komponente, die full-rate deklariert, lehnt einen Anteil unter 100 mit einer Meldung ab, die den angeforderten Anteil und die von der Komponente deklarierte Genauigkeit nennt — zwei Dinge, die die Selektorverletzung nicht sagt. Die Werte werden daher aus dem abgeleitet, was am Markt verfügbare Produkte implementieren, statt als Taxonomie entworfen zu werden: request-mirroring trägt full-rate und sampled, weil sich reale Proxys genau so aufteilen, wobei einer eine Einstellung für die Kopierrate bietet und ein anderer keine.
  • Ein Wert sagt eine Fähigkeit aus, nie einen konfigurierten Zustand. Für einen Entwickler lesen sich beide gleich, und nur eines davon ist eine Eigenschaft der Komponente. Ein Proxy, der das Zertifikat eines Upstreams prüfen kann, trägt upstream-tls: trust-anchor, unabhängig davon, ob irgendein Deployment die Prüfung aktiviert — das Label ist das, worüber ein Feature auswählt, bevor irgendetwas konfiguriert ist, und es mit Konfiguration zu befrachten, würde es genau in dem Moment unlesbar machen, in dem es verwendet wird.
  • Was die Standardbibliothek mitbringt. core/gateway/nginx trägt request-mirroring: full-rate, upstream-tls: trust-anchor und concurrency-cap: total, eine einzige Obergrenze für jede Anfrage, die es weiterleitet. core/gateway/contour trägt request-mirroring: sampled, caller-identity: client-certificate und upstream-tls: trust-anchor. core/gateway/envoy-gateway trägt dieselben drei Werte wie core/gateway/contour, außerdem period-budget: tokens, das die Token zählt, die jede Antwort eines über Envoy AI Gateway bereitgestellten Modells meldet, und concurrency-cap: per-target, eine Obergrenze für die laufenden Anfragen an jedes bereitgestellte Modell. core/gateway/kong trägt upstream-tls: trust-anchor und prompt-guard: pattern-list, wobei sein AI Prompt Guard die Nachrichten einer Modellanfrage mit den Listen abgleicht, die seine Routen enthalten. core/gateway/tyk trägt upstream-pinning: public-key, das core/upstream-key-pinning auswählt. core/gateway/litellm trägt caller-identity: injected-header, content-masking: entity-recognition, period-budget: cost, prompt-guard: pattern-list, upstream-tls: trust-anchor und concurrency-cap: per-target, eine Obergrenze für die laufenden Anfragen an jeden Eintrag seiner Modell-Map. core/gateway/cloudflare-ai-gateway trägt period-budget: cost. core/gateway/apisix trägt period-budget: tokens, das die Token zählt, die die Antwort jedes Modells meldet, ohne etwas zu bepreisen, und prompt-guard: pattern-list. core/gateway/kong-enterprise trägt period-budget: tokens, das die Token zählt, die die Antwort jedes Modells meldet, und content-masking: entity-recognition. core/gateway/traefik-hub trägt content-masking: entity-recognition und prompt-guard: pattern-list, wobei seine Content-Guard-Middleware die Treffer der in ihrer Konfiguration hinterlegten Muster oder die Entitätstypen maskiert, die ein von ihr aufgerufener Presidio-Analysator erkennt, oder eine Anfrage ablehnt, auf die ein Muster passt, sowie period-budget: cost, bepreist anhand der modellbezogenen Preisliste, die mit seiner Quota-Middleware ausgeliefert wird und stattdessen die Token zählen kann, die jede Antwort meldet. core/gateway/agentgateway trägt content-masking: pattern-list und prompt-guard: pattern-list, wobei sein Guard auf Basis regulärer Ausdrücke die Treffer der in seiner Konfiguration hinterlegten Muster maskiert oder ablehnt und keine Entitätstypen erkennt, sowie period-budget: cost, die Budgets, die es pro API-Schlüssel in US-Dollar führt, bepreist anhand seines Modellkostenkatalogs, oder in Token. core/gateway/higress trägt content-masking: pattern-list, wobei sein Plugin ai-data-masking die Treffer der in seiner Konfiguration hinterlegten Muster im Text der Nachrichten einer Chat-Anfrage maskiert und keine Entitätstypen erkennt, sowie period-budget: tokens, das die Prompt- und Completion-Token, die jede Antwort meldet, zusammen zählt, ohne etwas zu bepreisen. core/gateway/azure-api-management trägt period-budget: tokens, das die Prompt- und Completion-Token, die jede Antwort meldet, zusammen zählt, mit einer separaten Zählung an jedem Gateway der Instanz, ohne etwas zu bepreisen. core/security/nemo-guardrails und core/security/trustyai-guardrails-gateway, zwei Guards, die im Pfad eines Modells stehen und eine Anfrage mit einem trainierten Klassifikator beurteilen, tragen prompt-guard: classifier, das die guard-Sockets des KI-Gateways und des NGINX-Gateways auswählen. Die KI-Gateways unter ihnen — core/gateway/litellm, core/gateway/cloudflare-ai-gateway, core/gateway/apisix, core/gateway/envoy-gateway, core/gateway/kong-enterprise, core/gateway/traefik-hub, core/gateway/agentgateway, core/gateway/higress und core/gateway/azure-api-management — tragen semantic, und die übrigen tragen keinen gateway.aggrega.ai/intelligence-Wert, und das ist die Trennung, die funktioniert, keine Ausnahme davon: Ein Feature, das eine Spiegelung braucht, erreicht die drei Komponenten, die eine haben, ein Produktstufen-Selektor würde unter ihnen nur Envoy Gateway erreichen, aus einem Grund, der nichts über Spiegelung aussagt, und ein Feature, das einen Prompt-Guard, Inhaltsmaskierung oder ein Periodenbudget braucht, erreicht ein KI-Gateway anhand dessen, was es tun kann, statt anhand der Stufe, auf der es steht, während eines, das die laufenden Anfragen begrenzt, das NGINX-Gateway erreicht, das keinen Stufenwert trägt, so wie es Envoy Gateway und das KI-Gateway erreicht, und eines, das eine Anfrage anhand einer Musterliste ablehnt, das Open-Source-Kong erreicht, das ebenfalls keinen trägt, so wie es APISIX erreicht. Eine Komponente, die auf einer dieser Achsen nichts zu beschreiben hat, trägt dort keinen Wert statt eines schwächsten, sodass ein Selektor, der irgendeinen Wert auf dieser Achse nennt, korrekterweise nicht an sie angehängt wird.

12. security.aggrega.ai/text-anonymization

  • Wer schreibt es? Der Plattformarchitekt, auf einem Dienst, der an der Maskierung sensibler Texte beteiligt ist. Wo diese Arbeit auf zwei Dienste aufgeteilt ist, gehört analyzer auf den, der sensible Abschnitte in einem Text findet und meldet, und anonymizer auf den, der die ihm übergebenen Abschnitte umschreibt; sanitizer gehört auf einen Dienst, der beides in einem Aufruf erledigt, indem er die sensiblen Abschnitte im an ihn gesendeten Text findet, sie selbst umschreibt und mit dem umgeschriebenen Text antwortet.
  • Wer verwendet es? Der statische Analysator, über den usesSchema-Selektor eines Sockets.
  • Compiler-Anwendungsfall: Darüber erhält ein Konsument die richtige Adresse. core/gateway/litellm deklariert einen Socket pii_analyzer, der security.aggrega.ai/text-anonymization=analyzer selektiert, und einen Socket pii_anonymizer, der den Wert anonymizer selektiert, sodass das Verdrahten eines der beiden Dienste mit dem Socket des anderen den Build mit einer Selektorverletzung abbricht, die den Socket nennt. core/gateway/kong-enterprise deklariert einen Socket, pii_sanitizer, der den Wert sanitizer selektiert, und core/gateway/traefik-hub einen, pii_analyzer, der allein den Wert analyzer selektiert, weil der Content Guard, den sein Chart-Recipe für core/data-masking schreibt, selbst ersetzt, was der Analyzer findet. Der Compiler leitet die Adresse weiter, die die selektierte Komponente veröffentlicht, und prüft nichts darüber, was dort antwortet.
  • Was die Standardbibliothek enthält. core/security/presidio-analyzer trägt analyzer und core/security/presidio-anonymizer trägt anonymizer. Beide sprechen die Presidio-HTTP-API, die das AI-Gateway aufruft, wenn eine Anbindung von core/data-masking oder das gateway-eigene values.log_masking Entitätstypen auflistet, und der Content Guard von Traefik Hub ruft allein den Analyzer auf, wenn eine Anbindung von core/data-masking an diesem Gateway sie auflistet. core/security/kong-ai-pii-service trägt sanitizer und spricht die API des AI-PII-Dienstes von Kong, die der AI PII Sanitizer von Kong Gateway Enterprise mit jedem Text aufruft, den er maskiert, einschließlich seiner regulären Ausdrücke, solange eine Anbindung von core/data-masking an diesem Gateway besteht. Der Sanitizer legt ihm keine Anmeldedaten vor und jeder Text erreicht ihn unmaskiert, daher ist seine Adresse eine clusterinterne, die nicht dafür gedacht ist, außerhalb des Clusters freigegeben zu werden.

13. model.aggrega.ai/api

  • Wer schreibt es? Der Platform Architect, an jeder Komponente der Kategorie model und an einem Gateway, das eine Modell-API bereitstellt. Der Wert gibt an, welche Modell-API unter der Adresse antwortet, die die Komponente veröffentlicht: openai, wo es die OpenAI-API ist — die des Anbieters selbst oder die Implementierung eines Servers —, anthropic, wo es die Messages API von Anthropic ist, gemini, wo es die Gemini API von Google ist, und native, wo es die eigene API des Produkts und keine der genannten ist, die ein Konsument über den Client dieses Produkts erreicht. Jeder Wert wird aus der eigenen Referenz des Produkts abgelesen, und eine Komponente trägt ihn unabhängig davon, was ein bestimmtes Release konfiguriert.
  • Wer konsumiert es? Der Static Analyzer, über den usesSchema-Selektor eines Sockets, sowie die Assertions des AI-Gateways, von core/gateway/kong, von core/gateway/kong-enterprise, von core/gateway/apisix, von core/gateway/envoy-gateway, von core/gateway/traefik-hub, von core/gateway/agentgateway und von core/gateway/higress bei jeder Verbindung zu ihren models-Sockets.
  • Compiler-Anwendungsfall: Er ermöglicht es, dass ein einziger Socket entweder ein Modell oder ein Gateway annimmt, das Modelle bereitstellt. Der model-Socket jedes Agenten außer den fünf weiter unten genannten Runtimes, der target_model-Socket von core/ai-tool/model-invocation und die beiden Modell-Sockets von core/datastore/cognee selektieren component.aggrega.ai/category in (ai-model, gateway), model.aggrega.ai/api: Die Kategorieanforderung lässt die beiden Kategorien zu, und die Schlüsselanforderung lässt unter deren Komponenten nur diejenigen zu, die das Label tragen, sodass das Verdrahten eines solchen Sockets mit einem Gateway, das keine Modell-API bereitstellt, den Build mit einer Selektorverletzung abbricht, die den Socket nennt. Die Anforderungen eines Selektors müssen alle erfüllt sein und seine Alternativen liegen innerhalb der Menge eines einzigen Schlüssels, daher muss der eine Schlüssel, auf den beide Arten von Komponenten ansprechen, an jeder Modellkomponente ebenso wie am Gateway sitzen — weshalb das Label eine API benennt, statt nur Gateways zu kennzeichnen. Ein Gateway, das es trägt, veröffentlicht die Schlüssel endpoint und model, die ein Modell veröffentlicht, sodass das Recipe eines Konsumenten beides auf die gleiche Weise liest. Ein Agent, dessen Recipes die Variablen einer einzigen Modell-API liefern, nennt stattdessen deren Wert: Die model-Sockets von core/ai-agent/openai-agents-sdk, core/ai-agent/agent-framework und core/ai-agent/mastra selektieren model.aggrega.ai/api=openai, der von core/ai-agent/claude-agent-sdk selektiert model.aggrega.ai/api=anthropic und der von core/ai-agent/google-adk selektiert model.aggrega.ai/api=gemini, sodass das Verdrahten eines von ihnen mit einem Modell oder einem Gateway, das eine andere API bereitstellt, den Build mit einer Selektorverletzung abbricht, die den Socket nennt. Der Socket von core/ai-agent/google-adk schränkt außerdem die Kategorie auf ai-model ein und weist jedes Gateway ab, weil der Client von ADK keine Adresse liest und die Anmeldedaten eines Gateways an Googles eigene Adresse senden würde. Das AI-Gateway liest den Wert, statt nach ihm zu selektieren: Sein models-Socket selektiert component.aggrega.ai/category=ai-model und lässt damit jedes Modell zu, und weil das Gateway ein dort verdrahtetes Modell seinem Proxy allein über die OpenAI-API beschreibt, bricht die Assertion seiner Component den Build bei einer Verbindung ab, deren Ziel einen anderen Wert als openai trägt, nennt die Verbindung und weist darauf hin, diesen Upstream stattdessen in die von Hand geschriebene Modellzuordnung des Gateways einzutragen. core/gateway/kong, core/gateway/kong-enterprise, core/gateway/apisix, core/gateway/envoy-gateway, core/gateway/traefik-hub, core/gateway/agentgateway und core/gateway/higress lesen ihn an ihren eigenen models-Sockets auf die gleiche Weise, weil jedes die Route eines verdrahteten Modells, bei agentgateway dessen Modelleintrag, allein für die OpenAI-API schreibt. Der Compiler behandelt den Wert als opaken String und prüft nichts darüber, was unter der Adresse antwortet.
  • Was die Standardbibliothek enthält. core/gateway/litellm, core/gateway/kong, core/gateway/kong-enterprise, core/gateway/apisix, core/gateway/envoy-gateway, core/gateway/traefik-hub, core/gateway/agentgateway und core/gateway/higress tragen openai, ebenso die selbst gehosteten Server core/ai-model/vllm, ollama, docker-model-runner, tgi, tei, nvidia-nim und litellm, die verwalteten APIs core/ai-model/openai, openai-embedding und nvidia-api sowie der Broker core/ai-model/openai-compatible, der auf einen Dienst gerichtet wird, der diese API spricht. core/ai-model/anthropic trägt anthropic, und core/ai-model/gemini trägt gemini. Jede andere Modellkomponente trägt native.

14. tool.aggrega.ai/transport

  • Wer schreibt es? Der Platform Architect, an einem Tool, das ein Konsument über einen Transport erreicht, den er sprechen muss. Der Wert benennt diesen Transport.
  • Wer konsumiert es? Der Static Analyzer, über den Tool-Socket eines Konsumenten.
  • Compiler-Anwendungsfall: Darüber erhält ein Konsument nur die Tools, mit denen er kommunizieren kann. Ein Tool-Socket selektiert component.aggrega.ai/category=ai-tool, tool.aggrega.ai/transport=http: Die Kategorieanforderung lässt Tools und nichts anderes zu, und die Transportanforderung lässt nur die über HTTP erreichten Tools zu, sodass das Verdrahten eines solchen Sockets mit einem Tool, das kein solches Label trägt, den Build mit einer Selektorverletzung abbricht, die den Socket nennt. Wie ein Tool erreicht wird, muss ein Label sein und kein veröffentlichter Wert, weil ein Selektor Labels liest und niemals den Inhalt eines Werts. Der Compiler behandelt den Wert als opaken String und prüft nichts darüber, was unter der Adresse antwortet.
  • Was die Standardbibliothek enthält. core/ai-tool/mcp trägt http. Es bindet einen Model-Context-Protocol-Server an einen Agenten an, und das Manifest wählt, wie dieser Server realisiert wird: helm/mcp und compose/mcp führen ein Image aus, das das Protokoll über HTTP bereitstellt; helm/mcp-stdio-bridge und compose/mcp-stdio-bridge führen ein Paket, das nur stdio spricht, hinter einer versionsfixierten Bridge aus, die es über HTTP bereitstellt; helm/mcp-remote und compose/mcp-remote erreichen einen Server, den jemand anderes betreibt, und führen nichts aus. Jede Realisierung veröffentlicht dieselben host, port, endpoint, protocol und credential_header, sodass sich die Verdrahtung eines Konsumenten mit der Realisierung nicht ändert. Die eigenen Anmeldedaten eines Servers sind Umgebungsvariablen, die im Slot server_env des Tools gehalten werden: auf Kubernetes per Referenz an die Bridge geliefert und auf Docker Compose so, wie sie geliefert werden, in die Umgebung des Dienstes geschrieben, wobei eine Compose-Variablenreferenz die Anmeldedaten aus der Datei heraushält; die Anmeldedaten eines entfernten Servers hält der Konsument an seiner eigenen Verbindung zum Tool und legt sie unter dem Header vor, den credential_header nennt, Authorization, sofern das Release keinen anderen nennt. Wo ein entfernter Server seinen Schlüssel aus seiner eigenen Adresse liest, hält der Konsument auch die gesamte Adresse an dieser Verbindung, in einem endpoint-Slot, der auf Kubernetes durch eine Referenz auf ein Secret und auf Docker Compose durch eine Compose-Variablenreferenz gefüllt wird, sodass der Schlüssel in keine gerenderte Datei gelangt, während infra.endpoint des Tools die Adresse ohne den Teil enthält, der den Schlüssel trägt; examples/mcp-address-from-secret baut beides. core/ai-agent/openai-agents-sdk, core/ai-agent/claude-agent-sdk, core/ai-agent/agent-framework, core/ai-agent/google-adk und core/ai-agent/mastra sowie die Flow-Plattformen core/ai-agent/flowise und core/ai-agent/n8n deklarieren einen Tool-Socket dieser Form, tools, und liefern die Adresse jedes verdrahteten Tools sowie die Anmeldedaten der Verbindung per Referenz unter Variablen, die nach dem Alias der Verbindung benannt sind, während eine Verbindung, die einen inject:-Block schreibt, anstelle der aus den Veröffentlichungen des Tools abgeleiteten Variablen das erhält, was dieser Block vorgibt, wobei der Inhalt ihrer Slots credential und endpoint unter dem Namen des Alias bleibt; ein eigener Konsument deklariert einen auf die gleiche Weise. Jede der drei Flow-Plattformen bringt beim Deployment einen im Aggregate verfassten Flow in die Plattform, auf beiden Zielen: Langflow lädt die mitgeführte Definition bei jedem Start aus seinem Flows-Verzeichnis, der Chatflow von Flowise wird durch einen einmaligen Schritt angelegt, der sich als das Owner-Konto anmeldet, das das Release nennt, und der Workflow von n8n wird durch einen Init-Schritt importiert, bevor die Plattform startet. core/ai-agent/langflow deklariert einen tools-Socket derselben Form, der keinen inject:-Block zulässt, und liefert jede Verbindung stattdessen über diesen Flow, weil die MCP-Tools-Komponente von Langflow die Adresse eines Servers nur aus den eigenen Einstellungen von Langflow oder aus dem Flow übernimmt, niemals aus einer Variablen: Seine Recipes schreiben die Adresse des Tools in den MCP-Tools-Knoten, dessen Server nach dem Alias der Verbindung benannt ist, liefern die Anmeldedaten der Verbindung per Referenz als Variable, die der Header dieses Knotens nennt — unter Authorization eine Variable, die Bearer und die Anmeldedaten enthält —, und lassen die Hosts der verdrahteten Tools und Stores durch Langflows Schutz vor privaten Adressen. Alle drei Plattformen deklarieren außerdem einen vector_store-Socket, der datastore.aggrega.ai/engine in (vector, semantic-memory, search) selektiert und auf die gleiche Weise die Adresse jedes verdrahteten Stores liefert — den endpoint, den er veröffentlicht, für core/datastore/pgvector eine Verbindungs-URI ohne Passwort, oder eine aus seinem Protokoll, Host und Port zusammengesetzte — sowie die Anmeldedaten der Verbindung per Referenz; ein Store, der außerdem seine Datenbank und seinen Benutzer veröffentlicht, wie es core/datastore/pgvector tut, erreicht Flowise und n8n auch in diesen Teilen, da der PostgreSQL-Vektorknoten keiner der beiden Plattformen einen Verbindungsstring annimmt; Langflow, dessen PGVector-Komponente einen einzigen String annimmt, erhält einen solchen Store als AGGREGA_VECTOR_STORE_<ALIAS>_CONNECTION_STRING, mit den Anmeldedaten der Verbindung als Passwort, per Referenz auf Kubernetes und so, wie sie geliefert werden, auf Docker Compose. Ein Flowise-Chatflow liest eine gelieferte Variable über eine gleichnamige Runtime-Variable, die auf der Variables-Seite von Flowise angelegt wird, und ein n8n-Workflow liest eine über $env nur dort, wo das Aggregate den Wert allow_env_access_in_nodes der Plattform setzt, da ihre Recipes standardmäßig die Sperre von n8n für den Umgebungszugriff in Knoten beibehalten.

2. Port-Abstraktion (die Zero-Port-Konvention)

Der Open-Source-Katalog der Aggrega-Standardbibliothek empfiehlt, physische Port-Deklarationen aus der kognitiven Schicht der Components wegzulassen und die Portwahl stattdessen über das Ops-Recipe zu leiten. Autoren, die dieser Empfehlung folgen, vermeiden Portkollisionen zwischen Deployment-Zielen, verhindern Backdoor-APIs, die den Injection Contract umgehen, und halten die Netzwerktopografie über Anbieter hinweg flexibel. Der Compiler selbst ist agnostisch gegenüber Ports — er leitet alle Werte weiter, die das aufgelöste JSON Schema zulässt. Die Konvention bietet einen ausdrücklichen Ausweg für Legacy-Systeme, deren physische Ports sich nicht verschieben lassen.

  • Der Cloud-native Standard (dynamische Injektion): Für moderne Arbeitslasten lassen Components physische Ports vollständig (keine ports- oder expose-Arrays) aus ihrer schema:-Deklaration weg. Platform-Ops-Recipes wählen den internen TCP/UDP-Port und veröffentlichen ihn als benannten provides-Schlüssel, den nachgelagerte Konsumenten über den .context.uses-Injection-Contract lesen.
  • Der Legacy-Ausweg (explizite Deklaration): Wenn eine Legacy-Komponente einen unveränderlichen, fest codierten Port hat, legt der Platform Architect ausdrücklich ein Feld port in der schema:-Deklaration der Component offen. Dies gibt dem Developer einen validierten Weg, die physische Einschränkung zu deklarieren. Der Compiler trägt den Wert unverändert durch die Pipeline; das Recipe konsumiert ihn über {{ .values.port }}.
  • Betriebsports (Out-of-Band): Ports, die ausschließlich von der Cluster-Infrastruktur genutzt werden (z. B. Prometheus-Scraping, Envoy-Sidecar-Metriken), bleiben vor der kognitiven Schicht des Developers verborgen. Sie werden von Platform Ops out-of-band über Features injiziert (z. B. indem das Feature core/prometheus-exporter angebunden wird, dessen Scrape-Port zur infra des Betreibers gehört).

3. Domänenspezifische Schemas (Konfigurationsintelligenz)

Die values-Blöcke des Entwicklers (die für den Go-Compiler opak sind, aber durch die schema:-Deklaration der Component streng typisiert werden) werden validiert, um explizite AI-Workflows zu unterstützen:

  • Agenten-Links (Abhängigkeits-Arrays): Das gemeinsame Agenten-Parameterschema der Standardbibliothek führt tools_allowed und agents_allowed als values-Arrays, die die Katalog-Components benennen, die ein Agent aufrufen oder an die er delegieren darf — eine dokumentierte Konvention, die der Compiler nicht auswertet. Ein Link, den der Compiler als topologische Kante verdrahtet, ist ein uses-Socket, den die Component des Agenten in ihrem usesSchema deklariert, und der Selektor dieses Sockets ist das, was der Build prüft.
  • Tiefe Partitionierung des kognitiven Gedächtnisses (CoALA): Statt eines einzigen flachen Speicher-Buckets kann ein Architekt einen cognitive_memory-Socket deklarieren, dessen Verbindungen semantisches, episodisches und prozedurales Gedächtnis als explizite topologische Kanten auf unterschiedliche Infrastrukturziele abbilden, sodass Policy-Engines granulare Zugriffsschranken auswerten und vorschreiben können (z. B. sicherstellen, dass ein Agent semantisches Gedächtnis lesen, es aber bei einer Übernahme nicht überschreiben kann). Die Standardbibliothek deklariert keinen solchen Socket.
  • Multimodale Pipelines: Das schema: einer Component kann explizite Ausführungsstufen wie document_chunking, embedding_generation und storage_routing als typisierte values deklarieren, sodass ein deklarativer Datenfluss validiert wird, bevor irgendetwas gerendert wird. Die Standardbibliothek deklariert keine solchen Stufen.

4. Gateway-Intelligenz und Routing

Die AI-Gateways der Standardbibliothek tragen die Kontrollen für das Routing von Anfragen an LLM-APIs: core/gateway/litellm, das im Cluster läuft, und zwei gehostete Dienste — core/gateway/cloudflare-ai-gateway, das gehostete Gateway von Cloudflare, das sein Terraform-Recipe in einem Cloudflare-Konto anlegt, und core/gateway/azure-api-management, das AI-Gateway von Azure API Management, dessen Terraform-Recipe einer bereits bestehenden API-Management-Instanz eine API hinzufügt, die ein Modell bereitstellt, samt deren Backend und Policy. Die Helm- und Compose-Recipes jedes gehosteten Gateways verweisen darauf, wo es bereits konfiguriert ist. Manche Kontrollen sind Werte am Gateway selbst und manche sind daran angebundene Features, und jedes Feature unten gibt an, an welchem Gateway die Standardbibliothek es realisiert. Bei einem gehosteten Gateway wird jede Kontrolle in die eigene Konfiguration des Gateways geschrieben — eine Einstellung der Ressource des Cloudflare-Gateways, ein Element der Policy der API auf Azure API Management —, sodass nur sein Terraform-Recipe eine tragen kann, und seine Helm- und Compose-Recipes brechen den Build bei jeder Anbindung ab. Im Folgenden ist „das AI-Gateway“ core/gateway/litellm, „das gehostete Gateway“ core/gateway/cloudflare-ai-gateway, und das Gateway von Azure API Management wird voll ausgeschrieben.

Außerhalb von Aggrega, zur Laufzeit

Agent

sein Socket model, mit dem Gateway verbunden

KI-Gateway

mit den daran angehängten Kontrollen

Token-Budget

semantischer Cache

Schutz vor Prompt-Injection

Modell

ein Anbieter hinter dem Gateway

Die Anfragen eines Agenten laufen über das Gateway, mit dem sein Socket model verbunden ist, sodass jede an das Gateway angehängte Kontrolle zwischen dem Agenten und dem Modell steht. Die drei hier gezeigten sind die Features core/period-budget, core/semantic-caching und core/prompt-injection-shield, nebeneinander dargestellt, um zu zeigen, wo sie sitzen, und nicht als Konfiguration eines einzelnen Gateways: Die Einträge unten geben an, welches Gateway jede Kontrolle realisiert und was den Build anhält.

  • Die Modelle dahinter: Die Modellzuordnung des AI-Gateways — die Aliasse, die es bereitstellt, jeweils mit dem Upstream, an den eine Anfrage dafür gesendet wird — hat zwei Teile. Eine mit dem models-Socket des Gateways verdrahtete Modellkomponente, verwaltet oder selbst gehostet, wird unter dem Alias der Verbindung bereitgestellt, ihr Eintrag aus dem endpoint und model geschrieben, die das Modell veröffentlicht, Strings, die der Compiler in die Konfiguration des Gateways leitet und niemals auflöst; das Modell ist daher eine Komponente des Graphen, erreicht über eine eigene Kante. Das Gateway beschreibt ein solches Modell seinem Proxy allein über die OpenAI-API, sodass eine Verbindung zu einem Modell, dessen model.aggrega.ai/api nicht openai ist, den Build abbricht und die Verbindung nennt. Der andere Teil sind die values.models des Gateways, von Hand eingegebene Einträge in der eigenen Anbieter/Modell-Notation des Proxys: für einen Upstream, den der Katalog nicht modelliert, für einen Anbieter, dessen eigene API nicht die OpenAI-API ist, und für mehrere Einträge, die sich einen Alias teilen, was verdrahtete Modelle nicht können, da jedes unter dem Alias seiner eigenen Verbindung bereitgestellt wird. Ein verdrahteter Eintrag legt die Anmeldedaten vor, die seine eigene Verbindung trägt, wie „Der Schlüssel, den ein Aufrufer vorlegt“ unten beschreibt, und niemals den provider_key des Gateways; jeder von Hand eingegebene Eintrag legt die einen Anmeldedaten in diesem Slot vor. Ein Alias, den beide Teile veröffentlichen, bricht den Build ab und nennt ihn, ebenso ein Gateway, dem keiner der beiden Teile ein Modell gibt.

  • Im Pfad eines Agenten: Das Gateway veröffentlicht einen endpoint und ein model, die Schlüssel, die eine Modellkomponente veröffentlicht, und trägt model.aggrega.ai/api: openai, sodass der model-Socket eines Agenten das Gateway direkt annimmt und jede daran angebundene Kontrolle zwischen diesem Agenten und den Anbietern dahinter steht. Das model, das es veröffentlicht, ist der Alias, den sein values.model nennt, und der Build bricht ab, wenn keiner der beiden Teile der Zuordnung ihn veröffentlicht; es darf nur weggelassen werden, wo das Gateway einen einzigen Alias bereitstellt und ein Eintrag von values.models ihn veröffentlicht, der dann der veröffentlichte ist. Ein Aufrufer, der einen anderen Alias wünscht, den die Zuordnung veröffentlicht, fragt denselben Endpunkt namentlich danach. core/gateway/cloudflare-ai-gateway veröffentlicht dieselben zwei Schlüssel — die Adresse eines der Endpunkte des Gateways, zusammengesetzt aus dem Cloudflare-Konto und der ID des Gateways, und das Modell, nach dem ein Aufrufer fragt, das das Gateway ungeprüft weiterleitet —, trägt aber kein model.aggrega.ai/api, sodass der model-Socket eines Agenten es nicht annimmt. core/gateway/azure-api-management veröffentlicht sie ebenfalls — die Adresse seiner API, zusammengesetzt aus dem Host der Instanz und dem Pfad der API, und das Modell, nach dem ein Aufrufer fragt, ungeprüft weitergeleitet — und trägt ebenfalls kein model.aggrega.ai/api: Die API beantwortet die Chat-Completions-Anfrage von OpenAI, aber standardmäßig legt ein Aufrufer einen API-Management-Abonnementschlüssel in einem eigenen Header vor statt des Bearer-Tokens von OpenAI, sodass ein einfacher OpenAI-Client nicht genügt, um sie aufzurufen.

  • Kong vor Modellen: core/gateway/kong, das Open-Source-Gateway Kong, stellt die mit seinem eigenen models-Socket verdrahteten Modelle über Kongs AI Proxy bereit und realisiert von den Kontrollen unten allein die Prompt-Deny-Patterns, als Kongs AI Prompt Guard auf jeder Route jedes verdrahteten Modells. Jedes verdrahtete Modell erhält eine Chat-Route und eine Completion-Route unter /<alias>/v1, geschrieben aus dem endpoint und model, die das Modell veröffentlicht, und seine Recipes importieren diese Routen in das PostgreSQL-Backend des Gateways, bevor es startet. Die Route wählt das Modell, sodass eine Anfrage an das Modell gesendet wird, das ihr Pfad nennt, welchen Modellnamen sie auch trägt. Das Gateway legt die eigenen Anmeldedaten jeder Verbindung als Bearer-Token vor, das seine Konfiguration namentlich aus der Umgebung des Gateways liest, und eine Verbindung zu einem Modell, dessen model.aggrega.ai/api nicht openai ist, bricht den Build ab. Es veröffentlicht die Route des Alias, den sein values.model nennt, als seinen endpoint und diesen Alias als sein model und trägt model.aggrega.ai/api: openai, sodass der model-Socket eines Agenten es so annimmt, wie er das AI-Gateway annimmt. Ist nichts mit diesem Socket verdrahtet, stellt das Gateway kein Modell bereit und veröffentlicht beide Schlüssel leer, und ein damit verdrahteter Agent liest dann keine Adresse und keinen Modellnamen. Der Import fügt Routen hinzu und aktualisiert sie, entfernt aber keine, sodass eine Route, deren Verbindung entfernt wird, weiter antwortet, und der Prompt Guard, den eine Anbindung von core/prompt-deny-patterns geschrieben hat, nach dem Entfernen der Anbindung weiter abweist, bis jedes davon über Kongs Admin API gelöscht wird. Aus demselben Grund deklariert das Gateway keine Aufrufer, und seine Modellrouten prüfen keinen Schlüssel eines Aufrufers: Kong unterscheidet Aufrufer nur als die Consumer, die ein Authentifizierungs-Plugin nennt, und ein Consumer und sein Schlüssel blieben, einmal importiert, nach dem Entfernen des Aufrufers aus dem Release authentifizierungsfähig, wobei ein rotierter Schlüssel den alten weiter funktionieren ließe; auch kann ein key-auth-Schlüssel nicht per Referenz gehalten werden, sodass der Schlüssel eines Aufrufers Kong nur als Literal in einer gerenderten Datei erreichen könnte.

  • Kong Gateway Enterprise vor Modellen: core/gateway/kong-enterprise, Kongs kostenpflichtige Edition desselben datenbankgestützten Gateways, stellt die an seinen eigenen Socket models angebundenen Modelle über die Routen bereit, die core/gateway/kong bereitstellt; sie werden aus derselben Konfiguration geschrieben und durch einen Schritt im eigenen Pod des Gateways in dessen PostgreSQL-Backend importiert, bevor das Gateway startet, und es veröffentlicht sein endpoint und sein model wie Kong. Seine einzige Realisierung ist ein Chart-Recipe über Kongs offizielles Helm-Chart; eine Compose-Realisierung gibt es nicht. Es führt das Image aus, das das Release in infra.image benennt, einschließlich Versions-Tag, weil Kong das Enterprise-Image unter eigenen Bedingungen vertreibt und der Katalog deshalb keines benennt; der Build bricht ab, solange dieser Schlüssel nicht gesetzt ist oder sein Tag keine Version enthält. Die Lizenz erreicht das Gateway per Referenz auf das Secret, das an seinen erforderlichen Slot license gebunden ist, niemals als Wert, und der Build bricht ab, solange nichts diesen Slot bindet. Der Compiler validiert keine Lizenz und kontaktiert keinen Anbieter, sodass ein Release, das fehlerfrei baut, nichts über eine Lizenz aussagt: Kong liest die Lizenz beim Start eines Knotens, und ein Knoten ohne gültige Lizenz verhält sich wie mit einer abgelaufenen, wobei seine Entitätskonfiguration schreibgeschützt ist und sein Proxy-Verkehr mit der bereits vorhandenen Konfiguration bedient wird. Kong vertreibt seine AI-Plugins als sein Angebot AI Gateway Enterprise, eine Berechtigung innerhalb der Lizenz, die kein Build sehen kann, und überspringt ein solches Plugin, statt es abzulehnen, wo der Lizenz diese Berechtigung fehlt; daher bricht das Zuordnen von core/semantic-caching, core/period-budget, core/data-masking, core/fallback-chain, core/retry-policy oder core/target-selection den Build ab, bis das Release infra.ai_gateway_entitled auf true setzt und damit bestätigt, dass die Lizenz diese Berechtigung enthält. Von den folgenden Kontrollen realisiert es das Periodenbudget und die Fallback-Kette, jeweils in die Routen geschrieben, die das Gateway importiert, und es realisiert core/data-masking so, wie es „Datenexfiltration und Abfangen von Payloads“ weiter unten beschreibt; seine Realisierungen des semantischen Caches, der Retry-Policy und der Zielauswahl brechen bei jeder Zuordnung ab und nennen jeweils den Grund, und das Nebenläufigkeitslimit, das Audit-Logging, die Prüfung auf Prompt Injection, die Antwortvalidierung und die Prompt-Sperrmuster haben dort keine Realisierung, sodass eine Zuordnung einer dieser Kontrollen den Build abbricht. Eine geänderte Routenmenge löst ein Rollout des Gateways aus, und der Import fügt Routen hinzu und aktualisiert sie, entfernt aber keine, sodass eine Route, deren Verbindung entfernt wird, und ein Plugin, das ein AI-Feature geschrieben hat, sobald das Feature entfernt ist, in der Datenbank bleiben, bis sie über Kongs Admin API gelöscht werden; aus den Gründen, die der vorige Aufzählungspunkt nennt, deklariert es ebenfalls keine Aufrufer, und seine Modellrouten prüfen keinen Schlüssel eines Aufrufers. Dass ein laufendes Gateway eine dieser Kontrollen durchsetzt, wird von keinem Build beobachtet.

  • APISIX vor Modellen: core/gateway/apisix, das Open-Source-Gateway Apache APISIX, stellt die an seinen eigenen Socket models angebundenen Modelle über den AI-Proxy von APISIX bereit, wo das Manifest sein Chart-Recipe bindet, das APISIX 3.18.0 ausführt. Jedes angebundene Modell erhält eine Chat-Route und eine Completion-Route unter /<alias>/v1 – nur die Chat-Route, solange ein Periodenbudget oder Prompt-Sperrmuster zugeordnet sind, da APISIX bei einer Completion-Anfrage keine Tokens zählt und sein Prompt Guard keine liest –, geschrieben aus dem endpoint und dem model, die das Modell veröffentlicht, in eine mit dem Gateway gerenderte Routendatei, die es beim Start und erneut bei jeder Änderung der Datei liest. Ein Gateway, das seine Routen aus dieser Datei liest, liest kein etcd und betreibt keine Admin API, sodass bei einem angebundenen Modell eine Verbindung etcd oder eine Zuordnung admin_key den Build abbricht und ohne angebundenes Modell beide erforderlich sind. Die Route wählt das Modell. Das Gateway präsentiert die eigene Anmeldeinformation jeder Verbindung als Bearer-Token, das seine Routen namentlich aus der Umgebung des Gateways lesen, und eine Verbindung zu einem Modell, dessen model.aggrega.ai/api nicht openai ist, bricht den Build ab. Es veröffentlicht die Route des Alias, den sein values.model benennt, als sein endpoint und diesen Alias als sein model und trägt model.aggrega.ai/api: openai, sodass der Socket model eines Agenten es so annimmt wie das AI-Gateway; ohne angebundenes Modell veröffentlicht es beide Schlüssel leer. Eine Route, deren Verbindung entfernt wird, fehlt im nächsten Rendering. Ein Release kann die Aufrufer des Gateways in infra.callers benennen und ihre Schlüssel über den Slot caller_keys, ein Secret mit einem Datenschlüssel pro Aufrufername: Jeder Aufrufer ist dann ein Consumer in der Routendatei, dessen Schlüssel namentlich aus diesem Secret gelesen wird, und jede Route lehnt eine Anfrage, die keinen deklarierten Schlüssel als Authorization: Bearer <key> präsentiert – so, wie ein OpenAI-Client einen präsentiert –, mit HTTP 401 ab und entfernt den Schlüssel aus der Anfrage, die sie weiterleitet. Ohne Aufrufer sind die Routen offen. Sein Workload-Recipe, mit APISIX 3.17.0, hält seine Routen in etcd, rendert keine und bricht bei einer Verbindung zu diesem Socket sowie bei infra.callers ab. Von den folgenden Kontrollen realisiert es das Periodenbudget, einen semantischen Cache für die Aufrufer, die es deklariert, und Prompt-Sperrmuster.

  • Envoy Gateway vor Modellen: core/gateway/envoy-gateway, das Open-Source-Projekt Envoy Gateway, stellt die an seinen eigenen Socket models angebundenen Modelle über Envoy AI Gateway bereit, dessen Controller, core/gateway/envoy-ai-gateway-operator, das Gateway über seinen Socket extension als seinen Extension-Server aufruft. Ein angebundenes Modell ohne etwas an diesem Socket bricht den Build ab, und bei angebundenem Controller platziert das Release das Gateway in envoy-gateway-system, sonst bricht der Build ab. Jedes angebundene Modell wird zu einer Regel einer einzigen dem Gateway zugeordneten AI-Route, ausgewählt anhand des Modellnamens, den eine Anfrage trägt, mit einem Backend, das aus dem endpoint und dem model geschrieben wird, die das Modell veröffentlicht, sodass jedes angebundene Modell unter /v1 an der eigenen Adresse des Gateways bereitgestellt wird. Das Gateway präsentiert die eigene Anmeldeinformation jeder Verbindung als Bearer-Token, das der Controller von Envoy AI Gateway aus dem Secret liest, das die Anmeldeinformation benennt, und eine Verbindung zu einem Modell, dessen model.aggrega.ai/api nicht openai ist, bricht den Build ab. Solange ein Modell angebunden ist, übernimmt jede Route am Gateway den Anfragepuffer von 50Mi pro Verbindung, den Envoy AI Gateway konfiguriert. Es veröffentlicht seine Adresse, qualifiziert mit envoy-gateway-system, damit sie aus jedem Namespace aufgelöst wird, als sein endpoint und den Alias, den sein values.model benennt, als sein model und trägt model.aggrega.ai/api: openai, sodass der Socket model eines Agenten es so annimmt wie das AI-Gateway; ohne angebundenes Modell veröffentlicht es beide Schlüssel leer. Der Webhook des Controllers stellt ein Zertifikat bereit, das cert-manager ausstellt, daher muss cert-manager bereits im Cluster laufen, es sei denn, das Release benennt im infra.webhook_tls_secret des Controllers ein Secret mit einem vom Betreiber bereitgestellten Zertifikat, das der Webhook dann bereitstellt. Von den folgenden Kontrollen realisiert es das Periodenbudget, die Retry-Policy und das Nebenläufigkeitslimit, jeweils in die eine Traffic-Policy der Route geschrieben, die seine Modelle bereitstellt. Den semantischen Cache und die Antwortvalidierung realisiert es nicht, da Envoy AI Gateway keine Antwort aufbewahrt, mit der es eine spätere Anfrage beantworten könnte, und keine Antwort gegen ein Schema prüft, ebenso wenig die Fallback-Kette: Envoy AI Gateway fällt zurück, indem es auf weitere Backends der Regel eines Modells wiederholt, und das Gateway schreibt die Wiederholungsanzahl seiner einen Traffic-Policy in jede Regel der Route, die seine Modelle bereitstellt, sodass eine Fallback-Liste genau ihre Sendungen nur dort erhielte, wo die Liste jedes angebundenen Modells dieselbe Länge hat. Es realisiert core/audit-logging als sein Zugriffsprotokoll, wie „Audit-Logging“ weiter unten beschreibt, und lehnt namentlich ab, was dieses Protokoll nicht festhalten kann: was eine Anfrage gekostet hat, da die Kosten pro Anfrage, die Envoy AI Gateway berechnen kann, keine Einheit haben und das Gateway keine Preise kennt; einen vom Gateway verifizierten Aufrufer, da auf diesem Pfad nichts den Aufrufer verifiziert; und eine Aufbewahrungsdauer, da dieses Protokoll weder einen Speicher noch eine Aufbewahrungseinstellung hat. examples/envoy-ai-gateway-token-budget baut den gesamten Pfad auf, mit einem Agenten, der das verwaltete Modell von OpenAI über das Gateway erreicht.

  • agentgateway vor Modellen: core/gateway/agentgateway, das Open-Source-Projekt agentgateway, stellt die an seinen eigenen Socket models angebundenen Modelle aus einer einzigen Konfigurationsdatei bereit, die seine Recipes rendern. Jedes angebundene Modell ist ein Eintrag dieser Datei, benannt nach dem Alias der Verbindung und aus dem endpoint und dem model, die das Modell veröffentlicht, als OpenAI-kompatibler Anbieter von Chat Completions geschrieben, sodass jedes angebundene Modell unter /v1 an der eigenen Adresse des Gateways bereitgestellt wird und der Modellname, den eine Anfrage trägt, es auswählt: Die Anfrage erreicht das Modell mit dem Modellnamen, den das Modell veröffentlicht, und ein Name, den keine Verbindung trägt, wird mit HTTP 404 beantwortet. Das Gateway präsentiert die eigene Anmeldeinformation jeder Verbindung als Bearer-Token, das die Datei als Variable benennt, die das Gateway beim Lesen der Datei aus seiner Umgebung liest, wobei eine dort fehlende Variable seinen Start verhindert, und eine Verbindung zu einem Modell, dessen model.aggrega.ai/api nicht openai ist, bricht den Build ab. Es veröffentlicht diese Basis-URL /v1 als sein endpoint und den Alias, den sein values.model benennt, als sein model und trägt model.aggrega.ai/api: openai, sodass der Socket model eines Agenten es so annimmt wie das AI-Gateway; ohne angebundenes Modell veröffentlicht es beide Schlüssel leer. Zwei Recipes führen dasselbe, per Digest fixierte Image aus: agentgateway-chart rendert das eigenständige Helm-Chart des Projekts, das aus der Registry des Projekts abgerufen wird, und realisiert die folgenden Kontrollen, und agentgateway führt das Image als einen einzigen Docker-Compose-Dienst aus und realisiert keine davon und auch keine Aufrufer, sodass eine Zuordnung dort den Build abbricht und ihren Typ nennt; greifen Sie auf Kubernetes zum Chart, wo der Build diese Registry erreichen kann. Auf dem Chart kann ein Release die Aufrufer des Gateways in infra.callers und ihre Schlüssel über den Slot caller_keys benennen, wie bei APISIX: Jeder Aufrufer ist ein API-Schlüssel der Datei, im Strict-Modus geprüft und namentlich aus diesem Secret gelesen, sodass eine Modellanfrage, die keinen deklarierten Schlüssel als Authorization: Bearer <key> präsentiert, mit HTTP 401 abgelehnt wird und der Schlüssel aus der weitergeleiteten Anfrage entfernt wird; ohne Aufrufer sind die Modellrouten offen. agentgateway setzt jeden Schlüssel, den die Datei auf diese Weise benennt – den eines angebundenen Modells bei beiden Recipes und den eines Aufrufers auf dem Chart –, in den Text der Datei ein, bevor es die Datei als YAML liest, daher muss ein Schlüssel ein einfaches Token sein – Buchstaben, Ziffern und -, ., _, ~, +, / und = –, und andere Zeichen können als ein anderer Schlüssel geladen werden oder das Gateway anhalten. Das Gateway liest seine Datei erneut, wenn sie sich ändert, sodass ein aus dem Release entfernter Aufrufer abgelehnt wird, sobald die eingehängte Datei aktualisiert ist. Solange core/audit-logging oder core/period-budget mit dem Geltungsbereich caller zugeordnet ist, gibt das Chart-Recipe dem Gateway einen Speicher, eine SQLite-Datei auf einem eigenen Volume, und führt ein einziges Replikat aus. Von den folgenden Kontrollen realisiert es die Datenmaskierung, Prompt-Sperrmuster, das Periodenbudget, das Audit-Logging und die Retry-Policy, jeweils in die Datei geschrieben, und lehnt namentlich jeden Wert ab, den es nicht einhalten kann. Die Datenmaskierung ersetzt jeden Treffer der Muster, die die Zuordnung auflistet, durch <masked> oder beantwortet unter refuse die Anfrage oder die Antwort mit HTTP 403, und zwar in den System- und Entwickler-Prompts einer Anfrage, ihren übrigen Nachrichten und den Argumenten und Ergebnissen ihrer Tool-Aufrufe sowie im Nachrichtentext einer Antwort, die vollständig eintrifft; sie erkennt keine Entitätstypen und stellt nichts wieder her. agentgateway maskiert keine gestreamte Antwort, daher wird, solange Antworten maskiert werden, eine Modellanfrage, die eine gestreamte Antwort anfordert, vor der Weiterleitung mit HTTP 403 abgelehnt, ebenso jede Modellanfrage, deren Body größer ist als die 2 MiB, die das Gateway für diese Prüfung liest, ob gestreamt oder nicht. Eine Ablehnung durch einen Guard, auch die durch ein Sperrmuster, ist HTTP 403 mit dem Body „The request was rejected due to inappropriate content“ (Die Anfrage wurde wegen unangemessener Inhalte abgelehnt). Das Budget, die Aufzeichnungen und die Wiederholung sind unter „Periodenbudget“, „Audit-Logging“ und „Resilienz“ weiter unten beschrieben. Seine Realisierungen der Fallback-Kette, der Zielauswahl, des semantischen Caches, der Antwortvalidierung und der Prüfung auf Prompt Injection brechen bei jeder Zuordnung ab und nennen jeweils den Grund, und das Nebenläufigkeitslimit lässt sich ihm nicht zuordnen, da es keinen Wert dataplane.aggrega.ai/concurrency-cap trägt.

  • Traefik Hub vor Modellen: core/gateway/traefik-hub, das kostenpflichtige Gateway von Traefik, stellt die an seinen eigenen Socket models angebundenen Modelle über die Chat-Completion-Middleware von Traefik Hub bereit. Seine einzige Realisierung ist ein Chart-Recipe über das eigene Helm-Chart von Traefik; eine Compose-Realisierung gibt es nicht. Es führt das Image aus, das das Release in infra.image benennt, einschließlich Tag, weil Traefik Traefik Hub unter eigenen Bedingungen vertreibt und der Katalog deshalb keines benennt; der Build bricht ab, solange dieser Schlüssel nicht gesetzt ist oder keinen Tag benennt. Das Lizenz-Token erreicht das Gateway per Referenz auf das Secret, das an seinen erforderlichen Slot license gebunden ist, unter dem Datenschlüssel token, niemals als Wert, und der Build bricht ab, solange nichts diesen Slot bindet oder es einen anderen Datenschlüssel veröffentlicht. Traefik erfordert ausgehendes HTTPS zu api.traefik.io, wo das Gateway sein Token validiert; ab Traefik Hub v3.21 bedient das Gateway weiter, solange dieser Host nicht erreichbar ist, und versucht es im Hintergrund erneut, und ein Token gilt standardmäßig ein Jahr, wobei das Gateway anhält, sobald es abläuft. Das Chart-Recipe schaltet den Export der Fehlerprotokolle des Gateways an die Plattform von Traefik durch das Chart und dessen Prüfung auf eine neuere Version ab. Der Compiler validiert kein Token und kontaktiert keinen Anbieter, sodass ein Release, das fehlerfrei baut, nichts darüber aussagt, ob das Gateway startet. Jedes angebundene Modell erhält eine Route unter /<alias>/v1/chat/completions, die über einen Service vom Typ ExternalName an das endpoint gesendet wird, das das Modell veröffentlicht, und das model anfordert, das es veröffentlicht, unabhängig vom Modellnamen, den eine Anfrage trägt, sodass der Pfad das Modell wählt; es stellt nur Chat Completions bereit. Das Gateway präsentiert die eigene Anmeldeinformation jeder Verbindung als Bearer-Token, das Traefik Hub aus dem Secret liest, das die Chat-Completion-Middleware der Verbindung benennt, und eine Verbindung zu einem Modell, dessen model.aggrega.ai/api nicht openai ist oder dessen Endpunkt eine Adresse statt eines Hosts benennt, bricht den Build ab. Es veröffentlicht die Route des Alias, den sein values.model benennt, als sein endpoint und diesen Alias als sein model und trägt model.aggrega.ai/api: openai, sodass der Socket model eines Agenten es so annimmt wie das AI-Gateway; ohne angebundenes Modell veröffentlicht es beide Schlüssel leer. Ein Release kann die Aufrufer des Gateways in infra.callers und die htpasswd-Hashes ihrer Schlüssel über den Slot caller_keys benennen: Die API-Key-Middleware von Traefik Hub steht dann vor jeder Modellroute und lehnt eine Anfrage ab, die keinen deklarierten Schlüssel als Authorization: Bearer <key> präsentiert, und der Schlüssel wird aus der weitergeleiteten Anfrage entfernt; ohne Aufrufer sind die Routen offen. Was Traefik Hub mit dem Eintrag eines Aufrufers macht, der ein Secret oder einen Datenschlüssel benennt, das bzw. der nicht existiert, gibt seine Referenz nicht an, sodass die Routen im ungünstigsten Fall so offen sind wie ohne Aufrufer. Von den folgenden Kontrollen realisiert es das Periodenbudget, den semantischen Cache für die Aufrufer, die es deklariert, Prompt-Sperrmuster und die Datenmaskierung über Middlewares des AI-Gateways von Traefik Hub sowie die Fallback-Kette und die Retry-Policy über das eigene Failover und die eigene Wiederholung von Traefik, jeweils in die Routen geschrieben, die sein Chart-Recipe rendert. Das AI-Gateway ist eine Berechtigung innerhalb der Lizenz, die kein Build sehen kann, und was Traefik Hub mit einem gültigen Token macht, dessen Lizenz sie nicht enthält, ist nicht dokumentiert, daher bricht das Zuordnen einer der ersten vier den Build ab, bis das Release infra.ai_gateway_entitled auf true setzt. Seine Realisierungen der Prüfung auf Prompt Injection, des Audit-Loggings, der Zielauswahl und der Antwortvalidierung brechen bei jeder Zuordnung ab und nennen jeweils den Grund, und das Nebenläufigkeitslimit lässt sich ihm nicht zuordnen, da es keinen Wert dataplane.aggrega.ai/concurrency-cap trägt. Dass ein laufendes Gateway eine dieser Kontrollen durchsetzt, wird von keinem Build beobachtet.

  • Higress vor Modellen: core/gateway/higress, das Open-Source-Gateway Higress, auf Envoy aufgebaut und über Kubernetes-Ressourcen konfiguriert, stellt die an seinen eigenen models-Socket angeschlossenen Modelle über den AI-Proxy von Higress bereit. Seine einzige Realisierung ist ein Chart-Recipe über das projekteigene Helm-Chart higress-core, das den Controller von Higress samt seinem Discovery-Dienst und das Gateway ausführt; eine Compose-Realisierung gibt es nicht, da das Projekt seine Compose-Distribution hauptsächlich für lokale Tests vorsieht und diese Distribution mehrere zusammenwirkende Dienste ausführt, die über einen eigenen Store konfiguriert werden. Das Recipe pinnt das Chart, die Images und jedes Plugin-Modul, das es schreibt, und akzeptiert in infra.source_version nur die Chart-Versionen, für die seine Konfiguration nachgewiesen ist; das Gateway lädt diese Module zur Laufzeit aus der Plugin-Registry von Higress, die der Cluster erreichen muss und die der Build nicht prüfen kann. Der Controller überwacht nur den Namespace des Release, unter einer IngressClass, die nach dem Gateway und diesem Namespace benannt ist, sodass zwei Higress-Gateways in einem Namespace kollidieren. Jeder Alias erhält eine Route unter /<alias>/v1, die an den endpoint gesendet wird, den das Modell des Alias über einen Eintrag der gatewayeigenen Registry veröffentlicht, und das von ihm veröffentlichte model anfordert, unabhängig davon, welchen Modellnamen eine Anfrage trägt, sodass der Pfad das Modell wählt; Verbindungen, die in ihrem serves-Wert denselben Alias nennen, teilen sich dessen Anfragen zu gleichen Teilen. Das Gateway präsentiert die eigene Anmeldeinformation jeder Verbindung als Bearer-Token, das der Higress-Controller aus dem Secret liest, das die Konfiguration des AI-Proxys nennt, im Namespace des Gateways, und an das Gateway übergibt, sodass der Schlüssel in keiner gerenderten Datei steht; ein Secret-Name, der einen Punkt enthält, bricht den Build ab, da Higress den Namen nur bis zu seinem ersten Punkt liest, und eine Verbindung ohne Anmeldeinformation reicht den Schlüssel weiter, den die Anfrage präsentiert. Der AI-Proxy von Higress kopiert außerdem den Authorization-Header, den ein Client sendet, in einen X-HI-ORIGINAL-AUTH-Header, und jede Modellroute entfernt diese Kopie, bevor die Anfrage das Modell erreicht, sodass ein Schlüssel, den ein Client präsentiert, nie neben der eigenen Anmeldeinformation einer Verbindung übertragen wird. Über https prüft das Gateway, dass das Zertifikat eines Modells auf die Vertrauensanker des Systems zurückführt und den Host des Modells nennt, unabhängig davon, welchen Host der Client gesendet hat, und sendet dem Modell andernfalls nichts: Das Recipe kennzeichnet die Route jedes Alias, dessen Verbindungen alle https sind, mit der Higress-Annotation higress.io/backend-protocol: HTTPS, sodass das Gateway den Servernamen aus dem Host übernimmt, den der AI-Proxy in jede Anfrage schreibt – dem des Modells, qualifiziert mit dem Namespace des Modells, wo er keinen Punkt enthält –, und das Zertifikat dagegen prüft. Diese Annotation gilt für jede Verbindung eines Alias, sodass ein Alias, der http- und https-Verbindungen mischt, den Build abbricht und beide nennt; sie unter zwei Aliassen bereitzustellen behebt dies. Eine Verbindung zu einem Modell, dessen model.aggrega.ai/api nicht openai ist oder dessen Endpunkt eine Adresse statt eines Hosts nennt, bricht den Build ab. Es veröffentlicht die Route des Alias, den sein values.model nennt, als seinen endpoint und diesen Alias als sein model und trägt model.aggrega.ai/api: openai, sodass der model-Socket eines Agenten es so annimmt wie das AI-Gateway; ist nichts angeschlossen, veröffentlicht es beide Schlüssel leer. Es deklariert keine Aufrufer, sodass seine Modellrouten keinen Schlüssel eines Aufrufers prüfen, und ein Wert, der einen vom Gateway verifizierten Aufrufer erfordert, wird namentlich abgelehnt. Von den unten beschriebenen Kontrollen realisiert es das Periodenbudget, das Audit-Logging und die Retry-Policy, jeweils auf die Modellrouten geschrieben, und es realisiert core/data-masking so, wie es „Datenexfiltration und Abfangen von Payloads“ unten beschreibt. Seine Realisierungen der Antwortvalidierung, der Fallback-Kette, des semantischen Caches, der Prüfung auf Prompt-Injection und der Zielauswahl brechen bei jedem Anhängen ab und nennen jeweils den Grund, und weder Prompt-Sperrmuster noch das Nebenläufigkeitslimit lassen sich an es anhängen, da es keinen Wert dataplane.aggrega.ai/prompt-guard oder dataplane.aggrega.ai/concurrency-cap trägt. Dass ein laufendes Gateway eine dieser Kontrollen durchsetzt, wird von keinem Build beobachtet.

  • Azure API Management vor einem Modell: core/gateway/azure-api-management, das AI-Gateway von Azure API Management, einem gehosteten Dienst, stellt eine Modell-API über eine API auf einer bereits bestehenden API-Management-Instanz bereit. Sein Terraform-Recipe liest die Instanz und fügt die API hinzu, ihre Chat-Completions-Operation, das Backend, an das sie weiterleitet, und die Policy der API, die den Subscription Key des Aufrufers aus dem Weitergeleiteten entfernt und sich bei der Modell-API so authentifiziert, wie infra.backend_authentication es angibt: mit der verwalteten Identität der Instanz, mit einem in Key Vault gehaltenen Provider-Schlüssel oder ohne Authentifizierung. Seine Helm- und Compose-Recipes referenzieren eine außerhalb des Release konfigurierte API und brechen den Build bei jedem Anhängen ab. Von den unten beschriebenen Kontrollen realisiert sein Terraform-Recipe den semantischen Cache, das Periodenbudget, die Prüfung auf Prompt-Injection und die Retry-Policy, jeweils in die Policy der API geschrieben. Es realisiert weder das Nebenläufigkeitslimit, da Microsoft die Obergrenze, die seine Concurrency-Policy durchsetzt, als nie ganz genau bezeichnet, und als niedriger, wenn mehrere Kapazitätseinheiten in einer Region laufen, noch die Fallback-Kette, da die API an ein einziges Backend weiterleitet und Azures eigenes Fallback, die Prioritätsgruppen eines Backend-Pools, spätere Anfragen von einem Backend abzieht, dessen Circuit Breaker ausgelöst hat, statt eine fehlgeschlagene Anfrage an ein anderes Modell weiterzuschicken. Seine Realisierung von core/audit-logging bricht bei jedem Anhängen ab und nennt, was außerhalb ihrer Reichweite liegt: das Log selbst, das eine Diagnoseeinstellung auf der Instanz einschaltet; was eine Anfrage gekostet hat, solange require_cost aktiv ist, da Azures Log der Modellanfragen Token-Zählungen und das Modell, aber keinen Preis erfasst; und eine Aufbewahrungsdauer, wo retention_days angegeben ist, da eine Zeile so lange erhalten bleibt, wie der Log-Analytics-Arbeitsbereich, in dem sie landet, sie aufbewahrt. Dass die Policies so gelten und durchgesetzt werden, wie Microsoft es dokumentiert, wird von keinem Build beobachtet.

  • Der Schlüssel, den ein Aufrufer präsentiert: Ein Server, der den Schlüssel prüft, den seine Aufrufer präsentieren, hält diesen Schlüssel in einem eigenen Slot, der auf jedem modellbereitstellenden Ziel, das einen prüft, api_key heißt – core/ai-model/vllm, tei und tgi, das LiteLLM-Modell und das AI-Gateway, wo es der Schlüssel ist, den LiteLLM seinen Master Key nennt –, und jedes seiner Recipes liefert den Schlüssel als die Variable, die der Server liest. core/gateway/apisix und core/gateway/agentgateway halten jeweils einen Schlüssel für jeden Aufrufer, den ihr Release in infra.callers nennt, in ihrem caller_keys-Slot: ein einziges Secret, das den Schlüssel jedes Aufrufers unter dessen Namen enthält. core/gateway/traefik-hub hält seine Aufrufer auf dieselbe Weise, nur dass sein Secret den htpasswd-Hash des Schlüssels jedes Aufrufers enthält, mit dem seine Schlüsselprüfung einen präsentierten Schlüssel vergleicht, sodass es nicht das Secret ist, aus dem der Aufrufer seinen Schlüssel präsentiert. Ein Aufrufer hält den Schlüssel, den er präsentiert, auf seiner eigenen Seite, auf der Verbindung, auf der er ihn präsentiert, in einem Slot, den sein Socket deklariert: Die Agenten der Standardbibliothek deklarieren einen auf ihrem model-Socket, credential, das AI-Gateway auf seinem models-Socket und auf seinem cache_store-Socket, wo es das Passwort ist, das der semantische Cache des Gateways seinem Store präsentiert, core/gateway/kong und core/gateway/kong-enterprise auf ihren models-Sockets, core/gateway/apisix auf seinem models-Socket und auf seinem cache_store-Socket, wo es ebenso das Passwort ist, das sein semantischer Cache seinem Store präsentiert, core/gateway/agentgateway auf seinem models-Socket, core/gateway/envoy-gateway auf seinem models-Socket und auf seinem cache-Socket, wo es das Passwort ist, das der Rate-Limit-Dienst des Gateways dem Store präsentiert, der die Zählung eines Periodenbudgets führt, core/gateway/higress auf seinem models-Socket und auf seinem cache-Socket, wo es das Passwort ist, das sein Token-Limit dem Store präsentiert, der die Zählung eines Periodenbudgets führt, und core/gateway/traefik-hub auf seinem models-Socket, auf seinem cache-Socket, wo es das Passwort ist, das sein Kontingent dem Store präsentiert, der die Zählung eines Periodenbudgets führt, und auf seinem cache_store-Socket, wo es das Passwort ist, das sein semantischer Cache seinem Store präsentiert – sodass ein Agent, der ein Modell erreicht, oder ein Gateway, das ein von ihm bereitgestelltes Modell erreicht, dort den Schlüssel dieser Verbindung hält. Das AI-Gateway, die beiden Kongs, APISIX und agentgateway liefern den Schlüssel jedes angeschlossenen Modells unter einer eigenen Variable, die der Eintrag oder die Route dieses Modells in ihrer Konfiguration nennt; Envoy Gateway nennt das Secret in der Security-Policy des Backends des Modells, und der Controller von Envoy AI Gateway liest den Schlüssel daraus; Traefik Hub nennt das Secret und den Datenschlüssel in der Chat-Completion-Middleware der Route des Modells und liest den Schlüssel daraus. Eine Verbindung zu einem Modell mit dem Label component.aggrega.ai/hosting: managed trägt einen oder gibt in ihren eigenen values an, dass das Modell keinen annimmt, unauthenticated: true; fehlt beides, bricht die Zusicherung des Aufrufers den Build ab und nennt die Verbindung und ihr Ziel, und ein anders gelabeltes Modell löst keinen solchen Abbruch aus. Ein Schlüssel, den die Component eines Aufrufers stattdessen in einem eigenen Slot deklariert, ist ein einziger Schlüssel für jede Verbindung, die sie herstellt. Keines der beiden Enden sieht die Anhänge des anderen, sodass der Server nichts über den Schlüssel eines Aufrufers erfährt, und die beiden stimmen überein, weil das Aggregate beide aus einem Parameter speist: Wo beide Enden Secrets in einem Geltungsbereich auflösen – einem Kubernetes-Namespace, einem Compose-Projekt –, referenzieren sie ein Secret, andernfalls hält jedes sein eigenes, aus demselben Store-Eintrag realisiert. vLLM, TEI und TGI prüfen jeweils einen einzigen Schlüssel, sodass jeder Aufrufer denselben Schlüssel präsentiert und der Server seine Aufrufer nicht unterscheiden kann, und TGI vergleicht seinen Schlüssel ohne Beachtung der Groß- und Kleinschreibung; APISIX, agentgateway und Traefik Hub prüfen jeweils den Schlüssel jedes deklarierten Aufrufers und unterscheiden ihre Aufrufer daran; die beiden Kongs deklarieren keine Aufrufer und prüfen keinen Schlüssel eines Aufrufers, aus den Gründen, die „Kong vor Modellen“ oben nennt; das LiteLLM-Modell und das AI-Gateway akzeptieren außerdem die Schlüssel, die sie ausstellen, solange ihre Buchhaltungsdatenbank angehängt ist. Credential-Modell arbeitet diese Form in einem Aggregate durch.

  • Zwischen Zielen wählen: core/target-selection deklariert, wie ein Gateway zwischen mehreren Zielen wählt, die dieselbe Anfrage bedienen können, mit einer strategy von latency (das Ziel, das beobachtet am schnellsten antwortet) oder cost (das Ziel, dessen Aufruf am günstigsten ist). Die Strategie ist Teil dessen, was die Anwendung von ihrem Gateway verlangt, daher hängt der Entwickler sie im Aggregate an. Auf dem AI-Gateway sind die Ziele die Einträge seiner values.models, die denselben Alias veröffentlichen – ein angeschlossenes Modell wird unter dem Alias seiner Verbindung bereitgestellt, den kein anderer Eintrag veröffentlichen darf –, und die Standardbibliothek realisiert latency, indem sie das latency-based-routing des Proxys in die Routing-Konfiguration schreibt, die das Recipe des Gateways rendert: Der Proxy sendet jede Anfrage an den Eintrag, dessen letzte zehn Antworten im Durchschnitt am wenigsten Zeit benötigt haben, pro Ausgabe-Token, wo eine Antwort ihre Tokens meldet, oder bis zum ersten Token bei einer gestreamten Anfrage, und ein noch nicht versuchter Eintrag gilt als der schnellste. Ohne den Anhang nennt die Konfiguration keine Strategie, und der Proxy wählt zufällig unter diesen Einträgen. cost wird dort namentlich abgelehnt: Der Proxy bepreist einen Eintrag, indem er dessen Ziel, genau wie geschrieben, in einer Preistabelle nachschlägt, die die Modelle von OpenAI und Anthropic ohne das Provider-Präfix nennt, das die Ziele des Gateways tragen, und bepreist einen Eintrag, den er nicht findet, mit einem festen Ersatzpreis, sodass die Einträge, die sich einen Alias teilen, gleich bepreist und nach ihrer Reihenfolge gewählt würden. Auf core/gateway/kong-enterprise bricht jeder Anhang ab, weil jedes daran angeschlossene Modell auf eigenen Routen bereitgestellt wird, die nur dieses eine Modell tragen, was nichts zur Auswahl lässt. Auf core/gateway/agentgateway bricht ebenfalls jeder Anhang ab und nennt den Grund: agentgateway zieht zufällig zwei der Ziele eines Modellnamens und nimmt dasjenige, dessen Gesundheit, geteilt durch die Zeit, die es zum Antworten gebraucht hat, höher bewertet wird, sodass das schnellste Ziel nur genommen wird, wenn es gezogen wird, und es wählt kein Ziel nach Kosten. Auf core/gateway/higress bricht ebenfalls jeder Anhang ab und nennt den Grund: Higress kann die Latenz eines Dienstes messen, aber sein Load-Balancer-Plugin läuft nach dem AI-Proxy – der das Modell, die Adresse und die Anmeldeinformation der Anfrage bereits für den von der Route aufgelösten Kandidaten gesetzt hat – und schreibt seine Wahl in einen Anfrage-Header, nach dem ohne einen Envoy-Filter, den dieser Katalog nicht rendert, nichts routet, sodass die Wahl nicht wirksam wird, und es wählt kein Ziel nach Kosten. Auf core/gateway/traefik-hub bricht ebenfalls jeder Anhang ab und nennt den Grund: Traefik wählt nach niedrigster Antwortzeit nur unter den Servern eines Service, die ein Modellname und eine Anmeldeinformation abdecken, und gleicht zwischen Services nach Gewicht oder nach einem Hash der Client-Adresse aus, nie nach Latenz, und keine seiner Strategien wählt ein Ziel nach Kosten; zudem wird jedes an das Gateway angeschlossene Modell auf einer eigenen Route bereitgestellt, die nur dieses eine Modell trägt, was nichts zur Auswahl lässt. Auf jedem anderen Gateway bricht ein Anhang den Build ab.

  • Resilienz: core/fallback-chain leitet eine Anfrage, deren Modell fehlschlägt, an andere Modelle weiter: chains nennt für jeden Modell-Alias, der ausweicht, die Aliase, die der Reihe nach versucht werden, bis einer antwortet, wobei ein fehlschlagender Fallback seinerseits seinem eigenen Eintrag folgt, und max_hops begrenzt, wie weit eine Anfrage entlang dieser Kette weitergereicht wird. Die Standardbibliothek realisiert es auf dem AI-Gateway, indem sie beides in die Routing-Konfiguration schreibt, die das Recipe des Gateways rendert, und bricht den Build bei einem Namen ab, den die Modellzuordnung des Gateways nicht veröffentlicht. Eine Anfrage weicht erst aus, wenn das Gateway den angefragten Alias aufgegeben hat: Wo ein Alias mehr als einmal veröffentlicht ist, wechselt ein fehlgeschlagener Aufruf zuerst als Wiederholung zu einem anderen seiner Einträge, begrenzt durch die Wiederholungsanzahl des Gateways. core/retry-policy legt diese Anzahl fest — wie oft das Gateway eine Anfrage senden darf, den ersten Versand eingeschlossen (max_attempts), bei einem Fehler, der durch erneutes Senden behoben wird, etwa eine abgelehnte Verbindung, ein Rate Limit oder ein Timeout —, und die Standardbibliothek realisiert es auf dem AI-Gateway, indem sie sie in die Routing-Konfiguration schreibt, die das Recipe des Gateways rendert. Auf core/gateway/envoy-gateway wird es als Retry der Traffic Policy auf der Route realisiert, die die verbundenen Modelle bedient, derselben Policy, die das Rate Limit eines Periodenbudgets trägt, weil Envoy Gateway einer Route eine einzige Traffic Policy zuordnet: Eine Anfrage wird nach einer abgelehnten Verbindung oder einem abgelehnten Stream, einem Reset oder einer Antwort 429, 503 oder 504 erneut gesendet, bis zu max_attempts Sendungen, und an ein Modell, das innerhalb des Anfrage-Timeouts der Route nichts antwortet, wird nicht erneut gesendet, weil dieses Timeout alle Sendungen umfasst. Auf core/gateway/azure-api-management wird es als Azures Retry um die Weiterleitung realisiert, im Backend-Abschnitt der Policy der API: Eine Anfrage, die mit HTTP 429 oder einem 5xx-Status beantwortet wird, wird erneut gesendet, wobei ihr Body zurückgehalten wird, damit er erneut gesendet werden kann, eine Sekunde nach dem vorherigen Versand, bis zu max_attempts Sendungen. Bei einer abgelehnten oder abgebrochenen Verbindung und bei einem Modell, das innerhalb des Timeouts der Weiterleitung nichts antwortet, wird nicht erneut gesendet, weil Azure den Retry bei einem solchen Fehler beendet und ihn an den on-error-Abschnitt der Policy übergibt. Azure wiederholt nach dem ersten Versand 1- bis 50-mal, daher schreibt ein max_attempts von 1 keinen Retry, und ein Wert über 51 wird ausdrücklich abgelehnt. Der Retry tritt an die Stelle der Weiterleitung, die die API erben würde, sodass, solange er angehängt ist, eine in einem weiteren Geltungsbereich der Instanz vorgenommene Weiterleitungseinstellung, etwa ein Timeout, nicht für die API gilt, die mit den Standardwerten von Azure weiterleitet. Auf dem gehosteten Gateway wird core/retry-policy realisiert, indem in die Ressource des Gateways dessen Wiederholungsanzahl geschrieben wird, die die Sendungen nach der ersten angibt, von 1 bis 5, sodass max_attempts von 2 bis 6 berücksichtigt und jeder andere Wert abgelehnt wird; core/fallback-chain wird dort nicht realisiert, weil dieses Gateway nur innerhalb einer Route, die eine Anfrage anstelle eines Modells nennt, zwischen Modellen ausweicht, sodass eine Anfrage für ein Modell nie ausweicht. Auf core/gateway/kong-enterprise wird core/fallback-chain auf seinem Chart-Recipe realisiert: Die Chat- und Completion-Routen jedes Alias, dem chains einen Eintrag gibt, tragen Kongs AI Proxy Advanced anstelle seines AI Proxy, mit dem Modell des Alias und den Modellen, auf die sein Durchlauf ausweicht, als Ziele in Prioritätsreihenfolge — der Alias, dann die Fallbacks seines Eintrags der Reihe nach, wobei dem eigenen Eintrag eines Fallbacks seinerseits nur gefolgt wird, solange weniger als max_hops gezählt wurden. Der Balancer sendet eine Anfrage einmal an jedes Ziel des Durchlaufs, der Reihe nach, bis eines antwortet, geht nach einem Verbindungsfehler oder -Timeout, einem ungültigen Antwort-Header oder einer Antwort 429, 500, 502, 503 oder 504 weiter und gibt jede andere Antwort so zurück, wie sie kam. Der Build bricht ab bei einem Namen, den der Socket models nicht trägt, bei einem Durchlauf, der einen Alias zweimal erreicht, neben core/retry-policy, da Kong eine einzige Wiederholungsanzahl für den gesamten Durchlauf führt und nicht erneut an ein Modell senden kann, bevor es ausweicht, und bei einem Gateway-Image älter als 3.12. core/retry-policy wird dort nicht realisiert, und seine Realisierung bricht jede Anbindung unter Angabe des Grundes ab: Jedes verbundene Modell wird auf eigenen Routen bedient, die nur dieses eine Modell tragen, daher muss ein Retry die Anfrage erneut an dasselbe Ziel senden, und Kongs Referenz lässt sich in beide Richtungen lesen, was die Frage angeht, ob sein Balancer das tut. Auf core/gateway/agentgateway wird core/retry-policy auf dem Chart-Recipe als Retry-Policy der eigenen Konfiguration des Gateways realisiert, angehängt an den Listener, auf dem seine Modellanfragen eintreffen: Eine Anfrage wird sofort und an dasselbe Modell erneut gesendet nach einer Antwort 429, 500, 502, 503 oder 504, einer abgelehnten oder zurückgesetzten Verbindung, einer Verbindung, deren Aufbau länger als 11 Sekunden dauert, oder einer fehlgeschlagenen Namensauflösung, bis zu max_attempts Sendungen. agentgateway sendet eine Anfrage einmal öfter, als seine Policy Versuche angibt, daher wird die Policy als max_attempts minus eins geschrieben, max_attempts 1 schreibt keine, und ein Wert über 256 wird ausdrücklich abgelehnt. Eine Anfrage, deren Body größer als 64 KiB ist, wird einmal gesendet, und die Konfiguration setzt kein Timeout, sodass auf ein Modell, das die Verbindung annimmt und nichts antwortet, gewartet wird, statt erneut zu senden. core/fallback-chain wird dort nicht realisiert, und seine Realisierung bricht jede Anbindung unter Angabe des Grundes ab: agentgateway wechselt zwischen Modellen, indem es ein fehlgeschlagenes für die nachfolgenden Anfragen ausschließt, während die fehlgeschlagene Anfrage mit ihrem Fehler beantwortet wird, sodass keine Anfrage entlang einer Kette geführt wird. Auf core/gateway/higress wird core/retry-policy als eigener Retry der Route realisiert, geschrieben als Ingress-Annotationen auf jede Modellroute: Eine Anfrage wird nach einer abgelehnten oder zurückgesetzten Verbindung, einer 5xx-Antwort oder einer 429 erneut gesendet, auch ein POST, bis zu max_attempts Sendungen; max_attempts 1 schaltet den Retry ab und überschreibt den Retry, den die Control Plane von Higress einer Route ohne Annotation gibt, und ein Wert über 2147483648 wird ausdrücklich abgelehnt. An ein Modell, das die Verbindung annimmt und dann nichts oder langsam antwortet, wird nicht erneut gesendet, da die Route keine Frist pro Versuch setzt, und eine gestreamte Anfrage wird nur erneut gesendet, bevor ihre Antwort begonnen hat. Auch core/fallback-chain wird dort nicht realisiert, und seine Realisierung bricht jede Anbindung unter Angabe des Grundes ab: Higress leitet eine fehlgeschlagene Anfrage höchstens einmal weiter, an ein einziges anderes Ziel — das Standard-Backend einer Route oder die eine Fallback-Route, die seine Konsole für eine AI-Route schreibt —, sodass keine Anfrage entlang einer Kette geführt wird. Auf core/gateway/traefik-hub werden beide auf dem Chart-Recipe realisiert, und jedes bricht den Build bei einem Traefik-Hub-Image älter als v3.20 ab, dessen Failover keine Middlewares auf den Services annimmt, die es versucht, und dessen Retry einen POST nicht aufgrund des Status einer Antwort erneut senden kann — ausgenommen eine Retry-Policy mit einer einzigen Sendung. core/fallback-chain führt die Route jedes Alias, dem chains einen Eintrag gibt, durch verschachtelte Failovers von Traefik selbst und versucht die Modelle des Durchlaufs des Alias der Reihe nach — der Alias, dann die Fallbacks seines Eintrags der Reihe nach, wobei dem eigenen Eintrag eines Fallbacks seinerseits nur gefolgt wird, solange weniger als max_hops gezählt wurden —, jedes mit eigenem Modellnamen, eigenen Zugangsdaten, Quotas und Retry. Eine Antwort 429 oder 500 bis 504 eines Modells führt die Anfrage nach einem etwaigen Retry dieses Modells zum nächsten weiter; jede andere Antwort wird so zurückgegeben, wie sie kam, die des letzten Modells, wie auch immer sie lautet, und ein Anfrage-Body über 1 MiB wird mit HTTP 413 abgelehnt, statt gesendet zu werden. Der Build bricht bei einem Namen ab, den der Socket models nicht trägt, und bei einem Durchlauf, der einen Alias zweimal erreicht. core/retry-policy ist die Retry-Middleware von Traefik, als letzte auf jeder Modellroute oder auf jedem Modell, das ein Durchlauf versucht: Eine Anfrage wird sofort erneut gesendet nach einer Verbindung, die nichts an das Modell übertragen hat, und nach einer Antwort 429 oder 500 bis 504, auch ein POST, bis zu max_attempts Sendungen, die erste eingeschlossen, und max_attempts 1 schreibt nichts. Nach einer Antwort, die das Gateway selbst bildet — eine Ablehnung durch seine Schlüsselprüfung, ein Guard, die Maskierung oder eine Quota —, wird nie erneut gesendet, ebenso wenig nach einer gestreamten Antwort, sobald sie begonnen hat.

  • Periodenbudget: core/period-budget begrenzt, was der Datenverkehr durch ein Gateway in einem Zeitraum verbrauchen darf: ein limit, die period, die es abdeckt, ein scope — alles, was das Gateway bedient, jeder Aufrufer oder jedes Modell — und eine unit — Kosten in US-Dollar oder Tokens —, und sobald das, was das Gateway im Zeitraum gezählt hat, das Limit überschreitet, werden weitere Modellanfragen abgelehnt. Es lässt sich an jede Komponente anbinden, die dataplane.aggrega.ai/period-budget deklariert. Die Standardbibliothek realisiert es auf dem AI-Gateway, dessen Budget alles abdeckt, was das Gateway bedient, in US-Dollar gezählt wird und zu Beginn jedes Zeitraums neu beginnt — eine Anzahl von Tagen ab Mitternacht UTC oder ein Kalendermonat ab seinem ersten Tag: Die Realisierung schreibt das Limit und den Zeitraum in die Konfiguration, die das Recipe des Gateways rendert, lehnt jede andere Einheit, jeden anderen Geltungsbereich und jeden anderen Zeitraum namentlich ab — darunter 30d, das das Gateway als Kalendermonat zählt — und bricht ab, sofern nicht die Credential-Slots database_url und api_key des Gateways beide angebunden sind, denn ohne seine Buchhaltungsdatenbank führt das Gateway keine Zählung und ohne einen administrativen Schlüssel prüft es keinen Aufrufer gegen das Budget. Sobald die Zählung das Limit überschreitet, lehnt das Gateway die Modellanfragen des administrativen Schlüssels ebenso ab wie die jedes Aufrufers; seine Modellauflistung und seine Schlüsselverwaltung antworten diesem Schlüssel weiterhin. Auf dem gehosteten Gateway wird es als Ausgabenlimit-Regel auf der Ressource des Gateways realisiert, gezählt in US-Dollar über ein Fenster, das mit der Zeit vorrückt — der letzte period, für Modelle, deren Preise das Gateway kennt — für alles, was das Gateway bedient: Ein Budget pro Aufrufer oder pro Modell, Tokens und ein Kalendermonat werden namentlich abgelehnt. Auf core/gateway/apisix wird es auf dem Chart-Recipe realisiert und auf die Routen der verdrahteten Modelle als Token-Ratenbegrenzung von APISIX geschrieben: gezählt in den Tokens, die die Antwort jedes Modells meldet — total_tokens, prompt_tokens oder completion_tokens — über ein festes Fenster von period, das sich mit der ersten Modellanfrage nach dem Schließen des vorherigen Fensters öffnet statt nach der Uhr, für alles, was das Gateway bedient, für jedes verdrahtete Modell einzeln oder für jeden Aufrufer, den sein Release in infra.callers deklariert, einzeln, wobei das Gateway sie anhand des Schlüssels unterscheidet, den jeder vorlegt. Sobald die Zählung das Limit erreicht, beantwortet das Gateway Modellanfragen mit HTTP 503, bis sich das Fenster schließt; die Tokens einer Anfrage werden hinzugezählt, sobald ihre Antwort abgeschlossen ist, sodass die Anfrage, die das Limit erreicht, bedient wird, und eine Antwort, die sein semantischer Cache liefert, zählt nichts und wird über das Limit hinaus geliefert. APISIX zählt bei einer Completion-Anfrage keine Tokens, daher erhält jedes verdrahtete Modell, solange das Budget angebunden ist, nur seine Chat-Route, und es hält die Zählung im Speicher des Gateway-Prozesses, daher läuft das Chart mit einem Replikat und ein Neustart öffnet ein neues Fenster. Ein Budget in US-Dollar, eines pro Aufrufer, solange infra.callers keine deklariert, ein Kalendermonat und ein zweites Budget auf einem Gateway werden namentlich abgelehnt, ebenso eine Anbindung an sein Workload-Recipe, das keine Route rendert. Auf core/gateway/envoy-gateway wird es als nutzungsbasiertes Rate Limit von Envoy Gateway realisiert, auf der AI-Route, die die mit dem Gateway verdrahteten Modelle bedient: Die Route deklariert die Token-Zählung, die unit benennt — total_tokens, prompt_tokens oder completion_tokens — als Kosten, die Envoy AI Gateway aus jeder Antwort abliest, und eine Traffic Policy auf dieser Route verbucht sie, wenn die Antwort abgeschlossen ist, gegen limit Tokens pro Einheit des Rate Limits von Envoy Gateway, für alles, was das Gateway bedient, oder für jedes verdrahtete Modell einzeln. Jedes Fenster ist an der UTC-Uhr festgelegt — eine Sekunde, eine Minute, eine Stunde, ein Tag ab Mitternacht, eine Woche ab einem Donnerstag oder 30 bzw. 365 Tage, gezählt ab dem 1. Januar 1970 — und 1mo ist ein Kalendermonat, unter einer Einstellung des Rate-Limit-Dienstes von Envoy Gateway, die dann für jedes monatliche Rate Limit gilt, das diese Installation führt. Die Zählung führt der Rate-Limit-Dienst, den die Control Plane von Envoy Gateway für jedes von ihr bediente Gateway erstellt und einschaltet, im Redis-Protokoll-Speicher, der mit dem Socket cache des Gateways verdrahtet ist. Sobald die Zählung das Limit überschreitet, beantwortet das Gateway Modellanfragen mit HTTP 429, bis das Fenster endet; die Tokens einer Anfrage werden hinzugezählt, sobald ihre Antwort abgeschlossen ist, sodass die Anfrage, die das Limit überschreitet, bedient wird. Solange der Speicher oder der Rate-Limit-Dienst nicht erreichbar ist oder eine Prüfung länger dauert als das Rate-Limit-Timeout von Envoy, werden Modellanfragen mit HTTP 500 abgelehnt, unter einer Einstellung der Control Plane von Envoy Gateway, die dann für jedes Rate Limit gilt, das diese Installation führt, sodass auch ein von Hand darauf angewendetes Rate Limit geschlossen fehlschlägt; eine Anfrage, die kurz vor einem Ausfall zugelassen wurde, wird dennoch bedient und nicht gezählt, weil ihre Tokens nach der Antwort verbucht werden, und ein Speicher, der die Zählung im Arbeitsspeicher hält, beginnt bei einem Neustart jedes Fenster von vorn. Ein Budget in US-Dollar, eines pro Aufrufer — das Gateway unterscheidet Aufrufer nur anhand eines Headers, den der Aufrufer selbst schreibt, und nichts auf diesem Pfad überprüft ihn —, jeder andere Zeitraum und ein zweites Budget auf einem Gateway werden namentlich abgelehnt, ebenso eine Anbindung, bei der nichts mit dem Socket models oder cache verdrahtet ist. Auf core/gateway/azure-api-management wird es als Token-Limit von Azure realisiert, in die Policy der API geschrieben: gezählt in den Prompt- und Completion-Tokens, die jede Antwort meldet, zusammen, für alles, was die API bedient, oder für jedes API-Management-Abonnement, dessen Schlüssel das Gateway überprüft — entweder als Kontingent über ein festes Fenster an der UTC-Uhr, eine Stunde, ein Tag, eine Woche, ein Kalendermonat oder ein Kalenderjahr (1h, 1d, 7d, 1mo oder 12mo; Microsoft sagt nicht, an welchem Tag eine Woche beginnt), das nach Überschreitung mit HTTP 403 beantwortet wird, oder als Rate über eine Minute (1m), die mit HTTP 429 beantwortet und auf den klassischen Tarifen über ein gleitendes Fenster und auf den v2-Tarifen als Token-Bucket gezählt wird. Die Zählung ist die Nutzung, die jede Antwort meldet, sodass gleichzeitige Anfragen das Limit überschreiten können, und jedes Gateway der Instanz führt seine eigene Zählung. Ein Budget in US-Dollar oder allein in Prompt- oder Completion-Tokens, eines pro Modell — das Modell, das eine Anfrage benennt, schreibt der Aufrufer, und mehrere Namen können ein Modell erreichen —, eines pro Abonnement auf einer API, die keinen Abonnementschlüssel verlangt, jeder andere Zeitraum und ein Limit, das keine ganze Zahl ist, werden namentlich abgelehnt. Der Consumption-Tarif führt kein Token-Limit aus. Auf core/gateway/kong-enterprise wird es auf dem Chart-Recipe realisiert und in die Routen, die das Gateway importiert, als AI Rate Limiting Advanced von Kong geschrieben: gezählt in den Tokens, die die Antwort jedes Modells meldet — total_tokens, prompt_tokens oder completion_tokens — in festen Fenstern von period, einer Anzahl von Sekunden, Minuten, Stunden oder Tagen, wobei jede Anfrage in dem einen Fenster gezählt wird, in das ihr Zeitpunkt fällt, für alles, was das Gateway bedient, oder für jedes verdrahtete Modell einzeln, wobei eine Anfrage unter Scope model gegen den Alias gezählt wird, den sie benannt hat, gleich welches Modell sie beantwortet hat. Sobald die Zählung das Limit erreicht, wird die nächste Modellanfrage mit HTTP 429 beantwortet, bis das Fenster endet, sodass die Anfrage, die das Limit überschreitet, bedient wird; Kong kann eine Anfrage auch vorab ablehnen, anhand seiner eigenen Schätzung der Prompt-Tokens, die sie enthält. Die Zählung wird im PostgreSQL-Backend des Gateways geführt, von jedem Replikat geteilt und über einen Neustart hinweg erhalten. Ein Budget in US-Dollar — Kong zählt Kosten nur anhand eines Preises, den seine Konfiguration jedem Modell gibt, und der Katalog liefert keinen —, eines pro Aufrufer — Kong unterscheidet Aufrufer nur als die Consumer, die ein Authentifizierungs-Plugin benennt, und das Gateway deklariert keine Aufrufer, aus den Gründen, die „Kong vor den Modellen“ oben nennt —, ein Kalendermonat, ein zweites Budget auf einem Gateway und ein Gateway-Image älter als 3.15 werden namentlich abgelehnt, ebenso eine Anbindung, bei der nichts mit dem Socket models verdrahtet ist. Auf core/gateway/agentgateway wird es auf dem Chart-Recipe realisiert, in die Konfiguration des Gateways geschrieben und in den Gesamt-Tokens gezählt, die jede Antwort meldet: unter Scope caller als Budget auf dem API-Schlüssel jedes Aufrufers, den sein Release in infra.callers deklariert, über feste Fenster von period, ausgerichtet an der Unix-Epoche, wobei ein Tag um Mitternacht UTC beginnt, geführt in einem SQLite-Speicher auf einem Volume, das das Recipe rendert, mit einem Replikat; unter Scope gateway oder model als Token-Bucket für alles, was das Gateway bedient, oder für jeden Modellnamen, den eine Anfrage verlangt, alle period bis zum Limit aufgefüllt, gerechnet ab dem Zeitpunkt, zu dem das Gateway seine Konfiguration gelesen hat, und in seinem Arbeitsspeicher gehalten, sodass ein Neustart oder eine geänderte Konfiguration ihn erneut auffüllt. Sobald das Gezählte das Limit erreicht, werden Modellanfragen mit HTTP 429 beantwortet, bis das Fenster endet oder der Bucket aufgefüllt ist; die Anfrage, die es erreicht, wird bedient. Ein Budget in US-Dollar — der Modellkostenkatalog des Gateways bepreist keines der mit ihm verdrahteten Modelle, sodass das Budget nichts zählen würde —, allein in Prompt- oder Completion-Tokens, eines pro Aufrufer, solange infra.callers keine deklariert, ein Kalendermonat, ein Limit, das keine ganze Zahl ist, und ein zweites Budget auf einem Gateway werden namentlich abgelehnt, ebenso eine Anbindung, bei der nichts mit dem Socket models verdrahtet ist; sein Compose-Recipe hat keine Realisierung davon. Auf core/gateway/traefik-hub wird es auf dem Chart-Recipe als Quota-Middleware von Traefik Hub auf der Route jedes verdrahteten Modells realisiert, die ihre Zählung im Redis-Protokoll-Speicher führt, der mit dem Socket cache des Gateways verdrahtet ist: Sie zählt die Tokens, die jede Antwort meldet — total_tokens, prompt_tokens oder completion_tokens — oder, unter usd, deren Kosten in US-Dollar, bepreist nach einer Liste von Modellen, die mit der Middleware ausgeliefert wird, wobei ein Modell, für das sie keinen Preis hat, mit HTTP 422 abgelehnt wird, über ein Fenster, das mit der Zeit gleitet, wobei das zu einem Zeitpunkt Gezählte einen Zeitraum später wieder frei wird, für jedes verdrahtete Modell einzeln oder für alles, was das Gateway bedient, solange ein Modell verdrahtet ist. Sobald die Zählung das Limit erreicht, werden Modellanfragen mit HTTP 429 abgelehnt; die Zählung einer Anfrage wird hinzugefügt, sobald ihre Antwort abgeschlossen ist, sodass die Anfrage, die das Limit überschreitet, und jede neben ihr bediente bedient wird, und eine Antwort, die der semantische Cache liefert, zählt nichts. Die Referenz von Traefik sagt, dass die Quota Anfragen ungezählt bedient, solange der Speicher nicht erreichbar ist. Ein Budget pro Aufrufer — die Quota unterscheidet Anfragen anhand der Adresse des Clients, eines Anfrage-Headers oder des Hosts der Anfrage, und keines davon ist der Aufrufer, den die Schlüsselprüfung des Gateways überprüft hat —, eines für das gesamte Gateway, solange mehrere Modelle verdrahtet sind, da die Referenz von Traefik nicht sagt, ob Routen, die eine Quota benennen, deren Zählung teilen, ein Kalendermonat und jeder Zeitraum außer Stunden oder Tagen oder Minuten oder Sekunden, die ganze Stunden ergeben, werden namentlich abgelehnt, ebenso ein Limit, das keine ganze Zahl von Tokens ist, und eine Anbindung, bei der nichts mit dem Socket models oder cache verdrahtet ist. Auf core/gateway/higress wird es auf dem Chart-Recipe als Token-Limit-Plugin von Higress auf der Route jedes verdrahteten Modells realisiert, das seine Zählung im Redis-Protokoll-Speicher führt, der mit dem Socket cache des Gateways verdrahtet ist: Es addiert die Prompt- und Completion-Tokens, die jede Antwort meldet, zusammen, sobald die Antwort abgeschlossen ist, über ein festes Fenster von period — eine Sekunde, eine Minute, eine Stunde oder ein Tag —, das sich öffnet, wenn die erste Antwort darin gezählt wird, für alles, was das Gateway bedient, oder für jeden Alias einzeln. Solange die Zählung das Limit überschreitet, werden Modellanfragen mit HTTP 429 beantwortet, bis das Fenster endet, sodass die Anfrage, die das Limit überschreitet, bedient wird. Eine Antwort, die keine Nutzung meldet, zählt nichts, daher bittet das Recipe das Modell einer gestreamten Anfrage, seine Nutzung zu melden, und lehnt mit HTTP 403 eine gestreamte Anfrage ab, die diese Meldung abschaltet, ebenso eine Anfrage, deren Content-Type weder application/json enthält noch mit multipart/form-data beginnt und die der AI-Proxy weiterleitet, ohne die Meldung anzufordern, und eine, deren Body die Plugins des Gateways nicht lesen — ein komprimierter Body, ein Content-Type, der octet-stream oder grpc enthält, ein Upgrade; ein Client, der absichtlich einen Body sendet, den die Validierung des Gateways nicht dekodieren kann, kommt an diesen Ablehnungen vorbei, und eine solche gestreamte Anfrage bleibt ungezählt. Ohne angebundene Maskierung kann eine Anfrage, deren Body den 32-KiB-Puffer des Gateways überschreitet, mit HTTP 413 abgelehnt werden, je nachdem, wann der Speicher antwortet. Solange der Speicher nicht erreichbar ist, werden Modellanfragen bedient und nicht gezählt: Das Plugin hat keine Einstellung, die sie dann ablehnt. Ein Budget in US-Dollar oder allein in Prompt- oder Completion-Tokens, eines pro Aufrufer — das Gateway deklariert keine Aufrufer, also überprüft es keinen —, jeder andere Zeitraum, ein Limit, das keine ganze Zahl ist, und ein zweites Budget auf einem Gateway werden namentlich abgelehnt, ebenso eine Anbindung, bei der nichts mit dem Socket models oder cache verdrahtet ist.

  • Nebenläufigkeit: core/concurrency-limit begrenzt, wie viele Anfragen ein Gateway gleichzeitig führt (max_in_flight), was verhindert, dass ein Ansturm von Aufrufern zu einer Warteschlange beim dahinterliegenden Modell wird. scope gibt an, was eine Obergrenze zählt: gateway, der Standard, zählt jede Anfrage, die das Gateway weiterleitet, zusammen; model gibt jedem Ziel, an das das Gateway Anfragen sendet, eine eigene Zählung, wobei ein Ziel jeder Upstream-Eintrag ist, an den das Gateway routet, sodass dort, wo ein Modellname mehrere Einträge hat, jeder einzeln gezählt wird. Die Obergrenze und ihr Geltungsbereich sind eine Kapazitätsdimensionierung, über die der Betreiber entscheidet, festgelegt im infra der Anbindung, daher bindet der Betreiber sie im Release an. Die Obergrenze wird pro laufendem Proxy gezählt, sodass dort, wo mehrere Replikate laufen, jedes von ihnen so viele zulässt. Sie lässt sich an jede Komponente anbinden, die dataplane.aggrega.ai/concurrency-cap deklariert, und eine Realisierung lehnt den Geltungsbereich, den ihr Gateway nicht zählt, namentlich ab. Auf core/gateway/nginx wird Scope gateway als limit_conn von NGINX realisiert, mit einem Schlüssel aus einem Wort, das für jede Anfrage gleich ist, sodass NGINX jede Anfrage, die es verarbeitet, als eine Gesamtzahl zählt, gehalten in einem Speicher, den seine Worker-Prozesse teilen, und eine Anfrage über der Obergrenze mit HTTP 503 beantwortet; Scope model wird abgelehnt, da NGINX keine Zählung pro Upstream-Ziel führt, ebenso ein max_in_flight über 65535, dem Höchstwert, den limit_conn annimmt. Auf core/gateway/envoy-gateway wird Scope model als Circuit Breaker der Traffic Policy auf der Route realisiert, die die verdrahteten Modelle bedient, derselben Policy, die auch das Rate Limit eines Periodenbudgets und den Retry der Retry-Policy trägt: Envoy Gateway wendet ihn auf das Backend jeder Regel dieser Route an, und jedes verdrahtete Modell hat eine eigene Regel, sodass höchstens max_in_flight Anfragen gleichzeitig an jedes verdrahtete Modell gesendet werden und eine Anfrage über der Obergrenze mit HTTP 503 beantwortet und nicht erneut gesendet wird; ein Senden, das die Retry-Policy wiederholt, zählt wie das erste gegen die Obergrenze. Die Worker-Threads von Envoy prüfen die Zählung und erhöhen sie danach, sodass gleichzeitig eintreffende Anfragen sie kurzzeitig über die Obergrenze bringen können. Scope gateway wird abgelehnt, da Envoy Gateway eine Obergrenze pro Backend führt und keine für deren Summe, ebenso eine Anbindung, bei der nichts mit dem Socket models verdrahtet ist. Auf dem AI-Gateway wird Scope model als max_parallel_requests jedes Eintrags seiner Modellzuordnung realisiert, ob von Hand eingetragen oder verdrahtet: Höchstens max_in_flight Anfragen sind gleichzeitig an jeden Eintrag unterwegs, und eine Anfrage, die ihren Eintrag voll vorfindet, wird mit HTTP 429 beantwortet — nach den Retries des Gateways, wo ihr Alias einen Eintrag hat, und sofort, wo er mehrere hat, selbst wenn ein anderer davon noch Platz hat, da der Proxy den Eintrag auswählt, bevor er zählt —, sofern nicht core/fallback-chain Fallbacks für ihren Alias auflistet, an die sie dann weitergesendet wird. Der Proxy hält jede Zählung im Arbeitsspeicher, wo ein Datensatz standardmäßig zehn Minuten nach seiner Erstellung verfällt und eine neue Zählung dann bei null beginnt, daher setzt die Anbindung diese Lebensdauer auch auf ein Jahrhundert, sodass jede Zählung erhalten bleibt, solange der Proxy läuft. Wegen dieser Lebensdauer lehnt das Gateway eine Anfrage, die priority trägt, ab, solange die Obergrenze angebunden ist, selbst wo das Release das Feld zulässt, da der Proxy für jede solche Anfrage einen Warteschlangeneintrag hält, bis ihr Datensatz verfällt; und der Build bricht bei einer Modellzuordnung mit mehr als 100 Einträgen ab, jenseits derer der Speicher, in dem die Zählungen gehalten werden, der 200 Datensätze fasst und einen verwirft, sobald er voll ist, eine Zählung verwerfen könnte. Scope gateway wird dort abgelehnt, da die eine Gesamtzahl des Proxys nur von einem Anfragebegrenzer gelesen wird, den eine Umgebungsvariable einschaltet und der eine Anfrage für ihre erste Sekunde zählt. Auch das gehostete Gateway realisiert sie nicht: Das Anfragelimit, das sein Terraform-Recipe in die Ressource des Gateways schreibt, ist eine Rate, eine Anzahl von Anfragen über ein Intervall, statt einer Obergrenze für die laufenden Anfragen.

  • Audit-Protokollierung: core/audit-logging veranlasst ein Gateway, für jede Modellanfrage, die es bedient, einen Datensatz aufzubewahren, der das Modell nennt, das geantwortet hat, und die Tokens, die die Antwort meldet, und jede Realisierung gibt an, wo der Datensatz landet. Es wird an jede Komponente angehängt, die gateway.aggrega.ai/intelligence: semantic trägt, und seine drei Werte gehören dem Betreiber und werden in seinem infra gesetzt, daher hängt der Betreiber es im Release an. require_cost, standardmäßig aktiviert, lässt den Datensatz zusätzlich angeben, was jede Anfrage gekostet hat, in einer Währung, die die Realisierung nennt. require_verified_caller, standardmäßig aktiviert, lässt ihn den Aufrufer nennen, den das Gateway verifiziert hat, über einen Schlüssel, den das Gateway ausgestellt oder geprüft hat. retention_days, standardmäßig nicht gesetzt, lässt das Gateway einen Datensatz löschen, sobald er so viele Tage alt ist; ohne diesen Wert löscht das Gateway selbst keinen Datensatz, und ein Datensatz besteht so lange, wie der Ort, an dem er landet, ihn aufbewahrt. Ein Gateway, das einen Wert nicht einhalten kann, lehnt die Anhängung beim Build ab und nennt dabei den Wert, sodass eine Anhängung, die require_cost und require_verified_caller auf ihren Standardwerten belässt, die Kosten und den verifizierten Aufrufer erhält oder einen Abbruch. Wird require_verified_caller deaktiviert, wird ein Datensatz akzeptiert, dessen Aufrufer das ist, was die Anfrage selbst behauptet, oder gar kein Aufrufer: Jeder, der eine Anfrage sendet, kann sie dann einem anderen Aufrufer zuschreiben lassen, sodass ein solcher Datensatz nicht zeigt, wer eine Anfrage gesendet hat. Auf dem AI-Gateway ist der Datensatz eine Zeile in der Buchhaltungsdatenbank des Gateways, und jeder Wert wird eingehalten: Die Zeile gibt an, was die Anfrage in US-Dollar gekostet hat, bepreist anhand der Tabelle, die das Gateway pro Modell führt — ein Modell, das die Tabelle nicht bepreist, wird als kostenlos erfasst —, und nennt den Schlüssel, den das Gateway verifiziert hat, mit dem Benutzer und dem Team, denen der Schlüssel gehört, während der Endbenutzer, den eine Zeile nennt, ungeprüft das ist, was die Anfrage angibt. Ohne seine Buchhaltungsdatenbank schreibt das Gateway keine Zeile, und ohne einen Administrationsschlüssel prüft es keinen Aufrufer und schreibt keine Zeile für eine Anfrage, die keinen Schlüssel vorlegt und keinen Endbenutzer nennt, daher bricht der Build ab, sofern nicht die Credential-Slots database_url und api_key des Gateways beide angehängt sind; solange values.log_masking des Gateways auflistet, was maskiert werden soll, erfasst es nur beantwortete Anfragen. Auf core/gateway/envoy-gateway ist der Datensatz eine Zeile des Zugriffsprotokolls des Gateways, die sein Recipe schreibt, solange die Anhängung vorhanden ist: eine JSON-Zeile pro Anfrage auf der Standardausgabe der Data Plane, mit den Feldern, die Envoy Gateway standardmäßig schreibt, dem Modell, das die Anfrage genannt hat, dem Modell, das geantwortet hat, und den Prompt-, Completion- und Gesamt-Tokens, die die Antwort meldet, wobei die Route, die die Modelle bedient, diese Zählungen deklariert, damit Envoy AI Gateway sie erfasst. Eine Anfrage, die das Modell nicht beantwortet hat, enthält kein antwortendes Modell und keine Tokens, und das Zugriffsprotokoll bewahrt selbst nichts auf, sodass die Lebensdauer einer Zeile davon abhängt, was diese Ausgabe sammelt. Kein Feld nennt einen vom Gateway verifizierten Aufrufer: Die Adresse des Clients und die Header, die er sendet, werden so geschrieben, wie sie ankommen. Das Gateway führt keine Preise, nichts an der Route, die sein Recipe rendert, verifiziert den Aufrufer, und das Zugriffsprotokoll bewahrt keinen Datensatz auf, den es löschen könnte, daher baut seine Realisierung eine Anhängung, die require_cost und require_verified_caller deaktiviert und kein retention_days angibt, und bricht andernfalls ab, wobei sie jeden Wert nennt, den sie nicht einhalten kann, alle in einem einzigen Fehler; sie bricht auch ab, wenn nichts mit dem Socket models verbunden ist. Auf core/gateway/agentgateway ist der Datensatz eine Zeile, die das Gateway in einen SQLite-Speicher auf einem Volume schreibt, das sein Chart-Recipe rendert, solange die Anhängung vorhanden ist, mit einer Replica, und zwar für jede Modellanfrage, die seine Schlüssel-, Budget- und Autorisierungsprüfungen besteht, einschließlich der Ablehnung durch einen Guard: das Modell, das das Gateway beim Modellserver angefragt hat — der Name, den das verbundene Modell veröffentlicht, nicht der Alias, den der Aufrufer gesendet hat —, und das Modell, das geantwortet hat, die Input-, Output- und Gesamt-Tokens, die die Antwort meldet, ihr Status und ihr Timing sowie, für jeden Aufrufer, den sein Release in infra.callers deklariert, der Name dieses Aufrufers, aus dem API-Schlüssel, den das Gateway verifiziert hat. Eine Anfrage, die wegen ihres Schlüssels, durch eine Autorisierungsregel oder durch das Budget eines Aufrufers abgelehnt wird, hinterlässt keine Zeile. Kein Prompt- oder Antworttext wird aufbewahrt, und die Zeilen werden über die Admin-Schnittstelle des Gateways gelesen, die innerhalb seines Pods lauscht. require_verified_caller wird eingehalten, solange Aufrufer deklariert sind; require_cost wird namentlich abgelehnt, da der Modellkostenkatalog des Gateways keines der mit ihm verbundenen Modelle bepreist, ebenso require_verified_caller ohne deklarierten Aufrufer und retention_days, da das Gateway keinen Datensatz löscht; sein Compose-Recipe hat keine Realisierung davon. Auf core/gateway/higress ist der Datensatz das Feld ai_log der Zugriffsprotokollzeile des Gateways, das das Statistik-Plugin von Higress füllt, solange die Anhängung vorhanden ist: das Modell, das geantwortet hat, und die Input-, Output- und Gesamt-Tokens, die die Antwort meldet, auf der Standardausgabe des Gateways, ohne Prompt- oder Antworttext. Das Gateway deklariert keine Aufrufer, bepreist nichts und bewahrt keinen Datensatz auf, den es löschen könnte, daher baut seine Realisierung eine Anhängung, die require_cost und require_verified_caller deaktiviert und kein retention_days angibt, und bricht andernfalls ab, wobei sie jeden Wert nennt, den sie nicht einhalten kann, alle in einem einzigen Fehler; sie bricht auch ab, wenn nichts mit dem Socket models verbunden ist. Auf core/gateway/traefik-hub bricht jede Anhängung ab und nennt den Grund: Traefik Hub bewahrt einen Datensatz einer Modellanfrage nur als OpenTelemetry-Span auf, den seine AI-Middlewares an ein Tracing-Backend exportieren — mit dem Modell und, auf der detaillierten Stufe, den Tokens und ihren Kosten in US-Dollar —, und seine Realisierung verbindet kein Tracing-Backend, sodass der Datensatz nirgends landen würde; auch nennt der Span keinen Aufrufer, sodass er nicht den nennen kann, den die Schlüsselprüfung des Gateways verifiziert hat. Auf core/gateway/azure-api-management bricht jede Anhängung ab, wie der Aufzählungspunkt des Gateways weiter oben sagt, und kein anderes Gateway der Standardbibliothek realisiert es, daher bricht eine Anhängung an jedem anderen Gateway ab und nennt den Typ.

  • Semantisches Caching: core/semantic-caching deklariert einen Cache, der einen Prompt mit der Antwort beantwortet, die für einen früheren, in der Bedeutung hinreichend ähnlichen Prompt gespeichert wurde, statt das Modell erneut aufzurufen. embedding_model nennt das Modell, das jeden Prompt in einen Vektor umwandelt, so wie das Gateway es veröffentlicht; eine gespeicherte Antwort wird ausgeliefert, wenn die beiden Prompts mindestens im Maß von similarity_threshold ähnlich sind, und sie bleibt für ttl_seconds verwendbar. scope legt fest, wer einen Cache teilt: end_user, der Standard, hält jeden Endbenutzer, den das Gateway identifiziert, getrennt, während key jeden Aufrufer, der denselben Schlüssel vorlegt, aus einem einzigen Cache bedient, sodass einem Endbenutzer hinter diesem Schlüssel eine für einen anderen erzeugte Antwort ausgeliefert werden kann. core/data-masking deklariert einen Konflikt damit, sodass der Build bei einer Komponente abbricht, die beide trägt. Die Standardbibliothek realisiert es auf dem AI-Gateway, das die Antworten in einem mit seinem Socket cache_store verbundenen core/datastore/redis hält, wobei es dem Speicher das Passwort vorlegt, das das Credential dieser Verbindung enthält, sofern der Speicher eines verlangt, und der Speicher jede Antwort entfernt, sobald ttl_seconds verstrichen sind; es cacht Chat-, Responses- und Messages-Anfragen, nicht Completions oder Embeddings. Die Realisierung bricht den Build ab, sofern nicht der Slot api_key des Gateways angehängt ist, weil das Gateway ohne einen Administrationsschlüssel keinen Aufrufer prüft, ferner bei einem embedding_model, das die Modellzuordnung des Gateways nicht veröffentlicht, und wenn nichts mit cache_store verbunden ist. Eine gespeicherte Antwort wird nur einer Anfrage ausgeliefert, die dem entspricht, worunter sie gespeichert wurde: dem Schlüssel, den die Anfrage vorlegt und den das Gateway verifiziert, mit dem Team und der Organisation dieses Schlüssels; bei end_user dem Endbenutzer, den die Anfrage nennt; und dem Modell, das die Anfrage anfordert, mit ihren übrigen Parametern. Das Gateway schreibt Schlüssel, Team, Organisation und Endbenutzer in die Anfrage selbst und überschreibt dabei jeden Wert, den ein Aufrufer dafür in einer Chat-Anfrage gesendet hat; bei einer Responses- oder Messages-Anfrage entfernt es ein Team-, Organisations- oder Endbenutzerfeld aus den eigenen Metadaten der Anfrage und lehnt eines ab, das dort den Schlüssel nennt, sodass sich keine Anfrage durch bloßes Nennen Zugang zu den Antworten eines anderen Schlüssels verschaffen kann. Die eigenen Metadaten einer Anfrage können sie dennoch innerhalb der Antworten des Schlüssels verschieben, den sie vorlegt: Bei einer Responses-Anfrage ersetzt model_group das angeforderte Modell in dem, worunter ihre Antwort gespeichert wird; bei einer Responses- oder Messages-Anfrage lässt caching_groups Anfragen, die dieselbe Gruppe von Modell-Aliassen nennen, Antworten über diese hinweg teilen; und bei einer Responses- oder Chat-Anfrage hält redis_namespace Anfragen, die einen Namespace nennen, von solchen getrennt, die keinen nennen. Das Gateway liest einen Endbenutzer aus einem Header oder einem Body-Feld, das die Anfrage selbst nennt, und verifiziert keines davon: Bei end_user werden einem Aufrufer, der einen anderen Endbenutzer nennt, die Antworten dieses Endbenutzers ausgeliefert, und Anfragen, die keinen Endbenutzer nennen, teilen sich unter dem vorgelegten Schlüssel einen Cache mit jeder anderen solchen Anfrage. Das gehostete Gateway realisiert es nicht: Sein Cache beantwortet nur eine Anfrage, die mit einer früheren identisch ist. Auf core/gateway/azure-api-management wird es als Lookup und Store des semantischen Caches von Azure realisiert, die in die Policy der API geschrieben werden: embedding_model nennt ein Backend, das die API-Management-Instanz bereits für ein Embeddings-Modell besitzt und das die Instanz mit ihrer verwalteten Identität erreicht, und die Instanz benötigt einen als ihr externer Cache konfigurierten Redis-Cache mit RediSearch, was der Build beides nicht sehen kann, daher bricht der Build ab, bis der Betreiber durch Setzen von infra.cache_serves_vector_search des Gateways bestätigt, dass der Cache RediSearch bereitstellt; der Speicher bewahrt eine Antwort für ttl_seconds auf; und similarity_threshold wird als Score-Schwellenwert von Azure geschrieben, eins minus der Schwellenwert, wobei dieser Score als Kosinusdistanz gelesen wird, da Microsoft seinen Bereich und seine Richtung angibt — niedriger erfordert ähnlichere Prompts —, nicht aber sein Maß. Eine Antwort wird getrennt pro API und pro API-Management-Abonnement gespeichert und ausgeliefert, dessen Schlüssel das Gateway verifiziert, daher behält die Realisierung key bei, lehnt es auf einer API ab, die keinen Abonnementschlüssel verlangt, und lehnt end_user ab: Die API, die sein Recipe rendert, validiert kein Token eines Endbenutzers, sodass das Gateway keinen verifizierten Endbenutzer getrennt halten kann. Auch core/gateway/contour und core/gateway/nginx realisieren es nicht, da sie keinen semantischen Cache bieten. Auf core/gateway/agentgateway bricht seine Realisierung jede Anhängung ab und nennt den Grund: agentgateway hält keinen Cache von Antworten, und sein Prompt-Caching markiert nur, wo ein Anbieter, der Prompts selbst cacht, dies tun darf. Auf core/gateway/kong-enterprise bricht seine Realisierung jede Anhängung ab und nennt den angeforderten Scope: Kongs AI Semantic Cache hat keine Einstellung, die die gespeicherten Antworten eines Aufrufers von denen eines anderen getrennt hält, und das Gateway unterscheidet Aufrufer nur als die Consumer, die ein Authentifizierungs-Plugin nennt, und deklariert keine Aufrufer, aus den Gründen, die „Kong vor Modellen“ weiter oben nennt, sodass bei end_user wie bei key jede Anfrage einen einzigen Cache teilen würde. Auf core/gateway/higress bricht seine Realisierung jede Anhängung ab und nennt den angeforderten Scope: Der semantische Cache von Higress speichert jede Antwort unter einem einzigen Schlüsselpräfix, gefolgt vom Prompt-Text, und nichts in diesem Schlüssel nennt einen Aufrufer oder einen Endbenutzer, während das Gateway keine Aufrufer deklariert, sodass jede Anfrage einen einzigen Cache teilen würde. Auf core/gateway/apisix wird es auf dem Chart-Recipe realisiert, als semantischer Cache von APISIX 3.18.0 auf die Chat-Route jedes verbundenen Modells geschrieben, für die Aufrufer, die sein Release in infra.callers deklariert: Eine Antwort wird pro Route und pro Aufrufer gespeichert, unter dem Schlüssel, den der Aufrufer vorgelegt hat und den das Gateway verifiziert, sodass keinem Aufrufer eine für einen anderen gespeicherte Antwort ausgeliefert wird; die Realisierung behält key bei und lehnt end_user namentlich ab, weil das Gateway die Endbenutzer hinter einem Schlüssel nicht unterscheiden kann. embedding_model nennt eine Verbindung am Socket models des Gateways, mit deren Endpunkt, Modell und Credential der Cache die Embeddings berechnet. Der Cache berechnet das Embedding der letzten Benutzernachricht einer Anfrage und liefert eine gespeicherte Antwort aus, deren Nachricht mindestens im Maß von similarity_threshold ähnlich ist und deren frühere Nachrichten — ein System-Prompt, frühere Turns — dieselben sind. Die Antworten liegen für ttl_seconds in einem mit dem Socket cache_store des Gateways verbundenen core/datastore/redis, dem der Cache das Passwort vorlegt, das das Credential dieser Verbindung enthält, und eine nach Bedeutung ausgelieferte Antwort wird unter dieser Anfrage für weitere ttl_seconds erneut gespeichert. Completion-Anfragen werden nicht gecacht, und ein Fehler des Speichers oder des Embeddings ist ein Miss: Die Anfrage wird trotzdem beantwortet. Die Realisierung bricht ab, wenn kein Aufrufer deklariert ist, wenn nichts mit cache_store oder dem Socket models verbunden ist, und bei einem embedding_model, das keine Verbindung dort trägt. APISIX ordnet eine gespeicherte Antwort nach Route und Aufrufer statt nach Gateway zu, sodass zwei APISIX-Gateways, die mit demselben Speicher verbunden sind, oder zwei Releases eines Aggregate, die ihr Gateway auf denselben externen Speicher richten, einem gleichnamigen Aufrufer auf demselben Alias und Modell eine gecachte Antwort ausliefern können. Sein Workload-Recipe enthält, mit APISIX 3.17.0, überhaupt keinen semantischen Cache. Auf core/gateway/traefik-hub wird es auf dem Chart-Recipe als semantischer Cache von Traefik Hub auf der Route jedes verbundenen Modells realisiert, für die Aufrufer, die sein Release in infra.callers deklariert: Eine Antwort wird pro verbundenem Modell und pro Aufrufer gespeichert, unter dem Aufrufer, den die Schlüsselprüfung des Gateways verifiziert hat, jeder mit seinem eigenen Schlüssel, sodass keinem Aufrufer eine für einen anderen gespeicherte Antwort ausgeliefert wird; die Realisierung behält key bei und lehnt end_user namentlich ab, weil das Gateway die Endbenutzer hinter einem Schlüssel nicht unterscheiden kann. embedding_model nennt eine Verbindung am Socket models des Gateways, mit deren Endpunkt, Modell und Credential der Cache das Embedding des Textes einer Anfrage berechnet. similarity_threshold wird als Distanzgrenze des Caches geschrieben, eins minus der Schwellenwert, gelesen als Kosinusdistanz, da die Referenz von Traefik die Richtung der Grenze angibt, nicht aber ihr Maß. Eine Antwort wird für ttl_seconds in einem mit dem Socket cache_store des Gateways verbundenen core/datastore/redis aufbewahrt, und eine Anfrage, die für ein Embedding zu groß ist, wird ohne Cache beantwortet. Die Realisierung bricht ab, wenn kein Aufrufer deklariert ist, wenn nichts mit cache_store oder dem Socket models verbunden ist, bei einem embedding_model, das keine Verbindung dort trägt, und bei einem Traefik-Hub-Image, dessen Tag keine Version ab v3.19.11 innerhalb von 3.19 oder ab v3.20.6 nennt, da eine frühere Version einen einzigen Cache unter allen Aufrufern einer Route teilt.

  • Prompt-Injection-Prüfung: core/prompt-injection-shield deklariert, dass die Modellanfragen, die ein Gateway weiterleitet, vor dem Aufruf des Modells auf einen Versuch geprüft werden, die dem Modell gegebenen Anweisungen außer Kraft zu setzen, und zwar mit einer sensitivity von standard oder strict — wobei strict mehr solcher Versuche ablehnt und mit ihnen auch mehr legitime Anfragen. Die Prüfung ist das Urteil eines probabilistischen Klassifikators: Sie übersieht manche Angriffe — darunter umformulierte, kodierte oder anders geschriebene —, lehnt manche legitime Anfragen ab und ist bekanntermaßen umgehbar, sie ist also eine Kontrolle neben anderen, und sie beurteilt weder die Antwort des Modells noch Tool-Call-Argumente oder Bilder. Sie lässt sich an jedes Gateway anhängen, und eine Realisierung schickt die Anfragen des Gateways entweder durch einen Guard, der an seinen guard-Socket angeschlossen ist und vom Gateway nichts weiter verlangt, als dass es an eine konfigurierte Adresse weiterleitet, oder sie schaltet eine Prüfung ein, die das Gateway selbst ausführt. Bei einem Guard prüft der Guard jede Anfrage und leitet das, was er zulässt, an das Modell weiter, und wird das Feature angehängt, ohne dass etwas an diesem Socket hängt, bricht der Build ab und nennt ihn. Die Standardbibliothek realisiert es auf dem AI-Gateway und auf dem NGINX-Gateway, jeweils mit core/security/nemo-guardrails als Guard: ein Dienst, der die OpenAI-Chat-Completions-API spricht und dessen Rail die letzte Benutzernachricht einer Anfrage an den Klassifikator des daran angeschlossenen core/security/trustyai-huggingface-detector sendet und die Anfrage ablehnt, wenn der Score dieses Klassifikators den Schwellenwert des Guards erreicht. Eine abgelehnte Anfrage beantwortet der Guard selbst, mit einer gewöhnlichen Completion, und nichts davon erreicht das Modell; ist der Guard oder sein Detektor nicht erreichbar, wird die Anfrage ebenfalls abgelehnt. Beide brechen den Build ab, sofern der Guard nicht genau dieser ist und mit dem Schwellenwert läuft, den die Sensitivität benennt — 0.5 für standard und 0.001 für strict, die beiden für den Standardklassifikator des Detektors gemessenen Werte, dessen Modell das Gateway nicht prüfen kann, da es den Guard sieht und nicht den Detektor dahinter. Auf dem AI-Gateway wird jeder Alias der Modellzuordnung an den Guard geschickt, jedes Ziel als openai/<model> geschrieben, sodass die Zuordnung die von Hand geschriebene ist: Ein an den models-Socket des Gateways angeschlossenes Modell würde mit den Anmeldedaten seiner eigenen Verbindung an seinen eigenen Endpunkt geschickt, am Guard vorbei, und die Realisierung bricht den Build ab, solange dieser Socket eine Verbindung hält, und nennt sie. Das AI-Gateway lehnt jede Anfrage außer einer Chat-Completion ab, der einzigen Art, die der Guard prüft; auf dem NGINX-Gateway leitet seine einzige Location an den Guard statt an den Upstream weiter, und der Guard beantwortet keine andere Modellroute. Auf core/gateway/azure-api-management wird es als Azures eigenes Prompt Shield realisiert, das in der Policy der API über das Azure-AI-Content-Safety-Backend der Instanz eingeschaltet wird, das infra.content_safety_backend_id benennt, und der Build bricht ab, solange dieser Schlüssel nicht gesetzt ist: Azure AI Content Safety prüft jede Anfrage auf einen Benutzerangriff, bevor das Modell aufgerufen wird, noch vor dem Nachschlagen in einem semantischen Cache, und das Gateway beantwortet eine erkannte mit HTTP 403, so wie es eine Anfrage beantwortet, die länger ist, als der Dienst akzeptiert. Das Shield ist ein- oder ausgeschaltet, daher wird standard beibehalten und strict namentlich abgelehnt, und es läuft mit Microsofts eigener Sensitivität, die nicht an dem Schwellenwert gemessen ist, den standard bei den Guards benennt. Die Instanz erreicht dieses Backend mit ihrer verwalteten Identität, die die Rolle Cognitive Services User auf dem Dienst benötigt; der Build sieht keines von beiden. Kein Gateway der Standardbibliothek außer diesen dreien realisiert es, und das Anhängen an ein anderes bricht den Build ab und nennt den Typ: Die meisten rendern keine Route, die eine Realisierung durch einen Guard schicken könnte — sie halten ihre Routen in einem eigenen Speicher, beziehen sie von den Diensten dahinter oder sind ein gehosteter Dienst, auf dem die Standardbibliothek keine Prüfung dieser Art einschaltet —, und core/gateway/apisix, dessen Chart-Recipe die Routen der daran angeschlossenen Modelle rendert, sowie core/gateway/envoy-gateway, dessen Recipe die AI-Route der daran angeschlossenen Modelle rendert, haben keine Realisierung davon. Auf core/gateway/agentgateway, dessen Recipes für jedes daran angeschlossene Modell einen Eintrag rendern, bricht die Realisierung jedes Anhängen ab und nennt den Grund: agentgateway beurteilt eine Anfrage auf einen solchen Versuch nur über einen Dienst, den es aufruft — einen Webhook, den der Betreiber betreibt, oder Azure AI Content Safety, Google Model Armor oder AWS Bedrock Guardrails —, und die Realisierung schließt keinen davon an. Auf core/gateway/higress bricht die Realisierung ebenfalls jedes Anhängen ab und nennt den Grund: Higress beurteilt einen solchen Versuch nur über einen Dienst, den es aufruft — den Content-Security-Dienst von Alibaba Cloud oder, über eine Erweiterung, die sein Quellcode enthält, die seine Erweiterungsversion 2.2.5 aber nicht veröffentlicht, einen vom Betreiber betriebenen Qwen3Guard-Modelldienst —, wobei jeder die Anfrage durchlässt, wenn dieser Aufruf fehlschlägt, und die Realisierung schließt keinen von beiden an. Auf core/gateway/traefik-hub bricht die Realisierung ebenso jedes Anhängen ab und nennt den Grund: Traefik Hub beurteilt einen solchen Versuch nur über einen Dienst, den es aufruft — seine Middlewares LLM Guard und Parallel LLM Guard, die einen Guard-Dienst oder ein Modell mit einer Anfrage und unter Bedingungen aufrufen, die die Realisierung schreiben müsste, und deren Arbeit mit einem Detektor für Prompt-Angriffe nicht gemessen ist, sodass dort keine Sensitivität einer Prüfung entspricht; oder seine Middlewares Azure Prompt Shield, Amazon Bedrock Guardrails und GCP Model Armor, die gehostete Dienste aufrufen, die die Realisierung nicht anschließt. Der Guard liest nur die letzte Benutzernachricht, sodass eine Systemnachricht, ein früherer Turn oder ein Tool-Ergebnis das Modell ungelesen erreicht, und nur Verkehr, der das Gateway durchquert, wird geprüft: Eine Arbeitslast, die die Adresse des Modells direkt aufruft, umgeht es.

  • Antwortvalidierung und Evaluierungen: core/response-validation deklariert eine Prüfung der Antwort eines Modells gegen ein JSON Schema, bevor sie den Aufrufer erreicht: schema enthält das Schema selbst, und eine Antwort, die ihm nicht entspricht, wird zurückgewiesen statt weitergegeben — oder, mit aktiviertem invert, eine Antwort, die ihm entspricht. Das Schema gehört zum Anhang und ist für jede Anfrage dasselbe, nicht eines, das der Aufrufer mit seiner eigenen Anfrage sendet; der Entwickler hängt es daher im Aggregate an und schreibt das Schema in dessen values. Keine Realisierung der Standardbibliothek setzt es um: Auf core/gateway/agentgateway bricht seine Realisierung jedes Anhängen ab und nennt den Grund — die Antwort-Guards von agentgateway gleichen Muster ab oder rufen einen Content-Safety- oder Webhook-Dienst auf, und keiner davon nimmt ein Schema an —, ebenso seine Realisierung auf core/gateway/higress, deren Antwortprüfung eine bestandene Antwort mit dem bloßen JSON beantwortet, das sie in der Nachricht der Antwort findet, statt mit der Chat-Completion, die ihre OpenAI-Route zurückgibt, die von jedem Client übersprungen wird, der den Anfrage-Header X-HIGRESS-AI-JSON-RESP: true sendet, und die ein mehr als sechs Ebenen tief verschachteltes Schema ungeprüft lässt; und ebenso seine Realisierung auf core/gateway/traefik-hub, da keine Middleware in der Referenz von Traefik Hub eine Antwort gegen ein Schema prüft — seine Middleware Chat Completion prüft Anfragen gegen das Chat-Completion-Schema, sein API-Management prüft Anfrage-Bodys gegen ein OpenAPI-Dokument, und sein LLM Guard sendet eine Antwort an einen externen Dienst, den die Realisierung nicht anschließt; auf jedem anderen Gateway bricht ein Anhang den Build ab und nennt den Typ. core/traffic-shadowing kopiert Live-Anfragen an einen zweiten Dienst und verwirft dessen Antworten, sodass ein Kandidatenmodell oder -dienst unter echtem Datenverkehr evaluiert werden kann, ohne dass ein Aufrufer seine Ausgabe sieht. Es lässt sich an jede Komponente anhängen, die dataplane.aggrega.ai/request-mirroring deklariert, was das AI-Gateway nicht tut; die Standardbibliothek realisiert es auf dem NGINX-Gateway, das den gesamten Datenstrom statt eines Anteils davon kopiert, und bricht bei einem kleineren Anteil namentlich ab.

5. Asynchrone Ausführung und HITL-Infrastruktur

Aggrega behandelt Frameworks mit menschlicher Interaktion (wie AutoGen und LangGraph) als Worker-Knoten. Um „schlafende“ Agenten zu unterstützen, die ohne Zustandsverlust auf menschliche Eingaben warten, können Plattformarchitekten an den Components dieser Agenten Sockets usesSchema deklarieren, die die explizite Bindung von Komponenten der Kategorie Datastore an sie strikt erzwingen, ausgewählt über das Engine-Label des Datastores — datastore.aggrega.ai/engine in (vector, semantic-memory, search) für einen Speicher, aus dem der Agent per Ähnlichkeit abruft, oder datastore.aggrega.ai/engine=kv für einen, in den er seinen Ausführungszustand als Checkpoint schreibt. Der Socket bindet an das Engine-Label statt an einen Produktnamen, sodass ein Autor wählt, welcher Speicher angeschlossen wird, und die Deklaration dennoch gilt. Für Feedbackschleifen vom Menschen zum Agenten (z. B. Slack-Integrationen) lässt sich außerdem eine Governance-Verdict-Rolle so konfigurieren, dass sie die Architektur zurückweist, sofern keine explizit deklarierte Gateway-Komponente angehängt ist, sodass Callback-Webhooks über eine deklarierte Ingress-Grenze eintreten.

Agenten, die auf einem Framework oder SDK aufbauen, um das herum eine Anwendung geschrieben ist, statt als eigenes Produkt ausgeliefert zu werden, haben in der Standardbibliothek eine einzige Form. Das Release nennt das Image der Anwendung, das der Katalog nicht festlegt. Ein Socket model überträgt, was das Framework vom angeschlossenen Modell liest — seine Adresse und seinen Modellnamen, wo das Framework sie liest, und das Credential der Verbindung, per Referenz — in die Variablen, die dieses Framework liest. Wo das Framework keinen eigenen Server definiert, ist die Komponente ein worker und öffnet keinen Port: core/ai-agent/crewai und core/ai-agent/langgraph haben diese Form, ebenso core/ai-agent/openai-agents-sdk, dessen Socket model nur ein Modell oder Gateway mit model.aggrega.ai/api: openai annimmt, core/ai-agent/claude-agent-sdk, dessen Socket nur eines mit model.aggrega.ai/api: anthropic annimmt, und core/ai-agent/agent-framework für eine auf Microsoft Agent Framework aufgebaute Anwendung, die selbst nichts bereitstellt, dessen Socket nur eines mit model.aggrega.ai/api: openai annimmt und die Variablen liefert, die die Python-OpenAI-Clients von Agent Framework lesen; diese drei brechen den Build ab und nennen infra.image, bis das Release es setzt. Das OpenAI Agents SDK lädt standardmäßig einen Trace jedes Laufs zu OpenAI hoch, daher schaltet core/ai-agent/openai-agents-sdk diesen Upload ab, sofern das Aggregate seinen Wert upload_traces_to_openai nicht auf true setzt. Wo das Framework selbst HTTP bereitstellt, ist die Komponente ein server auf dem eigenen Port des Frameworks und veröffentlicht die Adresse, die ein Aufrufer erreicht, als host, port, endpoint und protocol, und auch sie bricht den Build ab und nennt infra.image, bis das Release es setzt: core/ai-agent/google-adk stellt die REST-API von ADK auf Port 8000 bereit und liefert den Schlüssel, den der Gemini-Client von ADK an die Gemini-API sendet, wobei sein Socket model nur ein Modell mit model.aggrega.ai/api: gemini annimmt, etwa core/ai-model/gemini, und nie ein Gateway, dessen Adresse der Client von ADK nicht lesen würde; core/ai-agent/mastra stellt den von Mastra gebauten Server auf Port 4111 bereit, der auf Kubernetes bereit ist, sobald seine Route /health antwortet, nimmt ein Modell oder Gateway mit model.aggrega.ai/api: openai an und veröffentlicht, wo das Aggregate in seinem Wert agent_id einen der Agenten der Anwendung nennt, die Adresse der Agent2Agent-Karte dieses Agenten, sodass core/ai-tool/agent-invocation an ihn delegieren kann. Die Routen beider Server antworten jedem Aufrufer, sofern die Anwendung sie nicht authentifiziert, daher bricht ein Anhang core/public-ingress oder core/http-route an einem der beiden den Build ab, bis das Release sein infra.routes_authenticated auf true setzt und damit bestätigt, dass die Anwendung jede Anfrage authentifiziert, die ihre Routen annehmen. Die SDK- und Server-Runtimes und core/ai-agent/agent-framework deklarieren außerdem einen optionalen Socket tools, der die Adresse jedes angeschlossenen Tools und das Credential der Verbindung per Referenz unter Variablen liefert, die nach dem Alias der Verbindung benannt sind. Da die Anwendung der eigene Code des Release ist, sind die Variablen, die diese Agenten für diesen Code zum Lesen liefern, Standardwerte: Jeder ihrer Sockets lässt einen Block inject: zu, über den das Aggregate die Variablen oder die Dateien nennt, die die Anwendung stattdessen liest, während eine Variable, die das Framework selbst liest, und das, was ein Anhang an der Verbindung liefert, bestehen bleiben. Dasselbe gilt für die eigenen Werte des Agenten: Jede Komponente lässt an sich selbst einen Block inject: aus Einträgen env und file zu, und ein Eintrag, dessen Template einen ihrer eigenen Werte und sonst nichts von der Komponente liest — keinen anderen Wert, weder ihr infra noch ihre Metadaten oder ihre Identität —, ersetzt den Standardnamen, unter dem ein Recipe diesen Wert liefert, etwa CREWAI_ROLE für den role eines CrewAI-Agenten. Ein Import der Agentendeklarationen eines CrewAI-Projekts, der langgraph.json einer LangGraph-Anwendung, der Agentenkonfigurationen einer Google-ADK-Anwendung oder eines deklarativen Agenten von Agent Framework erstellt Entwürfe dieser Agenten — core/ai-agent/crewai, core/ai-agent/langgraph, core/ai-agent/google-adk und core/ai-agent/agent-framework —, angeschlossen an den Datenspeicher, den die Konfiguration nennt, und an das Modell, das sie nennt, wo der Socket model des Agenten es annimmt, neben einem Release-Entwurf, der das Image, in dem das Programm läuft, vom Betreiber benennen lässt, und liest nur die Konfiguration, nie das Programm, wie Importer-Plugins beschreibt.

6. Topologische Sicherheitsvalidierung und Durchsetzung zur Laufzeit

Da KI-Workloads neuartige Angriffsvektoren mit sich bringen (wie Prompt-Injection und autonome Datenexfiltration), erfordert ihre Absicherung, statische Architektur-Governance mit aktiver Durchsetzung zur Laufzeit zu verbinden. Als Ahead-of-Time-Compiler (AOT) fängt Aggrega keinen Live-Netzwerkverkehr ab und wertet keine KI-Prompts aus. Stattdessen löst es komplexe Sicherheitsanforderungen über einen zweiteiligen architektonischen Handshake: statische Architekturkompilierung (zur Kompilierzeit) und Übergabe an die Ausführung (zur Deploy-Zeit).

A. Kompilierzeit: Policy-Validierung und Artefakterzeugung

Der Compiler erstellt einen flachen Graphen der Zwischendarstellung (IR), der alle Knoten, Kanten und angehängten Features enthält. Bevor physische Infrastruktur erzeugt wird, wird die Sicherheitslage des Unternehmens durchgesetzt, indem dieser statische JSON-Graph in einer Governance-Verdict-Rolle gegen branchenübliche Policy-Engines ausgewertet wird.

Da der Socket generische JSON-Daten auswertet, ist er nicht an eine einzelne Policy-Sprache gebunden. Unternehmen können ihre Architekturregeln mit dem Standard kompilieren und durchsetzen, der am besten zu ihrem Ökosystem passt:

  • Open Policy Agent (OPA/Rego): Eine weit verbreitete Sprache zur Auswertung komplexer, mehrstufiger Graphbeziehungen und zur Berechnung von Least-Privilege-Zugriffen über verteilte Topologien hinweg. Die in die CLI kompilierte Rego-Engine führt .rego-Dateien unverändert aus; eine Policy, die den vollständigen Builtin-Umfang von OPA benötigt, wird mit der eigenen Toolchain von OPA kompiliert und läuft hinter einem Adapter-Guest.
  • Common Expression Language (CEL): Die in die CLI kompilierte CEL-Engine führt Regeln aus, die als einzelne Ausdrücke über einem Dokument geschrieben sind, so wie eine Validating-Admission-Policy von Kubernetes geschrieben wird.
  • Kyverno: Wertet statische JSON/YAML-Manifeste aus, sodass Teams Policies in nativem YAML schreiben können, statt Rego zu lernen. Mit dem Compiler wird kein Kyverno-Guest ausgeliefert; er führt Policies nur als WebAssembly-Guests aus und ruft nie die Kyverno-CLI auf, daher laufen Kyverno-Regeln hinter einem Guest, der die Engine kapselt.
  • Benutzerdefinierte Validierung in Rust/TypeScript: Sicherheitsteams können maßgeschneiderte organisationsweite Policies in Standardsprachen schreiben und sie zu Wasm kompilieren, damit sie als Validierungs-Gate dienen.

Sobald die Policy-Engine den Graphen validiert hat, übersetzt der Compiler diese abstrakten Sicherheitsanforderungen in physische Konfiguration. Wenn ein Entwickler ein Sicherheits-Feature anhängt — zum Beispiel core/data-masking auf dem AI-Gateway —, führt der Compiler den Pipeline-Schritt aus, den seine Realisierung nennt, ein isoliertes WebAssembly-Plugin (Wasm), und dieser Schritt schreibt die Einstellung, die die Kontrolle benötigt, in die Konfiguration, die das eigene Recipe des Gateways bereits erzeugt. Eine Realisierung kann das Schreiben stattdessen dem eigenen Recipe des Gateways überlassen, das den Anhang liest und die Einstellung selbst schreibt, wie es core/data-masking auf core/gateway/kong-enterprise tut, und eine Realisierung für eine andere Art von Kontrolle kann eine eigene Ressource ausgeben; in jedem Fall ist die Ausgabe ein statisches Artefakt, das aus dem geschrieben wird, was der Entwickler angehängt hat.

B. Deploy-Zeit und Laufzeit: Übergabe an die Ausführung und Durchsetzung

Die Verantwortung von Aggrega endet genau in dem Moment, in dem es die Verarbeitung der Eingabe abschließt und die konfigurierten statischen Artefakte in das Ausgabeverzeichnis schreibt. Es ist ein reiner Compiler: Es schreibt die Konfiguration, und danach geht die Kontrolle vollständig an das System zurück, das es aufgerufen hat.

Wie diese Konfigurationen ausgeführt werden, ist äußerst flexibel und liegt vollständig beim Unternehmen:

  • Die Artefaktübergabe (Deploy-Zeit): Externe Deployment-Controller übernehmen, um die Artefakte in die Realität umzusetzen. Das könnte ein strikter GitOps-Controller (wie ArgoCD oder Flux) sein, der Dateien in einen Kubernetes-Cluster synchronisiert, es könnte aber ebenso gut eine gewöhnliche CI/CD-Pipeline sein, die terraform apply ausführt, oder ein Entwickler, der ein lokales Shell-Skript gegen Docker Compose ausführt.
  • Durchsetzung zur Laufzeit: Sobald die Konfigurationen auf die Zielumgebung angewendet sind, übernimmt die physische Infrastruktur. Die von Aggrega konfigurierten spezialisierten Werkzeuge (etwa ein Guardrail-Sidecar, ein aktives Service-Mesh oder native Cloud-Firewalls) starten und beginnen ihre aktive Arbeit: Payloads physisch abfangen, JWTs verifizieren oder bösartige Prompt-Injections verwerfen.

7. Wie Aggrega KI-Sicherheitsherausforderungen begegnet

Durch die Entkopplung der Architekturvalidierung von der Ausführung zur Laufzeit können Plattformteams Aggrega nutzen, um Konfigurationslösungen für die nachfolgend beschriebenen KI-Schwachstellen explizit zu modellieren, zu validieren und zu erzeugen.

A. Datenexfiltration und Abfangen von Payloads

  • Das Problem: Ein autonomer Agent könnte versuchen, vertrauliche Unternehmensdaten an eine nicht autorisierte externe API abfließen zu lassen.
  • Die Lösung von Aggrega:
    1. Kompilierzeit (Validierung und Erzeugung): Das Plattformteam verfasst eine Policy (z. B. Rego), die in einer Governance-Verdict-Rolle ausgewertet wird und besagt: „Jeder Pfad, der durch ein AI-Gateway führt, muss core/data-masking tragen.“ Fehlt es, bricht der Compiler ab. Ist es vorhanden, schreibt die Realisierung, die das Manifest bindet, die Maskierung in die Konfiguration, die das Gateway bereits erzeugt: auf core/gateway/litellm Guardrail-Einträge, die auf die regulären Ausdrücke passen, die der Anhang auflistet, und die den Text für die aufgelisteten Entitätstypen an einen Presidio-Analyzer und -Anonymizer senden, die an die Sockets pii_analyzer und pii_anonymizer des Gateways angeschlossen sind; auf core/gateway/kong-enterprise Kongs AI PII Sanitizer auf den Chat- und Completion-Routen jedes angeschlossenen Modells, geschrieben vom Chart-Recipe des Gateways, der den Text, den er maskiert, mit den regulären Ausdrücken und den Entitätstypen, die der Anhang auflistet, an den Kong-AI-PII-Dienst sendet, der an den Socket pii_sanitizer des Gateways angeschlossen ist; auf core/gateway/agentgateway die eigenen Guards für reguläre Ausdrücke des Gateways, von seinem Chart-Recipe in seine Konfiguration geschrieben, die jeden Treffer der aufgelisteten Muster durch <masked> ersetzen oder unter refuse die Anfrage oder die Antwort mit HTTP 403 beantworten und keine Entitätstypen erkennen; diese Guards maskieren keine gestreamte Antwort, daher schreibt dasselbe Recipe, solange Antworten maskiert werden, eine Regel, die eine Anfrage, die eine solche verlangt, vor ihrer Weiterleitung mit HTTP 403 zurückweist, ebenso jede Anfrage, deren Body größer ist als die 2 MiB, die das Gateway für diese Regel liest, gestreamt oder nicht; auf core/gateway/traefik-hub ein Content Guard des AI-Gateways von Traefik Hub auf der Route jedes angeschlossenen Modells, geschrieben von seinem Chart-Recipe, der die Treffer der aufgelisteten Muster über seine Engine für reguläre Ausdrücke maskiert oder die der aufgelisteten Entitätstypen über den Presidio-Analyzer, der an den Socket pii_analyzer des Gateways angeschlossen ist, eine Engine pro Anhang; auf core/gateway/higress das Higress-Plugin ai-data-masking auf der Route jedes angeschlossenen Modells, geschrieben von seinem Chart-Recipe, das jeden Treffer der aufgelisteten Muster in den Nachrichten einer Chat-Anfrage durch den Namen des Musters in Klammern ersetzt und keine Entitätstypen erkennt. Eine Policy kann auch die engere Frage stellen — ob die Maskierung zwischen den vertraulichen Daten und dem Provider liegt —, indem sie die Anhänge jeder Komponente entlang der Route liest statt der Anhänge der Route als Ganzes, wie es examples/policy-data-class-route tut.
    2. Laufzeit (physische Durchsetzung): Sobald der Orchestrator die generierten Artefakte bereitgestellt hat, ersetzt das Gateway jeden Treffer im Anfragetext, den es maskiert, vor dem Weiterleiten durch einen Platzhalter, sodass der Modellanbieter den Platzhalter erhält; mit action: refuse leitet die Anbindung nichts von einer Anfrage weiter, die einen Treffer enthält, und beantwortet sie stattdessen mit einem Fehler. Ein Erkenner, der nicht erreichbar ist oder einen Fehler meldet, lässt die Anfrage fehlschlagen, sodass ihr Text nicht weitergegeben wird. Was die Maskierung nicht erreicht, entscheiden zwei Werte, deren Standardwerte der Schutz sind. Auf dem AI-Gateway maskiert das Gateway, sofern die Anbindung auch Antworten maskiert, den Text der Antwort und die Teile, die ein Modell oder sein Anbieter daneben hinzufügt — eine Ablehnung, Zitate und Annotationen, die Abfrage und die Ergebnisse einer Websuche, Felder unter eigenen Namen des Anbieters — oder sendet unter refuse nichts von einer Antwort, die einen Treffer enthält; eine gestreamte Antwort, die es per Muster maskiert, erreicht den Aufrufer vollständig, am Ende. Standardmäßig lehnt das AI-Gateway, was seine Maskierung in einer Anfrage nicht erreicht — eine Route wie die Bilderzeugung, ein Feld wie safety_identifier, ein Bild oder eine Datei in der Konversation, ein Tool, das der Anbieter selbst ausführt —, mit HTTP 400 ab, bevor es irgendetwas davon weiterleitet; ein Betreiber, der akzeptiert, dass solcher Text den Anbieter unmaskiert erreicht, setzt allow_unmasked_text an der Anbindung im Release, wobei die Realisierung genau auflistet, was dann durchgeht, und Inhalte, die kein Text sind, weiterhin allow_non_text_content unterliegen. Standardmäßig wird zurückgehalten, was eine maskierte Antwort enthält und ihre Maskierung nicht lesen kann — gesprochenes Audio und sein Transkript, ein Bild, die Wahrscheinlichkeiten der vom Modell gewählten Token —, und ein fehlgeschlagener Aufruf erreicht den Aufrufer mit einer festen Meldung anstelle der vom Anbieter zurückgegebenen; allow_unmasked_reply_parts lässt diese den Aufrufer unmaskiert erreichen. Den eigenen Text einer Antwort lässt dieser Wert nie durch, doch die Teile, die er durchlässt, können die Worte der Antwort enthalten: das Transkript einer gesprochenen Antwort, die Token hinter den Token-Wahrscheinlichkeiten, die Fehlermeldung eines Anbieters, die die Antwort zitiert. Auf core/gateway/kong-enterprise wird jeder Treffer durch einen nummerierten Platzhalter ersetzt, sodass eine Anbindung, die Muster unter redact auflistet, placeholder_shows_name: false setzt; refuse erreicht nur Anfragen, ab Kong 3.12, das eine Anfrage mit einem Treffer mit HTTP 400 beantwortet; und Antworten werden ab 3.12 maskiert, wobei eine Anfrage, die eine gestreamte Antwort verlangt, dann vor dem Weiterleiten abgelehnt und allow_streamed_replies abgelehnt wird. Kongs Sanitizer liest den Text der Benutzer-Turns, den Prompt einer Completion und den Nachrichtentext einer Antwort, und Kongs Referenz nennt keine Einstellung, die eine Anfrage wegen dessen ablehnt, was der Sanitizer nicht liest, oder den Rest einer Antwort zurückhält, sodass auf diesem Gateway jeder Schutz zur Build-Zeit namentlich abgelehnt wird, solange er seinen Standardwert behält, und eine Anbindung sich bauen lässt, sobald das Release sie lockert — allow_unmasked_text und allow_non_text_content, wo Anfragen maskiert werden, allow_unmasked_reply_parts und mask_reasoning: false, wo Antworten maskiert werden —, wobei data-masking-kong-enterprise auflistet, was jeder dann durchlässt. Dort passiert eine Antwort, deren Text nicht als die einzelne Zeichenkette ankommt, die die OpenAI-API zurückgibt, ungelesen, und ihr eigener Text erreicht den Aufrufer unmaskiert; der Schutz davor ist die Prüfung des Builds an jedem an dieses Gateway angeschlossenen Modell, die bei einem Modell abbricht, dessen model.aggrega.ai/api nicht openai ist. Auf core/gateway/traefik-hub wird jeder Treffer durch eine Folge von * ersetzt, die so lang ist wie der Treffer, sodass eine Anbindung, die Muster unter redact auflistet, placeholder_shows_name: false setzt; refuse antwortet mit HTTP 403 anstelle der Anfrage oder der Antwort; und eine maskierte Antwort wird vollständig zurückgehalten und am Ende gesendet, auch eine gestreamte, sodass eine Anbindung, die Entitätstypen in Antworten maskiert, allow_streamed_replies setzt. Traefiks Referenz sagt nicht, welche Felder einer Chat-Anfrage oder -Antwort Content Guard liest, und nennt keine Einstellung, die eine Anfrage ablehnt oder einen Teil einer Antwort zurückhält, wegen dessen, was es nicht liest, sodass auf diesem Gateway jeder Schutz zur Build-Zeit namentlich abgelehnt wird, solange er seinen Standardwert behält, und eine Anbindung sich bauen lässt, sobald das Release sie lockert — allow_unmasked_text und allow_non_text_content, wo Anfragen maskiert werden, allow_unmasked_reply_parts und mask_reasoning: false, wo Antworten maskiert werden —, wobei data-masking-traefik-hub auflistet, was jeder dann durchlässt. Eine Anbindung, die sowohl Muster als auch Entitätstypen auflistet, und eine zweite Maskierungsanbindung an einem Gateway werden abgelehnt, da Traefiks Referenz nicht sagt, ob ein zweiter Content Guard auf einer Route den vom ersten maskierten Text liest oder die Anfrage, wie der Aufrufer sie gesendet hat. Auf core/gateway/higress ersetzt die Higress-Erweiterung ai-data-masking jeden Treffer der Muster, die die Anbindung auflistet, im Inhalt und im Reasoning jeder Nachricht einer Chat-Anfrage durch den Namen des Musters in eckigen Klammern; sie maskiert nur Anfragen, daher werden scope response und both abgelehnt, und sie erkennt keine Entitätstypen. Die Erweiterung liest sonst nichts von einer Anfrage, daher schreibt die Chart-Recipe des Gateways, solange die Schutzmaßnahmen ihre Standardwerte behalten, außerdem die Request-Validation-Erweiterung von Higress, um mit HTTP 403, bevor irgendetwas weitergeleitet wird, eine Anfrage abzulehnen, die enthält, was die Maskierung nicht liest — einen nicht als JSON gesendeten Body oder einen, der keine Chat-Completion ist, eine Nachricht, deren Inhalt eine Liste oder null ist, einen Tool-Call oder Tool-Turn, den Namen einer Nachricht, jeden Parameter außer den Nicht-Text-Parametern einer Chat-Completion und den eigenen Tools, dem Antwortformat und den Stoppsequenzen des Entwicklers —, sowie, was auch immer die Anbindung lockert, eine Anfrage, deren Body die Higress-Erweiterungen überspringen — einen komprimierten Body, einen Content-Type, der octet-stream oder grpc enthält, ein Upgrade — und einen Body mit dem Unicode-Ersatzzeichen U+FFFD, als das diese Validierung ein Byte liest, das kein gültiges UTF-8 ist, da die Maskierungserweiterung einen Body, der kein gültiges UTF-8 ist, unmaskiert weiterleitet. Eine Anfrage, deren Body den 32-KiB-Puffer des Gateways überschreitet, wird mit HTTP 413 abgelehnt. Die Validierung liest nur einen Body, den ihr JSON-Decoder akzeptiert, sodass ein Client, der absichtlich gültiges JSON sendet, das der Decoder ablehnt — etwa eine Zahl jenseits dessen, was ein Double fasst —, jede Ablehnung seines Bodys passiert: Die Maskierungserweiterung maskiert dann nur den reinen Inhalt und das Reasoning jeder Nachricht, sodass ein aufgelisteter Wert an jeder anderen Stelle des Bodys — die Argumente eines Tool-Calls, ein Name, jedes andere Feld — unmaskiert weitergeleitet wird, ebenso wie Inhalt, der mit JSON-Escape-Sequenzen geschrieben ist, und ist ein solcher Body zudem kein gültiges UTF-8, wird alles unmaskiert weitergeleitet. Ein Client, der einen Body absichtlich mehr als 127 Ebenen tief verschachtelt, innerhalb eines Feldes, das die Validierung zulässt, etwa tools, sendet gültiges JSON, das die Validierung dekodiert und zulässt, doch der JSON-Leser der Maskierungserweiterung hält bei dieser Tiefe an, sodass auch mit JSON-Escape-Sequenzen geschriebener Inhalt in diesem Body unmaskiert weitergeleitet wird. Maskierung allein genügt nicht: Text, den kein Muster trifft und kein Erkenner erkennt, passiert unverändert; auf dem AI-Gateway werden Tool-Call-Argumente und Tool-Ergebnisse Wert für Wert maskiert, die Namen ihrer Schlüssel jedoch nicht; die eigenen Tool-Definitionen, Antwortformate und Stoppsequenzen des Entwicklers passieren wie gesendet; das Gateway und die Erkennungsdienste sehen den Originaltext; was das Gateway über einen Aufruf aufzeichnet — in seinem eigenen Log oder in dem, was es an eine Logging-Integration übergibt —, kann diesen Text weiterhin enthalten; und Verkehr, der das Gateway nicht durchquert, wird nicht berührt.

B. Abwehr von MCP-Poisoning (Vertrauen und Isolation)

  • Das Problem: Wird ein Agent über ein vergiftetes Tool des Model Context Protocol (MCP) kompromittiert, kann er autonom destruktive Aktionen ausführen (etwa eine Datenbank löschen oder eine Überweisung autorisieren).
  • Die Lösung von Aggrega:
    1. Kompilierzeit (Validierung und Generierung): Der Entwickler hängt in seiner Aggregate.yaml ein Freigabe-Feature an das sensible Tool an. Die Standardbibliothek liefert kein solches Feature, daher wird dieses im eigenen Katalog des Unternehmens verfasst, zusammen mit dem FeatureRecipe, das es rendert. Der Compiler validiert den Graphen und übersetzt die Anbindung in die Konfiguration für einen L7-Proxy oder ein Webhook-Gateway.
    2. Laufzeit (physische Durchsetzung): Versucht der gekaperte Agent, das Tool aufzurufen, hält der bereitgestellte Proxy die Anfrage an und blockiert die Ausführung physisch, bis eine kryptografisch signierte Freigabe von einem menschlichen Operator eingeht.

C. Das „Confused Deputy“-Problem lösen (Kontextweitergabe)

  • Das Problem: In Multi-Agenten-Ketten könnte ein öffentlich erreichbarer Agent gekapert werden und einem internen, hoch privilegierten Agenten befehlen, sensible Daten abzurufen. Standard-Firewalls sehen nur, dass „Agent A mit Agent B spricht“, und lassen den Verkehr zu, wobei der Kontext des ursprünglichen böswilligen Benutzers vollständig verloren geht.
  • Die Aggrega-Lösung: Unternehmen können zwei spezifische Muster kombinieren:
    1. Weitergabe der Aufruferidentität über zwei Hops: Die Identität des ursprünglichen Aufrufers muss zwei verschiedene Hops überstehen, und jeder wird an einer anderen Stelle geschützt. Beim Gateway-Hop hängt der Entwickler core/context-propagation, das auf dataplane.aggrega.ai/caller-identity selektiert, an das Gateway an, über das eine Anfrage eintritt. Zur Kompilierzeit wird die Anbindung in der eigenen Konfiguration dieses Gateways realisiert — auf Envoy Gateway als Client-Traffic-Policy, die das Zertifikat jedes Clients gegen eine vom Release benannte Zertifizierungsstelle prüft und die Details des Zertifikats weiterleitet; auf dem LiteLLM-AI-Gateway als Request-Hook, der jeden von einem Aufrufer gelieferten Identitäts-Header entfernt und den Benutzer und das Team des vom Gateway verifizierten virtuellen Schlüssels hinzufügt, sowie dessen Organisation, wo der Schlüssel eine nennt, bei Anfragen an die Modellaliase, die die Anbindung in destinations auflistet. Zur Laufzeit erfährt der Dienst hinter dem Gateway, wer aufgerufen hat, statt nur, dass das Gateway aufgerufen hat. Beim Hop zwischen Arbeitslasten durchquert eine Anfrage, die ein Agent direkt an einen anderen richtet, dieses Gateway nie, daher wird sie am eigenen Ingress des empfangenden Agenten geprüft, wo ein Service Mesh jede Anfrage ablehnt, der ein signiertes Token fehlt, das die Absicht des ursprünglichen Benutzers belegt (z. B. eine Istio-JWT-AuthorizationPolicy). Die Standardbibliothek liefert das Feature für den Gateway-Hop und kein Feature für den Hop zwischen Arbeitslasten, sodass das Anhängen von core/context-propagation den Verkehr schützt, der durch ein Gateway läuft, und Aufrufe von Agent zu Agent der Mesh-Konfiguration überlässt, die das Unternehmen selbst bereitstellt. Ein Agent, den eine andere Partei betreibt und den core/ai-tool/agent-invocation über A2A als core/ai-agent/a2a-remote erreicht, liegt ganz außerhalb des Release: Diese Partei prüft jeden Aufruf anhand des Sicherheitsschemas, das die Agent Card des Agenten deklariert, und das Tool präsentiert die auf seiner Verbindung hinterlegten Anmeldedaten, per Referenz aus einem Secret gelesen, unter dem Anfrage-Header, den der Agent veröffentlicht. Wo die Card OAuth 2.0 Client Credentials oder OpenID Connect verlangt, hält die Verbindung stattdessen oder zusätzlich ein Client-Secret, mit der Client-ID, die der Betreiber darauf schreibt, und der Agent veröffentlicht die Token- oder Discovery-Adresse und die Scopes, die seine Card deklariert; der eigene Container des Tools bezieht damit das Token, erneuert es und präsentiert es bei jedem Aufruf; der Katalog liefert nur diese Eingaben, und kein Build kann prüfen, was der Container damit tut. Wo die Card Mutual TLS verlangt, hält die Verbindung ein Client-Zertifikat und, wo eine Zertifizierungsstelle, der das Image nicht bereits vertraut, das Serverzertifikat des Agenten signiert, auch diese Stelle; jedes wird als Dateien aus einem von der Verbindung benannten Secret in den Container des Tools eingehängt, und der Container präsentiert das Zertifikat selbst im TLS-Handshake. Das Tool erreicht also einen Agenten, dessen Card einen API-Schlüssel in einem Header oder einem Cookie deklariert, ein HTTP-Authentifizierungsschema mit festem Wert wie Bearer oder Basic, wobei das Secret den ganzen Header-Wert enthält, OAuth 2.0 oder OpenID Connect mit dem Client-Credentials-Grant oder Mutual TLS. Es erreicht keinen, dessen Card einen Schlüssel im Query-String verlangt, ein HTTP-Schema, das auf eine Challenge des Agenten antwortet, wie Digest, oder einen anderen OAuth-2.0-Flow als Client Credentials. Ebenso wenig präsentiert es Anmeldedaten gegenüber einem Agenten, den eine andere Partei über reines HTTP betreibt: Wo die Adresse dieses Agenten http ist, brechen Anmeldedaten oder ein Client-Secret auf der Verbindung den Build ab und nennen die Verbindung, weil die Anmeldedaten oder das mit dem Secret bezogene Token unverschlüsselt zu ihm übertragen würden. Ein Agent, der innerhalb des Release läuft, bleibt mit beidem über http erreichbar, und die Anmeldedaten durchqueren dann das Cluster-Netzwerk unverschlüsselt.
    2. Payload-Prüfung zwischen Agenten: Eine Anfrage, die ein Agent direkt an einen anderen sendet, durchquert nie das AI-Gateway, daher wird sie am eigenen Ingress des empfangenden Agenten geprüft, von einer Guardrail-Engine, die neben diesem Agenten läuft (z. B. NeMo Guardrails). Zur Kompilierzeit rendert das FeatureRecipe, das ein an den empfangenden Agenten angehängtes Feature realisiert, die Konfiguration der Engine. Zur Laufzeit bewertet die Engine jede Anfrage anhand von Regeln, die das Unternehmen schreibt, und lehnt eine ab, die diese Regeln zurückweisen; wie gut sie eine gekaperte Anfrage von einer legitimen unterscheidet, liegt bei der Engine und den Regeln, denn Aggrega kompiliert Konfiguration und bewertet nie einen Prompt. Die Standardbibliothek liefert kein Feature, das eine solche Engine platziert, daher wird dieses Muster im eigenen Katalog des Unternehmens verfasst. Der eigene Muster-Guard eines Gateways, dataplane.aggrega.ai/prompt-guard: pattern-list, ist enger gefasst, und core/prompt-deny-patterns schaltet ihn ein — auf dem AI-Gateway wird jede Nachricht einer Anfrage gelesen und Groß- und Kleinschreibung ignoriert, auf core/gateway/apisix und core/gateway/kong wird jede Nachricht jeder Rolle als ein Text gelesen, Groß- und Kleinschreibung zählt, und auch eine Liste von Mustern, denen eine Anfrage entsprechen muss, wird beachtet, auf core/gateway/agentgateway werden jede Nachricht, jedes Tool-Call-Argument und jedes Tool-Ergebnis getrennt gelesen, Groß- und Kleinschreibung zählt, und auf core/gateway/traefik-hub wird die Anfrage als Chat-Completion gelesen, deren gelesene Felder Traefiks Referenz nicht auflistet, Groß- und Kleinschreibung zählt: Er lehnt eine Modellanfrage ab, deren Text wörtlich einem der Ausdrücke entspricht, die die Anbindung auflistet — eine Paraphrase, eine andere Sprache oder eine Kodierung passiert ihn —, und nur bei Verkehr, der durch das Gateway läuft, sodass eine direkt zwischen Agenten gesendete Anfrage nie auf ihn trifft. core/prompt-injection-shield ist sein klassifikatorbasiertes Gegenstück auf demselben Hop, das jede Modellanfrage, die ein Gateway weiterleitet, durch einen NeMo-Guardrails-Guard schickt, der an den guard-Socket dieses Gateways angeschlossen ist, oder durch das Prompt Shield von Azure AI Content Safety auf Azure API Management, und auch es deckt nur Verkehr ab, der das Gateway durchquert.

D. Topologische Risikoanalyse

  • Das Problem: Komplexe KI-Architekturen mit Dutzenden miteinander verbundener Modelle, Vektoren und Tools sind zu umfangreich, als dass ein Mensch sie manuell auf transitive Schwachstellen prüfen könnte (z. B. „Kann Agent A mit Tool B sprechen, das mit Agent C spricht, der Zugriff auf Datenbank D hat?“).
  • Die Aggrega-Lösung: Diese Prüfung läuft vorab. Da Aggrega im Speicher einen vollständigen IR-Graphen der beabsichtigten Topologie aufbaut, kann eine Governance-Verdict-Rolle fortgeschrittene Pfadfindungsregeln über die gesamte Architektur ausführen. Erkennt die Policy eine durchgehende, transitive Kette von Kanten, die an einem öffentlichen Knoten beginnt und an einer hochsensiblen Datenbank endet, ohne dass irgendwo entlang dieser Kette eine der vom Unternehmen geforderten Kontrollen angehängt ist, bricht sie den Build sofort ab. Die unsichere Architektur wird blockiert, bevor auch nur eine einzige Zeile Infrastrukturcode generiert wird.

8. Beobachtbarkeit & Compliance

Um strenge regulatorische Anforderungen (z. B. den EU AI Act) zu erfüllen, können Plattformarchitekten das Feature-System von Aggrega nutzen, um KI-Beobachtbarkeit als strukturelle Infrastrukturanforderung durchzusetzen, statt sich auf Anwendungscode zu verlassen:

  • Audit-Protokollierung: Von Unternehmen verfasste Wasm-Plugins können Gateway-Sidecars so konfigurieren, dass sie rohe, ungeschwärzte Prompts und Antworten asynchron in einen sicheren WORM-Storage-Bucket (Write Once, Read Many) streamen und dabei die Standard-Anwendungsprotokolle umgehen.
  • LLM-Tracing: Proxy-Features können die Data-Plane so konfigurieren, dass sie KI-spezifische OpenTelemetry-Span-Header extrahiert und weiterleitet, sodass sich komplexe Reasoning-Schleifen von Agenten in externen Tools visualisieren lassen.

9. Feature-Kompatibilität & topologische Sicherheit

Da der Kern-Compiler agnostisch gegenüber den Mechanismen der physischen Infrastruktur ist, stützt er sich vollständig auf explizite Deklarationen im Katalog, um die Erzeugung inkompatibler Konfigurationen zu verhindern.

  • conflictsWith: Eine Liste, die ein Feature in seiner Katalog-Entität unter interoperability deklariert: die Features, neben denen es nicht angehängt werden kann. Der Compiler vergleicht sie mit den Features, die jede Komponente am Ende trägt, sobald jeder Geltungsbereich beigetragen hat — die eigenen Anhänge der Komponente, die auf einem Subsystem oder einer Boundary geschriebenen, die sie enthält, die in ihrem Komponenteneintrag im Release und die durch annotationsgesteuerte Expansion erzeugten —, und hält vor dem Rendern physischer Artefakte an, wenn eine Komponente beide trägt (d. h. wenn ein Autor direkt oder über einen Geltungsbereich zwei Features anhängt, die der Autor eines der beiden ausdrücklich als inkompatibel deklariert hat). Eine Deklaration genügt, und Features werden unabhängig von ihren Versionen über den Namen abgeglichen. Der Compiler liest nichts in die Namen hinein: Die Inkompatibilität ist die Deklaration des Autors, und die Prüfung ist ein Vergleich von Namen. Atomarität und Reinheit von Features selbst bleiben ein Gesellschaftsvertrag — nichts prüft, dass ein Feature genau eine Sache tut.

10. Dynamisches Topologie-Mapping (Auflösung von Abhängigkeiten)

Um den IR-Graphen ohne fest codierte Regeln aufzubauen, liest der Compiler ihn aus drei expliziten Deklarationen:

  • Kanten über uses: Entwickler verknüpfen Komponenten im Block uses jeder Instanz, indem sie die Zielkomponente in einem Socket nennen, und jede Kante des Graphen stammt aus einem solchen. Ein Eintrag in values, der zufällig eine andere Komponente nennt, erzeugt keine Kante: Der Compiler liest keine Bedeutung in einen Wert hinein.
  • Kantenziele: Jedes Ziel in uses muss eine Komponente nennen, die der Build enthält; ein Ziel, das nicht existiert, bricht den Build ab und nennt den Socket, an den es angeschlossen war.
  • Knotenübergreifende Typsicherheit: Die usesSchema-Selektor-Strings fungieren als explizite Out-of-Band-Anweisungen, die während der statischen Analyse nativ von der Label-Matching-Engine des Go-Compilers ausgewertet werden. Sie garantieren, dass Entwickler Standardkomponenten nicht versehentlich mit einem deklarierten Socket verbinden können, der eine bestimmte KI-native Fähigkeit oder ein bestimmtes Compliance-Label erfordert. Die Garantie ist konstruktionsbedingt auf deklarierte Sockets beschränkt: Ein Selektor steht in einem usesSchema-Eintrag, sodass ein Ad-hoc-Socket keinen auszuwertenden Selektor hat. Jede Kante hält fest, ob ihr Socket im Katalog deklariert war, sodass ein Betreiber, der die Garantie lückenlos benötigt, sie als Governance-Verdict verlangen kann.

11. Automatisiertes Design agentischer Systeme (ADAS)

Fortgeschrittene KI-Systeme verfügen über Meta-Agenten, die Code schreiben, um spontan neue Agenten zu erfinden und bereitzustellen. Da Aggrega eine statische Ahead-of-Time-Architektur (AOT) voraussetzt, löst es die Weiterentwicklung der Infrastruktur zur Laufzeit über zwei explizite Grenzen:

  • Die Grenze der vorab bereitgestellten Sandbox: Für kurzlebige, zur Laufzeit erfundene Tools definiert der Architekt ein Feature (z. B. dynamic-execution-environment). Ist es angehängt, erzeugt das Wasm-Rendering-Plugin die Konfiguration zur Bereitstellung eines abgeschotteten Compute-Pools (etwa einer WebAssembly-Laufzeitumgebung). Der Meta-Agent injiziert neuen Code in diese Sandbox, doch sein Wirkungsradius ist durch die generierten statischen Netzwerkrichtlinien begrenzt.
  • Der Meta-Agent in der „Entwickler“-Rolle (die GitOps-Schleife): Benötigt der Meta-Agent tatsächlich neue physische Infrastruktur, agiert er als Entwickler. Er schreibt eine neue Aggregate.yaml und committet sie in Git. Dies löst die Standard-CI/CD-Pipeline aus. Eine Governance-Verdict-Rolle analysiert die von der KI angeforderte Topologie statisch und hält den Build sicher an, falls die KI eine Schwachstelle halluziniert hat.

12. Modellserialisierung & Sicherheit der Lieferkette

Die Bereitstellung eines Open-Source-Modells bedeutet oft, undurchsichtige .pkl- oder .gguf-Dateien herunterzuladen, die bösartige Code-Payloads enthalten können. Unternehmen können die Sicherheit der Modell-Lieferkette als Konfigurationsproblem der Zielplattform behandeln. Durch die Definition eines model_provenance-Feature im Katalog kann das Wasm-Rendering-Plugin eines Unternehmens die Konfiguration auswerten und in Laufzeitartefakte (etwa Kubernetes-Kyverno-Richtlinien) übersetzen, sodass der Ziel-Cluster so konfiguriert ist, dass er den Orchestrator daran hindert, unsignierte oder nicht verifizierte Modellgewichte abzurufen.