Aktivierung und Konfiguration von JetBrains AI Assistant in unterstützten IDEs

JetBrains AI Assistant integriert generative KI-Coding-Funktionen, autonome mehrstufige Agenten und tiefgehende semantische Code-Intelligenz direkt in die Entwicklungsumgebungen von JetBrains, darunter IntelliJ IDEA, PyCharm, WebStorm, GoLand, CLion, Rider, PhpStorm, RubyMine, RustRover, DataGrip und DataSpell. Anstatt als isolierte Chat-Oberfläche oder generischer Textprädiktor zu agieren, verbindet sich der Assistent mit dem internen Projektindex der IDE, den abstrakten Syntaxbäumen (AST) und den Versionskontrollsystemen, um kontextsensitive Codegenerierung, mehrzeilige automatische Vervollständigungen, Vorschläge für nächste Bearbeitungsschritte (Next Edit Suggestions), automatisierte Testerstellung und strukturelles Refactoring bereitzustellen. Eine erfolgreiche Bereitstellung und Konfiguration von JetBrains AI Assistant erfordert von Softwareentwicklern und technischen Führungskräften die Überprüfung der IDE-Versionsvoraussetzungen, die Durchführung der Installation und Lizenzaktivierung für Einzel- oder Enterprise-Tarife, die Feinabstimmung der Vervollständigungsparameter im Editor, die Festlegung von Projektregeln auf Repository-Ebene sowie die Konfiguration von Sicherheitsgrenzen für Modellanbieter und externe Tools des Model Context Protocol (MCP).

IDE-Kompatibilität und Versionsvoraussetzungen

Bevor JetBrains AI Assistant aktiviert wird, müssen Entwickler sicherstellen, dass ihre lokale Umgebung bestimmte Laufzeit-, Plattform- und Organisationskriterien erfüllt.

Unterstützte Umgebungen und IDE-Basisversionen

JetBrains AI Assistant wird als Plugin bereitgestellt, das für die gesamte JetBrains-Produktpalette verfügbar ist. Unterstützte IDEs erfordern spezifische Mindestversionen:

• Kommerzielle JetBrains-IDEs: Kompatibel ab Version 2023.3 für alle kommerziellen IDEs, einschließlich IntelliJ IDEA Ultimate, PyCharm Professional, WebStorm, CLion, GoLand, Rider, PhpStorm, RubyMine, RustRover, DataGrip und DataSpell.
• Community Edition IDEs: Erfordert Version 2024.1.1 oder neuer für quelloffene Community-Editionen (wie IntelliJ IDEA Community Edition oder PyCharm Community Edition). Um ein organisationsweites JetBrains AI-Abonnement in Community-Editionen zu verknüpfen, müssen Teams Version 2024.2.1 oder neuer einsetzen.
• Plattformübergreifende Unterstützung: Unterstützt auf 64-Bit-Workstations unter Windows, macOS (Intel und Apple Silicon) sowie Linux, sofern diese die Standard-Systemanforderungen der jeweiligen Host-IDE erfüllen.

Rechentopologien: Cloud-LLMs vs. lokale Hardware

Standardmäßig führt JetBrains AI Assistant Inferenzen über cloudgehostete Large Language Models aus, die vom JetBrains AI-Dienst oder Drittanbieter-API-Dienstleistern verwaltet werden. In dieser Konfiguration entsteht auf den Entwickler-Workstations kaum eine zusätzliche Belastung für CPU, GPU oder Akku.

Teams, die selbst gehostete Open-Weight-Modelle (wie Ollama oder private OpenAI-kompatible Inferenz-Endpunkte) nutzen, müssen der Workstation jedoch dedizierte Rechenkapazitäten zuweisen, einschließlich ausreichend dediziertem VRAM (üblicherweise 8 GB bis 24 GB, abhängig von der Parameter-Quantisierung), um Token-Streaming in Echtzeit zu gewährleisten.

Organisatorische Voraussetzungen

Für Entwickler, die von einem Arbeitgeber oder einer Bildungseinrichtung bereitgestellte IDE-Lizenzen verwenden, wird der Zugriff auf KI-Funktionen auf Organisationsebene verwaltet:

1. Ein Organisationsadministrator muss den JetBrains AI-Dienst in der Administrationskonsole des geschäftlichen JetBrains Account aktivieren.
2. Wenn die Organisation strenge IP-Governance- oder Sicherheitsrichtlinien durchsetzt, können Administratoren gemeinsame Guthaben-Pools zuweisen oder freigegebene Drittanbieter festlegen, bevor Entwickler die Aktivierung vornehmen können.

