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 (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
+ 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 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, 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:

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

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

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

# 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:

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:

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:

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:

# 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 für Modellauswahl, Leistungsoptimierung und GPU-Konfiguration.

Option B: OpenHands + vLLM (hohe Leistung)

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

# 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 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:

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

# 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:

-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

# 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

# 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

# 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

# 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

# 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)

# 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 — Quellcode, Issues und Releases

• OpenHands-Dokumentation — Offizielle Doku einschließlich LLM-Konfiguration

• Ollama auf Clore.ai — Lokale LLMs für kostenlose Agenten-Inferenz ausführen

• vLLM auf Clore.ai — Hochleistungsfähiges lokales LLM-Serving

• GPU-Vergleichsleitfaden — Wähle die richtige GPU für deinen Workload

• OpenHands Discord — Community-Support und Modellempfehlungen

• SWE-bench-Leaderboard — Vergleiche die Agentenleistung bei echten GitHub-Issues