# Droid nutzen: Schritt-für-Schritt-Anleitung zur Factory Droid CLI

URL: https://agentvera.dev/de/blog/how-to-use-droid/ · Veröffentlicht: 2026-11-14

Factory Droid im Terminal nutzen: installieren, anmelden, Modell wählen, droid exec mit Autonomiestufen ausführen sowie AGENTS.md, MCP und eigene Droids einrichten.

**Kurz gesagt:**

- Installiere mit curl -fsSL https://app.factory.ai/cli | sh (oder brew install --cask droid), starte droid im Projekt, melde dich im Browser an und beschreibe die Aufgabe. Droid fragt vor Dateiänderungen und Befehlen.
- Für Skripte und CI ist droid exec standardmäßig schreibgeschützt; --auto low erlaubt Änderungen, medium auch Installs, Builds, Tests und Commits, high auch Pushes und Deploys. Headless nutzt du FACTORY_API_KEY.
- Der Free-Plan läuft mit eigener Inferenz (ChatGPT, Copilot, OpenRouter oder API-Keys); Pro kostet 20 $ im Monat (Stand November 2026). Regeln gehören in AGENTS.md, Einstellungen und MCP-Server nach ~/.factory/.

Um Droid, den Coding-Agenten von Factory, zu nutzen, installierst du die CLI mit `curl -fsSL https://app.factory.ai/cli | sh`, startest `droid` in einem Projekt, meldest dich im Browser an und beschreibst die Aufgabe. **Droid fragt, bevor es eine Datei ändert oder einen Befehl ausführt; für Skripte und CI gibt es `droid exec`, das schreibgeschützt bleibt, bis du seine Autonomie erhöhst.**

Diese Anleitung behandelt die Droid CLI mit Stand November 2026 (Version 1.12): Installation, Anmeldung, Modelle, die interaktive Sitzung, `droid exec` und seine Autonomiestufen, AGENTS.md, MCP-Server, eigene Droids und die Kosten.

## Was ist Droid?

