Entwicklung & Code
Core Java: Java Agents und Instrumentation API im praktischen Einsatz
Die Java Instrumentation API ist ein Teil des java.lang.instrument-Pakets und ermöglicht es, den Bytecode von Klassen zur Laufzeit zu verändern oder zu analysieren. Sie ist insbesondere für das Entwickeln von Profilern, Agenten, Monitoring-Tools oder auch dynamischen Sicherheitsmechanismen gedacht, die tief in das Verhalten einer Java-Anwendung eingreifen müssen, ohne dabei den Quellcode selbst zu verändern.

Seit 1996 programmiert Sven Java in Industrieprojekten und seit über 15 Jahren weltweit in Branchen wie Automobil, Raumfahrt, Versicherungen, Banken, UN und Weltbank. Seit über 10 Jahren ist er von Amerika bis nach Neuseeland als Speaker auf Konferenzen und Community Events, arbeitete als Developer Advocate für JFrog und Vaadin und schreibt regelmäßig Beiträge für IT-Zeitschriften und Technologieportale.
Neben seinem Hauptthema Core Java beschäftigt er sich mit TDD und Secure Coding Practices.
Im Zentrum dieser API steht das Konzept der Java Agents. Ein Agent ist eine spezielle Komponente, die beim Start der JVM oder auch zur Laufzeit über die Attach API geladen werden kann. Der Agent nutzt dann ein Instrumentation-Interface, das vom JVM-Launcher übergeben wird. Über dieses Interface erhält der Agent die Möglichkeit, bereits geladene Klassen zu inspizieren, neue Klassen zu transformieren oder das Verhalten der JVM zu beeinflussen – etwa durch das Einfügen von Hooks, das Messen von Aufrufzeiten oder das Injizieren von Sicherheitsprüfungen.
Die grundlegende Aufgabe besteht also darin, während des Classloading-Prozesses den Bytecode zu transformieren, ohne dabei die Semantik der Sprache Java zu verletzen. Technisch ermöglichen dies die ClassFileTransformer. Entwickler müssen sie zunächst registrieren, dann können die ClassFileTransformer bei jedem Ladevorgang einer Klasse den Bytecode manipulieren, bevor die JVM diesen interpretiert oder kompiliert.
Ein typischer Einstiegspunkt für einen statischen Agenten ist eine Klasse mit einer premain(String agentArgs, Instrumentation inst)-Methode. Bei dynamischen Agenten kommt stattdessen die agentmain(String agentArgs, Instrumentation inst)-Methode zum Einsatz. Beide Varianten erlauben es, Transformer zu registrieren und damit das Verhalten der Anwendung unterhalb der Sprachebene zu beeinflussen.
Das Verwenden der Instrumentation API erfordert ein tiefes Verständnis der JVM-Architektur und des Java-Klassenlademechanismus. Gleichzeitig eröffnet sie aber auch einzigartige Möglichkeiten zur Laufzeitanalyse und -modifikation, die mit den üblichen Mitteln in Java nicht erreichbar wären – und das in einer Art und Weise, die sich elegant in bestehende Anwendungen integrieren lässt, ohne diese neu zu kompilieren.
Vor- und Nachteile der Java Instrumentation API
Ein zentraler Vorteil der Java Instrumentation API liegt in der Fähigkeit zur transparenten Bytecode-Manipulation: Das Verhalten bestehender Klassen lässt sich ändern, ohne deren Quellcode anzufassen. Das ist besonders relevant in sicherheitskritischen oder hochdynamischen Umgebungen, etwa beim Einfügen von Logging-, Tracing- oder Metrik-Code. Die API ermöglicht zudem eine Class Retransformation. Dabei lassen sich auch bereits geladene Klassen unter bestimmten Bedingungen nachträglich verändern – ein Feature, das in Verbindung mit Tools wie JRebel oder modernen Observability-Werkzeugen wie OpenTelemetry intensiv zum Einsatz kommt.
(Bild: Playful Creatives / Adobe Stock)

