Die neuen Sicherheitsrisiken des agentischen Entwicklungslebenszyklus

Die wichtigsten Erkenntnisse

• Der agentische Entwicklungslebenszyklus ist der Prozess, in dem KI-Agenten Software planen, entwickeln, verändern, testen und ausliefern, indem sie mit Tools, Codebasen und Umgebungen interagieren

• Risiken entstehen jetzt, bevor Code das Repository erreicht. Dadurch verschiebt sich die zentrale Sicherheitsfrage von „Ist dieser Code sicher?“ zu „Können wir dem System vertrauen, das ihn erstellt hat?“

• Agenten bringen an drei Stellen Risiken mit sich: bei den eingesetzten Ressourcen, ihren Aktionen und den von ihnen erstellten Ergebnissen

• Herkömmliche AppSec sichert das Artefakt. Agentic Development Security erfordert dagegen die Absicherung des Prozesses, in dem es erstellt wird.

• Kontinuierliche Kontrollen innerhalb agentischer Workflows bieten Entwicklern und Agenten verlässliche Grenzen, innerhalb derer sie schnell arbeiten können.

Jahrelang beruhte die Anwendungssicherheit auf einer einfachen Annahme: Software durchläuft einen Lebenszyklus, und die Sicherheit überprüft die Artefakte auf ihrem Weg von der Entwicklung bis zur Produktion. Entwickler planen, schreiben Code, committen ihn, testen und scannen ihn und liefern ihn aus. Jede implementierte Kontrolle – von Pull-Request-Reviews über CI/CD-Gates bis hin zu Scans nach dem Commit – ging davon aus, dass zwischen den einzelnen Schritten ein Mensch Entscheidungen trifft, die ein Tool später überprüfen kann.

KI-Agenten stellen diese Annahme infrage: Software wird nicht mehr nur von Menschen geschrieben und anschließend überprüft. Sie wird zunehmend von autonomen Systemen zusammengestellt, verändert und ausgeführt, die handeln können, bevor herkömmliche Kontrollen das Ergebnis überhaupt zu Gesicht bekommen. Der „Entwickler“ ist nicht mehr immer eine Person. Manchmal übernimmt das System selbst die Entwicklung.

Für diesen Wandel gibt es einen Begriff, den Sie kennen sollten: der agentische Entwicklungslebenszyklus. Er verändert, wo Risiken in Ihrer Software entstehen – und damit auch, was Sie absichern müssen.

Was ist der agentische Entwicklungslebenszyklus?

Der agentische Entwicklungslebenszyklus ist der Prozess, in dem KI-Agenten Software planen, entwickeln, verändern, testen und ausliefern, indem sie mit Tools, Codebasen, Datenquellen und Entwicklungsumgebungen interagieren.

Der traditionelle SDLC ist von Menschen gesteuert, artefaktbasiert und durch Kontrollpunkte geprägt: Die Arbeit schreitet schrittweise voran, und die Sicherheit überprüft die Ergebnisse jedes einzelnen Schritts. Der agentische Entwicklungslebenszyklus funktioniert anders: Er ist agentengesteuert, dynamisch, kontinuierlich und aktionsorientiert. Ein Agent kann ein Ziel interpretieren, ein Tool auswählen, Dateien ändern, ein Skript ausführen, eine API aufrufen, eine Abhängigkeit hinzufügen und produktionsreifen Code generieren – oft in einer einzigen, ununterbrochenen Abfolge.

Das ersetzt den SDLC nicht, sondern legt sich darüber und beschleunigt ihn. Agenten erstellen weiterhin Code, Abhängigkeiten, Konfigurationen, APIs und Infrastrukturänderungen. Sie erledigen das jedoch in Workflows, die weitaus schwerer zu überblicken und zu steuern sind als die Arbeit eines Entwicklers in einer IDE.

Warum agentische Entwicklung das Risikomodell verändert

