# Qwen Code verwenden: Schritt-für-Schritt-Anleitung

URL: https://agentvera.dev/de/blog/how-to-use-qwen-code/ · Veröffentlicht: 2026-10-29

Qwen Code verwenden: die qwen-CLI installieren, per /auth oder API-Key anmelden, ein Modell wählen und QWEN.md, MCP-Server und den Headless-Modus einrichten.

**Kurz gesagt:**

- Installiere Qwen Code mit dem offiziellen Skript, npm (Node.js 22+) oder Homebrew, starte qwen in einem Projekt und wähle mit /auth einen Anbieter. Der kostenlose Qwen-OAuth-Zugang endete am 15. April 2026.
- Jeder OpenAI-kompatible Key funktioniert: Setze OPENAI_API_KEY, OPENAI_BASE_URL und OPENAI_MODEL oder lege Anbieter in ~/.qwen/settings.json an. Lokale Modelle über Ollama laufen genauso.
- Projektregeln gehören in QWEN.md (AGENTS.md wird mitgelesen), MCP-Server fügst du mit qwen mcp add hinzu, und qwen -p erledigt eine einzelne Aufgabe ohne Oberfläche für Skripte und CI.

Um Qwen Code zu verwenden, installierst du die `qwen`-CLI mit dem offiziellen Skript, npm oder Homebrew, startest `qwen` in einem Projektordner, wählst mit `/auth` einen Modellanbieter und beschreibst, was du willst. Qwen Code liest deinen Code, bearbeitet Dateien und führt Befehle aus; wann es um Erlaubnis fragt, bestimmt der Freigabemodus, den du wählst. Seit der kostenlose Qwen-OAuth-Zugang am 15. April 2026 endete, brauchst du einen API-Key oder Tarif bei einem Anbieter oder ein lokales Modell.

Das ist der Grundablauf. Diese Anleitung deckt den Rest ab: die Anmeldeoptionen und was den kostenlosen Zugang ersetzt hat, OpenAI-kompatible Keys und lokale Modelle, die Modellwahl, Freigabemodi, `QWEN.md`, MCP-Server, den Headless-Modus für Skripte und Qwen Code neben anderen Agenten. Alles hier folgt dem offiziellen Repository und der Dokumentation von Qwen Code, Stand Oktober 2026.

## Was Qwen Code ist

Qwen Code ist ein Coding-Agent für das Terminal vom Qwen-Team bei Alibaba, veröffentlicht unter der Apache-2.0-Lizenz. Er ist aus Gemini CLI hervorgegangen; wenn du Googles Agenten kennst, wirkt der Aufbau vertraut, inzwischen wird er aber schon lange eigenständig entwickelt. Er ist auf Qwens eigene Coding-Modelle abgestimmt, aber nicht an sie gebunden: Er spricht die API-Formate von OpenAI, Anthropic und Gemini und arbeitet mit lokalen Modellen.

Neben dem Terminal bietet das Projekt eine Desktop-App, Integrationen für VS Code, Zed und JetBrains sowie SDKs für TypeScript, Python und Java. Diese Anleitung bleibt bei der CLI.

## Schritt 1: Qwen Code installieren

| Plattform | Befehl |
| --- | --- |
| macOS, Linux | `curl -fsSL https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/installation/install-qwen-standalone.sh \| bash` |
| Windows (PowerShell) | `irm https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/installation/install-qwen-standalone.ps1 \| iex` |
| Jede Plattform mit Node.js 22+ | `npm install -g @qwen-code/qwen-code@latest` |
| macOS, Linux (Homebrew) | `brew install qwen-code` |

Starte nach der Installation per Skript dein Terminal neu, damit der Befehl `qwen` im PATH liegt. Das npm-Paket braucht Node.js 22 oder neuer. Zum Aktualisieren führst du denselben npm- oder Homebrew-Befehl erneut aus.

## Schritt 2: mit /auth anmelden

Wechsle in ein Projekt und starte Qwen Code:

```bash
cd my-project
qwen
```

Beim ersten Start, und später jederzeit mit `/auth`, zeigt Qwen Code vier Wege, ein Modell anzubinden:

