Agentische Entwicklung in RAD Studio
Mit Kai hält agentische KI Einzug in die Delphi- und C++Builder-Entwicklung innerhalb von RAD Studio. Der Assistent nutzt Projektkontext, erzeugt Quellcode und Formulare und begleitet mehrstufige Aufgaben direkt in der IDE. Cloud-Modelle und lokale LLMs lassen sich je nach Qualität, Kosten und Schutzbedarf flexibel anbinden.
Künstliche Intelligenz hält zunehmend Einzug in integrierte Entwicklungsumgebungen (IDE). Häufig beginnt die Unterstützung mit Autovervollständigung: Der Editor übermittelt einen Ausschnitt des Codes an ein Sprachmodell und zeigt die wahrscheinlichste Fortsetzung an. Kai erweitert dieses Prinzip um eine agentische Ebene. Es handelt sich um ein kostenpflichtiges Add-on für RAD Studio, Delphi und C++Builder. Es verbindet kontextbezogene Vorschläge mit einem Agent Chat, der nicht nur antwortet, sondern – abhängig von Modus und Freigaben – eigenständig Aktionen im Projekt ausführen kann: Dateien lesen und ändern, Formulare erzeugen, Builds starten und Compilerdiagnosen auswerten.
Der Unterschied zu einem Chatfenster neben der IDE liegt im verfügbaren Kontext. Kai arbeitet dort, wo Projektdateien, Editor, Form Designer und Toolchain zusammenlaufen. Dateien lassen sich im Chat mit @ referenzieren; der Agent kann die Projektstruktur berücksichtigen und Ergebnisse unmittelbar als Änderungsvorschlag anwenden. Für Delphi gilt das ebenso wie für den C++Builder. Die Qualität hängt dennoch von der Auswahl der Dateien, einem klaren Ziel und den Kenntnissen des Modells über die Programmiersprache und Bibliothek ab.
Kai ist deutlich mehr als eine Autocomplete-Funktion. Für kleinere "Eingriffe" bleibt die Inline-Vervollständigung oft der schnellste Weg. Bei einer mehrstufigen Aufgabe – etwa "Erzeuge eine Suchfunktion, baue das Formular, kompiliere das Projekt und behebe die auftretenden Fehler" – kann der Agent dagegen eine Kette von Werkzeugaufrufen koordinieren. Das Model Context Protocol (MCP) bildet dabei die Erweiterungsschicht: Kai kann IDE-nahe Werkzeuge sowie zusätzliche MCP-Server ansprechen. Aus einer natürlichsprachlichen Anforderung entsteht so ein kontrollierbarer Ablauf aus Planung, Implementierung, Build, Fehlerkorrektur und Überarbeitung. Agentisch bedeutet dabei nicht autonom im organisatorischen Sinn: Der Entwickler definiert Ziel und Grenzen, prüft Änderungen und entscheidet über die Übernahme (Abb. 1).
Agentische KI im Entwickleralltag
Für die Arbeit am Quelltext bietet Kai drei Modi. Ghost Text blendet nach einer kurzen Pause eine Fortsetzung direkt im Editor ein; Tab übernimmt diesen Vorschlag, Esc verwirft ihn. Die CodeInsight-Integration platziert die KI-Option in der bekannten Vorschlagsliste und lässt sich über Strg+Leertaste aufrufen. Panel Completions zeigen mehrere Alternativen nebeneinander, die kopiert oder eingefügt werden können. Damit lässt sich die Interaktion an die Aufgabe anpassen.
Der Agent Chat ist das Zentrum für projektbezogene Aufgaben. Er kann Object Pascal- oder C++-Code erklären und überarbeiten, neue Units beziehungsweise Quelldateien anlegen, Methoden implementieren, Abhängigkeiten nachvollziehen und eine Änderung über mehrere Dateien verteilen. Auch die visuelle Entwicklung gehört zum vorgesehenen Funktionsumfang: Kai kann VCL- oder FireMonkey-Formulare erzeugen und Controls konfigurieren. Beispiele zeigen, dass teilweise komplette Entwürfe einer Applikation allein durch das Schreiben der passenden Prompts generiert werden können, d.h., ohne dass man im Idealfall manuell Code schreiben muss (Abb. 2). Das ist kein Beweis für eine fehlerfreie Ein-Klick-Entwicklung, zeigt aber die Stärke eines kurzen, iterativen Dialogs direkt am Projekt.
Besonders interessant ist die Build Integration. Der Agent kann eine Anwendung kompilieren, Meldungen lesen, Korrekturen vorschlagen und erneut bauen. Das spart bei der Fehlersuche Zeit: Fehlende Units, falsche Bezeichner, unpassende Typen oder syntaktische Probleme werden im gleichen Kontext sichtbar, in dem die Änderung entstanden ist. Ein erfolgreicher Build ist allerdings nur eine technische Zwischenprüfung. Fachlogik, Nebenläufigkeit, Speicherverwaltung, Plattformunterschiede und Sicherheitsanforderungen müssen weiterhin durch Reviews und Tests abgesichert werden.
Bei Bestandsanwendungen verschiebt sich der Nutzen von der Generierung zur Orientierung und Modernisierung. Kai kann alte Units zusammenfassen, Abhängigkeiten erläutern, große Methoden in kleinere Einheiten zerlegen, veraltete Muster markieren oder eine UI schrittweise an aktuelle VCL-Styles anpassen (Unterstützung beim Refactoring). Entscheidend ist, die Modernisierung in kleine, testbare Aufgaben zu zerlegen. Eine pauschale Aufforderung, eine umfangreiche Legacy-Anwendung "zu modernisieren“, liefert schwer prüfbare Änderungen und erhöht das Risiko von Regressionen.
Installation und Anbindung der Modelle
Kai ist ein separates Add-on und wird nicht automatisch mit RAD Studio installiert. Die Erweiterung steht für RAD Studio, Delphi und C++Builder 12.x und 13.x in den Editionen Professional, Enterprise und Architect zur Verfügung. Sie kann über den GetIt Package Manager bezogen werden. Nach der Installation ist ein Neustart der Entwicklungsumgebung erforderlich. Für eine erste Erprobung wird eine 30-Tage-Testlizenz angeboten.
Die Einrichtung erfolgt unter Tools > Optionen >Kai. Die Einstellungen für den Agent Chat und die Codevervollständigung sind voneinander getrennt. Dadurch können für beide Aufgaben unterschiedliche Modelle eingesetzt werden.
Die Codevervollständigung profitiert vor allem von kurzen Antwortzeiten. Für die Analyse größerer Codebereiche, Änderungen über mehrere Dateien oder das Ausführen von Entwicklungsschritten ist dagegen ein leistungsfähigeres Modell mit einem größeren Kontextfenster sinnvoll.
Die Verbindung zu einem Cloud-Modell erfolgt über die Zugangsdaten des jeweiligen Anbieters. Abhängig vom Dienst werden eine API-Adresse, ein API-Schlüssel oder eine Anmeldung über das zugehörige Benutzerkonto benötigt. Kai kommuniziert anschließend direkt mit dem gewählten Dienst und zeigt die dort verfügbaren Modelle an. Unterstützte Zugänge bestehen unter anderem für OpenAI, Anthropic Claude, Google Gemini und GitHub Copilot.
Ein lokales Modell wird über die Adresse des zugehörigen Inferenzservers angebunden. Dafür eignen sich beispielsweise Ollama und LM Studio. Darüber hinaus können kompatible Server im lokalen Netzwerk oder in der unternehmenseigenen Infrastruktur verwendet werden. Das Modell muss somit nicht auf dem Entwicklungsrechner ausgeführt werden. Ein zentraler Rechner mit geeigneter GPU kann die Modelle für mehrere Entwickler bereitstellen. In diesem Fall müssen Zugriffsrechte, Authentifizierung, Protokollierung und die Trennung verschiedener Projekte geregelt werden. Bei Cloud-Modellen werden der ausgewählte Quellcode, der Prompt und weitere benötigte Kontextinformationen direkt an den jeweiligen Anbieter übertragen. Für diese Daten gelten dessen vertragliche Regelungen zu Datenschutz, Speicherung und Nutzung.
Cloud, lokal oder kombiniert
Die Wahl des Modells beeinflusst Antwortqualität, Geschwindigkeit, Kosten und Datenschutz. Kai schreibt kein bestimmtes Sprachmodell vor. Teams können daher je nach Aufgabe zwischen Cloud-Diensten und lokal betriebenen Modellen wählen. Cloud-Modelle bieten in der Regel eine hohe Leistungsfähigkeit und werden vom Anbieter laufend aktualisiert. Welche Modelle tatsächlich auswählbar sind, hängt vom Benutzerkonto, dem gebuchten Tarif, der Schnittstelle des Anbieters und der eingesetzten Kai-Version ab. Konkrete Modellbezeichnungen können sich kurzfristig ändern. Für ein Entwicklungsteam ist es deshalb sinnvoller, Anforderungen an Qualität, Kontextgröße, Kosten und zulässige Datenübertragung festzulegen, statt dauerhaft ein einzelnes Modell vorzuschreiben.
Lokale Modelle behalten Quellcode und Projektdaten innerhalb der eigenen Infrastruktur. Sie eignen sich insbesondere für vertrauliche Anwendungen, regulierte Umgebungen oder den Betrieb ohne externe Internetverbindung. Außerdem fallen keine nutzungsabhängigen Gebühren eines Cloud-Anbieters an. Dem stehen Kosten für Hardware, Betrieb, Updates und Administration gegenüber. Auch die Leistungsfähigkeit muss berücksichtigt werden: Kleinere Modelle benötigen weniger Speicher und antworten schneller, erreichen bei umfangreichen Analysen oder mehrstufigen Aufgaben jedoch häufig nicht die Qualität größerer Modelle.
Für die Codevervollständigung ist die Unterstützung von Fill-in-the-Middle (FIM) relevant. Dabei erhält das Modell sowohl den Quellcode vor als auch nach der aktuellen Cursorposition und erzeugt den fehlenden Abschnitt. Ob eine bestimmte LLM-Version zuverlässig funktioniert, sollte mit den im Unternehmen verwendeten Delphi- und C++-Projekten geprüft werden.
Die freie Modellwahl (Tabelle 1) erleichtert es, unterschiedliche Anforderungen abzudecken. Ein kleines lokales Modell kann schnelle Codevorschläge erzeugen, während ein leistungsfähiges Cloud-Modell komplexe Abhängigkeiten oder größere Änderungen analysiert. Sensible Quelltexte können vollständig innerhalb des Unternehmens verarbeitet werden. Gleichzeitig bleibt ein Wechsel des Anbieters möglich, wenn sich Preise, Verfügbarkeit oder technische Anforderungen ändern.
In vielen Fällen bietet sich eine kombinierte Nutzung an. Allgemeine Codevorschläge, Testgerüste oder die Arbeit mit öffentlich dokumentierten Schnittstellen können über einen Cloud-Dienst erfolgen. Geschäftslogik, proprietäre Algorithmen und Kundencode werden dagegen mit einem lokalen Modell verarbeitet. Diese Festlegung des Einsatzes von lokalen und Cloud-Modellen sollte nicht allein dem Entwickler überlassen bleiben. Verbindliche Projektregeln, freigegebene Modelle und technisch begrenzte Zugriffsrechte verhindern, dass vertrauliche Inhalte versehentlich an einen externen Dienst übertragen werden.
| KI-Integeration | Beispiele | Anbindung | Geeignete Aufgaben |
| Cloud-API | OpenAI, Claude | API-Adresse und API-Schlüssel | umfangreiche Analysen, Agent Chat und große Projektkontexte |
| Benutzerkonto | GitHub Copilot | Anmeldung über das GitHub-Konto | Codevervollständigung und kurze Vorschläge im Editor |
| Kommandozeile | Claude Code, Gemini CLI | Anmeldung über die jeweilige Kommandozeilenanwendung | Agentenaufgaben über einen vorhandenen Anbieterzugang |
| Lokal | Ollama, LM Studio | Adresse des lokalen oder internen Servers | vertrauliche Projekte und Betrieb ohne externen Cloud-Dienst |
| Eigener Server | OpenAI-kompatible API, llama.cpp, TGI oder Hugging Face | Konfiguration von Serveradresse und gegebenenfalls Zugangsdaten | zentrale Modellbereitstellung innerhalb des Unternehmens |
Praxis: Von der Idee zum geprüften Build
Ein sinnvoller Arbeitsablauf beginnt mit einer klar abgegrenzten Aufgabe. Statt die KI allgemein mit der Entwicklung einer Anwendung zu beauftragen, sollten Ziel, technischer Rahmen und Prüfkriterien vorgegeben werden. Als Beispiel dient eine VCL-Anwendung, die Daten über eine externe Schnittstelle abruft und in einem Formular darstellt. Bereits die Aufgabenbeschreibung sollte festlegen, welche Komponenten verwendet werden, wie die Zuständigkeiten im Projekt verteilt sind und welche Fehlerfälle zu berücksichtigen sind. Kai analysiert daraufhin den vorhandenen Projektkontext und schlägt die erforderlichen Änderungen vor. Diese können den Quellcode, Formulare und weitere Projektdateien betreffen. Bevor die Änderungen übernommen werden, sollte der Entwickler ihren Umfang und ihre Einordnung in die bestehende Architektur prüfen. Auf diese Weise entsteht keine schwer überschaubare Gesamtänderung, sondern eine Folge kleiner, nachvollziehbarer Schritte.
Anschließend kann Kai das Projekt in der IDE kompilieren und die Meldungen des Compilers auswerten. Erkannte Fehler lassen sich den betroffenen Stellen zuordnen und gezielt korrigieren. Danach wird der Build erneut ausgeführt. Dieser Ablauf kann mehrere Runden umfassen, sollte jedoch durch klare Grenzen kontrolliert werden. Änderungen an öffentlichen Schnittstellen, Projektoptionen oder Abhängigkeiten sollten beispielsweise nur nach ausdrücklicher Freigabe erfolgen (Abb. 4).
Ein erfolgreicher Build belegt lediglich, dass sich das Projekt technisch übersetzen lässt. Ob die Anwendung fachlich korrekt arbeitet, lässt sich daraus nicht ableiten. Deshalb folgen Tests, die Prüfung der Änderungen und gegebenenfalls eine Überarbeitung des erzeugten Codes. Kai kann dabei helfen, Verantwortlichkeiten besser zu trennen, wiederholten Code zusammenzufassen, Bezeichner zu vereinheitlichen oder Testfälle vorzubereiten. Die Bewertung von Architektur, Sicherheit, Laufzeitverhalten und Wartbarkeit bleibt Aufgabe des Entwicklungsteams.
Dieses Vorgehen eignet sich nicht nur für neue Anwendungen. In Delphi-Projekten kann KI-gestützt Quellcode für Datenzugriffe, REST-Schnittstellen, Benutzeroberflächen oder Tests erstellt werden. Bei C++Builder kommen unter anderem die Einbindung vorhandener Bibliotheken und die Überarbeitung der Speicherverwaltung infrage.
Auch bei bestehenden Anwendungen kann die KI unterstützen. Der Agent kann Projektstrukturen erläutern, Abhängigkeiten untersuchen und Vorschläge für eine schrittweise Modernisierung erstellen. Statt große Teile einer Anwendung auf einmal umzubauen, sollten einzelne Verantwortlichkeiten nacheinander überarbeitet, kompiliert und getestet werden. Technische Besonderheiten wie Plattformabhängigkeiten, Schnittstellen zu Drittkomponenten oder abweichendes Laufzeitverhalten erfordern weiterhin eine manuelle Prüfung.
Über das Model Context Protocol lassen sich zusätzliche Werkzeuge einbinden, etwa für Versionsverwaltung, Dokumentation oder Aufgabenverwaltung. Damit erweitert sich allerdings auch der Handlungsspielraum des Agenten. Zugriffe sollten deshalb auf die tatsächlich benötigten Funktionen beschränkt, Änderungen protokolliert und weitreichende Aktionen ausdrücklich bestätigt werden. Inhalte aus Dokumentationen oder externen Dateien dürfen zudem nicht ungeprüft übernommen werden.
Fazit und Ausblick
Kai erweitert RAD Studio um Funktionen, die deutlich über eine klassische Codevervollständigung hinausgehen. Der Assistent kann Projektzusammenhänge berücksichtigen, Quellcode und Formulare bearbeiten, Builds ausführen und Compilerdiagnosen in die weitere Bearbeitung einbeziehen. Dadurch entsteht ein Arbeitsablauf, bei dem Entwicklungsschritte direkt innerhalb der IDE beschrieben, umgesetzt und überprüft werden können.
Der praktische Nutzen liegt vor allem in kurzen, kontrollierten Bearbeitungsfolgen. Entwickler wählen den relevanten Kontext aus, formulieren eine begrenzte Aufgabe und prüfen anschließend die vorgeschlagenen Änderungen. Kai kann diese Schritte beschleunigen, nimmt dem Team aber weder Architekturentscheidungen noch Code Reviews, Tests und Sicherheitsprüfungen ab. Auch ein erfolgreich kompilierter Quellcode kann fachliche Fehler, ungeeignete Abhängigkeiten oder schwer wartbare Strukturen enthalten.
Ein wesentlicher Vorteil ist die freie Wahl des Sprachmodells. Teams können Cloud-Dienste, lokale Modelle oder beide Varianten miteinander kombinieren. Damit lassen sich Leistungsfähigkeit, Kosten und Datenschutz an die Anforderungen eines Projekts anpassen. Zugleich entsteht zusätzlicher Aufwand für die Auswahl und Bewertung der Modelle, die Verwaltung von Zugängen sowie die Festlegung zulässiger Daten und Funktionen.
Für bestehende Delphi- und C++Builder-Projekte ist insbesondere die Unterstützung bei Analyse und Modernisierung interessant. Die KI kann Abhängigkeiten erläutern, umfangreiche Methoden untersuchen und schrittweise Änderungen vorbereiten. Gerade bei langlebigen Anwendungen sollte eine Modernisierung jedoch in kleinen Einheiten erfolgen. Nach jedem Schritt sind Build, Tests und eine fachliche Prüfung erforderlich.
Künftig dürfte sich der Schwerpunkt weiter von einzelnen Codevorschlägen hin zu zusammenhängenden Entwicklungsaufgaben verschieben. Die Anbindung zusätzlicher Werkzeuge über das Model Context Protocol kann diesen Ansatz erweitern, etwa durch den Zugriff auf Dokumentationen, Versionsverwaltung oder Aufgabenverwaltung. Voraussetzung dafür sind klar begrenzte Berechtigungen und nachvollziehbare Werkzeugaufrufe.
Damit verändert sich auch die Rolle des Entwicklers. Neben der eigentlichen Implementierung gewinnen die präzise Beschreibung von Aufgaben, die Auswahl des richtigen Projektkontexts und die Bewertung erzeugter Änderungen an Bedeutung. Die KI kann den Weg von einer Anforderung zu einem geprüften Build verkürzen. Die Verantwortung für Qualität, Sicherheit und Wartbarkeit bleibt jedoch beim Entwicklungsteam.
- Embarcadero. (o. J.). Kai für RAD Studio: Agentische KI für Delphi und C++Builder. www.embarcadero.com/de/products/rad-studio/kai
- Embarcadero. (2026, 12. Juni). Kai features. RAD Studio DocWiki. docwiki.embarcadero.com/RADStudio/Florence/en/Kai_Features
- GitHub. (o. J.). Integrating agentic AI into your enterprise's software development lifecycle. GitHub Docs. docs.github.com/de/copilot/tutorials/roll-out-at-scale/enable-developers/integrate-ai-agents