Herkömmliche AppSec geht davon aus, dass Risiken in Artefakten stecken, etwa in Quellcode, Open-Source-Abhängigkeiten, Containern, Infrastructure as Code und APIs. Das gilt nach wie vor. Agentische Entwicklung erweitert jedoch die Angriffsfläche um das System, das diese Artefakte erstellt. Die Sicherheitsfrage ändert sich von „Ist dieser Code sicher?“ zu „Können wir dem System vertrauen, das ihn erstellt hat?“ Das ist eine andere Frage, auf die die meisten Sicherheitsprogramme noch keine Antwort geben können.

Die drei Kontrollpunkte des agentischen Entwicklungslebenszyklus

Um diesen neuen Lebenszyklus zu verstehen, lohnt es sich, die drei Bereiche zu betrachten, in denen Agenten Risiken mit sich bringen: die verwendeten Eingaben, die ausgeführten Aktionen und die erstellten Ergebnisse. Wenn Risiken kontinuierlich entstehen, müssen Sie sie an drei Stellen berücksichtigen: bei den Ressourcen, die Agenten nutzen, ihren Aktionen und den von ihnen erstellten Ergebnissen.

1. Was Agenten nutzen

Agenten beginnen nicht bei null. Um ihre Aufgaben zu erledigen, greifen sie auf MCP-Server, Skills, APIs, externe Tools, Datenquellen und Entwicklungsintegrationen zurück. Diese Ressourcen können Teil Ihrer Software-Lieferkette werden, obwohl sie nie als herkömmliche Abhängigkeiten deklariert wurden. Außerdem werden sie oft zur Laufzeit und ohne Überprüfung ausgewählt und aufgerufen.

Zu den Risiken zählen nicht genehmigte MCP-Server, anfällige oder bösartige Skills, externe Tools mit unklarer Herkunft und nicht erfasste KI-Tools. Das ist kein hypothetisches Szenario: Die Forschung von Snyk hat 76 bestätigte bösartige Skills unter 3.984 untersuchten Skills aufgedeckt, und etwa ein Drittel der öffentlichen MCP-Server weist ausnutzbare Schwachstellen auf.

Wenn Sie nicht wissen, welche Ressourcen Agenten nutzen, können Sie auch nicht wissen, welche Risiken in den Entwicklungsworkflow gelangen.

2. Was Agenten tun

Agenten schlagen nicht einfach eine Änderung vor und warten ab. Sie führen Skripte aus, fragen interne Systeme ab, ändern Dateien und rufen APIs in Maschinengeschwindigkeit auf.

Dadurch entstehen Risiken durch die unsichere Ausführung von Befehlen, den unbefugten Zugriff auf Systeme oder Daten, die Offenlegung von Daten über Tool-Aufrufe, Prompt-Injection in Entwicklungsworkflows und unvorhersehbare Aktionsketten. Ein Beispiel aus der Praxis ist ein Coding-Agent, der wiederholte Anweisungen zum „Einfrieren“ ignorierte, eine Produktionsdatenbank löschte und anschließend Datensätze erfand, um den Fehler zu vertuschen. Der Agent reagierte auf ein kleines Hindernis mit den Berechtigungen, über die er zufällig verfügte.

Das Verhalten von Agenten muss in Echtzeit gesteuert werden, denn Aktionen können schneller erfolgen, als Menschen eingreifen können.

3. Was Agenten erstellen

Agenten erstellen Code und Abhängigkeiten, die Teil Ihrer Software werden. Selbst wenn die Ergebnisse funktionsfähig aussehen, kann KI-generierter Code standardmäßig Schwachstellen, unsichere Muster oder Fehlkonfigurationen enthalten.

Herkömmliche AppSec geht davon aus, dass Code nach dem Schreiben überprüft werden kann. Bei der agentischen Entwicklung wird die Ausgabe jedoch in Maschinengeschwindigkeit erstellt und kann vom Vorschlag bis zum Commit gelangen, bevor die Sicherheit überhaupt sehen kann, was geändert wurde oder warum. Das Risiko besteht nicht nur darin, dass KI-generierter Code unsicher sein kann. Unsichere Ergebnisse können früher eingebracht, schneller vervielfältigt und ausgeliefert werden, bevor herkömmliche Kontrollpunkte aufholen.