| Option | Was es ist |
| --- | --- |
| QwenCloud | Alibabas Qwen-API: ein Token-Plan-Abo mit monatlichem Credit-Kontingent oder ein normaler Key mit nutzungsbasierter Abrechnung. Schaltet außerdem das eingebaute Websuche-Tool von Qwen Code frei. |
| Alibaba ModelStudio | Alibaba Cloud Model Studio: der Coding Plan für einzelne Entwickler (feste Monatsgebühr mit Wochenkontingent), ein Token Plan für Teams oder ein normaler API-Key |
| Third-party Providers | Fertige Einträge für DeepSeek, Grok, MiniMax, Z.AI, Kimi, ModelScope, OpenRouter, Requesty und weitere |
| Custom Provider | Jeder OpenAI-, Anthropic- oder Gemini-kompatible Endpunkt: ein Proxy, ein Gateway oder ein lokaler Server |

Mit `/doctor` siehst du in einer Sitzung, welche Authentifizierung aktiv ist. Der alte Shell-Befehl `qwen auth` wurde entfernt; Anbieter wechselst du also über `/auth`.

### Was aus dem kostenlosen Qwen-OAuth-Zugang wurde

Lange war der einfachste Einstieg die Anmeldung mit einem qwen.ai-Konto über Qwen OAuth samt kostenlosem Tageskontingent. Die Dokumentation sagt jetzt, dass **der kostenlose Qwen-OAuth-Zugang am 15. April 2026 eingestellt wurde**. Er taucht in `/auth` nicht mehr auf, und neue Anfragen darüber werden abgelehnt, selbst wenn noch ein altes Token im Cache liegt. Wenn du einem älteren Tutorial gefolgt bist und der Agent plötzlich nicht mehr antwortet, liegt es daran. Wähle stattdessen eine der Optionen oben. Was 2026 noch nichts kostet, steht in unserer Übersicht [Die besten kostenlosen KI-Coding-Tools](/de/blog/best-free-ai-coding-tools/ "Die besten kostenlosen KI-Coding-Tools").

### Einen beliebigen OpenAI-kompatiblen API-Key nutzen

Am schnellsten richtest du Skripte und Server mit drei Umgebungsvariablen ein:

```bash
export OPENAI_API_KEY="sk-..."
export OPENAI_BASE_URL="https://openrouter.ai/api/v1"
export OPENAI_MODEL="your-model-id"
qwen
```

Das sind die Variablen des OpenAI-kompatiblen Protokolls, das die meisten Anbieter abdeckt. Die Formate von Anthropic und Gemini haben eigene (`ANTHROPIC_API_KEY`, `ANTHROPIC_BASE_URL`, `ANTHROPIC_MODEL` sowie `GEMINI_API_KEY`, `GEMINI_MODEL`).

Statt die Keys in jeder Shell zu exportieren, kannst du sie in einer `.env`-Datei ablegen. Qwen Code sucht im Projekt und in dessen Elternordnern nach `.qwen/.env` und `.env`, danach nach `~/.qwen/.env` und `~/.env`, und lädt nur die erste gefundene Datei. Kommandozeilen-Flags schlagen Shell-Variablen, Shell-Variablen schlagen `.env`, und `.env` schlägt den `env`-Block in `settings.json`.

Für eine dauerhafte Einrichtung legst du den Anbieter in `~/.qwen/settings.json` an. `envKey` nennt die Variable, in der der Key steht:

```json
{
  "modelProviders": {
    "openai": [
      {
        "id": "qwen3-coder-plus",
        "name": "qwen3-coder-plus",
        "baseUrl": "https://dashscope.aliyuncs.com/compatible-mode/v1",
        "description": "Qwen3-Coder via Dashscope",
        "envKey": "DASHSCOPE_API_KEY"
      }
    ]
  },
  "security": { "auth": { "selectedType": "openai" } },
  "model": { "name": "qwen3-coder-plus" }
}
```

Die Datei nimmt auch einen `env`-Block mit dem Key selbst an, speichert ihn dann aber im Klartext. Die Dokumentation empfiehlt für Projekt-Secrets `.qwen/.env`, die nicht in Git landet.

### Lokale Modelle mit Ollama

Ollama, vLLM und LM Studio bieten eine OpenAI-kompatible API, ein lokales Modell ist also einfach ein weiterer `openai`-Anbieter mit lokaler `baseUrl`. Ollama braucht keinen echten Key, ein Platzhalter genügt:

```json
{
  "env": { "OLLAMA_API_KEY": "ollama" },
  "modelProviders": {
    "openai": [
      {
        "id": "qwen2.5-7b",
        "name": "Qwen2.5 7B (Ollama)",
        "envKey": "OLLAMA_API_KEY",
        "baseUrl": "http://localhost:11434/v1",
        "generationConfig": { "contextWindowSize": 32768 }
      }
    ]
  }
}
```

Die `id` muss dem Modellnamen in Ollama entsprechen. Ein kleines lokales Modell tut sich mit langen Agent-Sitzungen schwer; welche Modelle und wie viel Speicher es brauchbar machen, erklärt unser Artikel [Lokaler LLM-Coding-Agent](/de/blog/local-llm-coding-agent/ "Lokaler LLM-Coding-Agent").

## Schritt 3: ein Modell wählen

In einer Sitzung öffnet `/model` eine Auswahl mit den Modellen deiner Anbieter, `/model <model-id>` wechselt direkt. In der Shell setzt `qwen --model qwen3-coder-plus` (oder `-m`) das Modell für einen Lauf. Bei Thinking-Modellen stellt `/effort` die Denktiefe ein, sofern der Anbieter das unterstützt.

Welche Modelle du bekommst, hängt vom Anbieter ab. Stand Oktober 2026 listet der Alibaba Coding Plan Qwen-Modelle wie `qwen3-coder-plus`, `qwen3-coder-next` und `qwen3.7-plus` sowie Modelle von Drittanbietern wie GLM, Kimi und MiniMax. Ein Key mit nutzungsbasierter Abrechnung gibt dir, was die API des jeweiligen Anbieters bereitstellt.

## Schritt 4: die Grundlagen einer Sitzung

Der Bildschirm von Qwen Code ist ein Chat mit deinem Projekt. Ein paar Dinge brauchst du ständig:

- **`@pfad`** hängt eine Datei an deine Nachricht, `@ordner/` liest die Textdateien eines Ordners.
- **`!befehl`** führt einen Shell-Befehl aus, etwa `!git status`. Ein einzelnes `!` schaltet in den Shell-Modus, bis du wieder `!` tippst.
- **Shift+Tab** (unter Windows Tab) wechselt durch die Freigabemodi.

| Befehl | Was er tut |
| --- | --- |
| `/auth` | Anbieter wählen oder wechseln |
| `/model` | Modell wechseln |
| `/init` | Eine erste `QWEN.md` für das Projekt anlegen |
| `/memory` | Den Memory-Manager öffnen |
| `/mcp` | MCP-Server und ihre Tools auflisten |
| `/approval-mode` | Den Freigabemodus dieser Sitzung ändern |
| `/compress` | Den Verlauf durch eine Zusammenfassung ersetzen, um Kontext freizumachen |
| `/clear` | Die Unterhaltung leeren |
| `/resume` | Eine frühere Sitzung wieder öffnen |
| `/restore` | Dateien auf den Checkpoint vor einem Tool-Aufruf zurücksetzen |
| `/stats` | Token-Verbrauch und geschätzte Kosten |
| `/doctor` | Installation und Authentifizierung prüfen |
| `/quit` | Beenden |

In der Shell öffnet `qwen --continue` die letzte Sitzung des aktuellen Projekts und `qwen --resume <id>` eine bestimmte.

## Schritt 5: Freigabemodi

Qwen Code hat fünf Freigabemodi, die festlegen, was es ohne Nachfrage tun darf:

| Modus | Dateiänderungen | Shell-Befehle | Gut für |
| --- | --- | --- | --- |
| Plan | Nein, nur lesen | Nein | Code erkunden und eine Änderung planen |
| Ask Permissions (`default`) | Fragt jedes Mal | Fragt jedes Mal | Unbekannte oder kritische Codebasen |
| Auto-Edit (`auto-edit`) | Automatisch | Fragt | Alltagsarbeit mit vielen Änderungen |
| Auto (`auto`) | Prüft ein Klassifikator | Prüft ein Klassifikator | Lange Sitzungen mit Sicherheitsnetz |
| YOLO (`yolo`) | Automatisch | Automatisch | Vertrauenswürdige Automatisierung in isolierten Umgebungen |

