Ga naar hoofdinhoud

OpenHands: De open-source AI-codeeragent uitgelegd

Een overzicht van OpenHands, de open-source AI-codeeragent, met de architectuur, een lokale setup met Ollama, een hands-on bugfix, beveiliging en beperkingen, en een vergelijking met Claude Code, Cursor en GitHub Copilot.
· 15 min lezen

Verken met AI

OpenHands is een open-source platform voor AI-gedreven softwareontwikkeling, gebouwd rond een agent die je repository kan inspecteren, bestanden bewerken, commando's uitvoeren en tests draaien. Het maakt deel uit van de verschuiving naar agentische softwareontwikkeling: jij geeft de agent een volledige taak, en die werkt stap voor stap door tot het klaar is of jouw input nodig heeft.

In dit artikel neem ik je mee door de architectuur van OpenHands en de belangrijkste features, laat ik zien hoe je het instelt met een lokaal model en vergelijk ik het met Claude Code, Cursor en GitHub Copilot.

Wat zijn AI-agents? Schrijf je in voor ons AI Agent Fundamentals-track om te ontdekken hoe AI-agents je manier van werken kunnen veranderen.

Wat is OpenHands?

OpenHands is een open-source platform voor het bouwen en draaien van AI-agents die met code werken.

De naam verwijst naar twee dingen. Ten eerste het project: een verzameling repositories met een SDK, een server, een browser-UI en een hosted service. Ten tweede de codeeragent die daar bovenop draait.

Zo werkt het:

  • Software Agent SDK: Een set Python- en REST-API's voor het bouwen van agents die met code werken, en de motor achter de OpenHands CLI en OpenHands Cloud
  • Agent Server: Stelt agent-executie, conversaties, tools en workspaces beschikbaar via REST- en WebSocket-API's
  • Agent Canvas: Eén browser-UI voor conversaties, bestanden, terminaloutput, modelconfiguratie, backends en automatiseringen
  • OpenHands Cloud: De beheerde commerciële service voor teams die geen eigen backend- en sandboxinfrastructuur willen draaien

Als mensen "OpenHands" zeggen, bedoelen ze meestal de agent. Met dat onderdeel werk ik in dit artikel.

Meestal geef je de agent een softwaretaak, wijs je naar een workspace met je code, en werkt die de taak af met de tools die beschikbaar zijn. Standaard zijn dat een terminal, een bestandseditor en een tasktracker.

De workspace hoeft niet je laptop te zijn. Agents kunnen de lokale machine als workspace gebruiken of draaien in efemere workspaces, bijvoorbeeld in Docker of Kubernetes.

OpenHands bindt je ook niet aan één modelprovider. Je kunt het gebruiken met Claude, GPT of een ander LLM, inclusief lokale modellen. Agent Canvas draait zelfs agents van derden zoals Claude Code en Codex in plaats van de standaard OpenHands-agent.

Kortom, OpenHands is een open agentplatform dat je op je eigen voorwaarden kunt draaien.

Hoe OpenHands werkt

OpenHands draait in een lus.

Een chatassistent krijgt je prompt en geeft tekst terug. De OpenHands-agent krijgt een taak, onderneemt een actie, bekijkt het resultaat en beslist wat de volgende stap is.

De OpenHands-agentlus

De OpenHands-agentlus

Dit is het algemene idee:

  • Ontvang de taak: Je beschrijft het doel in gewone taal, bijvoorbeeld "Fix de maandelijkse rapportage zodat maanden uit verschillende jaren niet samengevoegd worden"
  • Inspecteer de repository: De agent somt mappen op, opent bestanden en zoekt naar code die met de taak te maken heeft
  • Maak een plan: Het splitst de taak in stappen en noteert die in de tasktracker
  • Bewerk of maak bestanden: Het past de code aan met de bestandseditor
  • Draai commando's en tests: Het draait de testsuite of de app in de terminal
  • Inspecteer de resultaten: Het leest de output, inclusief fouten en gefaalde assertions
  • Itereer: Als er nog iets stuk is, gaat het terug, past het plan aan en probeert het opnieuw

De lus stopt wanneer de taak klaar is, of wanneer de agent iets nodig heeft dat alleen jij kunt leveren, zoals ontbrekende credentials of een beslissing over requirements.

Stap 6 maakt OpenHands anders dan de concurrentie. Een codeaanvullingstool ziet nooit wat er gebeurt als de voorgestelde code draait. OpenHands wel, waardoor het kan reageren op een gefaalde test en de oorzaak kan fixen.

