KI-Agenten filmen sich beim Programmieren: Cursors neue Funktion

Kurz gesagt

Die neue Funktion Agenten-Computernutzung von Cursor ermöglicht es KI-Cloud-Agenten, ihre eigenen virtuellen Maschinen zu steuern, wodurch sie Code autonom erstellen, testen und verifizieren können. Die Agenten laufen in isolierten VMs mit vollständigen Entwicklungsumgebungen, können Browser öffnen und localhost navigieren und liefern merge-bereite Pull-Requests mit Videos und Logs. Der Zugriff erfolgt über Cursor Desktop, Web, Slack, GitHub oder API. Über 30 % der internen Codeänderungen von Cursor werden mittlerweile von diesen autonomen Agenten erstellt.

Einleitung

Die Art und Weise, wie Entwickler Code schreiben, ändert sich rasant. Jahrelang haben KI-Code-Assistenten wie Cursor als intelligente Autocomplete-Tools funktioniert – sie schlugen die nächste Zeile vor, erklärten Code oder halfen beim Refactoring bestehender Arbeiten. Doch es findet eine große Veränderung statt.

Cursor kündigte an, was sie als "die größte Verschiebung in der Softwareentwicklung seit dem Übergang vom Tab-Autocomplete zur synchronen Arbeit mit Agenten" bezeichnen. Ihre Cloud-Agenten können nun ihre eigenen virtuellen Maschinen steuern, um funktionierenden Code zu erstellen, zu testen und zu demonstrieren.

Dies ist nicht nur eine inkrementelle Verbesserung. Laut der Ankündigung von Cursor werden 30-35 % ihrer gemergten Pull-Requests mittlerweile von autonomen Cloud-Agenten erstellt.

In diesem Leitfaden erfahren Sie, was die Agenten-Computernutzungsfunktion von Cursor leistet, wie sie funktioniert und wie Sie sie genau einrichten.

Was ist die Cursor Agenten-Computernutzung?

Die Cursor Agenten-Computernutzung ist eine Funktion, die es KI-Agenten ermöglicht, in ihren eigenen isolierten virtuellen Maschinen zu arbeiten, anstatt nur mit Ihrer lokalen Entwicklungsumgebung zu interagieren. Wenn Sie einen Cloud-Agenten starten, wird eine vollständige Entwicklungsumgebung in der Cloud hochgefahren – eine isolierte VM mit allem, was zum Erstellen, Testen und Verifizieren von Software benötigt wird.

Warum das wichtig ist

Traditionelle KI-Code-Assistenten funktionieren durch:

• Vorschläge von Code-Vervollständigungen in Ihrer IDE
• Beantwortung von Fragen zu Ihrer Codebasis
• Hilfe beim Refactoring oder Erklären von bestehendem Code

Die Cloud-Agenten von Cursor gehen noch weiter, indem sie tatsächlich die Arbeit erledigen:

• Ausführung in isolierten Cloud-Umgebungen
• Installation von Abhängigkeiten und Erstellung von Projekten
• Öffnen von Browsern und Testen der Benutzeroberfläche
• Verifizierung, dass Änderungen funktionieren, bevor sie zurückgemeldet werden
• Erstellung von merge-bereiten Pull-Requests mit Nachweisen

Die Technologie dahinter

Jeder Cloud-Agent läuft in seiner eigenen isolierten virtuellen Maschine. Dies bietet mehrere wichtige Vorteile:

1. Isolation: Agenten konkurrieren nicht um lokale Ressourcen
2. Parallelität: Mehrere Agenten können gleichzeitig arbeiten
3. Verifizierung: Agenten können ihre Änderungen tatsächlich testen
4. Nachweise: Jeder PR enthält Videos, Screenshots und Logs

Cloud-Agenten vs. traditionelle IDE-KI-Unterstützung

Das Verständnis des Unterschieds zwischen Cloud-Agenten und traditioneller IDE-basierter KI hilft, realistische Erwartungen zu setzen:

Traditionelles KI-Codieren (Cursor Klassischer Modus):