Ab Werk startet Qwen Code im Modus Auto: Ein modellbasierter Klassifikator erlaubt sichere Aktionen und blockiert riskante. Wechseln kannst du mit `/approval-mode plan` oder Shift+Tab, oder du startest mit `qwen --approval-mode plan`. Eine gute Gewohnheit für alles Nichttriviale: in Plan anfangen, sich auf einen Ansatz einigen und dann für die Umsetzung zu Auto-Edit oder Auto wechseln. YOLO gehört in Container oder Wegwerf-Maschinen, wo ein falscher Befehl keinen bleibenden Schaden anrichten kann.

## Schritt 6: QWEN.md und Projektkontext

`QWEN.md` ist das Briefing, das Qwen Code zu Beginn jeder Sitzung lädt: Build- und Testbefehle, Konventionen, Ordner, die tabu sind. Sie kann an drei Orten liegen, und alle werden geladen:

| Datei | Gilt für |
| --- | --- |
| `~/.qwen/QWEN.md` | Dich, in jedem Projekt |
| `QWEN.md` im Projektstamm | Das ganze Team (committen) |
| `.qwen/QWEN.local.md` | Nur dich, nur in diesem Projekt (selbst in `.gitignore` eintragen) |

Mit `/init` durchsucht Qwen Code das Projekt und schreibt eine erste `QWEN.md`; existiert schon eine, schlägt es Ergänzungen vor, statt sie zu überschreiben. Liegt im Repository bereits eine `AGENTS.md` für andere Tools, liest Qwen Code auch diese. In der `QWEN.md` bindet `@docs/git-workflow.md` eine weitere Datei ein.

```markdown
# Projektregeln

- Paketmanager: pnpm. Führe `pnpm test` aus, bevor du eine Aufgabe abschließt.
- TypeScript im Strict-Modus; kein `any` in neuem Code.
- Bearbeite niemals Dateien in src/generated/.
- Git-Workflow: @docs/git-workflow.md
```

Halte sie kurz; laut Dokumentation wird eine längere Datei weniger zuverlässig befolgt. Qwen Code führt außerdem ein eigenes Auto-Memory in `~/.qwen/projects/<projekt>/memory/`, schlichte Markdown-Dateien, die du bearbeiten oder in `/memory` abschalten kannst. Für Regeln, die nur für bestimmte Dateien gelten, nimmt `.qwen/rules/` Markdown-Dateien mit einem `paths:`-Feld an. Was in so eine Datei gehört, steht in [CLAUDE.md und AGENTS.md](/de/blog/claude-md-agents-md/ "CLAUDE.md und AGENTS.md"), und das gilt genauso für `QWEN.md`.

## Schritt 7: MCP-Server

[MCP-Server](/de/blog/what-is-mcp-server/ "Was ist ein MCP-Server") geben Qwen Code neue Tools wie einen Browser, einen Issue-Tracker oder eine Dokumentationssuche. Am schnellsten fügst du einen mit dem Befehl `qwen mcp` hinzu:

```bash
# ein entfernter Server über HTTP
qwen mcp add --transport http my-server http://localhost:3000/mcp

# ein lokaler Server, der als Prozess startet (stdio ist der Standard-Transport)
qwen mcp add pythonTools -e DATABASE_URL=$DB_CONNECTION_STRING python -m my_mcp_server

# wieder entfernen
qwen mcp remove my-server
```

Die Server landen im `mcpServers`-Block von `~/.qwen/settings.json` (Standard-Scope user) oder mit `--scope project` in `.qwen/settings.json`. Du kannst den Block auch von Hand bearbeiten: `command` und `args` für einen lokalen Prozess, `httpUrl` für einen HTTP-Server. `--include-tools` und `--exclude-tools` begrenzen, welche Tools ein Server anbietet. Lief Qwen Code schon, starte es neu und prüfe dann mit `/mcp`, ob der Server verbunden ist und welche Tools er hat.

## Schritt 8: Headless-Modus für Skripte und CI

`-p` (oder `--prompt`) erledigt eine einzelne Aufgabe ohne interaktive Oberfläche, auch stdin funktioniert:

```bash
qwen -p "Summarize what changed in src/ since the last tag"
cat error.log | qwen -p "Explain this stack trace"
qwen -p "List the TODOs in this repo" --output-format json > todos.json
```