Belangrijkste features van OpenHands

Autocomplete stelt tekst voor, en OpenHands voert acties uit op je project. Zo werkt dat.

Code bewerken

OpenHands bewerkt bestanden rechtstreeks en is niet beperkt tot één bestand tegelijk.

Stel dat een functie een nieuwe naam nodig heeft. De agent werkt de definitie bij, vindt elke aanroep en past de tests aan die ernaar verwijzen - allemaal binnen één taak.

Terminal- en toolgebruik

De agent heeft een eigen terminal. Hij kan dependencies installeren, scripts draaien, tests uitvoeren en de output van elk commando lezen.

Je kunt ook MCP (Model Context Protocol)-servers koppelen om de agent tools te geven waar hij niet voor ontworpen is, bijvoorbeeld een issuetracker of een databaseclient.

Repositorybegrip

De meeste codegeneratoren zien alleen wat je in de prompt plakt.

OpenHands opent de repository en verkent die. Het kan de README lezen, imports volgen en naar bestaande tests kijken om te begrijpen hoe het project is opgebouwd. Daardoor sluiten de wijzigingen waarschijnlijk beter aan op de bestaande code.

Lange taken geven een ander probleem: de conversatiegeschiedenis groeit voorbij wat het model kan vasthouden. OpenHands lost dit op met een contextcondenser, die oudere delen van de conversatie samenvat zodat de agent kan doorwerken.

Modelkeuze

Modelaanroepen lopen via LiteLLM, dus je kunt elke provider en elk model gebruiken dat het ondersteunt. De OpenHands-docs raden modellen aan uit de Claude-, GPT- en Gemini-families, plus open-weight modellen die hoog scoren op de OpenHands Index.

Als je code je machine niet mag verlaten, kun je een lokaal model draaien. OpenHands verbindt met lokale servers zoals LM Studio, Ollama, vLLM en SGLang.

Onthoud wel dat het model de resultaten sterk beïnvloedt. Sommige lokale modellen hebben moeite met betrouwbaar toolgebruik, zelfs met een groot contextvenster.

Autonome taakuitvoering

Zodra je een taak overdraagt, werkt de agent zelfstandig de lus af. Je hoeft geen fouten in een chat te plakken of te zeggen welk bestand daarna open moet.

Agent Canvas gaat nog een stap verder met automatiseringen. Ze integreren met Slack, GitHub, Linear en meer, en draaien op schema of als reactie op webhooks.

Maar autonomie garandeert geen correctheid. Je moet nog steeds de diff en de testresultaten reviewen voordat er iets gemerged wordt.

Hoe gebruik je OpenHands

De beste manier om OpenHands te begrijpen is het een bug geven en kijken wat er gebeurt.

In deze sectie draai ik OpenHands lokaal in Docker, koppel ik het aan een lokaal model via Ollama en vraag ik het om een bug te fixen in een klein Python-project.

OpenHands instellen

Je kunt OpenHands op een paar manieren draaien:

  • CLI-launcher: Installeer met uv tool install openhands --python 3.14 en start de GUI met openhands serve

  • Docker: Draai de appcontainer direct met één docker run-commando

  • Agent Canvas: De nieuwere browserclient die verbindt met lokale, self-hosted, Cloud- of Enterprise-backends

  • OpenHands Cloud: De hosted versie, als je liever niets zelf draait

Ik gebruik de Docker-route met de Local GUI. De OpenHands-docs noemen dit nu de verouderde Docker-gebaseerde browserapplicatie en verwijzen naar Agent Canvas als vervanging, maar het is nog steeds gedocumenteerd en de snelste manier om een GUI te draaien.

Je hebt Docker Desktop nodig op macOS, Linux of Windows met WSL. Op macOS open je Docker Desktop, ga je naar Settings > Advanced en schakel je de standaard Docker-socket in.

Start vervolgens de 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 gebruikt de Docker-socketmount om een aparte sandboxcontainer te starten, en de agent draait zijn commando's binnen die sandbox, niet op je host.

Zodra de logs laten zien dat de server draait, open je http://localhost:3000 in je browser.

OpenHands-welkomstpagina

OpenHands-welkomstpagina

Verbind een model

OpenHands doet niets totdat je een model opgeeft.

Ik gebruik Devstral Small 2, Mistral's 24B-model gebouwd voor agentisch coderen. Het is licht genoeg voor een enkele RTX 4090 of een Mac met 32GB RAM. Vereist Ollama 0.13.3 of later.

Start Ollama met een groter contextvenster en pull het model:

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

