Zum Hauptinhalt springen

OpenHands: Der Open-Source-KI-Coding-Agent erklärt

Ein Überblick über OpenHands, den Open-Source-KI-Coding-Agenten: Architektur, lokales Setup mit Ollama, ein praktischer Bugfix, Sicherheit und Grenzen sowie der Vergleich mit Claude Code, Cursor und GitHub Copilot.
· 15 Min. lesen

Entdecke KI

OpenHands ist eine Open-Source-Plattform für KI-gestützte Softwareentwicklung, aufgebaut rund um einen Agenten, der dein Repository inspizieren, Dateien bearbeiten, Befehle ausführen und Tests laufen lassen kann. Sie ist Teil des Trends hin zu agentischer Softwareentwicklung – du gibst dem Agenten eine komplette Aufgabe, und er arbeitet sie Schritt für Schritt ab, bis sie erledigt ist oder er deine Rückmeldung braucht.

In diesem Artikel führe ich dich durch die Architektur und die wichtigsten Funktionen von OpenHands, zeige dir die Einrichtung mit einem lokalen Modell und vergleiche es mit Claude Code, Cursor und GitHub Copilot.

Was sind KI-Agenten? Melde dich für unseren AI Agent Fundamentals Lernpfad an und erfahre, wie KI-Agenten deine Arbeit verändern können.

Was ist OpenHands?

OpenHands ist eine Open-Source-Plattform zum Erstellen und Ausführen von KI-Agenten, die mit Code arbeiten.

Der Name steht für zwei Dinge. Erstens das Projekt – eine Sammlung von Repositories mit einem SDK, einem Server, einer Browser-Oberfläche und einem gehosteten Service. Zweitens der Coding-Agent, der darauf aufsetzt.

So funktioniert es:

  • Software-Agent-SDK: Ein Satz aus Python- und REST-APIs zum Bauen von Code-Agenten – der Motor hinter der OpenHands-CLI und OpenHands Cloud
  • Agent Server: Stellt Ausführung, Konversationen, Tools und Workspaces über REST- und WebSocket-APIs bereit
  • Agent Canvas: Eine Browser-UI für Konversationen, Dateien, Terminalausgaben, Modellkonfiguration, Backends und Automationen
  • OpenHands Cloud: Der gemanagte, kommerzielle Service für Teams, die kein eigenes Backend und keine eigene Sandbox-Infrastruktur betreiben möchten

Wenn die meisten Leute von "OpenHands" sprechen, meinen sie den Agenten. Mit diesem Teil arbeite ich in diesem Artikel.

Typischerweise gibst du dem Agenten eine Softwareaufgabe, verweist ihn auf einen Workspace mit deinem Code, und er arbeitet die Aufgabe mit seinen Tools ab. Standardmäßig sind das ein Terminal, ein Dateieditor und ein Task-Tracker.

Der Workspace muss nicht dein Laptop sein. Agenten können lokal arbeiten oder in kurzlebigen Workspaces laufen, zum Beispiel in Docker oder Kubernetes.

OpenHands bindet dich auch nicht an einen Modellprovider. Du kannst Claude, GPT oder jedes andere LLM nutzen – inklusive lokaler Modelle. Agent Canvas kann sogar Drittanbieter-Agenten wie Claude Code und Codex anstelle des Standard-OpenHands-Agenten ausführen.

Kurz gesagt: OpenHands ist eine offene Agentenplattform, die du zu deinen eigenen Bedingungen betreiben kannst.

Wie OpenHands funktioniert

OpenHands läuft in einer Schleife.

Ein Chat-Assistent erhält deinen Prompt und gibt Text zurück. Der OpenHands-Agent bekommt eine Aufgabe, führt eine Aktion aus, betrachtet das Ergebnis und entscheidet, was als Nächstes zu tun ist.

Die OpenHands-Agentenschleife

Die OpenHands-Agentenschleife

Die Grundidee:

  • Aufgabe erhalten: Du beschreibst das Ziel in Alltagssprache, zum Beispiel "Korrigiere den Monatsbericht, damit keine Monate aus verschiedenen Jahren zusammengelegt werden"
  • Repository inspizieren: Der Agent listet Verzeichnisse auf, öffnet Dateien und sucht nach aufgabenrelevantem Code
  • Plan erstellen: Er zerlegt die Aufgabe in Schritte und hält sie im Task-Tracker fest
  • Dateien bearbeiten oder erstellen: Er ändert den Code mit seinem Dateieditor
  • Befehle und Tests ausführen: Er startet die Testsuite oder die App im Terminal
  • Ergebnisse prüfen: Er liest die Ausgaben, inklusive Fehlern und fehlgeschlagenen Assertions
  • Iterieren: Wenn noch etwas kaputt ist, geht er zurück, passt den Plan an und versucht es erneut

Die Schleife stoppt, wenn die Aufgabe erledigt ist oder der Agent etwas braucht, das nur du liefern kannst, etwa ein fehlendes Credential oder eine Entscheidung zu Anforderungen.

Schritt 6 unterscheidet OpenHands vom Wettbewerb. Ein Code-Vervollständigungstool sieht nie, was passiert, wenn sein Code läuft. OpenHands schon – und kann deshalb auf fehlgeschlagene Tests reagieren und die Ursache beheben.

Kernfunktionen von OpenHands

Autocomplete schlägt Text vor – OpenHands greift aktiv in dein Projekt ein. So funktioniert es.