Installation und Aktivierung von JetBrains AI Assistant

Das JetBrains AI Assistant-Plugin ist bei Einzelinstallationen standardmäßig nicht aktiviert und greift erst dann auf proprietären Quellcode zu, wenn es explizit installiert und aktiviert wurde.

Installationsmethoden

Entwickler können das Plugin über drei primäre Einstiegspunkte in unterstützten IDEs installieren:

1. JetBrains Marketplace (Einstellungen):
   • Öffnen Sie Settings (unter Windows/Linux) oder Preferences (unter macOS) über Strg+Alt+S bzw. Cmd+,.
   • Wählen Sie Plugins in der linken Seitenleiste und öffnen Sie den Reiter Marketplace.
   • Suchen Sie im Suchfeld nach AI Assistant.
   • Klicken Sie beim offiziellen JetBrains-Plugin-Eintrag auf Install und starten Sie die IDE neu, falls Sie dazu aufgefordert werden.
2. Tool-Fenster „AI Chat“:
   • Klicken Sie auf das Symbol AI Chat in der rechten Tool-Fensterleiste.
   • Klicken Sie im leeren Tool-Fenster auf die Schaltfläche Install Plugin, um die Hintergrundinstallation zu starten.
3. JetBrains AI-Widget in der Fensterleiste:
   • Suchen Sie in der Kopfzeile der modernen IDE-Benutzeroberfläche das Status-Widget JetBrains AI.
   • Klicken Sie auf Let's Go, um das Plugin automatisch herunterzuladen und zu initialisieren.

Lizenzierungsstufen und Aktivierungsszenarien

Nach der Installation müssen Entwickler das Plugin mit einem passenden Lizenzmodell aktivieren. JetBrains unterstützt mehrere Authentifizierungswege im Rahmen verschiedener Aktivierungsszenarien:

Übersicht der Lizenzierungsstufen

• AI Free: Bietet Basiszugriff auf leichtgewichtige Cloud-Modelle mit einem begrenzten monatlichen AI-Guthaben; wird Inhabern abgelaufener Abonnements oder Nutzern der kostenlosen Stufe automatisch zugewiesen.
• AI Pro: Das reguläre Einzelabonnement mit großzügigem Monatskontingent, prioritärem Modell-Routing und Unterstützung modernster LLMs (einschließlich GPT-4o, Claude 3.5 Sonnet und Gemini 1.5 Pro). Inhaber des JetBrains All Products Pack oder von dotUltimate erhalten häufig AI Pro-Berechtigungen.
• Pro Trial: Eine 30-tägige Evaluierungslizenz mit vollem Funktionsumfang, die neuen JetBrains Accounts bei der ersten Aktivierung automatisch gutgeschrieben wird.
• AI Business / Enterprise: Skaliert für Teams mit zentraler Abrechnung, Benutzerzuweisungssteuerung, geteilten Guthaben-Pools und Optionen für hybride On-Premises-Bereitstellungen über JetBrains AI Enterprise.

Rechtliche Zustimmung und Annahme der Nutzungsbedingungen

Während der ersten Aktivierung müssen Entwickler die Nutzungsbedingungen für JetBrains AI und die Richtlinie für die zulässige Nutzung (Acceptable Use Policy) prüfen und akzeptieren. Diese Bestimmungen legen verbindlich fest, dass zur Inferenz übertragener Quellcode flüchtig verarbeitet und keinesfalls zum Trainieren öffentlicher Basis-Foundation-Modelle gespeichert wird.

Zentrale IDE-Konfiguration und Verhaltenseinstellungen

Die globalen Konfigurationsoptionen für das Plugin befinden sich gebündelt unter Settings | Tools | AI Assistant (bzw. Preferences | Tools | AI Assistant unter macOS). Ein Blick in die Einstellungsreferenz ermöglicht es Entwicklern, das Werkzeug an ihre persönlichen Programmiergewohnheiten anzupassen.

Settings / Preferences
  ├── Tools
  │     └── AI Assistant
  │           ├── General Features (Name suggestions, pasted code, PR summaries)
  │           ├── Providers & API keys (BYOK, OAuth, Model selection)
  │           ├── Rules (Project-specific instructions)
  │           ├── Prompt Library (Custom prompt templates)
  │           ├── Skills (Debugger and runtime tools)
  │           └── Agents (ACP agent registries)
  └── Editor
        └── General
              └── Code Completion
                    └── Inline (Cloud completion, Next Edit Suggestions)