Negeer de contextlengte niet. Ollama's standaard is 4096 tokens, te klein voor zelfs de OpenHands-systeemprompt. De docs vragen om minimaal 22000.

Open in OpenHands Settings, ga naar het tabblad LLM en zet Advanced aan. Stel vervolgens in:

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

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

  3. API Key: Een willekeurige placeholderwaarde, zoals local-llm

LLM-instellingen voor een lokaal Ollama-model

LLM-instellingen voor een lokaal Ollama-model

De openai/-prefix vertelt OpenHands om via de OpenAI-compatibele API met Ollama te praten. De API-sleutel wordt niet gebruikt, maar het veld mag niet leeg zijn.

Open een repository

OpenHands kan je bestanden standaard niet zien. Je moet het project in de sandbox mounten.

Voor dit voorbeeld heb je een map nodig genaamd budget-tracker/project met twee bestanden. Het eerste telt uitgaven per maand op:

# 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

De docstring belooft sleutels als YYYY-MM, maar date[5:7] bewaart alleen de maand. Januari 2025 en januari 2026 belanden zo in dezelfde bucket.

Het tweede bestand heeft twee tests die de bug vangen:

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

Maak van de map een Git-repository, zodat je later kunt zien wat de agent wijzigt:

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

Als je nu python -m pytest draait, falen beide tests:

Falende tests

Falende tests

Om OpenHands toegang te geven, stop je de container en voeg je één regel toe aan het docker run-commando:

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

Dus het volledige commando is nu:

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

Het formaat is host_path:container_path:mode. Je project verschijnt in de sandbox onder /workspace, en rw staat de agent toe het te bewerken.

Mount alleen het project dat je door de agent wilt laten wijzigen. Alles wat read-write in /workspace is gemount, kan door de agent worden aangepast.

Geef de agent een taak

Start een nieuw gesprek en beschrijf het probleem zoals je een bugrapport zou schrijven:

De maandtotalen voegen uitgaven uit dezelfde maand in verschillende jaren samen.

Vind de oorzaak, fix het en draai de tests om te bevestigen dat ze slagen.

Dat is alles. Je hoeft de agent niet te wijzen op budget.py of te zeggen welke regel fout is.

Conversatie-output

Conversatie-output

De agentlus van eerder neemt het vanaf hier over. De agent kijkt in /workspace, leest beide bestanden en draait de tests om te zien wat faalt. Daarna bewerkt hij de code en draait de tests opnieuw.

De agent draait pytest in de sandboxterminal

De agent draait pytest in de sandboxterminal

Review de wijzigingen

De agent zegt dat hij klaar is. Je kunt nu de verschillen bekijken door de code-editor te openen en de wijzigingen te inspecteren.

De juiste fix is één regel in budget.py:

month = date[:7]

Gefixte budget.py

Gefixte budget.py

Je kunt ook een git diff doen om de verschillen te zien.

Dit moet je checken:

  • De broncode: De fix hoort in budget.py

  • De tests: Zorg dat de agent test_budget.py niet heeft aangepast om de assertions te laten slagen

  • De testrun: Draai zelf python -m pytest - vertrouw niet op de samenvatting van de agent

OpenHands-architectuur

OpenHands heeft zes hoofdonderdelen, elk met één taak.

Hoe de OpenHands-componenten verbinden

Hoe de OpenHands-componenten verbinden

AI-model

Het model doet het redeneren. Het krijgt de taak en de conversatiegeschiedenis en antwoordt met een bericht of een toolcall.

Het model wijzigt je bestanden niet en draait niets; het beslist alleen wat er daarna moet gebeuren. Modelaanroepen gaan via LiteLLM, waardoor dezelfde agent werkt met een hosted provider of een lokaal model zoals de Devstral-setup uit het artikel.

Agentlogica

De agent zit tussen het model en al het andere. Hij draait de reasoning-action-lus: het model om de volgende actie vragen, de tool uitvoeren en het resultaat of de fout afhandelen.

Hij beslist ook wat het model te zien krijgt. De agent beheert de conversatiegeschiedenis met condensers en voegt skills en prompts toe aan elke modelquery.

Elke stap wordt vastgelegd. De agent voert acties uit en krijgt observaties terug, en de conversatie houdt die eventgeschiedenis bij. Het model ziet deze events in de volgende beurt, zodat het weet wat er al is gebeurd.

Tools en acties

Tools zijn hoe de agent iets buiten het model beïnvloedt. De standaardset bevat een terminal, een bestandseditor en een tasktracker, en je kunt meer toevoegen via MCP-servers.