Codebearbeitung

OpenHands bearbeitet Dateien direkt – und ist nicht auf eine einzelne Datei pro Schritt beschränkt.

Angenommen, eine Funktion braucht einen neuen Namen. Der Agent aktualisiert die Definition, findet alle Aufrufstellen und passt die Tests an, die darauf verweisen – alles innerhalb einer Aufgabe.

Terminal- und Toolnutzung

Der Agent hat ein eigenes Terminal. Er kann Abhängigkeiten installieren, Skripte ausführen, Tests starten und die Ausgabe beliebiger Befehle lesen.

Du kannst außerdem MCP-Server (Model Context Protocol) anbinden, um dem Agenten Tools zu geben, für die er ursprünglich nicht gebaut wurde, etwa ein Issue-Tracker oder ein Datenbank-Client.

Repository-Verständnis

Die meisten Codegeneratoren sehen nur, was du in den Prompt einfügst.

OpenHands öffnet das Repository und erkundet es. Es kann die README lesen, Imports folgen und vorhandene Tests ansehen, um die Projektstruktur zu verstehen. So passen die Änderungen wahrscheinlicher zum bestehenden Code.

Lange Aufgaben erzeugen ein anderes Problem – der Gesprächsverlauf wächst über das Kontextfenster des Modells hinaus. OpenHands löst das mit einem Kontextkondensator, der ältere Teile zusammenfasst, damit der Agent weiterarbeiten kann.

Modellwahl

Modellaufrufe laufen über LiteLLM, daher kannst du jeden Provider und jedes unterstützte Modell nutzen. Die OpenHands-Dokumentation empfiehlt Modelle aus den Claude-, GPT- und Gemini-Familien sowie Open-Weight-Modelle mit guter Bewertung im OpenHands Index.

Wenn dein Code deine Maschine nicht verlassen darf, kannst du ein lokales Modell einsetzen. OpenHands verbindet sich mit lokalen Servern wie LM Studio, Ollama, vLLM und SGLang.

Merke: Das Modell beeinflusst die Ergebnisse stark. Manche lokale Modelle tun sich trotz großem Kontextfenster mit zuverlässiger Toolnutzung schwer.

Autonome Ausführung

Sobald du eine Aufgabe übergibst, arbeitet der Agent die Schleife eigenständig ab. Du kopierst keine Fehler zurück in einen Chat und sagst ihm nicht, welche Datei er als Nächstes öffnen soll.

Agent Canvas geht noch weiter mit Automationen. Sie integrieren sich in Slack, GitHub, Linear und mehr und laufen zeitgesteuert oder als Reaktion auf Webhook-Events.

Aber Autonomie garantiert keine Korrektheit. Du musst Diff und Testergebnisse prüfen, bevor etwas gemergt wird.

So nutzt du OpenHands

Am besten verstehst du OpenHands, wenn du ihm einen Bug gibst und zusiehst, was passiert.

In diesem Abschnitt lasse ich OpenHands lokal in Docker laufen, verbinde es über Ollama mit einem lokalen Modell und lasse es einen Bug in einem kleinen Python-Projekt beheben.

OpenHands einrichten

Du kannst OpenHands auf mehreren Wegen starten:

  • CLI-Launcher: Installiere es mit uv tool install openhands --python 3.14 und starte das GUI mit openhands serve

  • Docker: Starte den App-Container direkt mit einem einzigen docker run Befehl

  • Agent Canvas: Der neuere Browser-Client, der lokale, self-hosted, Cloud- oder Enterprise-Backends verbindet

  • OpenHands Cloud: Die gehostete Variante, wenn du nichts selbst betreiben willst

Ich nutze den Docker-Weg mit dem Local GUI. Die OpenHands-Dokumentation führt es inzwischen als veraltete, Docker-basierte Browser-App und verweist auf Agent Canvas als Ersatz, aber es ist weiterhin dokumentiert und der schnellste Weg zu einer laufenden GUI.

Du brauchst Docker Desktop auf macOS, Linux oder Windows mit WSL. Unter macOS öffnest du Docker Desktop, gehst zu Settings > Advanced und aktivierst den Standard-Docker-Socket.

Dann startest du die App:

docker run -it --rm --pull=always \
  -e AGENT_SERVER_IMAGE_REPOSITORY=ghcr.io/openhands/agent-server \
  -e AGENT_SERVER_IMAGE_TAG=1.26.0-python \
  -e LOG_ALL_EVENTS=true \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v ~/.openhands:/.openhands \
  -p 3000:3000 \
  --add-host host.docker.internal:host-gateway \
  --name openhands-app \
  docker.openhands.dev/openhands/openhands:1.8

OpenHands nutzt das Docker-Socket-Mount, um einen separaten Sandbox-Container zu starten. Der Agent führt seine Befehle in dieser Sandbox aus – nicht auf deinem Host.

Sobald die Logs zeigen, dass der Server läuft, öffne http://localhost:3000 im Browser.

OpenHands-Startseite

OpenHands-Startseite

Ein Modell verbinden

OpenHands macht nichts, bis du ein Modell angibst.

Ich nutze Devstral Small 2, Mistrals 24B-Modell für agentisches Coden. Es ist leicht genug für eine einzelne RTX 4090 oder einen Mac mit 32 GB RAM. Es erfordert Ollama 0.13.3 oder höher.