Automatisierungsfunktionen aktivieren und deaktivieren

Entwickler können spezifische Verhaltenshilfen gezielt steuern, um störende Vorschläge zu vermeiden:

• Provide AI-generated name suggestions: Schlägt bei Symbol-Refactorings direkt im Code (Shift+F6) kontextbezogene Bezeichner für Variablen, Funktionen und Klassen vor.
• Suggest converting pasted code to target file language: Erkennt automatisch, wenn fremder Code (wie ein in eine Java-Datei eingefügtes Python-Snippet) in den Editor eingefügt wird, und bietet an, die Syntax in die Zielsprache der Datei zu konvertieren.
• Generate a title for the shelved changelist: Erstellt auf Basis einer Diff-Analyse automatisch prägnante, aussagekräftige Titel für zurückgestellte Git-Änderungslisten (Shelved Changesets).
• GitHub Plugin: Generate PR summaries: Prüft Commits und geänderte Dateien, um beim Erstellen oder Prüfen von Pull Requests über das integrierte GitHub-Tool-Fenster strukturierte PR-Beschreibungen zu formulieren.

Anpassung der natürlichen Sprache

Standardmäßig antwortet AI Assistant im Systemgebietsschema oder auf Englisch. Teams in mehrsprachigen Umgebungen können unter Settings | Tools | AI Assistant | Natural Language eine bevorzugte Sprache festlegen, um sicherzustellen, dass Erklärungen, Docstrings und Commit-Nachrichten in der erforderlichen Arbeitssprache verfasst werden.

Schwellenwert für das Kürzen von Nachrichten (Message Trimming Threshold)

Bei umfangreichen Codebasen kann das Anhängen mehrerer Quelldateien selbst große Kontextfenster schnell ausschöpfen. Unter Settings | Tools | AI Assistant können Entwickler den Message Trimming Threshold (angegeben als Prozentsatz des gesamten Kontextfensters des Modells) konfigurieren. Übersteigt eine Nutzlast diesen Schwellenwert, kürzt AI Assistant automatisch unwesentliche äußere Strukturen, behält jedoch relevante Funktionssignaturen und Aufrufstellen bei, wodurch Token-Überlauf-Fehler vermieden werden.

Konfiguration der Code-Vervollständigung im Editor und von Next Edit Suggestions

JetBrains-IDEs verwenden eine Dual-Engine-Architektur für die Code-Vervollständigung: lokale On-Device-Vervollständigung und remote Cloud-Vervollständigung.

Lokale Full Line- vs. Cloud-basierte mehrzeilige Vervollständigung

Das Verständnis der Unterschiede zwischen den Mechanismen ist entscheidend für eine optimale Konfiguration:

1. Full Line Code Completion: Läuft vollständig lokal auf der Workstation des Entwicklers und verwendet kompakte, sprachspezifische neuronale Netzmodelle, die direkt mit der IDE ausgeliefert werden. Sie funktioniert komplett offline ohne Netzwerklatenz, verbraucht kein AI-Guthaben und überträgt keinen Code nach außen.
2. Cloud Code Completion: Wird von den Cloud-LLMs des AI Assistant angetrieben. Sie generiert mehrzeilige Codestrukturen, vollständige Methodenrümpfe, algorithmische Logik und begleitende Dokumentationskommentare auf Grundlage des erweiterten Dateikontexts.

Konfiguration der Inline-Vervollständigungsparameter

Um die Inline-Vervollständigung anzupassen, navigieren Sie zu Settings | Editor | General | Code Completion | Inline:

• Enable Cloud-Based Multi-Line Completions: Aktivieren Sie diese Option, damit AI Assistant während der Eingabe ausgegrauten Ghost-Text über eine oder mehrere Zeilen hinweg einblenden darf.
• Next Edit Suggestions (NES): Nach der Aktivierung analysiert AI Assistant aktuelle Änderungen und prognostiziert nachfolgende Bearbeitungsschritte. So werden Folgeanpassungen vorgeschlagen und Entwickler können direkt zu den betroffenen Stellen springen (z. B. Aktualisierung einer Schnittstellenimplementierung nach Änderung einer Methodensignatur).
• Trigger Delay (Debounce): Legt die erforderliche Tipp-Pause fest, bevor eine Cloud-Vervollständigungsanfrage ausgelöst wird. Entwickler mit Verbindungen mit hoher Latenz oder getakteten mobilen Internetverbindungen können diesen Wert erhöhen, um unnötige API-Roundtrips zu minimieren.