Droid ist der Coding-Agent für das Terminal von [Factory](https://factory.com "Factory"). Er liest deine Codebasis, schlägt Änderungen vor und wendet sie an, nachdem du zugestimmt hast. Derselbe Agent läuft auch in den Desktop- und Web-Apps von Factory, in IDE-Integrationen und über ein SDK. Version 1.0 erschien am 29. Oktober 2026, und neue Versionen kommen mehrmals pro Woche.

Droid ist an keinen Modellanbieter gebunden. Es bietet Modelle von Anthropic, OpenAI, Google und xAI sowie Open-Weight-Modelle, die Factory als „Droid Core“ zusammenfasst, und du kannst eigene Endpunkte hinzufügen.

## Schritt 1: CLI installieren

Unter macOS oder Linux:

```bash
curl -fsSL https://app.factory.ai/cli | sh
```

Weitere Möglichkeiten:

```bash
brew install --cask droid      # Homebrew
npm install -g droid           # npm
```

In der Windows PowerShell:

```powershell
irm https://app.factory.ai/cli/windows | iex
```

Unter Linux braucht die Anmeldung außerdem `xdg-utils` (`sudo apt-get install xdg-utils`). Später aktualisierst du mit `droid update`.

## Schritt 2: anmelden

```bash
cd my-project
droid
```

Beim ersten Start öffnet sich der Browser, damit du dich mit einem Factory-Konto anmeldest. Für CI und andere Rechner ohne Browser erstellst du in den Factory-Einstellungen einen API-Key und exportierst ihn:

```bash
export FACTORY_API_KEY=fk-...
```

## Schritt 3: in einer Sitzung arbeiten

Beschreibe die Aufgabe in einfachen Worten. Droid erklärt, was es vorhat, und fragt dann vor jeder Änderung und jedem Befehl. Nützliche Tasten und Befehle:

- `Shift+Tab` wechselt zwischen dem normalen Modus und dem Spec-Modus, in dem Droid einen Plan schreibt, bevor es Code ändert.
- `!` führt selbst einen Shell-Befehl aus; `?` listet die Tastenkürzel auf.
- `/model` wechselt das Modell, `/settings` öffnet die Einstellungen, `/review` fordert ein Review der Änderungen an.
- `/compress` kürzt eine lange Unterhaltung; `/sessions` listet frühere auf.

Um später weiterzumachen, führe `droid --resume` (oder `droid --resume <id>`) aus. `droid search "checkout bug"` findet eine alte Sitzung über ihren Text, und `--fork <id>` kopiert eine.

## Schritt 4: Modell wählen

Das Modell wechselst du mit `/model` in einer Sitzung, mit `-m` auf der Kommandozeile oder mit einem `model`-Schlüssel in den Einstellungen. In bezahlten Plänen zählt jedes Modell mit einem Multiplikator gegen deine Nutzung: Stand November 2026 zählt Claude Opus 5.5 mit 1,6x, Claude Sonnet 5.5 mit 0,8x und Claude Haiku 5.5 mit 0,04x. Nimm ein kleines Modell für Routineänderungen und ein großes für Design und Debugging.

Um deinen eigenen Key zu nutzen, füge in `~/.factory/settings.json` ein eigenes Modell hinzu:

```json
{
  "customModels": [
    {
      "model": "claude-sonnet-5-5",
      "displayName": "Sonnet (my key)",
      "baseUrl": "https://api.anthropic.com",
      "apiKey": "${ANTHROPIC_API_KEY}",
      "provider": "anthropic"
    }
  ]
}
```

`provider` ist `anthropic`, `openai`, `generic-chat-completion-api` oder `bedrock-converse`. Die Keys bleiben auf deinem Rechner.

## Schritt 5: droid exec und Autonomiestufen

`droid exec` führt eine einzelne Aufgabe ohne Chat aus, genau das, was du in Skripten und CI brauchst:

```bash
droid exec "summarize the changes on this branch"
droid exec --auto low "fix the failing unit test in price.test.ts"
droid exec -f task.md -o json --auto medium
```

Standardmäßig ist es schreibgeschützt. Du erhöhst, was es tun darf:

| Stufe | Was sie erlaubt |
|---|---|
| (Standard) | Nur Lesen |
| `--auto low` | Dateiänderungen |
| `--auto medium` | Zusätzlich Installs, Builds, Tests, commit, checkout und pull |
| `--auto high` | Zusätzlich Pushes und Deploys |

`--skip-permissions-unsafe` schaltet alle Rückfragen ab; heb dir das für Wegwerf-Container auf. Beachte, dass Exit-Code 0 bedeutet, dass Droid fertig ist, nicht dass die Aufgabe gelungen ist; prüfe das Ergebnis in der CI also selbst. Für interaktive Sitzungen kannst du in den Einstellungen mit `sessionDefaultSettings.autonomyLevel` eine Standardstufe und mit `permissionRules` (allow, ask, block) feinere Regeln festlegen.

## Schritt 6: AGENTS.md und Einstellungen

Droid liest `AGENTS.md` als Anweisungen für das Repository. Halte die Datei kurz: der Stack, wie Tests laufen, was nicht angefasst werden soll und was „fertig“ bedeutet. Unsere Anleitung zu [CLAUDE.md und AGENTS.md](/de/blog/claude-md-agents-md/ "CLAUDE.md und AGENTS.md") zeigt, was hineingehört.

Die Einstellungen liegen in `~/.factory/settings.json` für dich und in `.factory/settings.json` für das Projekt, jeweils mit einer `settings.local.json` für Überschreibungen, die du nicht committest.

## Schritt 7: MCP-Server und eigene Droids

MCP-Server fügst du auf der Kommandozeile hinzu:

```bash
droid mcp add docs https://example.com/mcp --type http
droid mcp add memory "npx -y @modelcontextprotocol/server-memory"
```

Sie werden in `~/.factory/mcp.json` (oder `.factory/mcp.json` für das Projekt) unter `mcpServers` gespeichert. In einer Sitzung verwaltest du sie mit `/mcp`, einschließlich OAuth-Anmeldungen.

Eigene Droids sind Subagenten: eine Markdown-Datei mit YAML-Header (`name`, `description`, `model`, `tools` und mehr) in `.factory/droids/` oder `~/.factory/droids/`. Droid gibt ihnen über sein Task-Tool Arbeit ab, und mit `/droids` verwaltest du sie. Ein kleiner „Test-Schreiber“ oder „Reviewer“ auf einem günstigen Modell ist ein guter erster Droid.

## Was Droid kostet (Stand November 2026)

| Plan | Preis | Hinweise |
|---|---|---|
| Free | 0 $ | Du bringst die Inferenz mit: ChatGPT, Copilot, OpenRouter oder eigene Keys |
| Pro | 20 $/Monat | Alle Modelle, Desktop-App, CLI und SDK |
| Plus | 100 $/Monat | Etwa 5x die Nutzung von Pro |
| Max | 200 $/Monat | Etwa 10x die Nutzung von Pro |
| Teams | 60 $/Monat + 40 $/Platz | Bis zu 10 Plätze |

Schau vor der Entscheidung auf die [Preisseite von Factory](https://factory.com/pricing "Preise von Factory"); die Pläne ändern sich oft.

## Typische Stolperfallen

- **Alte Doku-Links.** Die Doku ist von docs.factory.ai nach [docs.factory.com](https://docs.factory.com "Factory-Dokumentation") umgezogen; die Installations-URLs nutzen weiterhin app.factory.ai.
- **exec zu früh mit hoher Autonomie ausführen.** Starte CI-Jobs mit `--auto low` und erhöhe die Stufe nur für Schritte, die es brauchen.
- **Exit-Code 0 vertrauen.** Er bedeutet nur, dass der Lauf beendet ist. Prüfe danach die Tests oder den Diff.
- **`-r` bedeutet zweierlei.** In `droid` setzt `-r` eine Sitzung fort; in `droid exec` legt es den Reasoning-Aufwand fest. Schreib `--resume` aus, um Überraschungen zu vermeiden.

## Droid neben anderen CLIs in AgentVera betreiben

Wenn Droid dein einziger Agent ist, reichen dir die Apps von Factory vielleicht schon. Schwieriger wird es, wenn Droid neben Claude Code, Codex oder Gemini CLI im selben Projekt läuft. [AgentVera](/de/ "AgentVera") ist eine Desktop-App, die diese CLIs nebeneinander in echten Terminals ausführt, mit deinen eigenen Installationen und Anmeldungen. Die [Droid-Unterstützung](/de/agents/factory-droid/ "Factory Droid in AgentVera") funktioniert so:

- **Eine Sitzung pro Agent.** AgentVera findet die Sitzung, die Droid anlegt, und öffnet sie bei späteren Starts mit `droid --resume <id>` wieder, sodass die Unterhaltung einen Neustart der App übersteht.
- **Modell, Aufwand und Rolle.** Das Modell und den Aufwand, die du für den Agenten wählst, übergibt AgentVera über eine Einstellungsdatei, die Rolle des Agenten mit `--append-system-prompt`.
- **Deine Anmeldung oder deine API-Keys.** Droid behält deine Factory-Anmeldung. Unter Einstellungen → Konten kannst du `FACTORY_API_KEY`-Konten hinzufügen und jedem Agenten ein eigenes geben.
- **Bereiche, Worktrees und Review.** Führe Droid im Raster des [Workspace](/de/features/workspace/ "Workspace") neben anderen Agenten aus, jeden in seinem eigenen git worktree, und prüfe ihre Änderungen mit dem [Code-Review](/de/features/code-review/ "Code-Review").

Der kostenlose Plan umfasst bis zu 18 Agenten, MCP, Git, Docker, SSH, Code-Review und Token-Einsparungen. Pro kostet 9,99 $ im Monat; wenn du noch nie eine Testphase hattest, schaltet deine erste Anmeldung in der App Pro für 7 Tage frei, ohne Karte. Zum Ausprobieren: [AgentVera herunterladen](/de/download/ "AgentVera herunterladen").

## Fazit

Für den Start mit Droid brauchst du zwei Befehle: das Installationsskript und `droid`. Danach kommt es auf Kontrolle an: Lass interaktive Sitzungen auf Freigabe, starte `droid exec` mit `--auto low`, schreib die Regeln des Projekts in `AGENTS.md` und wähle das Modell pro Aufgabe mit Blick auf den Nutzungsmultiplikator.

Quellen: [Droid-Schnellstart](https://docs.factory.com/cli/getting-started/quickstart "Droid-Schnellstart"), [CLI-Referenz](https://docs.factory.com/docs/droid-cli/cli-reference "Droid-CLI-Referenz"), [droid exec](https://docs.factory.com/docs/droid-exec/overview "droid exec"), [Modelle](https://docs.factory.com/docs/models "Droid-Modelle"), [MCP](https://docs.factory.com/docs/harness/mcp "Droid MCP"), [Changelog](https://docs.factory.com/changelog/cli-updates "Droid-CLI-Changelog").

## Häufige Fragen

**Ist Factory Droid kostenlos?** Es gibt einen Free-Plan für 0 $, bei dem du die Inferenz mitbringst: Melde dich mit ChatGPT, GitHub Copilot oder OpenRouter an oder füge eigene API-Keys hinzu. Die bezahlten Pläne kosten Stand November 2026 im Monat 20 $ (Pro), 100 $ (Plus) und 200 $ (Max), mit jeweils mehr Nutzung pro Stufe.

**Kann ich mit Droid meinen eigenen API-Key nutzen?** Ja. Füge in ~/.factory/settings.json einen customModels-Eintrag mit Modellname, Base-URL, Anbieter und Key hinzu (der Key kann aus einer Umgebungsvariable gelesen werden). Die Keys bleiben auf deinem Rechner, und eigene Modelle funktionieren in der CLI und in der Desktop-App.

**Was ist der Unterschied zwischen droid und droid exec?** droid öffnet eine interaktive Sitzung, die vor jeder Änderung und jedem Befehl fragt. droid exec führt eine einzelne Aufgabe ohne Chat aus, für Skripte und CI. Es bleibt schreibgeschützt, bis du die Autonomie mit --auto low, medium oder high erhöhst.

**Liest Droid AGENTS.md?** Ja. AGENTS.md ist die Anweisungsdatei, die Droid für ein Repository liest: Dort gehören der Stack, der Testbefehl, die Regeln und das hinein, was nicht angefasst werden soll.

**Wie setze ich eine Droid-Sitzung fort?** Führe droid --resume aus, um eine der letzten Sitzungen zu wählen, oder droid --resume <id> für eine bestimmte. droid search "text" findet alte Sitzungen, und --fork <id> kopiert eine, damit du eine andere Richtung ausprobieren kannst.

---

**Ü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/