Starte Ollama mit größerem Kontextfenster und lade das Modell:

OLLAMA_CONTEXT_LENGTH=32768 OLLAMA_HOST=0.0.0.0:11434 ollama serve &
ollama pull devstral-small-2:24b

Unterschätze die Kontextlänge nicht. Der Standard bei Ollama sind 4096 Tokens – zu wenig selbst für den OpenHands-Systemprompt. Die Doku empfiehlt mindestens 22000.

Öffne in OpenHands die Settings, gehe zum Tab LLM und aktiviere Advanced. Stelle dann Folgendes ein:

  1. Custom Model: openai/devstral-small-2:latest

  2. Base URL: http://host.docker.internal:11434/v1

  3. API Key: Ein beliebiger Platzhalterwert, etwa local-llm

LLM-Einstellungen für ein lokales Ollama-Modell

LLM-Einstellungen für ein lokales Ollama-Modell

Das Präfix openai/ weist OpenHands an, über die OpenAI-kompatible API von Ollama zu kommunizieren. Der API-Schlüssel wird nicht genutzt, das Feld darf aber nicht leer sein.

Ein Repository öffnen

OpenHands sieht deine Dateien nicht automatisch. Du musst das Projekt in die Sandbox mounten.

Für dieses Beispiel brauchst du einen Ordner budget-tracker/project mit zwei Dateien. Die erste summiert Ausgaben pro Monat:

# budget.py
def monthly_totals(transactions):
    """Sum spending per month, keyed as 'YYYY-MM'.

    Each transaction is a (date, amount) tuple, for example ("2025-01-15", 42.0).
    """
    totals = {}
    for date, amount in transactions:
        month = date[5:7]
        totals[month] = totals.get(month, 0) + amount
    return totals

Die Docstring verspricht Keys im Format YYYY-MM, aber date[5:7] behält nur den Monat. Januar 2025 und Januar 2026 landen im selben Bucket.

Die zweite Datei enthält zwei Tests, die den Bug aufdecken:

# test_budget.py
from budget import monthly_totals


def test_same_month_in_different_years():
    transactions = [
        ("2025-01-10", 50.0),
        ("2025-01-20", 100.0),
        ("2026-01-12", 60.0),
    ]
    assert monthly_totals(transactions) == {"2025-01": 150.0, "2026-01": 60.0}


def test_single_month():
    transactions = [("2026-03-01", 20.0), ("2026-03-15", 5.5)]
    assert monthly_totals(transactions) == {"2026-03": 25.5}

Mach den Ordner zu einem Git-Repository, damit du später siehst, was der Agent geändert hat:

cd budget-tracker
git init
git add .
git commit -m "Initial commit"

Wenn du jetzt python -m pytest ausführst, schlagen beide Tests fehl:

Fehlschlagende Tests

Fehlschlagende Tests

Um OpenHands Zugriff zu geben, stoppe den Container und füge dem docker run Befehl eine Zeile hinzu:

-e SANDBOX_VOLUMES=$HOME/budget-tracker:/workspace:rw \

Der vollständige Befehl lautet nun:

docker run -it --rm --pull=always \
  -e AGENT_SERVER_IMAGE_REPOSITORY=ghcr.io/openhands/agent-server \
  -e AGENT_SERVER_IMAGE_TAG=1.26.0-python \
  -e LOG_ALL_EVENTS=true \
  -e SANDBOX_VOLUMES=$HOME/Desktop/budget-tracker:/workspace:rw \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v ~/.openhands:/.openhands \
  -p 3000:3000 \
  --add-host host.docker.internal:host-gateway \
  --name openhands-app \
  docker.openhands.dev/openhands/openhands:1.8

Das Format ist host_path:container_path:mode. Dein Projekt erscheint in der Sandbox unter /workspace, und rw erlaubt dem Agenten, es zu bearbeiten.

Mount nur das Projekt, das der Agent ändern soll. Alles, was read-write unter /workspace gemountet ist, kann vom Agenten geändert werden.

Dem Agenten eine Aufgabe geben

Starte eine neue Konversation und beschreibe das Problem wie in einem Bug-Report:

Die monatlichen Summen fassen Ausgaben desselben Monats aus verschiedenen Jahren zusammen.

Finde die Ursache, behebe sie und führe die Tests aus, um den Erfolg zu bestätigen.

Das war’s. Du musst den Agenten nicht auf budget.py hinweisen oder sagen, welche Zeile falsch ist.

Konversationsausgabe

Konversationsausgabe

Ab hier übernimmt die oben beschriebene Agentenschleife. Der Agent durchsucht /workspace, liest beide Dateien und führt die Tests aus, um die Fehler zu sehen. Dann bearbeitet er den Code und führt die Tests erneut aus.

Der Agent führt pytest im Sandbox-Terminal aus

Der Agent führt pytest im Sandbox-Terminal aus

Änderungen prüfen

Der Agent meldet, dass er fertig ist. Du kannst dir jetzt die Unterschiede ansehen, indem du den Code-Editor öffnest und die Änderungen inspizierst.

Der korrekte Fix ist eine Zeile in budget.py:

month = date[:7]

Budget.py behoben

Budget.py behoben

Du kannst dir die Unterschiede auch mit git diff anzeigen lassen.

Darauf solltest du achten:

  • Quellcode: Der Fix sollte in budget.py stehen

  • Tests: Stelle sicher, dass der Agent test_budget.py nicht angepasst hat, nur damit die Assertions grün werden

  • Testlauf: Führe python -m pytest selbst aus – verlass dich nicht auf die Zusammenfassung des Agenten