• Vorschläge erscheinen in Ihrer IDE, während Sie tippen
• Erfordert, dass Sie jede Änderung überprüfen und akzeptieren
• Begrenzt auf die Ressourcen Ihres lokalen Rechners
• Keine Möglichkeit, Tests auszuführen oder die Funktionalität zu überprüfen
• Sie behalten jederzeit die volle Kontrolle und den Kontext

Cloud-Agenten (autonom):

• Agenten arbeiten unabhängig ohne ständige Aufsicht
• Änderungen werden getestet und verifiziert, bevor Sie sie sehen
• Volle VM-Ressourcen für Builds und Tests verfügbar
• Erzeugt überprüfbare Artefakte, die zeigen, was getan wurde
• Sie greifen nur in der PR-Überprüfungsphase ein

Die entscheidende Verschiebung ist von "KI unterstützt mich" zu "KI erledigt es für mich". Dies ersetzt Entwickler nicht – es verlagert Ihre Rolle von der Implementierung zur Überprüfung und Steuerung.

Technische Anforderungen erklärt

Das Verständnis dessen, was unter der Haube passiert, hilft bei der Fehlerbehebung:

• VM-Umgebung: Jeder Agent erhält eine frische Ubuntu-basierte VM mit vorinstallierten gängigen Entwicklungstools
• Repository-Klonen: Der Agent klont Ihr Repository, einschließlich aller Submodule, um mit Ihrer tatsächlichen Codebasis zu arbeiten
• Abhängigkeitsverwaltung: Der Agent kann npm-Pakete, pip-Anforderungen oder andere Abhängigkeiten nach Bedarf installieren
• Netzwerkzugriff: Agenten können auf das Internet zugreifen, um Pakete zu klonen, Curl-Befehle auszuführen oder zu Localhost-Servern zu navigieren
• Artefakt-Speicher: Videos und Screenshots werden gespeichert und im generierten PR verlinkt

Diese Transparenz bedeutet, dass Sie immer wissen, in welcher Umgebung Ihr Code erstellt und getestet wurde.

Wie Cursor Cloud-Agenten funktionieren

Architekturübersicht

Wenn Sie einen Cursor Cloud-Agenten starten, geschieht Folgendes:

1. VM-Bereitstellung: Cursor startet eine isolierte virtuelle Maschine mit einer vollständigen Entwicklungsumgebung
2. Repository-Zugriff: Der Agent klont Ihr Repository und alle Abhängigkeiten
3. Aufgabenausführung: Der Agent liest Ihre Anforderungen, nimmt Änderungen vor und führt Tests durch
4. Verifizierung: Der Agent öffnet Browser, navigiert zu localhost, klickt sich durch die Benutzeroberfläche, um zu überprüfen, ob alles funktioniert
5. Artefakt-Generierung: Der Agent zeichnet Videos, Screenshots und Logs auf, die zeigen, was getan wurde
6. PR-Erstellung: Der Agent erstellt einen Pull-Request mit allen Nachweisen

Wo Sie Agenten starten können

Cursor Cloud-Agenten sind von mehreren Plattformen aus zugänglich:

Anforderungen

Bevor Sie Cloud-Agenten verwenden, stellen Sie sicher, dass Sie Folgendes haben:

• Max-Modus-kompatible Modelle aktiviert (nur diese Modelle unterstützen Cloud-Agenten)
• Lese- und Schreibberechtigungen für Ihr Repository
• Zugriff auf alle abhängigen Repositories oder Submodule

Derzeit unterstützen Cloud-Agenten GitHub- und GitLab-Repositories.

Schritt-für-Schritt-Einrichtungsanleitung

Schritt 1: Auf das Onboarding zugreifen

Navigieren Sie zu cursor.com/onboard, um loszulegen. Diese Seite führt Sie durch die anfängliche Agentenkonfiguration und lässt Sie beobachten, wie der Agent sich selbst einrichtet.

Schritt 2: Ihre Startplattform wählen

Sie haben mehrere Optionen:

Option A: Cursor Desktop

1. Öffnen Sie die Cursor IDE
2. Finden Sie die Agenten-Eingabe unten
3. Klicken Sie auf das Dropdown-Menü und wählen Sie "Cloud"
4. Beschreiben Sie, was Sie erstellt haben möchten

Option B: Cursor Web