Het model vraagt om een actie, zoals "draai pytest" of "vervang regel 8 in budget.py." De tool voert die uit en geeft een observatie terug, zoals de testoutput of het bijgewerkte bestand.

Voor een actie draait, gaat die door een securitycheck. De security analyzer beoordeelt elke actie eerst en kan de agent pauzeren voor jouw goedkeuring.

Ontwikkelomgeving

Tools draaien niet op je machine. Ze draaien in een sandbox.

In de Docker-setup draait OpenHands de agentserver in een eigen Dockercontainer. Daarom mount het artikel de Docker-socket: de appcontainer heeft die nodig om de sandbox te starten.

De sandbox hoeft niet lokaal te zijn. Agents kunnen ook in efemere workspaces draaien, bijvoorbeeld in Docker of Kubernetes, en de Agent Server stelt executie, tools en workspaces beschikbaar via REST- en WebSocket-API's. De agentlogica blijft hetzelfde, waar de sandbox ook draait.

Repository

De repository is waar de agent aan werkt. Die komt op twee manieren in de sandbox: een lokale map die je mount, zoals in het artikel, of een repo gekoppeld via de GitHub-, GitLab- of Bitbucket-integraties.

Een repository kan de agent ook vertellen hoe hij zich moet gedragen. Een AGENTS.md in de root wordt bij conversatiestart in de systeemprompt geïnjecteerd. Meer gerichte instructies gaan in .agents/skills/, waar de agent eerst een samenvatting ziet en de volledige content pas laadt als het nodig is.

Hier zet je projectregels neer die de agent niet kan raden, zoals "draai tests met make test, niet met pytest."

Menselijke review

Jij bent het laatste onderdeel van de architectuur.

OpenHands ondersteunt drie bevestigingsbeleid: elke actie goedkeuren, niets goedkeuren of alleen riskante acties goedkeuren. Dat laatste hangt af van de security analyzer, die elke actie labelt als LOW, MEDIUM, HIGH of UNKNOWN risk. NeverConfirm is de default, dus de agent draait zonder te stoppen tenzij je dit aanpast.

Het tweede controlemoment komt aan het einde. Het werk van de agent is pas klaar nadat jij de diff hebt gelezen en de testresultaten hebt gecheckt.

OpenHands-workflows

Ik liet zien hoe je een bug van één regel fixt, maar natuurlijk kan OpenHands veel grotere taken aan.

Wat deze taken gemeen hebben, is dat ze meer dan één stap vergen. Hier zijn zes soorten werk waar de agentlus logisch is.

Bugs fixen

De bug in dit artikel was makkelijk te zien in één bestand. In de echte wereld bijna nooit.

Stel dat de applicatielogs een KeyError in productie tonen, en de stacktrace wijst naar een functie drie aanroepen verwijderd van waar de foute data binnenkomt. Je plakt de stacktrace in OpenHands en vraagt om een fix.

De agent volgt de aanroepketen terug naar de bron van de data, schrijft een test die de fout reproduceert en bevestigt dat die test faalt. Dan fixt hij de code en draait de volledige testsuite om te checken dat er niets anders stuk gaat.

Een reproductietest is wat je moet zoeken. Die bewijst dat de agent de echte bug vond in plaats van alleen te zien waar de fout verschijnt.

Features implementeren

Featurewerk wijzigt meestal meer bestanden dan je verwacht.

Stel dat een commandline-rapportagescript een --since-vlag nodig heeft om transacties op datum te filteren. De agent moet de argumentparser vinden, de vlag toevoegen, de waarde doorgeven aan de filterlogica en de helptext updaten. Dan schrijft hij tests voor het nieuwe gedrag en werkt de README bij.

Dat zijn vier of vijf bestanden voor één kleine feature. De agent houdt ze bij in de tasktracker, zodat hij niet stopt zodra de eerste werkt.

Code refactoren

Refactoren draait om structuur veranderen zonder gedrag te veranderen, en de testsuite bewijst dat het gedrag gelijk blijft.

Stel dat een project één groot utils.py-bestand heeft met datumshelpers, stringhelpers en filehelpers door elkaar. Je vraagt OpenHands om het in drie modules te splitsen.

De agent maakt de nieuwe modules, verplaatst de functies en werkt elke import door de codebase bij. Hij draait de tests na elke verplaatsing. Zo weet hij, als er iets breekt, welke stap de oorzaak was.

Tests schrijven