OpenHands-Architektur

OpenHands hat sechs Hauptkomponenten, und jede hat eine klare Aufgabe.

So sind die OpenHands-Komponenten verbunden

So sind die OpenHands-Komponenten verbunden

KI-Modell

Das Modell übernimmt das Reasoning. Es erhält die Aufgabe und den Gesprächsverlauf und antwortet entweder mit einer Nachricht oder einem Toolaufruf.

Das Modell ändert keine Dateien und führt nichts aus. Es entscheidet nur, was als Nächstes passieren soll. Modellaufrufe laufen über LiteLLM, sodass derselbe Agent mit gehosteten Providern oder einem lokalen Modell wie dem Devstral-Setup aus dem Artikel funktioniert.

Agentenlogik

Der Agent sitzt zwischen dem Modell und allem anderen. Er betreibt die Reasoning-Action-Schleife: Er fragt das Modell nach der nächsten Aktion, führt das Tool aus und verarbeitet Ergebnis oder Fehler.

Er entscheidet auch, was das Modell sieht. Der Agent verwaltet den Gesprächsverlauf mit Kondensatoren und ergänzt Skills und Prompts bei jeder Modellanfrage.

Jeder Schritt wird protokolliert. Der Agent führt Aktionen aus und erhält Beobachtungen zurück, und die Konversation hält diese Ereignishistorie fest. Das Modell sieht diese Ereignisse im nächsten Zug und weiß so, was bereits passiert ist.

Tools und Aktionen

Über Tools wirkt der Agent außerhalb des Modells. Der Standard umfasst Terminal, Dateieditor und Task-Tracker; über MCP-Server lässt sich mehr hinzufügen.

Das Modell fordert eine Aktion an, etwa "pytest ausführen" oder "Zeile 8 in budget.py ersetzen". Das Tool führt sie aus und liefert eine Beobachtung zurück, z. B. die Testausgabe oder die aktualisierte Datei.

Vor der Ausführung erfolgt ein Sicherheitscheck. Der Security Analyzer bewertet jede Aktion und kann den Agenten für deine Freigabe pausieren.

Entwicklungsumgebung

Tools laufen nicht auf deinem Host, sondern in einer Sandbox.

Im Docker-Setup läuft der Agent Server in einem eigenen Docker-Container. Deshalb mountet der Artikel den Docker-Socket – der App-Container braucht ihn, um die Sandbox zu starten.

Die Sandbox muss nicht lokal sein. Agenten können auch in kurzlebigen Workspaces laufen, z. B. in Docker oder Kubernetes, und der Agent Server stellt Ausführung, Tools und Workspaces über REST- und WebSocket-APIs bereit. Die Agentenlogik bleibt gleich, egal wo die Sandbox läuft.

Repository

Am Repository arbeitet der Agent. Es gelangt auf zwei Arten in die Sandbox: als lokaler, gemounteter Ordner wie im Artikel oder über ein Repo, das per GitHub-, GitLab- oder Bitbucket-Integration verbunden ist.

Ein Repository kann dem Agenten auch Anweisungen geben. Eine AGENTS.md auf Root-Ebene wird zu Beginn in den Systemprompt injiziert. Präzisere Anweisungen kommen in .agents/skills/ – der Agent sieht zuerst eine Zusammenfassung und lädt den Vollinhalt nur bei Bedarf.

Hier platzierst du Projektregeln, die der Agent nicht erraten kann, etwa "Tests mit make test statt mit pytest ausführen."

Menschliche Prüfung

Du bist der letzte Teil der Architektur.

OpenHands unterstützt drei Bestätigungsrichtlinien: jede Aktion freigeben, nie freigeben oder nur riskante Aktionen freigeben. Letzteres hängt vom Security Analyzer ab, der Aktionen als LOW, MEDIUM, HIGH oder UNKNOWN einstuft. Standard ist NeverConfirm, also läuft der Agent ohne Stopp, bis du es änderst.

Die zweite Prüfstelle liegt am Ende. Die Arbeit des Agenten ist erst erledigt, wenn du den Diff gelesen und die Tests geprüft hast.

OpenHands-Workflows

Ich habe dir eine Ein-Zeilen-Korrektur gezeigt – natürlich kann OpenHands deutlich größere Aufgaben bewältigen.

Gemeinsam ist ihnen, dass sie mehr als einen Schritt erfordern. Sechs Arbeitstypen, bei denen die Agentenschleife Sinn ergibt:

Bugs beheben

Der hier gezeigte Bug war leicht in einer Datei zu erkennen. Im echten Leben ist das fast nie so.

Angenommen, Logs zeigen in Produktion einen KeyError, und der Stacktrace verweist auf eine Funktion drei Aufrufe entfernt von der Stelle, an der fehlerhafte Daten reinkommen. Du fügst den Stacktrace in OpenHands ein und bittest um einen Fix.

Der Agent verfolgt die Aufrufkette bis zur Datenquelle zurück, schreibt einen reproduzierbaren Test und bestätigt, dass er fehlschlägt. Dann behebt er den Code und führt die gesamte Testsuite aus, um Regressionen auszuschließen.

Ein Reproduktionstest ist der Punkt, auf den du achten solltest. Er beweist, dass der Agent den eigentlichen Bug gefunden hat – nicht nur die Stelle, an der der Fehler sichtbar wird.