Scans nach dem Commit reichen nicht mehr aus. Die Sicherheit muss die von Agenten erstellten Ergebnisse bereits bei ihrer Erstellung überprüfen.

Warum herkömmliche AppSec-Kontrollpunkte nicht ausreichen

Das bedeutet nicht, dass herkömmliche AppSec keine Rolle mehr spielt. Sie müssen weiterhin Code, Abhängigkeiten, Container und Infrastruktur scannen. Diese Grundlage ist heute wichtiger denn je, denn KI ersetzt Ihre Software-Lieferkette nicht – sie beschleunigt sie.

Herkömmliche Kontrollpunkte wurden jedoch für eine Welt entwickelt, in der Menschen die meisten Entwicklungsentscheidungen trafen, Code das wichtigste zu prüfende Artefakt war und Risiken oft beim Commit, Build oder Deployment entdeckt werden konnten. Die Sicherheit kann sich nicht länger allein auf nachgelagerte Prüfungen verlassen, sondern muss direkt in den agentischen Workflow eingebunden werden. Herkömmliche AppSec sichert das Artefakt. Agentic Development Security sichert den Prozess, in dem es erstellt wird.

Was die Absicherung des agentischen Entwicklungslebenszyklus erfordert

Den agentischen Entwicklungslebenszyklus abzusichern bedeutet nicht, Entwickler mit einem weiteren Review-Zyklus auszubremsen oder KI-Tools zu verbieten. Es bedeutet, Agenten verlässliche Grenzen zu setzen, damit Teams sie sicher einsetzen können. Dazu braucht es Kontrollen, die direkt in den Workflows greifen, in denen Agenten handeln.

Sicherheitsteams müssen herausfinden, welche Agenten, Tools, Skills und MCP-Server im Einsatz sind; bewerten, ob diesen Ressourcen zu vertrauen ist; steuern, worauf Agenten zugreifen und was sie ausführen dürfen; Richtlinien während agentischer Workflows durchsetzen; generierten Code und Abhängigkeiten in Echtzeit überprüfen; und sämtliche Aktivitäten der agentengesteuerten Entwicklung nachvollziehbar protokollieren.

Der gemeinsame Nenner ist die kontinuierliche Überwachung. Die Sicherheitsverantwortlichen müssen nah genug am Agenten arbeiten, um Risiken zu bewerten, bevor daraus ein committetes Artefakt, eine ausgeführte Aktion oder eine bereitgestellte Schwachstelle wird.

Der Lebenszyklus hat sich verändert. Die Sicherheit muss sich mit ihm verändern.

Der agentische Entwicklungslebenszyklus ist nicht einfach ein schnellerer SDLC. Er beschreibt eine andere Art der Softwareentwicklung, bei der autonome Systeme kontinuierlich Tools einbinden, Aktionen ausführen und Ergebnisse erzeugen können. Dieser Wandel bringt Sicherheitsfragen mit sich, für die Kontrollen an einzelnen Kontrollpunkten allein nie ausgelegt waren.

Um KI-gestützte Entwicklung sicher zu skalieren, brauchen Teams Transparenz und Kontrolle über den gesamten Lebenszyklus hinweg: darüber, was Agenten nutzen, was sie tun und was sie erstellen. Das Ziel ist nicht, die Einführung von KI auszubremsen. Vielmehr sollen Entwickler und Agenten verlässliche Grenzen erhalten, damit sie schnell arbeiten können, während die Sicherheit kontinuierlich im Hintergrund aktiv ist.

Möchten Sie genauer erfahren, wie KI-Agenten über herkömmliche Kontrollen hinaus handeln? Laden Sie noch heute den Spickzettel herunter.