Tastaturkürzel und Annahme-Bedienelemente

Inline-Ghost-Vorschläge können mit standardmäßigen Tastenkombinationen angenommen oder verworfen werden:

• Vollständigen Vorschlag annehmen: Drücken Sie Tab.
• Nächstes Wort annehmen: Drücken Sie Strg+Pfeil nach rechts (Windows/Linux) oder Option+Pfeil nach rechts (macOS), um den Vorschlag Token für Token schrittweise zu übernehmen.
• Nächste Zeile annehmen: Drücken Sie Strg+Pfeil nach unten oder das zugewiesene benutzerdefinierte Tastenkürzel, um Zeile für Zeile vorzugehen.
• Vorschlag verwerfen: Drücken Sie Esc oder tippen Sie nicht passende Zeichen weiter.
• Manuell auslösen: Wenn automatische Inline-Vorschläge deaktiviert sind, können Sie die Vervollständigung bei Bedarf über Alt+\ (Windows/Linux) bzw. Option+\ (macOS) manuell anfordern.

AI Chat, Kontextverwaltung und Projektregeln

Das Tool-Fenster AI Chat fungiert als interaktive Pair-Programming-Umgebung, die datei-, stacktrace- und projekthistorienübergreifende Schlussfolgerungen ziehen kann.

Kontextreferenzierung mit Mentions

Anstatt Quellcodefragmente manuell in die Eingabezeile zu kopieren, sollten Entwickler gezielten Kontext über @-Referenzen übergeben:

• @file:pfad/zur/Datei.java: Bettet den Inhalt einer bestimmten Projektdatei in den Prompt ein.
• @symbol:KlassenName#methodenName: Übergibt Deklaration, Docstrings und Implementierung einer bestimmten Klasse, Schnittstelle oder Funktion.
• @folder:src/main/services: Übergibt Verzeichnisstrukturen und Modulschnittstellen.
• @commit:hash: Liefert Git-Commit-Diffs und Metadaten für Code-Reviews und Regressionsanalysen.

Offizielle Dokumentation durchsuchen mit /docs

Entwickler, die Unterstützung zur IDE suchen, können offizielle JetBrains-Dokumentationen direkt über den Befehl /docs im Chat-Prompt abfragen. Die Eingabe von beispielsweise:

/docs how do I configure remote Docker debugging for GoLand?

löst eine RAG-Abfrage (Retrieval-Augmented Generation) auf der offiziellen JetBrains-Produktdokumentation aus und liefert verbindliche Anleitungen mit anklickbaren Deeplinks direkt in die Einstellungsdialoge der IDE.

Benutzerdefinierte Prompt-Bibliothek (Prompt Library)

Teams verwenden häufig wiederkehrende Architekturmuster, wie etwa das Erstellen von Repository-Klassen, das Mocken von HTTP-Clients oder das Migrieren von Legacy-Frameworks. Entwickler können solche Prompts unter Settings | Tools | AI Assistant | Prompt Library standardisieren:

1. Klicken Sie auf Hinzufügen (+), um eine neue benutzerdefinierte Prompt-Vorlage anzulegen.
2. Vergeben Sie einen aussagekräftigen Titel (z. B. Generate Spring Data JPA Repository).
3. Tragen Sie den Vorlagentext ein und verwenden Sie dynamische Platzhalter wie $SELECTION für den markierten Code.
4. Weisen Sie den Prompt dem Kontextmenü des Editors zu, um ihn mit einem Klick aufrufen zu können.

Durchsetzung von Standards über Projektregeln (ai-rules.md)

Um zu verhindern, dass AI Assistant Code generiert, der gegen Konventionen des Repositories verstößt, können Teams unter Settings | Tools | AI Assistant | Rules persistente Projektregeln anlegen oder eine Markdown-Datei im Repository-Stammverzeichnis unter .jetbrains/ai-rules.md einchecken.

Eine wirksame Regeldatei instruiert den Assistenten bezüglich Architekturgrenzen, Stilrichtlinien und Testmustern:

# Project Architectural Guidelines

## Technology Stack
- Java 21 LTS with Spring Boot 3.3
- Build Tool: Gradle with Kotlin DSL
- Testing: JUnit 5, AssertJ, and Testcontainers (avoid Mockito for integration tests)