Ongeteste code is een veelvoorkomend startpunt voor agentwerk, omdat de taak duidelijk is en makkelijk te verifiëren.

Stel dat een module voor datumparsing geen tests heeft. De agent leest de functies, schrijft pytest-cases voor normale inputs en randgevallen zoals lege strings, schrikkeljaren en ongeldige formats, en draait ze.

Als een nieuwe test faalt, moet de agent beslissen of de test fout is of dat de code een bug heeft. Dat is de beslissing die je zelf moet checken.

Bestaande codebases onderzoeken

Niet elke taak vereist codewijzigingen.

Je kunt OpenHands vragen stellen als "Waar valideert deze app user input voordat het de database bereikt?" De agent doorzoekt de codebase, volgt functieaanroepen over bestanden heen en antwoordt met bestands- en regelverwijzingen.

Handig als je aan een nieuw project begint of code oppakt die je maanden niet hebt aangeraakt. Voor read-only werk mount je de repository met modus :ro in plaats van :rw, zodat de agent niets kan wijzigen, zelfs niet per ongeluk.

Applicaties draaien en debuggen

Sommige bugs verschijnen alleen wanneer de applicatie draait.

Stel dat een API-endpoint een 500-fout teruggeeft en de tests dekt het niet. De agent start de server in zijn terminal, stuurt een request met curl en leest de traceback uit de serverlogs.

Daarna fixt hij de code, herstart de server en stuurt hetzelfde request opnieuw. Als de response nog steeds fout is, gaat de lus vanaf daar verder.

Dit is dezelfde edit-run-check-cyclus die je zelf ook zou doorlopen, alleen handelt de agent elke herstart en retry af.

OpenHands vs andere AI-codeeragents

OpenHands is niet de enige tool die een taak kan oppakken en zelfstandig kan afwerken. Claude Code, Cursor en GitHub Copilot hebben nu agentfeatures, maar ze verschillen op een paar belangrijke punten.

OpenHands vs Claude Code

Deze twee lijken het meest op elkaar. Beide draaien een agentlus die code leest, bestanden bewerkt, commando's draait en de resultaten checkt.

Het eerste verschil is eigenaarschap. Elke publieke OpenHands-repository heeft z'n eigen open-sourcelicentie, en je kunt alles lezen, aanpassen en zelf hosten. Claude Code is Anthropics propriëtaire agentische codeertool, beschikbaar in de terminal, IDE, desktopapp en browser.

Dat leidt tot de modelvraag. Claude Code is gebouwd rond Anthropics Claude-modellen. OpenHands werkt met elke provider die LiteLLM ondersteunt, inclusief de lokale Ollama-setup uit het artikel.

De dagelijkse workflow is ook anders. Claude Code begon als terminaltool, en daar gebruiken veel developers het nog steeds. OpenHands leunt op de browser-UI, en de CLI is feature-complete maar wordt primair voor stabiliteit onderhouden.

Beide tools laten je het gedrag van de agent sturen. Claude Code leest CLAUDE.md, settings, hooks, skills, commands en subagents uit de map .claude. OpenHands leest AGENTS.md en skills uit de repository, en met de SDK bouw je je eigen agents in Python.

Autonomie werkt in elk geval anders. Claude Code stuurt toolgebruik met permission modes, hooks en allow/deny-regels, en kan commando's sandboxen. OpenHands draait standaard elk commando binnen een Docker-sandbox en voegt daar bevestigingsbeleid bovenop toe.

Kort gezegd: Claude Code is de gepolijste optie die je direct installeert en gebruikt, terwijl OpenHands om meer setup vraagt en daar meer controle voor teruggeeft. Ze sluiten elkaar ook niet uit: Agent Canvas kan Claude Code als agent draaien in plaats van de standaard OpenHands-agent.

OpenHands vs Cursor

Cursor is een AI-code-editor. OpenHands is een agentplatform. Dat is het hoofdverschil, en de meeste andere volgen daaruit.

In Cursor werk je in de editor en werkt de agent naast je. Je ziet edits in je bestanden verschijnen, accepteert of weigert ze en typt door. In OpenHands beschrijf je een taak, werkt de agent in een sandbox en review jij het resultaat. De GUI bevat wel een VS Code-weergave in de sandbox, maar daar gebeurt niet het meeste werk.

Toegang tot repositories volgt dezelfde tweedeling. De agent van Cursor werkt aan de code die open staat in je editor. OpenHands werkt aan wat je in zijn sandbox mount of via een Git-integratie koppelt.