Features implementieren

Feature-Arbeit ändert meist mehr Dateien, als man erwartet.

Ein Reportskript für die Kommandozeile braucht z. B. ein --since Flag, um Transaktionen nach Datum zu filtern. Der Agent muss den Argumentparser finden, das Flag hinzufügen, den Wert an die Filterlogik übergeben und den Hilfetext aktualisieren. Danach schreibt er Tests für das neue Verhalten und passt die README an.

Für ein kleines Feature sind das vier bis fünf Dateien. Der Agent behält sie in seinem Task-Tracker im Blick, sodass er nicht aufhört, sobald die erste Stelle funktioniert.

Refactoring

Refactoring verändert die Struktur, nicht das Verhalten – und die Testsuite belegt, dass das Verhalten gleich blieb.

Ein Projekt hat etwa eine große utils.py mit Date-, String- und File-Helpern durcheinander. Du bittest OpenHands, sie in drei Module aufzuteilen.

Der Agent erstellt die neuen Module, verschiebt die Funktionen und aktualisiert alle Imports im Code. Nach jedem Schritt laufen die Tests. So erkennt er, welcher Schritt etwas kaputt gemacht hat.

Tests schreiben

Ungetesteter Code ist ein typischer Startpunkt, weil Aufgabe und Verifikation klar sind.

Ein Modul zur Datumsverarbeitung hat etwa keine Tests. Der Agent liest die Funktionen, schreibt pytest-Cases für Normalfälle und Randfälle wie leere Strings, Schaltjahre und ungültige Formate und führt sie aus.

Schlägt ein neuer Test fehl, muss der Agent entscheiden, ob der Test falsch ist oder der Code einen Bug hat. Diese Entscheidung solltest du selbst prüfen.

Bestehende Codebasen untersuchen

Nicht jede Aufgabe erfordert Codeänderungen.

Du kannst OpenHands Fragen stellen wie: "Wo validiert diese App Nutzereingaben, bevor sie die Datenbank erreichen?" Der Agent durchsucht die Codebasis, folgt Funktionsaufrufen über Dateien hinweg und antwortet mit Pfaden und Zeilenangaben.

Praktisch, wenn du in ein neues Projekt einsteigst oder Code nach Monaten wieder anfasst. Für reine Leseaufgaben mounte das Repo mit Modus :ro statt :rw – so kann der Agent nichts verändern, auch nicht versehentlich.

Anwendungen ausführen und debuggen

Manche Bugs zeigen sich nur im laufenden Betrieb.

Ein API-Endpunkt gibt z. B. einen 500er zurück, und die Tests decken ihn nicht ab. Der Agent startet den Server in seinem Terminal, sendet eine Anfrage mit curl und liest den Traceback aus den Serverlogs.

Dann behebt er den Code, startet den Server neu und sendet die gleiche Anfrage erneut. Ist die Antwort noch falsch, läuft die Schleife weiter.

Das ist derselbe Edit-Run-Check-Zyklus, den du selbst durchläufst – nur dass der Agent jeden Neustart und jeden Retry übernimmt.

OpenHands im Vergleich zu anderen KI-Coding-Agenten

OpenHands ist nicht das einzige Tool, das eine Aufgabe übernehmen und selbstständig abarbeiten kann. Claude Code, Cursor und GitHub Copilot haben inzwischen Agent-Funktionen – unterscheiden sich aber in wichtigen Punkten.

OpenHands vs. Claude Code

Die beiden sind sich am ähnlichsten. Beide betreiben eine Agentenschleife, die Code liest, Dateien bearbeitet, Befehle ausführt und Ergebnisse prüft.

Der erste Unterschied ist die Inhaberschaft. Jedes öffentliche OpenHands-Repository hat eine eigene Open-Source-Lizenz, und du kannst alles lesen, ändern und selbst hosten. Claude Code ist Anthropics proprietäres agentisches Coding-Tool, verfügbar im Terminal, in IDE, Desktop-App und Browser.

Das führt zur Modellfrage. Claude Code baut auf Claude-Modellen von Anthropic. OpenHands arbeitet mit jedem von LiteLLM unterstützten Provider – inklusive des lokalen Ollama-Setups aus dem Artikel.

Auch der Alltag unterscheidet sich. Claude Code startete als Terminal-Tool – dort nutzen es viele Entwickler immer noch. OpenHands setzt auf seine Browser-UI; die CLI ist funktionsvoll, wird aber vorrangig stabil gehalten.

Beide Tools lassen dich das Agentenverhalten steuern. Claude Code liest CLAUDE.md, Settings, Hooks, Skills, Commands und Subagenten aus dem Verzeichnis .claude. OpenHands liest AGENTS.md und Skills aus dem Repository, und mit dem SDK kannst du eigene Agenten in Python bauen.

Autonomie wird unterschiedlich geregelt. Claude Code steuert die Toolnutzung mit Permission-Modes, Hooks sowie Allow/Deny-Regeln und kann Befehle sandboxen. OpenHands führt standardmäßig alles in einer Docker-Sandbox aus und ergänzt Bestätigungsrichtlinien.

Kurz: Claude Code ist die polierte Option zum direkten Einsatz, OpenHands erfordert mehr Setup und gibt dir dafür mehr Kontrolle. Beides schließt sich nicht aus – Agent Canvas kann Claude Code als Agent anstelle des Standard-OpenHands-Agenten nutzen.