`--output-format` nimmt `text`, `json` oder `stream-json`. `qwen --continue -p "..."` setzt die letzte Sitzung fort, sodass ein Skript in mehreren Schritten arbeiten kann. Damit ein Headless-Lauf Dateien bearbeiten darf, setzt du einen Freigabemodus wie `--approval-mode auto-edit` oder auf einem isolierten Runner `--yolo`. Die Dokumentation sagt klar, dass `--yolo` keine Sandbox einschaltet: Shell-Befehle laufen mit den Rechten deines Benutzers. Budgets verhindern, dass ein unbeaufsichtigter Lauf ausufert:

```bash
qwen -p "Fix the failing unit tests" --yolo \
  --max-session-turns 30 --max-wall-time 10m --output-format json
```

Ein Lauf, der `--max-wall-time` oder `--max-tool-calls` überschreitet, endet mit Exit-Code 55, einer, der `--max-session-turns` überschreitet, mit 53, sodass CI die Fälle unterscheiden kann. Für echte Isolation führt `qwen -s` Tools in einer Sandbox aus (Seatbelt unter macOS, sonst Docker oder Podman).

## Häufige Stolperfallen

- **Der Agent funktioniert seit April 2026 nicht mehr.** Du warst auf dem eingestellten kostenlosen Qwen-OAuth-Zugang. Führe `/auth` aus und wähle einen anderen Anbieter.
- **„qwen auth“ zeigt einen Hinweis, dass der Befehl entfernt wurde.** Den Befehl gibt es nicht mehr; nutze `/auth` in einer Sitzung und `/doctor` zur Kontrolle.
- **Ein Key in `QWENCLOUD_API_KEY` oder `DASHSCOPE_API_KEY` wird ignoriert.** Anbieterspezifische Variablen greifen nur, wenn ein Anbieter in `settings.json` sie als `envKey` nennt. Sonst nimm `OPENAI_API_KEY`.
- **Ein neuer MCP-Server taucht nicht auf.** Er wurde hinzugefügt, während Qwen Code lief. Starte es im selben Projekt neu.
- **Lange Sitzungen werden langsam und teuer.** Nutze `/compress` oder `/clear`, halte `QWEN.md` kurz und schalte MCP-Server ab, die du nicht brauchst.

## Qwen Code neben anderen CLIs ausführen

Qwen Code hat eigene Subagenten und Worktree-Unterstützung, doch die bleiben innerhalb von Qwen Code. Willst du Qwen Code an einer Aufgabe, Claude Code an einer zweiten und Gemini CLI an einer dritten, jonglierst du wieder mit Terminal-Tabs. AgentVera ist eine Desktop-App, die diese CLIs nebeneinander in echten Terminals ausführt, mit deinen eigenen Installationen und Logins. Die [Qwen-Code-Unterstützung](/de/agents/qwen-code/ "Qwen Code") funktioniert so:

- **Dein Login.** Qwen Code behält seine eigene Anmeldung, das Terminal des Agenten fragt beim ersten Start. Ist `qwen` nicht installiert, installiert AgentVera es mit `npm i -g @qwen-code/qwen-code`.
- **Eine Sitzung pro Agent.** Jeder Agent startet mit eigener Sitzungs-ID (`--session-id`), eine gespeicherte Sitzung öffnet sich mit `--resume`.
- **Rolle und Modell.** Die Rolle des Agenten wird mit `--append-system-prompt` an den System-Prompt von Qwen Code angehängt. Lass das Feld Model leer für das Standardmodell von Qwen Code, oder wähle ein Modell, das AgentVera mit `--model` übergibt.
- **MCP bei jedem Start.** Die Server aus dem MCP-Manager von AgentVera und der Browser von AgentVera werden mit `--mcp-config` übergeben, deine eigene `settings.json` bleibt, wie sie ist.
- **Panes, Review und Flows.** Lass Qwen Code im Raster des [Workspace](/de/features/workspace/ "Workspace") neben Claude Code laufen, jeden Agenten in seinem eigenen Git-Worktree, mit automatischem Code-Review am Ende eines Turns. Qwen-Code-Agenten arbeiten auch in Broadcasts, geplanten Aufgaben und [Flows](/de/features/flows/ "Flows") (Pro und Team), in denen die Antwort eines Agenten an den nächsten geht.
- **Mehrere Konten.** Unter Settings → Accounts → Accounts of other agents kannst du weitere Qwen-Konten anlegen, die mit API-Keys laufen, und eine Fallback-Reihenfolge festlegen (Pro und Team).