Am 14. Oktober findet die betterCode() Java 2025 statt. Bei der von iX und dpunkt.verlag ausgerichteten Online-Konferenz dreht sich alles um das für September geplante Java 25, das auch als LTS-Release verfügbar sein wird. Außerdem gibt es eine Keynote und ein Panel zu 30 Jahren Java und einen Vortrag zu ML für Java-Anwendungen.
Ein weiterer Vorteil ist die Integration ohne Quelltextänderungen. Ein Agent lässt sich mit dem Java-Prozess starten oder zur Laufzeit hinzufügen, ohne dass die Zielanwendung überhaupt wissen muss, dass sie instrumentiert wird. Dies ist insbesondere bei Debugging-, Monitoring- oder Sicherheitsanwendungen essenziell.
Darüber hinaus ist die Instrumentation API seit Java 5 fester Bestandteil des JDK und erfordert keine zusätzlichen Bibliotheken. In sicherheitssensiblen Umgebungen – etwa in der kritischen Infrastruktur oder im behördlichen Einsatz – kann genau dieser Umstand sowohl für den Einsatz sprechen (da keine externen Abhängigkeiten eingebracht werden müssen), als auch dagegen (da Angreifer dieselbe Schnittstelle missbrauchen könnten, um laufende Anwendungen zu manipulieren).
Die Mächtigkeit der Instrumentation API bringt zwangsläufig auch erhebliche Nachteile mit sich. An erster Stelle steht die Komplexität der Bytecode-Manipulation. Obwohl es Libraries wie ASM (Assembly Manipulator) oder Byte Buddy gibt, die den Umgang mit Bytecode erleichtern, bleibt dessen Manipulation ein Einstieg tief in den Maschinenraum der JVM und setzt ein fundiertes Verständnis der Java-Klassenstruktur, des Classloading und der Bytecode-Spezifikation voraus.
Ein zweites Risiko betrifft die Stabilität und Vorhersehbarkeit: Eingriffe in den Bytecode können zu subtilen Fehlern führen, etwa wenn Methodensignaturen verändert, Sicherheitsprüfungen umgangen oder Synchronisationsblöcke manipuliert werden. Solche Fehler sind schwer zu testen und treten gegebenenfalls nur unter bestimmten Laufzeitbedingungen auf – was den Debugging-Aufwand drastisch erhöht.
Auch die Kompatibilität über verschiedene JVM-Versionen hinweg ist ein Problem. Nicht jede JVM verhält sich identisch beim Classloading oder bei der Transformation. Besonders mit GraalVM oder in AOT-Umgebungen kommt es vor, dass bestimmte Features der Instrumentation API nicht oder nur eingeschränkt funktionieren. Das betrifft insbesondere dynamisches Nachladen von Klassen oder den Zugriff auf Low-level JVM-Interna.
Zu guter Letzt ist auch der Performance-Overhead nicht zu vernachlässigen. Zwar ist das Registrieren eines Agent meist sehr effizient, aber wenn Transformer komplexe Operationen bei jedem Classload ausführen oder Metriken injizieren, kann dies zu messbaren Verzögerungen beim Start oder zur Laufzeit führen – insbesondere in I/O-intensiven Serveranwendungen.
Die Java Instrumentation API ist daher ein zweischneidiges Schwert: Sie bietet eine einzigartige Möglichkeit, tief in das Verhalten einer Java-Anwendung einzugreifen – allerdings zum Preis erhöhter Komplexität, potenzieller Instabilität und erschwerter Wartbarkeit. Ihr Einsatz sollte daher gut begründet und gezielt erfolgen – stets begleitet von einer Test- und Logging-Infrastruktur. In sicherheitskritischen oder hochdynamischen Kontexten, in denen keine Änderung des Anwendungscodes möglich ist, bleibt sie jedoch ein unverzichtbares Werkzeug.
Welche Performanceimplikationen gibt es?
Die Performanceimplikationen der Java Instrumentation API sind vielschichtig und hängen stark vom jeweiligen Anwendungsfall, der Komplexität der durchgeführten Transformationen und der Art der Zielanwendung ab. Grundsätzlich kann man drei Phasen unterscheiden, in denen die Instrumentation API die Performance beeinflusst: beim Classloading, zur Laufzeit der instrumentierten Klassen und im Zusammenhang mit speicher- oder sicherheitsrelevanten Operationen.
Einfluss während des Classloading
Der signifikanteste unmittelbare Einfluss entsteht beim Laden einer Klasse durch den Classloader. Sobald ein ClassFileTransformer registriert ist, wird er bei jedem Ladevorgang einer neuen Klasse aufgerufen. In diesem Moment übergibt die JVM den Original-Bytecode der Klasse an den Transformer, der ihn modifiziert oder unverändert zurückgeben kann. Die Dauer dieser Transformation wirkt sich direkt auf die Startzeit der Anwendung oder auf das dynamische Nachladen von Klassen aus.
Komplexe Transformationen, insbesondere solche, die mit ASM oder ähnlichen Bytecode-Libraries durchgeführt werden, erzeugen häufig einen messbaren Overhead – insbesondere bei Framework-basierten Anwendungen mit tausenden Klassen. Wenn zusätzlich Logging, Tracing oder Code-Injektionen in jede Methode erfolgen, steigt die Ladedauer teils exponentiell an, da jeder Methodenblock individuell bearbeitet werden muss.
Einfluss zur Laufzeit
Je nach den am Bytecode vorgenommenen Veränderungen, kann sich auch zur Laufzeit ein zusätzlicher Overhead ergeben. Das gilt insbesondere dann, wenn der Transformer zusätzlichen Kontrollfluss einfügt – etwa Logging-Anweisungen, Zeitmessung, zusätzliche Validierungen oder sicherheitsrelevante Checks. Solche Einfügungen können beispielsweise die Ausführung jeder Methode um mehrere Nanosekunden bis zu Millisekunden verlängern, was in hochfrequent aufgerufenen Methoden (z. B. in I/O-Schleifen oder Geschäftslogik) zu massiven Performanceverlusten führen kann.
Ein typisches Beispiel ist das Method Entry/Exit Tracing, bei dem vor und nach jeder Methode Logging-Code injiziert wird. Obwohl dieser Logging-Code selbst nicht aktiv schreibt, sondern nur passive Marker setzt, entsteht dennoch eine Speicher- und CPU-Last, die sich unter hoher Last summieren kann.
Darüber hinaus kann die Instrumentierung auch JIT-Optimierungen der JVM beeinträchtigen, insbesondere wenn unvorhersehbare Kontrollflüsse eingefügt oder Methoden künstlich aufgebläht werden. Dies führt gegebenenfalls dazu, dass bestimmte Hotspots nicht mehr in nativ optimierten Code überführt werden – mit entsprechenden Folgen für die Ausführungszeit.
Speicher- und Garbage-Collector-Effekte
Wird bei der Instrumentierung zusätzlicher Objektzustand eingeführt – beispielsweise durch statische Caches, Trace-Informationen oder assoziierte Metadaten –, kann das zu einem Anstieg der Heap-Nutzung führen. Kritisch wird die Situation, wenn Weak- oder Soft-References nicht korrekt verwaltet oder kontinuierlich neue Klassen mit leicht unterschiedlichen Strukturen erzeugt werden, was schlimmstenfalls zu einem OutOfMemoryError beim Klassenspeicher führt.
Die Java Instrumentation API lässt sich mit minimalem Einfluss auf die Performance nutzen, sofern man sie effizient und zielgerichtet einsetzt. Das setzt allerdings voraus, dass man die registrierten Transformer so schlank wie möglich hält, unnötige Transformationen vermeidet und Klassen gezielt filtert. Ferner ist stets zu bedenken, dass selbst kleine Änderungen im Bytecode weitreichende Auswirkungen auf die Optimierungsstrategien der JVM und das Speicherverhalten haben können. Daher sind ein sorgfältiges Benchmarking und gezieltes Monitoring unerlässlich, wenn man die API in Produktionssystemen einsetzen möchte.
Welche Sicherheitsimplikationen ergeben sich?
Da Instrumentation API Klassen zur Laufzeit manipulieren, Sicherheitsprüfungen entfernen oder neuen Bytecode injizieren kann, eröffnet sie eine Angriffsfläche, die weit über das hinausgeht, was typischer Anwendungscode leisten darf. Sie stellt damit ein potenzielles Einfallstor für Privilege Escalation, Code Injection und Persistenzmechanismen dar, wie sie bei Advanced Persistent Threats (APT) oder bösartigen Agenten zu beobachten sind.
Sicherheitsimplikationen im Detail
Es ist wichtig festzuhalten, dass die Instrumentation API bewusst an der JVM-Sandbox vorbei operieren kann. Ist ein Agent einmal aktiv – sei es beim Start über das -javaagent-Argument oder dynamisch über die Attach API – dann hat er im Kontext der laufenden JVM nahezu vollständige Kontrolle über alle geladenen Klassen. Der Agent kann Sicherheitsprüfungen entfernen, Stacktraces verändern, Kontrollfluss umleiten oder sensible Informationen aus dem Speicher extrahieren. Auch die Transformation von Klassen aus sicherheitsrelevanten Packages wie java.lang.reflect oder javax.crypto ist möglich, sofern keine SecurityManager-Restriktionen aktiv sind (die allerdings seit Java 17 deprecated und seit Java 21 vollständig entfallen sind).
Besonders kritisch in diesem Zusammenhang ist die Attach API, da sie es erlaubt, beliebige Java-Prozesse auf dem lokalen System zur Laufzeit mit einem Agenten zu versehen – solange derselbe Benutzerkontext vorliegt. Das bedeutet: Ein Angreifer, der sich Zugriff auf einen Shell-Account verschafft, könnte jeden beliebigen Java-Prozess dieses Benutzers kompromittieren, ohne dass dieser Prozess dafür vorbereitet sein müsste. Dieses Szenario entspricht einer Form von Runtime Privilege Escalation auf Prozessebene.
Entwicklung & Code
Google veröffentlicht Magika 1.0 zur KI-gestützten Dateityp-Erkennung
Die erste stabile Version von Googles Open-Source-Werkzeugs Magika zur KI-gestützten Dateityp-Erkennung liegt vor. Die Anwendung wurde für Version 1.0 in Rust neu entwickelt und unterstützt mehr als 200 verschiedene Dateitypen – doppelt so viele wie in der Alpha-Version vom vergangenen Jahr.
Weiterlesen nach der Anzeige
Die Neuentwicklung in Rust sorgt laut Google für deutliche Performance-Verbesserungen. Auf einem MacBook Pro mit M4-Chip verarbeite Magika knapp 1000 Dateien pro Sekunde. Das Tool nutzt die ONNX Runtime für schnelle KI-Inferenz und Tokio für asynchrone Parallelverarbeitung. Neben dem neuen nativen Client für die Kommandozeile stehen außerdem Module für Python und TypeScript zur Verfügung.
Von Jupyter Notebooks bis WebAssembly
Die erweiterte Typerkennung deckt auch spezialisierte Formate aus verschiedenen Bereichen ab: Data-Science-Formate wie Jupyter Notebooks, NumPy-Arrays oder PyTorch-Modelle gehören ebenso dazu wie moderne Programmiersprachen (Swift, Kotlin, TypeScript, Dart, Solidity, Zig) und DevOps-Konfigurationsdateien (Dockerfiles, TOML, HashiCorp HCL). Magika kann zudem genauer zwischen ähnlichen Formaten unterscheiden – etwa zwischen JSON und JSONL oder zwischen C- und C++-Code.
Für das Training des erweiterten Modells musste Google nach eigenen Angaben zwei Herausforderungen bewältigen: Der Trainingsdatensatz wuchs auf über 3 Terabyte an, was den Einsatz der hauseigenen SedPack-Bibliothek zum effizienten Streaming erforderte. Für seltene oder spezialisierte Dateitypen, von denen nicht genügend reale Beispiele verfügbar waren, setzte das Unternehmen auf generative KI: Googles Gemini-Modell erzeugte synthetische Trainingsdaten durch Übersetzung von Code und strukturierten Dateien zwischen verschiedenen Formaten.
Magika lässt sich auf Linux, macOS und Windows einrichten. Ferner können Entwickler das Tool als Bibliothek in Python-, TypeScript- oder Rust-Projekte integrieren. Laut Google verzeichnet das Projekt seit der Alpha-Version über eine Million Downloads pro Monat.
(fo)
Entwicklung & Code
Eine API für alle – Mozilla beendet LLM-Chaos
Mit dem Python-Paket any-llm veröffentlicht Mozilla eine einheitliche API für viele LLMs in Version 1, die bereits stabil für den produktiven Einsatz sein soll. Das entlastet Entwicklerinnen und Entwickler bei der Verwendung der Modelle, da sie nicht mehr für jedes einzelne LLM einen eigenen Adapter pflegen müssen.
Weiterlesen nach der Anzeige
Die angebundenen Modelle können in der Cloud oder lokal vorliegen und lassen sich über die asynchrone API leicht wechseln. Um die Performance zu verbessern, sind Client-Verbindungen wiederverwendbar. Das Tool liefert auch für das Reasoning eine standardisierte Ausgabe. Außerdem teilt any-llm den Anwenderinnen und Anwendern mit, wenn sich API-Modi oder -Endpunkte ändern.
Ein optionales LLM-Gateway dient dem Budget- und Key-Management und ist mandantenfähig. So kann er als LLM-Schnittstelle für Unternehmen dienen.
Die Liste der angebundenen Provider auf der GitHub-Seite ist bereits lang und umfasst Anthropic, Azure, Databricks, Deepseek, Gemini, Groq, Hugging Face, Llama, Mistral, Ollama, Perplexity, Watsonx und weitere. Zudem findet sich dort eine Tabelle, welche Funktionen any-llm jeweils unterstützt: Response, Reasoning, Image und so weiter.