De kloof is kleiner met de Cloud Agents van Cursor. Die draaien onbemand in de cloud en leveren werk via branches en pull requests, en ze hebben een gekoppeld GitHub-, GitLab-, Azure DevOps- of Bitbucket-account en een betaald plan nodig. Dat lijkt op wat OpenHands doet, maar dan op de infrastructuur van Cursor.

Uitbreidbaarheid is waar de twee het meest verschillen. Cursor ondersteunt MCP-servers en projectregels, maar de editor en de agent zijn gesloten producten. Met OpenHands kun je de agent zelf aanpassen, hem overal hosten en op een lokaal model draaien.

OpenHands vs GitHub Copilot

GitHub Copilot begon als een autocomplete-tool in je editor en groeide vandaaruit naar agentfeatures. OpenHands begon als agent.

Copilots grootste kracht is waar het leeft. Het werkt in VS Code en JetBrains-IDE's, en de cloudagent werkt direct op GitHub. OpenHands heeft niet zo'n IDE-integratie.

Voor repository-brede taken is de Copilot-cloudagent de beste vergelijking. Je wijst een issue toe, en hij werkt in een eigen efemere ontwikkelomgeving aangedreven door GitHub Actions, waar hij tests en linters kan draaien voordat hij pusht. OpenHands Cloud doet iets soortgelijks wanneer je @openhands noemt in een issue- of pull request-comment.

Platform is het belangrijkste verschil. De Copilot-cloudagent is beschikbaar voor alle betaalde Copilot-plannen in repositories die op GitHub staan. OpenHands werkt met GitHub, GitLab, Bitbucket of een lokale map, en draait op je eigen hardware als je dat wilt.

Copilot laat je wel een model kiezen voor een taak, maar alleen uit de modellen die GitHub aanbiedt. OpenHands heeft die beperking niet.

Hier is een korte samenvatting:

 OpenHandsClaude CodeCursorGitHub Copilot
BronOpen sourcePropriëtairPropriëtairPropriëtair
ModellenElke LiteLLM-provider, inclusief lokaalClaude-modellenMeerdere providers plus in-house modellenModellen aangeboden door GitHub
HoofdinterfaceBrowser-UI, SDKTerminal, IDE, desktop, browserAI-code-editorIDE-extensie, GitHub
Waar de agent draaitDocker-sandbox, lokaal of remoteJe machine of de cloud van AnthropicJe editor of de cloud van CursorJe IDE of GitHub Actions
Self-hostingJaNeeAlleen EnterpriseNee

OpenHands vergeleken met andere AI-agents

OpenHands voor software-engineeringteams

Voor een individuele developer is OpenHands een tool die je opent wanneer je hem nodig hebt. Voor een team ligt dat anders.

De meeste teams organiseren werk al rond issues, en OpenHands Cloud sluit daarop aan. Het integreert met GitHub, GitLab en Bitbucket, plus Slack, Jira en Linear. Je kunt @openhands noemen in een issue- of pull request-comment, en de agent pakt de taak daar op.

Dan is er werk waar niemand om vraagt maar dat iedereen nodig heeft. Agent Canvas-automatiseringen draaien op schema of als reactie op webhooks. Bijvoorbeeld: een team kan één Agent Server delen voor code review en dependency-updates, terwijl elke developer persoonlijke agents op z'n eigen laptop draait.

Testen werkt hetzelfde als in het artikel. De agent draait de testsuite in zijn sandbox voordat hij terugrapporteert. Maar de sandboxrun vervangt CI niet: je pipeline draait nog steeds op elke pull request, net als bij door mensen geschreven code.

Pull requests zijn een ander onderwerp. Wanneer OpenHands Cloud met GitHub werkt, vraagt het kortlevende tokens aan die na acht uur verlopen, met lees- en schrijfrechten op contents, issues, pull requests en workflows. In self-hosted Enterprise-omgevingen gebruikt de agent de GitHub-autorisatie van de gebruiker die hem heeft getriggerd, zodat elke wijziging te herleiden is tot een persoon.

Zo hoort verantwoordelijkheid te werken. De agent kan de pull request openen, maar een developer keurt hem goed. Branchbescherming en vereiste reviews gelden voor agent-PR's net zoals voor die van iedereen.

Geïsoleerde omgevingen maken dit op schaal mogelijk. Elke taak draait in een eigen sandbox, zodat twee agents die twee bugs fixen elkaars bestanden niet overschrijven of om dezelfde poort vechten.

OpenHands-beveiliging en sandboxing