## Code Conventions
- Prefer immutable records for Data Transfer Objects (DTOs).
- Enforce explicit constructor injection; do not use field-level `@Autowired`.
- All public REST controllers must return `ResponseEntity<T>` with OpenAPI 3 annotations.
- Handle database operations asynchronously via R2DBC where reactive pipelines are present.

## Security Constraints
- Never log raw authorization tokens, customer personally identifiable information (PII), or passwords.
- Enforce parameter binding on all SQL and JPQL queries to prevent injection vulnerabilities.

AI Assistant liest .jetbrains/ai-rules.md automatisch aus und hängt die darin definierten Vorgaben an alle innerhalb des Repositories abgesetzten Prompts an, sodass die erzeugten Vorschläge stets den Teamstandards entsprechen.

Coding-Agenten, ACP und Model Context Protocol (MCP)

Neuere Versionen von JetBrains AI Assistant gehen über passive Codevorschläge hinaus und unterstützen aktive, autonome Agenten-Workflows.

Autonome Coding-Agenten

Unter Settings | Tools | AI Assistant | Agents können Entwickler spezialisierte Programmier-Agenten einrichten:

• Junie: Der proprietäre Agent von JetBrains für dateiübergreifendes Refactoring, autonome Fehlerbehebung und Testerstellung. Junie erarbeitet einen schrittweisen Ausführungsplan, ändert Dateien, führt lokale Terminalbefehle oder Testrunner aus und präsentiert konsolidierte Diffs zur Prüfung durch den Entwickler.
• Claude Agent und OpenAI Codex: Integrationen, die Anbieterkonten oder API-Schlüssel nutzen, um durchgehende Programmieraufgaben eigenständig auszuführen.
• Agent Client Protocol (ACP): Ein standardisiertes Protokoll, mit dem Entwickler maßgeschneiderte oder proprietäre Drittanbieter-Agenten direkt in die IDE einbinden können, ohne eigene IDE-Plugins schreiben zu müssen.

Integration von Model Context Protocol (MCP)-Tools

Über MCP-Tools kann AI Assistant mit externen Umgebungen, Datenbanken, Container-Engines und unternehmensweiten Issue-Trackern interagieren.

Aus Sicherheitsgründen müssen Entwickler Datenbankberechtigungen unter Settings | Tools | AI Assistant explizit festlegen:

• Read database schemas: Erlaubt MCP-Agenten das Einsehen von Tabellen, Spaltentypen und Indizes, um präzise SQL-Abfragen zu formulieren.
• Modify database schemas: Steuert, ob Agenten DDL-Migrationsanweisungen (CREATE, ALTER, DROP) erstellen und ausführen dürfen.
• Read database data: Ermöglicht Agenten das Ausführen von Abfragen und Prüfen von Ergebnissen zur Fehlersuche in Datenbeständen.
• Modify database data: Erfordert eine explizite Bestätigung, bevor ein Agent Datenänderungsbefehle wie INSERT, UPDATE oder DELETE absenden darf.

Drittanbieter und benutzerdefinierte Modelle (BYOK)

Organisationen, die ihre KI-Ausgaben zentralisieren oder interne Modell-Gateways nutzen möchten, können AI Assistant über die Konfiguration Bring Your Own Key von den durch JetBrains verwalteten Cloud-Abonnements entkoppeln.

Konfiguration von Drittanbietern

Navigieren Sie zu Settings | Tools | AI Assistant | Providers & API keys:

1. Klicken Sie auf Add Provider und wählen Sie aus den unterstützten kommerziellen Anbietern:
   • OpenAI: Erfordert einen OpenAI-Plattform-API-Schlüssel mit Zugriff auf Modelle wie gpt-4o oder o1.
   • Anthropic: Erfordert einen Anthropic-API-Schlüssel mit Unterstützung für claude-3-5-sonnet oder claude-3-opus.
   • Google Cloud Vertex AI: Authentifiziert sich über Application Default Credentials (ADC) oder Service-Account-Schlüssel.
2. Hinterlegen Sie die Anmeldedaten und testen Sie die Verbindungslatenz.
3. Weisen Sie Modelle funktionalen Rollen zu (z. B. schnelle Modelle für Inline-Vervollständigungen vs. leistungsstärkere Reasoning-Modelle für AI Chat und Refactoring).

Anbindung lokaler und benutzerdefinierter Endpunkte