1. Gehen Sie zu cursor.com/agents
2. Melden Sie sich mit Ihrem Konto an
3. Wählen Sie Ihr Repository aus
4. Beschreiben Sie Ihre Aufgabe

Option C: GitHub-Integration

1. Navigieren Sie zu Ihrem Repository
2. Öffnen Sie ein Issue oder einen PR
3. Kommentieren Sie @cursor build a feature that...
4. Der Agent übernimmt die Aufgabe

Schritt 3: Agenten-Berechtigungen konfigurieren

Wenn Sie einen Cloud-Agenten zum ersten Mal verwenden, müssen Sie folgende Berechtigungen erteilen:

• Lese-/Schreibzugriff auf das Repository
• Zugriff auf alle abhängigen Repositories
• Zugriff auf Submodule, falls zutreffend

Schritt 4: Ihre Aufgabe definieren

Seien Sie präzise, was der Agent erreichen soll. Zum Beispiel:

• "Erstelle eine Anmeldeseite mit E-Mail- und Passwortfeldern"
• "Füge einen Dunkelmodus-Schalter zur Einstellungsseite hinzu"
• "Behebe den Fehler, bei dem die API bei ungültiger Eingabe 500 zurückgibt"

Je mehr Kontext Sie bereitstellen, desto besser kann der Agent liefern.

Schritt 5: Überwachen und Überprüfen

Während Agenten autonom arbeiten, können Sie:

• Den Remote-Desktop des Agenten in Echtzeit beobachten
• Generierte Artefakte (Videos, Screenshots) überprüfen
• Die Sitzung übernehmen, um Änderungen selbst auszuprobieren
• Den PR genehmigen oder Änderungen anfordern

Hauptfunktionen und -fähigkeiten

Selbsttest und Iteration

Vielleicht die mächtigste Funktion: Agenten können ihre Arbeit tatsächlich verifizieren. Sie können:

• Entwicklungsserver starten
• Browser öffnen und zu localhost navigieren
• Durch UI-Elemente klicken
• Automatisierte Tests ausführen
• Überprüfen, ob die Funktionalität wie erwartet funktioniert

Der Agent verbrachte 45 Minuten damit, eine vollständige Überprüfung der Cursor-Dokumentationsseite durchzuführen. Er lieferte eine Zusammenfassung aller getesteten Funktionen, einschließlich der Seitenleiste, der oberen Navigation, der Suche, der Schaltfläche zum Kopieren der Seite, des Dialogs zum Teilen von Feedback, des Inhaltsverzeichnisses und des Themenwechsels.

Artefakterfassung

Jeder Agentenlauf erzeugt reichhaltige Artefakte:

• Videos, die die Funktion in Aktion zeigen
• Screenshots von wichtigen Momenten
• Protokolle von Build- und Testprozessen
• Diff aller Codeänderungen

Dies beschleunigt die Überprüfung – Sie können genau sehen, was getan wurde, ohne den Branch auschecken zu müssen.

Fernsteuerung des Desktops

Möchten Sie die Änderungen selbst ausprobieren? Sie können den Remote-Desktop des Agenten direkt übernehmen. Dies ermöglicht Ihnen:

• Die Funktion in der Umgebung des Agenten zu testen
• Zu überprüfen, ob sie vor dem Mergen funktioniert
• Bei Bedarf zusätzliche Änderungen vorzunehmen
• Das lokale Auschecken des Branches zu vermeiden

Multi-Plattform-Zugriff

Cloud-Agenten funktionieren überall dort, wo Sie sind:

• Desktop: Volle IDE-Integration
• Web: Browserbasiertes Agenten-Management
• Mobil: Überwachung unterwegs
• Slack: Schnelle Agenten-Befehle
• GitHub: Issue- und PR-Integration

Anwendungsfälle aus der Praxis

Neue Funktionen entwickeln

Beschreiben Sie eine benötigte Funktion, und der Agent erstellt sie End-to-End: Gerüstbau, Implementierung, Tests und Verifizierung.

Fehler reproduzieren

Weisen Sie den Agenten an, einen Fehler zu reproduzieren, und er kann:

• Die Umgebung einrichten
• Die Fehlerbedingungen auslösen
• Die Grundursache untersuchen
• Eine Lösung vorschlagen und testen