Auf der GitHub-Seite von any-llm findet sich ene Tabelle mit unterstützten Modellen und Eigenschaften.
Um das Tool zu nutzen, sind Python 3.11 und die jeweiligen API-Keys erforderlich, die das Tool in einer Umgebungsvariablen speichert. Geplant hat Mozilla für die nächsten Versionen eine Batch-Funktion sowie die Anbindung weiterer LLMs und zusätzlicher Bibliotheken wie den MCP-Daemon.
Lesen Sie auch
(who)
Entwicklung & Code
KI Navigator #14: Muss KI gläsern sein? Zwischen Regulierung und Realität
Willkommen zur vierzehnten Ausgabe der KI-Navigator-Kolumne der DOAG KI Community!
Weiterlesen nach der Anzeige

Dr. Benjamin Linnik, promoviert in Kernphysik, vereint Expertise in Data Science, Software Engineering und Beratung. Als AI Tech Lead transformiert er Organisationen durch praktische AI-First-Ansätze – und schlägt dabei die Brücke zwischen technologischen Möglichkeiten und geschäftlichen Realitäten. Privat entspannt er gerne mit seiner Familie, umgeben von zwei Katzen und automatisiert gerne sein Smart-Home.

Dr. Alex Meistrenko hat als Unternehmensberater mit Fokus auf IT-Projekte in der Finanz- und Versicherungsbranche seine Leidenschaft für Systemarchitekturen, Datenmodellierung und Datenanalyse zum Beruf gemacht. Der promovierte Physiker und Mathematiker beschäftigt sich seit vielen Jahren mit der anwendungsorientierten Entwicklung von KI-Systemen – ebenso wie mit den mathematischen Prinzipien, auf denen sie beruhen.
Geschichte wiederholt sich
Die EU-KI-Regulierung erinnert uns Physiker an eine berühmte Debatte aus der Geschichte der Wissenschaft: Ende des 19. Jahrhunderts standen sich zwei Giganten der Physik gegenüber: Ludwig Boltzmann und Ernst Mach. Der einflussreiche Positivist Mach weigerte sich, Boltzmanns statistische Mechanik zu akzeptieren. „Ham’s aans g’sehn?“ (Haben Sie eins gesehen?), rief er provokant aus dem Publikum während einer von Boltzmanns Vorlesungen über Atome. Doch Boltzmann zeigte: Auch wenn jedes einzelne Molekül real ist und chaotisch wirkt, entstehen makroskopische Eigenschaften wie Temperatur und Druck aus statistischen Gesetzmäßigkeiten – ohne dass wir jeden einzelnen Molekülstoß verfolgen müssen.
Die EU verlangt von KI-Systemen eine transparente Nachvollziehbarkeit – aber was heißt das konkret? Es geht nicht darum, die Berechnung jedes einzelnen Tokens offenzulegen, sondern die Regulierung fordert, dass wir die Ergebnisse von KI-Systemen nachvollziehen und interpretieren können – so wie ein Physiker nicht die Bahn jedes einzelnen Gasmoleküls kennt, aber über Druck, Temperatur und Volumen das Verhalten des Gases zuverlässig beschreiben und steuern kann. Nicht mikroskopische Durchleuchtung, sondern makroskopisches Verständnis und Kontrolle sind das Ziel.
Die historische Parallele ist verblüffend: Damals wie heute geht es um dieselbe methodische Einsicht. In der Thermodynamik lehrt Boltzmann, dass man komplexe Systeme durch emergente statistische Eigenschaften verstehen und ihr Verhalten kontrollieren kann, ohne jeden Einzelprozess zu verfolgen. Bei der KI müssen wir ebenso akzeptieren, dass wir nicht jeden einzelnen Verarbeitungsschritt erklären müssen, sondern das Gesamtverhalten eines KI-Systems anhand der statistischen Gesetzmäßigkeiten und emergenten Eigenschaften überwachen und kontrollieren können.
Weiterlesen nach der Anzeige
LLMs verstehen: Von der Theorie zur Praxis
Die Kernfrage ist: Wie schaffen wir Vertrauen in Systeme, deren inneres Verhalten wir nicht vollständig verstehen und kontrollieren können? Dabei liegt die Antwort nicht in der unmöglichen Aufgabe, jeden Schritt zu erklären, sondern in der intelligenten Überwachung des Gesamtsystems – genau wie bei einem Motor, wo wir nicht jede Molekülbewegung im Brennraum verfolgen, aber sehr wohl die kritischen Parameter überwachen. Die Lösung liegt nicht in der Rückkehr zu deterministischen Ansätzen, sondern in der Entwicklung neuer Methoden für die Überwachung probabilistischer KI-Systeme.
Large Language Models (LLMs) sind probabilistische Systeme, deren Ausgabe nie deterministisch ist. LLMs verhalten sich wie ein komplexes Gas aus vielen Teilchen: Einzelne Token sind unvorhersehbar, aber das Gesamtverhalten lässt sich durch makroskopische Größen beschreiben und kontrollieren.
Die Kontrollgrößen der KI
Statt jeden einzelnen Schritt zu prüfen, überwachen moderne KI-Systeme makroskopische Metriken:
- Lösungsqualität: Wie gut löst das System die anvertrauten Aufgaben faktisch korrekt und relevant über Zeit und Anwendungsbereiche?
- Zuverlässigkeit: Wie konsistent sind die Antworten bei wiederholter Ausführung und unter gleichen Bedingungen?
- Durchsatz: Wie viele Aufgaben kann das System pro Zeiteinheit bearbeiten?
- Effizienz: Wie viel Rechenleistung und Kosten verursacht das System für nützliche Ergebnisse?
- Quellentreue (Faithfulness): Wie treu bleibt die generierte Antwort den bereitgestellten Quelldokumenten, ohne unbelegte Informationen hinzuzufügen?
Diese exemplarischen Metriken erklären nicht jeden einzelnen Prozess, geben aber ein klares Bild vom Gesamtzustand des Systems. Zusätzliche Metriken lassen sich je nach Anwendungsfall heranziehen, etwa Fairness bei verschiedenen Nutzergruppen, Latenz bei Echtzeitanwendungen oder Robustheit gegen Angriffe bei sicherheitskritischen Systemen.
Messung makroskopischer Metriken in der Praxis
In der Praxis werden makroskopische KI-Metriken durch eine Kombination bewährter Methoden erfasst, die drei zentrale Säulen umfassen:
- stichprobenartige Bewertung mit menschlichen Experten
- LLM-as-a-Judge
- Distributed Tracing
Stichprobenartige Bewertung mit menschlichen Experten: Statt jeden einzelnen Output zu prüfen, bewerten Fachexpertinnen und -experten repräsentative Stichproben in Testsystemen. Moderne Plattformen wie LangSmith oder Langfuse bieten Annotation Queues – strukturierte Warteschlangen, in denen Experten systematisch KI-Ausgaben nach vordefinierten Kriterien bewerten können. Diese Bewertungen schaffen Referenzdatensätze, um automatische Systeme zu kalibrieren.
LLM-as-a-Judge: skalierbare automatische Bewertung. Bei dieser Methode werden vordefinierte Testszenarien mit bekannten Sollergebnissen (Ground Truth) durch das zu testende System verarbeitet. Ein KI-System in der Richterrolle vergleicht dann die tatsächlichen Ausgaben mit den erwarteten Ergebnissen anhand festgelegter Bewertungskriterien wie Faktentreue und Relevanz. Dies ermöglicht eine konsistente und skalierbare Bewertung großer Datenmengen. Entscheidend ist die sorgfältige Auswahl und kontinuierliche Verfeinerung der Judge-Szenarien.
Distributed Tracing: Systemverhalten sichtbar machen. Moderne KI-Systeme nutzen OpenTelemetry und ähnliche Frameworks für Distributed Tracing. Wie ein Thermometer die Temperatur misst, ohne jedes Molekül zu erfassen, tracken diese Systeme Anfragen durch komplexe KI-Pipelines und sammeln dabei makroskopische Metriken wie Latenz, Durchsatz, Fehlerrate und Ressourcenverbrauch. Sie erfassen jeden Schritt im KI-System – vom Prompt über die Toolauswahl bis hin zur Modellausführung und Antwort – als „Span“ und verknüpfen sie zu einem „Trace“.
Dabei gilt die Unterscheidung zwischen Test- und Produktivsystem: Ein Mensch könnte im Prinzip jeden Pfad nachvollziehen, den ein KI-System genommen hat – das ist jedoch in Produktivsystemen weder praktikabel noch erwünscht. Aus Kostengründen wäre die manuelle Prüfung von Millionen von Traces unwirtschaftlich, und aus Datenschutzgründen ist es verboten, persönliche Nutzerdaten in den Traces für manuelle Inspektion zu speichern.
Stattdessen werden diese Trace-Daten automatisch zu makroskopischen Kennzahlen aggregiert: durchschnittliche Antwortzeiten, Fehlerquoten pro Zeitraum oder Ressourcenverbrauch nach Systemkomponenten. KI-Monitoring konzentriert sich auf datenschutzkonforme Aggregatdaten statt auf individuelle Nutzerinteraktionen.
Die drei Methoden ergänzen einander: Menschliche Bewertungen schaffen den Sollzustand während der Entwicklung in kontrollierten Testsystemen, LLM-Judges stellen sicher, dass die Qualität mit der Zeit nicht schlechter wird und Tracing-Systeme überwachen das laufende Systemverhalten in Produktivsystemen.
Differenzierte Sicht auf Regulierung
Das globale Regulierungsumfeld für KI zeigt klare prinzipielle Unterschiede zwischen den Regionen. Während die EU im Rahmen des ersten weltweiten KI-Gesetzes (EU AI Act Regulation) auf explizite Erklärbarkeit setzt, bevorzugen die USA, Australien, aber auch internationale Standards, System-Level Assurance – einen Ansatz, der makroskopische Metriken über mikroskopische Erklärbarkeit stellt und die Erklärung emergenter Eigenschaften des Gesamtsystems ohne detaillierte Kenntnis einzelner Entscheidungen zum Ziel hat.
Makroskopische Metriken für stochastische KI-Systeme sind technisch umsetzbar und bewährt. Beispiele hierfür sind durch die Standards und Methoden wie Assurance of AI-Enabled Systems und Artificial Intelligence Risk Management Framework (AI RMF 1.0) gegeben und zeigen insbesondere, dass System-Level Assurance auch im Bereich von KI-Systemen funktioniert.
Der EU-Weg ist technisch herausfordernder, aber nicht unmöglich, solange keine lückenlose mathematische Erklärung aller mikroskopischen Entscheidungen vorliegen muss – er erfordert jedoch andere technische Lösungen, die über makroskopische Metriken hinausgehen und möglicherweise höhere Entwicklungskosten zur Folge haben. Insbesondere lässt der EU-Weg aber auch viel Interpretationsspielraum für die Bedeutung einer transparenten und erklärbaren KI zu.
Darüber hinaus ist davon auszugehen, dass eine zweifelsfreie Klassifizierung eines KI-Systems als Hochrisiko-System (EU AI Act Art. 6) in der Praxis oft auf Schwierigkeiten stoßen wird. Folglich könnte die EU-Regulierung Innovation behindern oder zu alternativen technischen Entwicklungspfaden führen, in denen der KI-Einsatz im Bereich von Hochrisiko-Systemen auf grundlegende klassische ML-Verfahren beschränkt bleibt und somit die Erklärbarkeit von rückgekoppelten, nicht-linearen und tiefen neuronalen Netzen vermieden wird.
Hier ist davon auszugehen, dass sich solch eine Entwicklung zu einem enormen Wettbewerbsnachteil bspw. im Energiesektor entwickeln wird, der längerfristig in einer wiederholten Abhängigkeit von den führenden Tech-Giganten, vorwiegend aus den USA, resultieren wird, wie wir es auch schon im Bereich des Cloud-Computing erlebt haben.
Der Paradigmenwechsel: Von Code zu Systemen
Der Übergang von traditioneller zur AI-First-Entwicklung greift tiefer, als neue Tools einzuführen. In der traditionellen Entwicklung schreiben Developer den Code, führen manuelle Code-Reviews durch und pflegen separate Dokumentationen. AI-First-Entwicklung hingegen basiert auf natürlicher Sprache, automatisierten Abnahmetests, Everything-as-Code (inklusive Dokumentation) und autonomer Fehlerbehebung.
Die zentrale Frage lautet: Wie baut man Vertrauen in autonome KI-Systeme auf, damit sie sicher autonom arbeiten können? Die Antwort liegt in Quality Gates und makroskopischen Metriken, die emergente Eigenschaften des Gesamtsystems messen. Autonome Fehlererkennung und ausgeklügelte Quality Gates helfen dem KI-System, Fehler zu identifizieren und zu beheben.
Developer entwickeln sich zu KI-Kuratoren – eine zukunftsweisende Rolle, die weit über traditionelle Programmierung hinausgeht. Statt Code Zeile für Zeile zu schreiben, orchestrieren KI-Kuratoren intelligente Systeme: Sie definieren Architektur, etablieren Qualitätsstandards und schaffen adaptive Frameworks, während KI-Systeme die eigentliche Codegenerierung übernehmen.
KI-Kuratoren befähigen ihre Systeme zur selbstständigen Weiterentwicklung: Sie implementieren Lernmechanismen, die es dem System ermöglichen, aus Fehlern zu lernen, neue Technologien zu integrieren, sich an veränderte Anforderungen anzupassen und eigenständig Fähigkeiten zu erweitern. Durch kontinuierliche Validierung und strategische Führung entstehen Systeme, die nicht nur funktionieren, sondern sich proaktiv verbessern und mit dem Puls der Zeit entwickeln.
Als Beispiel für AI-First-Arbeitsweise: Das Recruiting-Startup Mercor erzielte mit 30 Mitarbeitern 100 Millionen US-Dollar jährliche Umsatzrate. Dieses technologienahe Startup ist ein Sonderfall und als AI-natives Unternehmen besonders früh dran – das Beispiel illustriert jedoch, in welche Richtung sich Automatisierungsgrade entwickeln könnten, auch wenn solche Ergebnisse noch nicht branchenübergreifend Standard sind.
-
UX/UI & Webdesignvor 3 MonatenDer ultimative Guide für eine unvergessliche Customer Experience
-
UX/UI & Webdesignvor 2 MonatenAdobe Firefly Boards › PAGE online
-
Social Mediavor 3 MonatenRelatable, relevant, viral? Wer heute auf Social Media zum Vorbild wird – und warum das für Marken (k)eine gute Nachricht ist
-
Apps & Mobile Entwicklungvor 2 MonatenGalaxy Tab S10 Lite: Günstiger Einstieg in Samsungs Premium-Tablets
-
UX/UI & Webdesignvor 3 WochenIllustrierte Reise nach New York City › PAGE online
-
Entwicklung & Codevor 3 MonatenPosit stellt Positron vor: Neue IDE für Data Science mit Python und R
-
Datenschutz & Sicherheitvor 2 MonatenHarte Zeiten für den demokratischen Rechtsstaat
-
Entwicklung & Codevor 2 MonatenEventSourcingDB 1.1 bietet flexiblere Konsistenzsteuerung und signierte Events