Für Air-Gapped-Umgebungen oder private Rechenzentren können Entwickler auf benutzerdefinierten Modellen aufsetzen:

+-------------------------------------------------------------+
|                      Local Workstation                      |
|                                                             |
|  +------------------------+      +-----------------------+  |
|  |     JetBrains IDE      |      |     Ollama Server     |  |
|  |  (AI Assistant Plugin) | ---> | (http://localhost:    |  |
|  |                        | <--- |  11434/v1)            |  |
|  +------------------------+      +-----------------------+  |
+-------------------------------------------------------------+

1. Starten Sie einen lokalen Inferenzserver, der eine OpenAI-kompatible API bereitstellt (wie Ollama, vLLM oder LM Studio).
2. Fügen Sie unter Providers & API keys einen Anbieter vom Typ Custom OpenAI-Compatible hinzu.
3. Konfigurieren Sie die Basis-URL (z. B. http://localhost:11434/v1 für Ollama) und geben Sie den geladenen Modellbezeichner an (etwa qwen2.5-coder:32b oder deepseek-coder-v2).
4. Verifizieren Sie, dass lokale Vervollständigungen zuverlässig ohne externen WAN-Datenverkehr in den Editor gestreamt werden.

Data Governance, Datenschutz und Enterprise-Kontrollen

Der Einsatz von KI-gestützten Programmierassistenten im geschäftlichen Umfeld erfordert transparente Datenschutzmaßnahmen und Überprüfbarkeit.

Datenübertragung und Grenzen des Modelltrainings

JetBrains definiert in seiner Dokumentation und im Trust Center klare Richtlinien zur Datenverarbeitung:

• Kein Training von Basis-Modellen: Quellcode von Kunden, Kontextdaten und generierte Vervollständigungen werden von JetBrains oder dessen Modellpartnern niemals gespeichert oder zum Trainieren von Basis-Foundation-Modellen verwendet.
• Flüchtige Verarbeitung (Ephemeral Processing): Prompts, die über den JetBrains AI-Dienst geroutet werden, werden ausschließlich zur Ausführung der Inferenz und zur Einhaltung von Protokollierungsvorschriften im Arbeitsspeicher gehalten und anschließend verworfen.
• Opt-in bei Datenfreigabe: Die Einstellung Send detailed code-related data ist standardmäßig deaktiviert. Wird sie manuell aktiviert, werden Telemetriedaten anonymisiert und ausschließlich zur Bewertung der Funktionsleistung der JetBrains-IDE herangezogen.

Unternehmens-Firewalls, Proxys und SSL-Inspektion

Entwickler-Workstations innerhalb von Unternehmensnetzwerken müssen ausgehende sichere Verbindungen zulassen:

• Gateway-Endpunkte: Fügen Sie ausgehende HTTPS- (Port 443) und WebSocket-Verbindungen (WSS) zu *.jetbrains.com sowie zu den Endpunkten der autorisierten Drittanbieter der Zulassungsliste hinzu.
• Enterprise-SSL-Inspektion: Fangen Sicherheitsgateways im Unternehmen TLS-Verbindungen über interne Zertifizierungsstellen (CA) ab, müssen Entwickler das CA-Zertifikat des Unternehmens in den Speicher für vertrauenswürdige Zertifikate der IDE (Settings | Tools | Server Certificates) importieren, um TLS-Handshake-Fehler zu vermeiden.

Quotenüberwachung und Deaktivierungsoptionen

Das Status-Widget JetBrains AI in der Fensterkopfzeile bietet Echtzeittransparenz über die Nutzungsdaten:

• Abonnement-Kontingent: Überwacht verbleibende monatliche AI-Credits und zeigt das monatliche Erneuerungsdatum an.
• Top-Up-Credits: Ermöglicht einzelnen Entwicklern oder Teams den Erwerb zusätzlicher Credit-Pakete, wenn anspruchsvolle Agentenaufgaben das Basiskontingent aufbrauchen.
• Gemeinsame Pool-Verwaltung: Zeigt den dynamischen Guthabenverbrauch an, wenn eine Anbindung an einen zentralen Unternehmens-Lizenzserver besteht.

Müssen Entwickler den AI Assistant vorübergehend deaktivieren, bestehen Optionen, die Funktionen über das Widget-Menü für ein einzelnes Projekt auszuschalten, nur die Cloud-Vervollständigung zu deaktivieren und die lokale Full Line-Unterstützung beizubehalten oder das Plugin installationsweit vollständig zu deinstallieren.