Een codeaanvullingstool stelt altijd tekst voor, en jij beslist of je die accepteert.

Een agent is anders. Die gaat door je project, voert commando's uit, installeert packages en bewerkt bestanden zelfstandig, vaak zonder te vragen. De vraag verschuift dus van "is deze code correct?" naar "wat heeft de agent gedraaid om hier te komen?"

Geïsoleerde uitvoeringsomgevingen

De Docker-sandbox beschermt je hostbestanden en -programma's, hostresources en andere containers en processen. Als de agent een destructief commando draait, blijft dat beperkt tot een container.

Er is één uitzondering om op te letten in de lokale setup. De appcontainer mount de Docker-socket van de host om sandboxes te kunnen starten, en toegang tot die socket betekent controle over Docker op je machine.

Repository-permissies

De sandbox beschermt alleen wat je niet mount. Gemonteerde bestanden en mappen kunnen worden gewijzigd of verwijderd.

Mount alleen het project waar je aan werkt, nooit je homedirectory. Gebruik voor read-only taken de modus :ro . Geef voor Git-integraties de agent toegang tot de specifieke repositories die hij nodig heeft en niets anders.

Secrets en credentials

Als je credentials verstrekt, zoals API-sleutels of tokens, kan de agent die gebruiken. En een agent die een secret kan lezen, kan die ook naar logs printen of ergens heen sturen.

Mount dus geen mappen met .env-bestanden die productiekeys bevatten. Geef de agent testcredentials met beperkte scope en roteer ze vaak.

Netwerktoegang

Standaard heeft de agent vanuit de container toegang tot internet. Dat is nodig om packages te installeren, maar zo kan hij ook elke externe service bereiken.

Dat opent de deur voor promptinjection. Een webpagina of issuecomment kan instructies bevatten die de agent mogelijk volgt. GitHub beperkt dit risico voor zijn eigen cloudagent met een firewall die internettoegang standaard beperkt, en het is de moeite waard om vergelijkbare limieten voor je OpenHands-setup te overwegen.

Commando-uitvoering

Je kunt bepalen welke commando's zonder goedkeuring draaien. OpenHands ondersteunt drie bevestigingsbeleid: alles goedkeuren, niets goedkeuren of alleen riskante acties goedkeuren. NeverConfirm is de default.

De optie "riskante acties" heeft een addertje. De standaard LLM security analyzer gebruikt het risiconiveau dat het model aan zijn eigen acties toekent. Een model kan een destructief commando als LOW risk labelen, en dan draait het zonder te vragen. De analyzer classificeert risico voor de beleidslaag - hij blokkeert op zichzelf niets, en de docs raden aan dit te combineren met Docker-isolatie.

Gegenereerde wijzigingen reviewen

Alles hierboven beperkt wat de agent kan doen. Maar de reviewfase is belangrijk omdat je daarmee checkt wat er wél is gebeurd.

Lees de volledige diff, niet alleen de bestanden waarvan je verwachtte dat ze zouden veranderen. Let extra op CI-configuratie, dependencybestanden en scripts. In OpenHands Cloud heeft de GitHub-token van de agent schrijftoegang tot workflows, dus een wijziging in .github/workflows kan beïnvloeden wat er in je pipeline draait.

Beperkingen van OpenHands

De code die OpenHands schrijft kan nog steeds bugs bevatten. Slaagde tests zeggen alleen dat de code overeenkomt met de tests, en de agent kan beide schrijven. Als de tests zwak zijn, kan de code slagen en toch fout zijn.

Complexe taken hebben je vaak in de loop nodig. Vage requirements of een ontwerpbeslissing die de agent niet kan nemen, zullen hem stoppen of, erger nog, de verkeerde kant op sturen.

Met een sterk hosted model kan OpenHands multi-bestandstaken goed aan. Met een klein lokaal model zie je mislukte toolcalls en chatbot-achtige antwoorden, en zelfs met een groot contextvenster kunnen sommige lokale modellen tools niet betrouwbaar gebruiken.

Agentlussen kosten ook meer dan chat. Elke stap stuurt de conversatiegeschiedenis terug naar het model, en lange taken nemen veel stappen. De OpenHands-docs waarschuwen dat de agent veel prompts naar het LLM stuurt en raden bestedingslimieten en gebruiksmonitoring aan. De contextcondenser helpt, maar vat oudere stappen samen, waardoor details bij lange taken verloren kunnen gaan.

Tooltoegang voegt beveiligingsrisico toe. Een agent met een terminal en netwerktoegang kan echte schade aanrichten als hij slechte instructies volgt, daarom zijn de sandbox en jouw review zo belangrijk.

