> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/openhands.md).

# OpenHands KI-Entwickler

Deploye OpenHands (früher OpenDevin) auf Clore.ai — betreibe einen vollständig autonomen KI-Softwareentwickler auf günstigen GPU-Cloud-Servern für Programmierung, Debugging und GitHub-Issue-Lösung.

## Überblick

[OpenHands](https://github.com/All-Hands-AI/OpenHands) (ehemals OpenDevin) ist eine Open-Source-Plattform für autonome KI-Softwareentwicklungsagenten. Mit über 65.000 GitHub-Sternen ist sie zu einem der beliebtesten Werkzeuge geworden, um echte Programmieraufgaben an KI zu delegieren — Code schreiben, Fehler beheben, GitHub-Issues lösen, Shell-Befehle ausführen, im Web browsen und mit deiner Codebasis von Anfang bis Ende interagieren.

Im Gegensatz zu typischen Code-Vervollständigungstools läuft OpenHands in einer **agentischen Schleife**: Sie erhält eine Aufgabe, plant, schreibt Code, führt ihn aus, beobachtet die Ausgabe und iteriert — alles ohne menschliches Eingreifen. Sie unterstützt Dutzende LLM-Backends, darunter OpenAI, Anthropic Claude, Google Gemini und lokal gehostete Modelle über Ollama oder vLLM.

**Warum Clore.ai für OpenHands?**

* OpenHands selbst ist CPU-basiert und benötigt keine GPU
* Wenn du es jedoch mit einem **lokalen LLM** (Ollama, vLLM) auf demselben Server kombinierst, entfallen API-Kosten und Latenz
* Die günstigen GPU-Server von Clore.ai ermöglichen es dir, sowohl OpenHands als auch ein lokales Modell bereits für **$0,20–$0,35/Stunde**
* Du erhältst persistenten Workspace-Speicher, Docker-in-Docker-Unterstützung und vollen Root-Zugriff
* Ideal für langlaufende autonome Aufgaben, die über Cloud-LLM-APIs teuer wären

**Typische Anwendungsfälle auf Clore.ai:**

* Autonome Codegenerierung aus einer Spezifikation oder einer Problembeschreibung
* Große Codebasen in Massen refaktorisieren
* OpenHands + Ollama zusammen ausführen für 100 % Offline-Agentenentwicklung
* CI/CD-Aufgabenautomatisierung ohne API-Kosten

***

## Anforderungen

OpenHands benötigt Zugriff auf den Docker-Socket und führt intern einen sandboxed Runtime-Container aus. Die folgende Tabelle enthält empfohlene Konfigurationen auf Clore.ai:

| Konfiguration                   | GPU                | VRAM  | RAM   | Speicher | Geschätzter Preis                         |
| ------------------------------- | ------------------ | ----- | ----- | -------- | ----------------------------------------- |
| **Nur API (kein lokales LLM)**  | Beliebig / nur CPU | k. A. | 8 GB  | 20 GB    | ca. 0,05–0,10 $/Std.                      |
| **+ Ollama (Llama 3.1 8B)**     | RTX 3090           | 24 GB | 16 GB | 40 GB    | ca. 0,07–0,21 $/h                         |
| **+ Ollama (Qwen2.5 32B)**      | RTX 4090           | 24 GB | 32 GB | 60 GB    | ca. 0,14–0,42 $/h                         |
| **+ vLLM (Llama 3.1 70B)**      | A100 80GB          | 80 GB | 64 GB | 100 GB   | [Bare Metal](https://clore.ai/bare-metal) |
| **+ vLLM (Llama 3.3 70B INT4)** | RTX 4090           | 24 GB | 32 GB | 80 GB    | ca. 0,14–0,42 $/h                         |

> **Hinweis:** Wenn du nur OpenAI-/Anthropic-/Gemini-APIs verwendest, funktioniert jeder Server mit ≥8 GB RAM. Eine GPU wird nur benötigt, wenn du ein lokales LLM auf derselben Maschine ausführen möchtest. Siehe die [GPU-Vergleichsleitfaden](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) für weitere Details.

**Softwareanforderungen auf dem Clore.ai-Server:**

* Docker Engine (auf allen Clore.ai-Images vorinstalliert)
* NVIDIA Container Toolkit (auf GPU-Images vorinstalliert)
* Docker-Socket erreichbar unter `/var/run/docker.sock`
* Ausgehender Internetzugang zum Herunterladen von GHCR-Images

***

## Schnellstart

### Schritt 1: Einen Clore.ai-Server auswählen und verbinden

Im [Clore.ai-Marktplatz](https://clore.ai), filtere Server nach:

* RAM ≥ 16 GB (für die lokale LLM-Kombination)
* Docker: ✓ aktiviert
* Wähle deine bevorzugte GPU, wenn du ein lokales Modell verwendest

Per SSH verbinden, sobald der Server bereitgestellt wurde:

```bash
ssh root@<server-ip> -p <port>
```

### Schritt 2: Überprüfen, ob Docker läuft

```bash
docker info
ls -la /var/run/docker.sock
```

Beide Befehle sollten erfolgreich sein. Wenn der Docker-Socket fehlt, kontaktiere den Clore.ai-Support oder wähle ein anderes Image.

### Schritt 3: OpenHands herunterladen und ausführen

```bash
# Workspace-Verzeichnis festlegen
export WORKSPACE_BASE=$(pwd)/workspace
mkdir -p $WORKSPACE_BASE

# OpenHands ausführen (lädt das neueste 0.38-Image von GHCR)
docker run -it --pull=always \\
  -e SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/all-hands-ai/runtime:0.38-nikolaik \\
  -e SANDBOX_USER_ID=$(id -u) \\
  -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \\
  -v $WORKSPACE_BASE:/opt/workspace_base \\
  -v /var/run/docker.sock:/var/run/docker.sock \\
  -p 3000:3000 \\
  --add-host host.docker.internal:host-gateway \\
  ghcr.io/all-hands-ai/openhands:0.38
```

### Schritt 4: Auf die Web-UI zugreifen

Die UI ist verfügbar unter `http://<server-ip>:3000`

> **Portweiterleitung in Clore.ai:** Stelle im Clore.ai-Dashboard sicher, dass Port `3000` in deiner Serverkonfiguration weitergeleitet/exponiert wird. Einige Vorlagen beschränken externe Ports — prüfe den Abschnitt "Ports" in deinen Serverdetails.

Beim ersten Start fordert OpenHands dich auf, einen LLM-Anbieter zu konfigurieren.

### Schritt 5: Dein LLM konfigurieren

In den Einstellungen der Web-UI:

* **Anbieter:** OpenAI, Anthropic, Google oder Benutzerdefiniert auswählen
* **API-Schlüssel:** Gib deinen API-Schlüssel ein
* **Modell:** z. B. `gpt-4o`, `claude-3-5-sonnet-20241022`, oder `ollama/llama3.1`

Für lokales Ollama (siehe Abschnitt GPU-Beschleunigung unten) verwende:

* Anbieter: `ollama`
* Basis-URL: `http://host.docker.internal:11434`
* Modell: `ollama/llama3.1:8b`

***

## Konfiguration

### Umgebungsvariablen

OpenHands kann vollständig über Umgebungsvariablen konfiguriert werden, die an `docker run`:

```bash
docker run -it --pull=always \\
  -e SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/all-hands-ai/runtime:0.38-nikolaik \\
  -e SANDBOX_USER_ID=$(id -u) \\
  -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \\
  -e LLM_MODEL=claude-3-5-sonnet-20241022 \\
  -e LLM_API_KEY=sk-ant-... \\
  -e LLM_BASE_URL="" \\
  -e SANDBOX_TIMEOUT=120 \\
  -e MAX_ITERATIONS=100 \\
  -v $WORKSPACE_BASE:/opt/workspace_base \\
  -v /var/run/docker.sock:/var/run/docker.sock \\
  -p 3000:3000 \\
  --add-host host.docker.internal:host-gateway \\
  ghcr.io/all-hands-ai/openhands:0.38
```

| Variable          | Beschreibung                                                     | Standard               |
| ----------------- | ---------------------------------------------------------------- | ---------------------- |
| `LLM_MODEL`       | Modellkennung (z. B. `gpt-4o`, `claude-3-5-sonnet-20241022`)     | In der UI festgelegt   |
| `LLM_API_KEY`     | API-Schlüssel für den LLM-Anbieter                               | In der UI festgelegt   |
| `LLM_BASE_URL`    | Benutzerdefinierte Basis-URL (für Ollama, vLLM, LiteLLM)         | Standard des Anbieters |
| `SANDBOX_TIMEOUT` | Timeout der Agenten-Sandbox in Sekunden                          | `120`                  |
| `MAX_ITERATIONS`  | Maximale Anzahl agentischer Schleifen pro Aufgabe                | `100`                  |
| `SANDBOX_USER_ID` | UID, unter der die Sandbox ausgeführt wird (verwende `$(id -u)`) | `0`                    |
| `LOG_ALL_EVENTS`  | Ausführliches Ereignis-Logging aktivieren (`true`/`false`)       | `false`                |

### Persistente Konfigurationsdatei

Du kannst Einstellungen persistent machen, indem du ein Konfigurationsverzeichnis einbindest:

```bash
mkdir -p /opt/openhands/config

docker run -it --pull=always \\
  -e SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/all-hands-ai/runtime:0.38-nikolaik \\
  -e SANDBOX_USER_ID=$(id -u) \\
  -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \\
  -v $WORKSPACE_BASE:/opt/workspace_base \\
  -v /var/run/docker.sock:/var/run/docker.sock \\
  -v /opt/openhands/config:/app/config \\
  -p 3000:3000 \\
  --add-host host.docker.internal:host-gateway \\
  ghcr.io/all-hands-ai/openhands:0.38
```

### Im Hintergrund ausführen (Detached Mode)

Für langlaufende Sitzungen auf Clore.ai:

```bash
export WORKSPACE_BASE=/opt/workspace
mkdir -p $WORKSPACE_BASE

docker run -d \
  --name openhands \\
  --restart unless-stopped \\
  --pull=always \\
  -e SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/all-hands-ai/runtime:0.38-nikolaik \\
  -e SANDBOX_USER_ID=0 \\
  -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \\
  -e LLM_MODEL=claude-3-5-sonnet-20241022 \\
  -e LLM_API_KEY=your_api_key_here \\
  -v $WORKSPACE_BASE:/opt/workspace_base \\
  -v /var/run/docker.sock:/var/run/docker.sock \\
  -p 3000:3000 \\
  --add-host host.docker.internal:host-gateway \\
  ghcr.io/all-hands-ai/openhands:0.38

# Logs anzeigen
docker logs -f openhands
```

***

## GPU-Beschleunigung (Integration eines lokalen LLM)

Obwohl OpenHands selbst die GPU nicht nutzt, erhältst du durch die Kombination mit einem **lokalen LLM** auf der GPU von Clore.ai laufenden Modell einen leistungsstarken, kosteneffizienten, API-freien autonomen Agenten.

### Option A: OpenHands + Ollama (empfohlen für Einsteiger)

Starte zuerst Ollama und richte dann OpenHands darauf aus:

```bash
# 1. Ollama starten (siehe Ollama-Anleitung für alle Details)
docker run -d \
  --name ollama \\
  --gpus all \
  -p 11434:11434 \
  -v ollama-data:/root/.ollama \\
  ollama/ollama:latest

# 2. Ein auf Programmierung optimiertes Modell herunterladen
docker exec ollama ollama pull qwen2.5-coder:7b
# Oder für mehr Leistung:
docker exec ollama ollama pull llama3.1:8b
docker exec ollama ollama pull deepseek-coder-v2:16b

# 3. OpenHands mit Verweis auf Ollama starten
export WORKSPACE_BASE=/opt/workspace
mkdir -p $WORKSPACE_BASE

docker run -d \
  --name openhands \\
  -e SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/all-hands-ai/runtime:0.38-nikolaik \\
  -e SANDBOX_USER_ID=0 \\
  -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \\
  -e LLM_MODEL=ollama/qwen2.5-coder:7b \\
  -e LLM_BASE_URL=http://host.docker.internal:11434 \\
  -e LLM_API_KEY=ollama \\
  -v $WORKSPACE_BASE:/opt/workspace_base \\
  -v /var/run/docker.sock:/var/run/docker.sock \\
  -p 3000:3000 \\
  --add-host host.docker.internal:host-gateway \\
  ghcr.io/all-hands-ai/openhands:0.38
```

> Siehe die vollständige [Ollama-Anleitung](/guides/guides_v2-de/sprachmodelle/ollama.md) für Modellauswahl, Leistungsoptimierung und GPU-Konfiguration.

### Option B: OpenHands + vLLM (hohe Leistung)

Für maximalen Durchsatz mit größeren Modellen:

```bash
# 1. vLLM mit einem Modell für Programmierung starten
docker run -d \
  --name vllm \\
  --gpus all \
  -p 8000:8000 \
  --ipc=host \\
  vllm/vllm-openai:latest \
  --model Qwen/Qwen2.5-Coder-32B-Instruct \
  --max-model-len 16384 \
  --gpu-memory-utilization 0.92

# Auf das Laden des Modells warten (~2–5 Min.)
docker logs -f vllm | grep "Application startup"

# 2. OpenHands mit vLLM-Backend starten
docker run -d \
  --name openhands \\
  -e SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/all-hands-ai/runtime:0.38-nikolaik \\
  -e SANDBOX_USER_ID=0 \\
  -e WORKSPACE_MOUNT_PATH=/opt/workspace \\
  -e LLM_MODEL=openai/Qwen/Qwen2.5-Coder-32B-Instruct \\
  -e LLM_BASE_URL=http://host.docker.internal:8000/v1 \\
  -e LLM_API_KEY=none \\
  -v /opt/workspace:/opt/workspace_base \\
  -v /var/run/docker.sock:/var/run/docker.sock \\
  -p 3000:3000 \\
  --add-host host.docker.internal:host-gateway \\
  ghcr.io/all-hands-ai/openhands:0.38
```

> Siehe die [vLLM-Anleitung](/guides/guides_v2-de/sprachmodelle/vllm.md) für vollständiges Setup, Quantisierungsoptionen und Multi-GPU-Konfigurationen.

### Empfohlene lokale Modelle für Programmierung

| Modell                  | Größe | Min. VRAM | Qualität |
| ----------------------- | ----- | --------- | -------- |
| `qwen2.5-coder:7b`      | 7B    | 8 GB      | ★★★☆☆    |
| `deepseek-coder-v2:16b` | 16B   | 12 GB     | ★★★★☆    |
| `qwen2.5-coder:32b`     | 32B   | 24 GB     | ★★★★☆    |
| `llama3.1:70b`          | 70B   | 48 GB     | ★★★★★    |

***

## Tipps & bewährte Praktiken

### 1. Workspace-Mounts sinnvoll verwenden

Binde dein tatsächliches Projektverzeichnis als Workspace ein, damit OpenHands deine Dateien direkt bearbeiten kann:

```bash
export WORKSPACE_BASE=/opt/my-project
git clone https://github.com/your/repo $WORKSPACE_BASE
```

### 2. Aufgaben-Prompting für beste Ergebnisse

OpenHands funktioniert am besten mit spezifischen, umsetzbaren Prompts:

```
✅ Gut: "Behebe den Authentifizierungsfehler in src/auth/login.py, bei dem JWT-Token 
         sofort ablaufen. Das Problem liegt in der Berechnung des Token-Ablaufs."

❌ Schlecht: "Behebe den Fehler"
```

### 3. Ressourcenverbrauch überwachen

```bash
# GPU- und Speichernutzung überwachen
watch -n 2 'nvidia-smi && docker stats --no-stream'
```

### 4. Iterationslimits festlegen

Verhindere, dass außer Kontrolle geratene Agenten zu viele API-Token verbrauchen:

```bash
-e MAX_ITERATIONS=50  # Auf 50 Schritte pro Aufgabe begrenzen
```

### 5. GitHub-Integration

OpenHands kann GitHub-Issues direkt lösen. In der UI konfigurieren:

* GitHub-Token: Dein persönlicher Zugriffstoken mit `repo` Scope
* OpenHands klont das Repo, behebt das Problem und erstellt einen PR

### 6. Kostenschätzung

Schätze bei API-basierten LLMs die Kosten pro Aufgabe:

* Einfacher Bugfix: ca. \~$0,05–0,15 (Claude Haiku/GPT-4o-mini)
* Komplexe Funktion: ca. \~$0,50–2,00 (Claude Sonnet/GPT-4o)
* Bei 100+ Aufgaben/Tag rechnet sich ein lokales LLM auf Clore.ai

***

## Fehlerbehebung

### Docker-Socket: Zugriff verweigert

```bash
# Fehler: Zugriff verweigert beim Versuch, mit dem Docker-Daemon zu verbinden
# Beheben: sicherstellen, dass der Socket zugänglich ist
ls -la /var/run/docker.sock
# Sollte anzeigen: srw-rw---- 1 root docker ...

# Deinen Benutzer bei Bedarf der docker-Gruppe hinzufügen
usermod -aG docker $USER
# Dann die Shell neu starten oder verwenden: newgrp docker
```

### Sandbox-Container startet nicht

```bash
# Prüfe, ob das Runtime-Image erreichbar ist
docker pull ghcr.io/all-hands-ai/runtime:0.38-nikolaik

# Prüfe die GHCR-Rate-Limits (möglicherweise ist eine Authentifizierung erforderlich)
docker login ghcr.io
```

### Port 3000 nicht erreichbar

```bash
# Prüfe, ob der Container läuft und der Port gebunden ist
docker ps | grep openhands
docker port openhands

# Clore.ai-Firewall prüfen — sicherstellen, dass Port 3000 in deiner Port-Zuordnung enthalten ist
# Im Clore.ai-Dashboard: Server → Ports → 3000:3000 hinzufügen
```

### LLM-Verbindungsfehler mit Ollama

```bash
# Teste, ob Ollama vom OpenHands-Container aus erreichbar ist
docker exec openhands curl http://host.docker.internal:11434/api/tags

# Falls es fehlschlägt, überprüfe, ob das --add-host-Flag in docker run enthalten war
# Prüfe außerdem, ob der Ollama-Container läuft:
docker ps | grep ollama
docker logs ollama | tail -20
```

### Agenten-Schleifen laufen endlos

```bash
# Max. Iterationen reduzieren
docker stop openhands
docker run ... -e MAX_ITERATIONS=30 ...

# Oder ein Timeout festlegen
-e SANDBOX_TIMEOUT=60
```

### Nicht genügend Speicher (OOM)

```bash
# Speichernutzung prüfen
free -h
docker stats

# Wenn ein lokales LLM läuft, probiere ein kleineres Modell
docker exec ollama ollama pull qwen2.5-coder:3b

# Oder eine quantisierte Version verwenden (weniger VRAM)
docker exec ollama ollama pull llama3.1:8b-instruct-q4_K_M
```

***

## Weiterführende Lektüre

* [OpenHands-GitHub-Repository](https://github.com/All-Hands-AI/OpenHands) — Quellcode, Issues und Releases
* [OpenHands-Dokumentation](https://docs.all-hands.dev) — Offizielle Doku einschließlich LLM-Konfiguration
* [Ollama auf Clore.ai](/guides/guides_v2-de/sprachmodelle/ollama.md) — Lokale LLMs für kostenlose Agenten-Inferenz ausführen
* [vLLM auf Clore.ai](/guides/guides_v2-de/sprachmodelle/vllm.md) — Hochleistungsfähiges lokales LLM-Serving
* [GPU-Vergleichsleitfaden](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — Wähle die richtige GPU für deinen Workload
* [OpenHands Discord](https://discord.gg/ESHStjSjD4) — Community-Support und Modellempfehlungen
* [SWE-bench-Leaderboard](https://www.swebench.com) — Vergleiche die Agentenleistung bei echten GitHub-Issues


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/openhands.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.