Ehrlich gesagt: Wenn du nur ein kostenloses gehostetes Modell willst, bietet Qwen Code das nicht mehr, und die kostenlosen Tools aus der oben verlinkten Übersicht sind ein besserer Start. Suchst du einen anbieterunabhängigen Agenten mit anderem Arbeitsablauf, ist opencode die naheliegendste Alternative. Raster, Worktrees, Code-Review und MCP-Manager gehören zum Free-Tarif. [Lade AgentVera herunter](/de/download/ "AgentVera herunterladen") und probiere es aus.

## Fazit

Um Qwen Code zu verwenden, installierst du es, startest `qwen` in einem Projekt und wählst mit `/auth` einen Anbieter, denn den kostenlosen Qwen-OAuth-Zugang gibt es nicht mehr. Jeder OpenAI-kompatible Key funktioniert über `OPENAI_*`-Variablen oder `settings.json`, lokale Modelle eingeschlossen. Beginne riskante Arbeit im Plan-Modus, leg deine Projektregeln in `QWEN.md` ab, füge Tools mit `qwen mcp add` hinzu und nutze `qwen -p` mit Budgets, wenn ein Skript oder CI-Job den Agenten braucht. Danach bleibt vor allem die Frage, welcher Anbieter und welches Modell zu deinem Budget passen, und Qwen Code lässt dich beides jederzeit wechseln.

## Häufige Fragen

**Ist Qwen Code kostenlos?** Die CLI ist kostenlos und Open Source unter Apache-2.0, aber der kostenlose Qwen-OAuth-Zugang wurde am 15. April 2026 eingestellt. Bezahlen musst du jetzt für das Modell: einen QwenCloud- oder Alibaba-Cloud-Model-Studio-Tarif, einen API-Key mit nutzungsbasierter Abrechnung oder einen Drittanbieter. Ein lokales Modell über Ollama kostet nur deine Hardware.

**Kann Qwen Code auch andere Modelle als Qwen nutzen?** Ja. Es spricht die API-Formate von OpenAI, Anthropic und Gemini, listet in /auth Drittanbieter wie DeepSeek, Kimi, Z.AI, MiniMax und OpenRouter auf und akzeptiert jeden eigenen OpenAI-kompatiblen Endpunkt, auch lokale Server wie Ollama, vLLM und LM Studio.

**Liest Qwen Code AGENTS.md?** Ja. Qwen Code lädt ~/.qwen/QWEN.md, die QWEN.md im Projekt und .qwen/QWEN.local.md, und wenn im Repository schon eine AGENTS.md für andere Tools liegt, liest es auch diese. Du musst dieselben Regeln nicht in zwei Dateien pflegen.

**Was ist aus dem Befehl qwen auth geworden?** Er wurde entfernt. Starte qwen und führe in der Sitzung /auth aus, um einen Anbieter zu wählen oder zu wechseln, und /doctor, um zu sehen, welche Authentifizierung aktiv ist. Für Skripte setzt du die Umgebungsvariablen des Anbieters oder trägst ihn in ~/.qwen/settings.json ein.

**Wie lasse ich Qwen Code in CI laufen?** Mit dem Headless-Modus: qwen -p "dein Prompt" mit --output-format json für maschinenlesbare Ausgabe. Setze einen Freigabemodus wie --approval-mode auto-edit oder --yolo nur auf einem isolierten Runner, denn --yolo schaltet keine Sandbox ein. Budgets wie --max-wall-time stoppen einen Lauf, der hängt.

---

**Über AgentVera.** AgentVera ist eine Desktop-App für macOS, Windows und Linux, entwickelt von Solviera Teknoloji. Sie führt 18 KI-Coding-Agenten (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) nebeneinander aus, pro Projekt, in echten Terminals mit den eigenen CLI-Installationen und Logins des Nutzers. Der kostenlose Plan hat unbegrenzt viele Agenten. Download: https://agentvera.dev/de/download/ · Preise: https://agentvera.dev/de/pricing/