En elke wijziging heeft nog steeds een persoon nodig die deze goedkeurt. Houd dat altijd in gedachten.

OpenHands en de toekomst van AI-codeeragents

AI-codeertools gingen van autocomplete naar chat naar agents die een volledige taak afwerken. OpenHands is een van de projecten die die laatste stap verder duwen.

De richting is in de hele industrie duidelijk. Cursor beschrijft een opkomend tijdperk waarin autonome cloudagents grotere taken over langere tijd uitvoeren. Copilot pakt nu issues op uit GitHub en Linear. Claude Code draait in de terminal, de browser en Slack.

Open-sourceplatformen hebben daarin een specifieke rol. Met OpenHands kun je inspecteren hoe de agent werkt, hem op je eigen infrastructuur draaien en het model kiezen. Voor teams met strikte datarichtlijnen is dat vaak de enige toegestane manier om agents te gebruiken.

Langere taken brengen ook nieuwe problemen. Een agent die een uur werkt neemt meer beslissingen dan eentje die een minuut werkt, en elke beslissing is een kans om af te drijven van wat je wilde. Betere modellen helpen, maar ook sandboxes, bevestigingsbeleid en review.

Conclusie

Wat OpenHands onderscheidt van concurrenten is controle. Je kunt de broncode lezen, hem op je eigen hardware hosten en met elk model draaien, inclusief een lokaal model. Strakkere commerciële tools zoals Claude Code, Cursor en GitHub Copilot bieden een betere ervaring, maar wel op hun voorwaarden.

Maar een agent met toegang tot je terminal en je repositories heeft nog steeds iemand nodig die het werk nakijkt. Lees altijd de diff en draai de tests zelf.

Wil je leren hoe je je eigen agent from scratch maakt? Bekijk dan ons webinar Introduction to Creating AI Agents in Python.

Dario Radečić

Auteur

Dario Radečić

Senior Data Scientist, gevestigd in Kroatië. Top Tech-schrijver met meer dan 700 gepubliceerde artikelen en meer dan 10 miljoen weergaven. Auteur van het boek Machine Learning Automation with TPOT.

FAQs

Wat is OpenHands?

OpenHands is een open-source platform voor het bouwen en draaien van AI-agents die met code werken. De codeeragent kan een repository inspecteren, bestanden bewerken, commando's en tests draaien en itereren op de resultaten totdat een taak klaar is. Je kunt het lokaal in Docker draaien, via de SDK of op OpenHands Cloud.

Is OpenHands gratis te gebruiken?

De OpenHands-software is open source, dus je kunt het zelf hosten zonder licentiekosten. Waar je wél voor betaalt is het model: hosted providers zoals Anthropic of OpenAI rekenen per token, en agentlussen gebruiken er veel. Als je een lokaal model via Ollama of LM Studio draait, zijn de enige kosten je hardware. OpenHands Cloud is een aparte, commerciële service.

Hoe verschilt OpenHands van GitHub Copilot of Cursor?

Copilot en Cursor zijn rond de editor gebouwd, waar de AI naast je werkt terwijl je code schrijft. OpenHands is agent-first: je beschrijft een taak, de agent werkt eraan in een sandbox en jij reviewt het resultaat. Het is ook open source, werkt met elk model dat LiteLLM ondersteunt en draait op je eigen infrastructuur, wat Copilot noch Cursor in dezelfde mate bieden.

Kan ik OpenHands met een lokaal model draaien?

Ja. OpenHands verbindt met lokale servers zoals LM Studio, Ollama, vLLM en SGLang via hun OpenAI-compatibele API's. Kies een model dat gebouwd is voor agentisch coderen, zoals Devstral Small 2 of Qwen3.6-35B-A3B, en zet het contextvenster op minimaal 22000 tokens. Kleinere general-purpose modellen falen vaak bij toolcalls en antwoorden als een chatbot.

Is het veilig om OpenHands toegang tot mijn code te geven?

OpenHands draait de commando's van de agent in een Docker-sandbox, wat je hostsysteem tegen de meeste fouten beschermt. Maar alles wat je in de sandbox mount kan worden gewijzigd of verwijderd, en alle credentials die je verstrekt kunnen door de agent worden gebruikt. Standaard vraagt de agent niet om goedkeuring voordat hij handelt, dus mount alleen het project dat je nodig hebt, gebruik beperkte testcredentials en review elke diff voordat je merge't.

Onderwerpen