Schnelle Korrekturen

Für kleine Änderungen können Sie die Aufgabe vollständig an den Agenten delegieren, ohne den Kontext wechseln zu müssen.

UI-Tests

Agenten können durch Benutzeroberflächen klicken, um zu überprüfen:

• Ob Benutzerabläufe korrekt funktionieren
• Ob responsives Design richtig gerendert wird
• Ob interaktive Elemente wie erwartet reagieren

API-Integrationsarbeit

Beim Erstellen von API-Integrationen können Agenten:

• Mock-Server einrichten
• API-Endpunkte testen
• Antwortverarbeitung überprüfen
• Dokumentation generieren

Hier ergänzen Tools wie Apidog die Agenten von Cursor hervorragend – nutzen Sie Apidog, um Ihre APIs zu entwerfen und zu testen, und lassen Sie dann die Cursor-Agenten die Frontend-Implementierung und -Integration übernehmen. Sie können beispielsweise Localhost-APIs mit Webhook-Diensten testen, um zu überprüfen, ob Ihre API-Integrationen korrekt funktionieren, bevor Sie sie bereitstellen.

Einschränkungen und Überlegungen

Aktuelle Einschränkungen

• Repository-Unterstützung: Derzeit nur GitHub und GitLab
• Modellbeschränkung: Nur Max-Modus-kompatible Modelle funktionieren
• Berechtigungsanforderung: Voller Lese- und Schreibzugriff erforderlich
• Neue Funktion: Noch in Entwicklung, einige Grenzfälle möglich

Wann verwenden und wann nicht

Am besten geeignet für:

• Klar definierte Feature-Anfragen
• Fehlerreproduktion und -behebung
• Boilerplate und Gerüstbau
• Test- und Verifizierungsaufgaben

Möglicherweise nicht ideal für:

• Hoch sicherheitssensible Codes (Berechtigungen sorgfältig prüfen)
• Komplexe architektonische Entscheidungen (menschliches Urteilsvermögen erforderlich)
• Aufgaben, die eine spezifische lokale Umgebungseinrichtung erfordern

Sicherheitsüberlegungen

Beim Erteilen von Repository-Zugriff an Agenten sollten Sie diese Sicherheitsbestimmungen beachten:

1. Verwenden Sie scoped Tokens: Anstatt vollen Repository-Zugriff zu gewähren, verwenden Sie Tokens mit den minimal erforderlichen Berechtigungen
2. Agentenaktionen überprüfen: Überprüfen Sie PRs immer gründlich vor dem Mergen, insbesondere für Produktionscode
3. Separate Umgebungen: Erwägen Sie, Agenten zunächst nur auf Nicht-Produktionszweigen zu verwenden
4. Audit-Logs: Nutzen Sie die Artefakt-Aufzeichnung von Cursor, um zu prüfen, was der Agent getan hat
5. Fangen Sie klein an: Beginnen Sie mit risikoarmen Aufgaben, um Vertrauen aufzubauen, bevor Sie sich kritischen Funktionen widmen

Cursors Ansatz mit isolierten VMs ist von Natur aus sicherer, als Agenten direkten lokalen Zugriff zu gewähren, aber eine verantwortungsvolle Nutzung erfordert dennoch Wachsamkeit.

Zukunft der autonomen Codierungsagenten

Best Practices, um das Beste aus Cloud-Agenten herauszuholen

Um die Produktivität mit den autonomen Agenten von Cursor zu maximieren, befolgen Sie diese bewährten Praktiken:

1. Klare, spezifische Prompts schreiben

Die Qualität der Agentenausgabe korreliert direkt mit der Klarheit des Prompts. Statt vager Anfragen wie „Login-Fehler beheben“, seien Sie spezifisch: „Wenn ein Benutzer das Anmeldeformular mit gültigen Anmeldedaten absendet, sollte er zu /dashboard weitergeleitet werden, stattdessen wird ein 401-Fehler angezeigt. Der Server gibt das richtige Token in der Antwort zurück.“

2. Frühzeitig Kontext bereitstellen

Geben Sie den Agenten frühzeitig relevanten Kontext: Dateipfade, relevante Code-Snippets, Fehlermeldungen oder Links zu verwandten Issues. Agenten können nur mit dem arbeiten, was sie wissen.