OpenHands vs. Cursor

Cursor ist ein KI-Code-Editor. OpenHands ist eine Agentenplattform. Das ist der Hauptunterschied, und die meisten weiteren leiten sich daraus ab.

In Cursor arbeitest du im Editor, der Agent arbeitet neben dir. Du siehst Änderungen in deinen Dateien, nimmst sie an oder lehnst sie ab und tippst weiter. In OpenHands beschreibst du eine Aufgabe, der Agent arbeitet in einer Sandbox, und du prüfst das Ergebnis. Die GUI enthält zwar eine VS-Code-Ansicht in die Sandbox, aber dort passiert nicht der Hauptteil der Arbeit.

Auch der Repository-Zugriff folgt dieser Trennung. Der Cursor-Agent arbeitet am Code, der im Editor geöffnet ist. OpenHands arbeitet an dem, was du in die Sandbox mountest oder über eine Git-Integration verbindest.

Mit Cursors Cloud Agents schrumpft die Lücke. Sie laufen unbeaufsichtigt in der Cloud und liefern Arbeit über Branches und Pull Requests zurück – benötigen aber einen verbundenen GitHub-, GitLab-, Azure-DevOps- oder Bitbucket-Account und einen kostenpflichtigen Plan. Das ist nah an OpenHands – nur auf Cursors Infrastruktur.

Am meisten unterscheiden sie sich bei der Erweiterbarkeit. Cursor unterstützt MCP-Server und Projektregeln, Editor und Agent sind aber geschlossene Produkte. Mit OpenHands kannst du den Agenten selbst ändern, überall hosten und auf ein lokales Modell setzen.

OpenHands vs. GitHub Copilot

GitHub Copilot begann als Autocomplete im Editor und hat daraus Agent-Funktionen entwickelt. OpenHands startete direkt als Agent.

Copolots größte Stärke ist, wo es lebt. Es arbeitet in VS Code und JetBrains-IDEs, und sein Cloud-Agent wirkt direkt auf GitHub. OpenHands hat diese IDE-Integration nicht.

Für Repository-Aufgaben ist der Copilot-Cloud-Agent der nächste Vergleich. Du weist ihm ein Issue zu, und er arbeitet in einer eigenen, kurzlebigen Entwicklungsumgebung, betrieben von GitHub Actions, wo er Tests und Linter ausführen kann, bevor er pusht. OpenHands Cloud macht Ähnliches, wenn du @openhands in einem Issue- oder PR-Kommentar erwähnst.

Die Plattform ist der Hauptunterschied. Der Copilot-Cloud-Agent ist für alle kostenpflichtigen Copilot-Pläne in Repositories auf GitHub verfügbar. OpenHands funktioniert mit GitHub, GitLab, Bitbucket oder einem lokalen Ordner und kann bei Bedarf auf deiner eigenen Hardware laufen.

Bei Copilot kannst du zwar ein Modell für eine Aufgabe wählen, aber nur aus den von GitHub angebotenen. OpenHands hat diese Einschränkung nicht.

Hier die Kurzfassung:

 OpenHandsClaude CodeCursorGitHub Copilot
SourceOpen SourceProprietärProprietärProprietär
ModelsJeder LiteLLM-Provider, inkl. lokalClaude-ModelleMehrere Provider plus Inhouse-ModelleVon GitHub angebotene Modelle
Main interfaceBrowser-UI, SDKTerminal, IDE, Desktop, BrowserKI-Code-EditorIDE-Erweiterung, GitHub
Where the agent runsDocker-Sandbox, lokal oder remoteDein Gerät oder Anthropics CloudDein Editor oder Cursors CloudDeine IDE oder GitHub Actions
Self-hostingJaNeinNur EnterpriseNein

OpenHands im Vergleich zu anderen KI-Agenten

OpenHands für Software-Engineering-Teams

Für einzelne Entwickler ist OpenHands ein Tool, das du bei Bedarf öffnest. Für Teams gilt das nicht.

Die meisten Teams organisieren Arbeit bereits über Issues – und OpenHands Cloud dockt dort an. Es integriert sich in GitHub, GitLab und Bitbucket sowie Slack, Jira und Linear. Du kannst @openhands in einem Issue- oder PR-Kommentar erwähnen, und der Agent übernimmt von dort.

Dann gibt es Arbeiten, die keiner explizit beauftragt, die aber alle brauchen. Agent-Canvas-Automationen laufen zeitgesteuert oder auf Webhook-Events. Zum Beispiel kann ein Team einen Agent Server für Code-Review und Dependency-Updates teilen, während jede Person persönliche Agenten auf dem eigenen Laptop betreibt.

Das Testen funktioniert wie im Artikel. Der Agent führt die Testsuite in seiner Sandbox aus, bevor er zurückmeldet. Der Sandbox-Lauf ersetzt aber kein CI – deine Pipeline läuft weiter bei jedem Pull Request, genauso wie bei von Menschen geschriebenem Code.

Auch Pull Requests sind wichtig. Wenn OpenHands Cloud mit GitHub arbeitet, fordert es kurzlebige Tokens an, die nach acht Stunden ablaufen, mit Lese- und Schreibzugriff auf Contents, Issues, Pull Requests und Workflows. In selbst gehosteten Enterprise-Setups nutzt der Agent die GitHub-Autorisierung der auslösenden Person – so ist jede Änderung zuordenbar.