3. Iterative Verfeinerung nutzen

Versuchen Sie nicht, Agenten alles auf einmal erstellen zu lassen. Beginnen Sie mit einer minimal funktionsfähigen Version, überprüfen Sie die Ergebnisse und erweitern Sie dann. Dies führt zu besseren Ergebnissen, als massive Anforderungen in einem Prompt zu dumpen.

4. Mehrere Agenten parallel einsetzen

Da Agenten in isolierten VMs laufen, können Sie mehrere Agenten gleichzeitig für verschiedene Aufgaben starten – einen für eine neue Funktion, einen anderen für eine Fehlerbehebung, einen dritten für Dokumentationsaktualisierungen.

5. Artefakte gründlich überprüfen

Die Video- und Screenshot-Artefakte sind nicht nur nette Extras – sie sind Ihr Fenster zu dem, was der Agent tatsächlich getan hat. Sehen Sie sie sich an, um Probleme zu erkennen, die Sie bei der Code-Überprüfung möglicherweise übersehen.

Integration in Ihren bestehenden Workflow

Cursor-Agenten lassen sich reibungslos in gängige Entwicklungsworkflows integrieren:

• CI/CD: Agenten können PRs erstellen, die Ihre bestehende CI-Pipeline auslösen
• Code-Review: Der Standard-PR-Review-Prozess gilt – keine speziellen Tools erforderlich
• Tests: Agenten können Ihre Test-Suite ausführen und die Ergebnisse in PRs einfügen
• Dokumentation: Agenten können README-Dateien, API-Dokumentationen oder Inline-Kommentare aktualisieren

Die entscheidende Erkenntnis ist, dass Agenten Ihren Workflow erweitern, anstatt ihn zu ersetzen. Sie überprüfen, testen und genehmigen weiterhin – aber die Fleißarbeit geschieht automatisch.

Die Ankündigung von Cursor stellt einen breiteren Trend dar. Der Bereich der KI-Codierung heizt sich auf:

• Anthropic veröffentlichte Claude Code mit Agentenfähigkeiten
• OpenAI führte Codex für autonomes Codieren ein
• Microsoft erweitert ständig die Funktionen von GitHub Copilot
• Google integriert KI-Agenten in Entwicklungsworkflows

Die autonome PR-Rate von Cursor von 30-35 % deutet darauf hin, dass dieses Modell funktioniert. Erwarten Sie, dass weitere Tools ähnliche Ansätze verfolgen werden, wenn die Technologie reifer wird.

Speziell für die API-Entwicklung schafft die Kombination von autonomen Agenten mit dedizierten API-Tools einen leistungsstarken Workflow: Agenten übernehmen Implementierung und Tests, während spezialisierte Tools wie Apidog API-Design, Dokumentation und umfassende Tests verwalten.

Fazit

Die Funktion "Agenten-Computernutzung" von Cursor stellt eine grundlegende Verschiebung in der Art und Weise dar, wie Software entwickelt wird. Indem KI-Agenten in ihren eigenen virtuellen Maschinen arbeiten, ihre Änderungen testen und verifizierte, artefakt-reiche Pull-Requests erstellen können, beweist Cursor, dass autonomes Codieren im großen Maßstab funktioniert.

Die Einrichtung ist unkompliziert: Wählen Sie Ihre Plattform, definieren Sie Ihre Aufgabe und lassen Sie den Agenten arbeiten. Da über 30 % des Cursor-eigenen Codes inzwischen von Agenten geschrieben werden, hat sich die Technologie bewährt.

Nächste Schritte:

• Probieren Sie das Onboarding unter cursor.com/onboard aus
• Beginnen Sie mit einer kleinen, klar definierten Aufgabe
• Überprüfen Sie die generierten Artefakte, um die Fähigkeiten des Agenten zu verstehen
• Überlegen Sie, wie autonome Agenten Ihren Entwicklungsworkflow erweitern könnten

Beginnen Sie mit Apidog: Testen Sie Apidog kostenlos, um Ihre APIs zu entwerfen, zu testen und zu dokumentieren, während Sie KI-gestützte Code-Assistenten wie Cursor für die Implementierung nutzen.