So sollte Verantwortung funktionieren. Der Agent kann den PR eröffnen, aber ein Entwickler gibt ihn frei. Branch Protection und Pflichtreviews gelten für Agent-PRs genauso wie für alle anderen.

Isolierte Umgebungen machen das skalierbar. Jede Aufgabe läuft in ihrer eigenen Sandbox – zwei Agenten, die zwei Bugs beheben, überschreiben sich nicht und streiten nicht um denselben Port.

OpenHands: Sicherheit und Sandbox

Ein Code-Completion-Tool schlägt immer nur Text vor – du entscheidest, ob du ihn annimmst.

Ein Agent ist anders. Er durchforstet dein Projekt, führt Befehle aus, installiert Pakete und ändert Dateien eigenständig, oft ohne zu fragen. Die Frage verschiebt sich also von "Ist dieser Code korrekt?" zu "Welche Befehle hat der Agent dafür ausgeführt?"

Isolierte Ausführungsumgebungen

Die Docker-Sandbox schützt Host-Dateien und -Programme, Ressourcen und andere Container und Prozesse. Führt der Agent destruktive Befehle aus, sind sie auf den Container beschränkt.

Eine Ausnahme im lokalen Setup: Der App-Container mountet den Docker-Socket des Hosts, um Sandboxes zu starten. Zugriff auf diesen Socket bedeutet Kontrolle über Docker auf deiner Maschine.

Repository-Berechtigungen

Die Sandbox schützt nur, was du nicht mountest. Gemountete Dateien und Verzeichnisse können geändert oder gelöscht werden.

Mounte nur das Projekt, an dem du arbeitest – niemals dein Home-Verzeichnis. Für Leseaufgaben nutze den Modus :ro . Bei Git-Integrationen gib dem Agenten nur Zugriff auf die konkreten Repositories, die er braucht.

Secrets und Zugangsdaten

Wenn du Credentials bereitstellst, kann der Agent sie nutzen. Ein Agent, der ein Secret lesen kann, kann es auch in Logs ausgeben oder irgendwohin senden.

Mounte daher keine Ordner mit .env-Dateien mit Produktions-Keys. Gib dem Agenten Test-Credentials mit begrenztem Scope und rotiere sie häufig.

Netzwerkzugriff

Standardmäßig kann der Agent aus dem Container ins Internet. Das braucht er für Paketinstallationen – kann aber auch beliebige externe Services erreichen.

Damit entsteht Prompt Injection als Risiko. Eine Webseite oder ein Issue-Kommentar kann Anweisungen enthalten, denen der Agent folgen könnte. GitHub reduziert dieses Risiko für seinen Cloud-Agent mit einer Firewall, die Internetzugriffe standardmäßig einschränkt – Ähnliches solltest du für dein OpenHands-Setup erwägen.

Befehlsausführung

Du kannst steuern, welche Befehle ohne Freigabe laufen. OpenHands unterstützt drei Bestätigungsrichtlinien: alles genehmigen, nichts genehmigen oder nur riskante Aktionen genehmigen. Standard ist NeverConfirm.

Die Option "riskante Aktionen" hat einen Haken. Der standardmäßige LLM-Sicherheitsanalysator nutzt die Risikoeinstufung, die das Modell seinen eigenen Aktionen gibt. Ein destruktiver Befehl kann als LOW markiert werden und läuft dann ohne Nachfrage. Der Analyzer klassifiziert das Risiko für die Policy-Schicht – er blockiert nichts von sich aus. Die Doku empfiehlt, ihn mit Docker-Isolation zu kombinieren.

Generierte Änderungen prüfen

Alles oben begrenzt, was der Agent tun kann. Die Prüfung ist wichtig, weil du damit kontrollierst, was er getan hat.

Lies den kompletten Diff – nicht nur die Dateien, deren Änderung du erwartet hast. Achte besonders auf CI-Konfiguration, Abhängigkeitsdateien und Skripte. In OpenHands Cloud hat das GitHub-Token des Agenten Schreibrechte auf Workflows – Änderungen in .github/workflows können also deine Pipeline verändern.

Einschränkungen von OpenHands

Auch der von OpenHands geschriebene Code kann Bugs enthalten. Bestehende Tests zu bestehen, heißt nur, dass der Code zu den Tests passt – der Agent kann beides schreiben. Sind die Tests schwach, kann der Code grün sein und trotzdem falsch.

Komplexe Aufgaben brauchen oft dich in der Schleife. Unklare Anforderungen oder eine Designentscheidung, die der Agent nicht treffen kann, stoppen ihn oder – schlimmer – schicken ihn in die falsche Richtung.

Mit einem starken gehosteten Modell bewältigt OpenHands Multi-File-Aufgaben gut. Mit einem kleinen lokalen Modell siehst du fehlschlagende Toolaufrufe und Chatbot-artige Antworten – und selbst mit großem Kontextfenster können manche lokalen Modelle Tools nicht zuverlässig nutzen.

Agentenschleifen kosten auch mehr als Chat. Jeder Schritt sendet den Gesprächsverlauf erneut an das Modell, und lange Aufgaben benötigen viele Schritte. Die Doku warnt, dass der Agent viele Prompts ans LLM sendet, und empfiehlt Ausgabenlimits sowie Usage-Monitoring. Der Kontextkondensator hilft, fasst aber ältere Schritte zusammen – Details können bei langen Aufgaben verloren gehen.

Toolzugriff erhöht das Sicherheitsrisiko. Ein Agent mit Terminal- und Netzwerkzugriff kann echten Schaden anrichten, wenn er schlechten Anweisungen folgt – daher sind Sandbox und deine Prüfung so wichtig.

Und jede Änderung braucht weiterhin eine menschliche Freigabe. Behalte das immer im Hinterkopf.

OpenHands und die Zukunft von KI-Coding-Agenten

KI-Coding-Tools haben sich von Autocomplete über Chat bis zu Agenten entwickelt, die komplette Aufgaben übernehmen. OpenHands gehört zu den Projekten, die diesen letzten Schritt vorantreiben.

Die Richtung ist branchenweit sichtbar. Cursor beschreibt eine neue Ära, in der autonome Cloud-Agenten größere Aufgaben über längere Zeiträume übernehmen. Copilot nimmt inzwischen Issues aus GitHub und Linear. Claude Code läuft im Terminal, Browser und in Slack.

Open-Source-Plattformen haben in diesem Wandel eine besondere Rolle. Mit OpenHands kannst du verstehen, wie der Agent arbeitet, ihn auf deiner eigenen Infrastruktur betreiben und das Modell wählen. Für Teams mit strengen Datenvorgaben ist das oft die einzige zulässige Option.

Längere Aufgaben bringen neue Probleme. Ein Agent, der eine Stunde arbeitet, trifft mehr Entscheidungen als einer, der eine Minute arbeitet – und jede Entscheidung ist eine Chance, sich vom Ziel zu entfernen. Bessere Modelle helfen, aber auch Sandboxes, Bestätigungsrichtlinien und Reviews.

Fazit

Der entscheidende Unterschied von OpenHands ist Kontrolle. Du kannst den Quellcode lesen, ihn auf eigener Hardware hosten und mit jedem Modell betreiben – auch lokal. Schlankere, kommerzielle Tools wie Claude Code, Cursor und GitHub Copilot bieten ein rundes Erlebnis – aber zu ihren Bedingungen.

Doch ein Agent mit Zugriff auf dein Terminal und deine Repositories braucht weiterhin jemanden, der seine Arbeit prüft. Lies immer den Diff und führe die Tests selbst aus.

Wenn du lernen willst, wie du deinen Agenten von Grund auf baust, sieh dir unser Webinar Introduction to Creating AI Agents in Python an.

Dario Radečić

Autor

Dario Radečić

Senior Data Scientist mit Sitz in Kroatien. Top Tech Writer mit über 700 veröffentlichten Artikeln, die mehr als 10 Millionen Mal aufgerufen wurden. Buchautor von Machine Learning Automation with TPOT.

FAQs

Was ist OpenHands?

OpenHands ist eine Open-Source-Plattform zum Erstellen und Ausführen von KI-Agenten, die mit Code arbeiten. Der Coding-Agent kann ein Repository inspizieren, Dateien bearbeiten, Befehle und Tests ausführen und auf den Ergebnissen iterieren, bis eine Aufgabe erledigt ist. Du kannst ihn lokal in Docker, über das SDK oder in OpenHands Cloud betreiben.

Ist OpenHands kostenlos nutzbar?

Die OpenHands-Software ist Open Source, daher kannst du sie ohne Lizenzkosten selbst hosten. Kosten entstehen beim Modell – gehostete Anbieter wie Anthropic oder OpenAI rechnen pro Token ab, und Agentenschleifen verbrauchen viele davon. Wenn du ein lokales Modell über Ollama oder LM Studio betreibst, fallen nur Hardwarekosten an. OpenHands Cloud ist ein separater, kommerzieller Dienst.

Worin unterscheidet sich OpenHands von GitHub Copilot oder Cursor?

Copilot und Cursor sind rund um den Editor gebaut – die KI arbeitet neben dir, während du Code schreibst. OpenHands ist Agent-first: Du beschreibst eine Aufgabe, der Agent arbeitet in einer Sandbox, und du prüfst das Ergebnis. Außerdem ist es Open Source, funktioniert mit jedem von LiteLLM unterstützten Modell und läuft auf deiner eigenen Infrastruktur – was weder Copilot noch Cursor in diesem Umfang bieten.

Kann ich OpenHands mit einem lokalen Modell betreiben?

Ja. OpenHands verbindet sich über OpenAI-kompatible APIs mit lokalen Servern wie LM Studio, Ollama, vLLM und SGLang. Wähle ein Modell für agentisches Coden, etwa Devstral Small 2 oder Qwen3.6-35B-A3B, und setze das Kontextfenster auf mindestens 22000 Tokens. Kleinere Generalistenmodelle scheitern oft bei Toolaufrufen und klingen wie ein Chatbot.

Ist es sicher, OpenHands Zugriff auf meinen Code zu geben?

OpenHands führt die Befehle des Agenten in einer Docker-Sandbox aus, die dein Hostsystem vor den meisten Fehlern schützt. Aber alles, was du in die Sandbox mountest, kann geändert oder gelöscht werden, und bereitgestellte Zugangsdaten kann der Agent nutzen. Standardmäßig fragt der Agent vor Aktionen nicht nach Freigabe. Mounte daher nur das benötigte Projekt, verwende begrenzte Test-Credentials und prüfe jeden Diff, bevor du mergest.

Themen

Ähnlich