En översikt av OpenHands, den öppna AI‑kodningsagenten, som täcker arkitekturen, en lokal setup med Ollama, en praktisk buggfix, säkerhet och begränsningar, samt hur den jämförs med Claude Code, Cursor och GitHub Copilot.
OpenHands är en öppen plattform för AI-driven mjukvaruutveckling, byggd kring en agent som kan inspektera ditt repo, redigera filer, köra kommandon och köra tester. Det är en del av skiftet mot agentisk mjukvaruutveckling – du ger agenten en hel uppgift, och den arbetar sig igenom den steg för steg tills den är klar eller behöver din input.
I den här artikeln går jag igenom OpenHands arkitektur och dess huvudfunktioner, visar hur du sätter upp det med en lokal modell och jämför det med Claude Code, Cursor och GitHub Copilot.
Vad är AI‑agenter? Gå vår AI Agent Fundamentals-track för att upptäcka hur AI‑agenter kan förändra hur du arbetar.
Vad är OpenHands?
OpenHands är en öppen plattform för att bygga och köra AI‑agenter som arbetar med kod.
Namnet täcker två saker. Det första är projektet – en samling repo:n med ett SDK, en server, ett webbläsargränssnitt och en hostad tjänst. Det andra är kodningsagenten som körs ovanpå allt detta.
Så här fungerar det:
Software Agent SDK: Ett set av Python- och REST‑API:er för att bygga kodagenter och motorn bakom OpenHands CLI och OpenHands Cloud
Agent Server: Exponerar agentkörning, konversationer, verktyg och arbetsytor via REST- och WebSocket‑API:er
Agent Canvas: Ett webbläsargränssnitt för konversationer, filer, terminalutdata, modellkonfiguration, backends och automationer
OpenHands Cloud: Den hanterade kommersiella tjänsten för team som inte vill drifta egen backend- och sandbox‑infrastruktur
När de flesta säger ”OpenHands” menar de agenten. Det är den delen jag jobbar med i den här artikeln.
Vanligtvis ger du agenten en mjukvaruuppgift, pekar den till en arbetsyta med din kod och den arbetar igenom uppgiften med de verktyg den har. Standarduppsättningen är en terminal, en filredigerare och en uppgiftsspårare.
Arbetsytan behöver inte vara din laptop. Agenter kan använda den lokala maskinen som arbetsyta eller köras i efemära arbetsytor, till exempel i Docker eller Kubernetes.
OpenHands låser dig inte heller till en modellleverantör. Du kan använda det med Claude, GPT eller någon annan LLM, inklusive lokala modeller. Agent Canvas kan till och med köra tredjepartsagenter som Claude Code och Codex i stället för standardagenten i OpenHands.
Kort sagt är OpenHands en öppen agentplattform som du kan köra på dina villkor.
Hur OpenHands fungerar
OpenHands körs i en loop.
En chattassistent tar emot din prompt och returnerar text. OpenHands‑agenten får en uppgift, vidtar en åtgärd, tittar på resultatet och bestämmer vad som ska göras härnäst.
OpenHands‑agentens loop
Detta är grundidén:
Ta emot uppgiften: Du beskriver målet på vanlig svenska, till exempel ”Fixa månadsrapporten så att den inte slår ihop månader från olika år”
Inspektera repot: Agenten listar kataloger, öppnar filer och söker efter kod relaterad till uppgiften
Gör en plan: Den delar upp uppgiften i steg och registrerar dem i sin uppgiftsspårare
Redigera eller skapa filer: Den ändrar koden med sin filredigerare
Kör kommandon och tester: Den kör testsviten eller appen i terminalen
Inspektera resultaten: Den läser utdata, inklusive fel och misslyckade assertioner
Iterera: Om något fortfarande är trasigt går den tillbaka, justerar planen och försöker igen
Loopen stannar antingen när uppgiften är klar, eller när agenten behöver något bara du kan ge, som en saknad autentiseringsuppgift eller ett beslut om krav.
Steg 6 gör OpenHands annorlunda än konkurrenterna. Ett kodkompletteringsverktyg ser aldrig vad som händer när dess kod körs. OpenHands gör det, så den kan reagera på ett misslyckat test och åtgärda orsaken.
Viktiga funktioner i OpenHands
Autokomplettering föreslår text, medan OpenHands agerar i ditt projekt. Så här.
Kodredigering
OpenHands redigerar filer direkt och är inte begränsad till en fil i taget.
Säg att en funktion behöver ett nytt namn. Agenten uppdaterar definitionen, hittar alla anropsställen och uppdaterar testerna som refererar till den – allt som en del av en och samma uppgift.
Terminal och verktygsanvändning
Agenten har en egen terminal. Den kan installera beroenden, köra skript, köra tester och läsa utdata från valfritt kommando.
Du kan också koppla MCP‑servrar (Model Context Protocol) för att ge agenten verktyg den inte är byggd för från början, till exempel ett ärendehanteringssystem eller en databasklient.
Förståelse av repository
De flesta kodgeneratorer ser bara det du klistrar in i prompten.
OpenHands öppnar repot och utforskar det. Den kan läsa README, följa importer och titta på befintliga tester för att förstå hur projektet är strukturerat. Det innebär att dess ändringar mer sannolikt passar den kod som redan finns.
Långa uppgifter skapar ett annat problem – konversationshistoriken växer förbi vad modellen kan hålla. OpenHands hanterar detta med en kontextkondenserare som sammanfattar äldre delar av konversationen så att agenten kan fortsätta arbeta.
Val av modell
Modellanrop går genom LiteLLM, så du kan använda vilken leverantör och modell som helst den stödjer. OpenHands‑dokumentationen rekommenderar modeller från familjerna Claude, GPT och Gemini, plus open‑weight‑modeller som får bra poäng på OpenHands Index.
Om din kod inte får lämna din maskin kan du köra en lokal modell. OpenHands kopplar till lokala servrar som LM Studio, Ollama, vLLM och SGLang.
Kom ihåg att modellen påverkar resultaten mycket. Vissa lokala modeller har svårt med pålitlig verktygsanvändning även med stort kontextfönster.
Autonom uppgiftskörning
När du lämnar över en uppgift arbetar agenten igenom loopen själv. Du behöver inte klistra in fel i en chatt eller säga vilken fil som ska öppnas härnäst.
Agent Canvas tar detta ett steg längre med automationer. De integrerar med Slack, GitHub, Linear och mer och körs enligt schema eller som svar på webhook‑händelser.
Men autonomi garanterar inte korrekthet. Du måste fortfarande granska diffen och testresultaten innan något mergas.
Så använder du OpenHands
Det bästa sättet att förstå OpenHands är att ge den en bugg och se vad den gör.
I det här avsnittet kör jag OpenHands lokalt i Docker, kopplar den till en lokal modell via Ollama och ber den fixa en bugg i ett litet Python‑projekt.
Sätt upp OpenHands
Du kan köra OpenHands på ett par sätt:
CLI‑startare: Installera med uv tool install openhands --python 3.14, starta sedan GUI:t med openhands serve
Docker: Kör appcontainern direkt med ett enda docker run‑kommando
Agent Canvas: Den nyare webbläsarklienten som kopplar till lokala, självhostade, Cloud‑ eller Enterprise‑backends
OpenHands Cloud: Den hostade versionen, om du hellre inte vill köra något själv
Jag använder Docker‑vägen med det lokala GUI:t. OpenHands‑dokumentationen listar det nu som den utfasade Docker‑baserade webbläsarapplikationen och pekar på Agent Canvas som ersättare, men den är fortfarande dokumenterad och det snabbaste sättet att få igång ett GUI.
Du behöver Docker Desktop på macOS, Linux eller Windows med WSL. På macOS, öppna Docker Desktop, gå till Settings > Advanced och aktivera standard‑Docker‑sockeln.
Starta sedan appen:
docker run -it--rm--pull=always \-eAGENT_SERVER_IMAGE_REPOSITORY=ghcr.io/openhands/agent-server \-eAGENT_SERVER_IMAGE_TAG=1.26.0-python \-eLOG_ALL_EVENTS=true \-v /var/run/docker.sock:/var/run/docker.sock \-v ~/.openhands:/.openhands \-p3000:3000 \
--add-host host.docker.internal:host-gateway \--name openhands-app \
docker.openhands.dev/openhands/openhands:1.8Drivs av
OpenHands använder Docker‑socket‑mounten för att starta en separat sandbox‑container, och agenten kör sina kommandon i den sandboxen, inte på din värd.
När loggarna visar att servern är uppe, öppna http://localhost:3000 i din webbläsare.
OpenHands välkomstsida
Anslut en modell
OpenHands gör ingenting förrän du ger den en modell.
Jag använder Devstral Small 2, Mistrals 24B‑modell byggd för agentisk kodning. Den är tillräckligt lätt för att köra på ett enda RTX 4090 eller en Mac med 32 GB RAM. Den kräver Ollama 0.13.3 eller senare.
Starta Ollama med ett större kontextfönster och hämta modellen:
OLLAMA_CONTEXT_LENGTH=32768OLLAMA_HOST=0.0.0.0:11434 ollama serve &
ollama pull devstral-small-2:24bDrivs av
Underskatta inte kontextlängden. Ollamas standard är 4096 tokens, vilket är för litet för att rymma ens OpenHands systemprompt. Dokumentationen ber om minst 22000.
I OpenHands, öppna Settings, gå till fliken LLM och slå på Advanced. Ställ sedan in:
Custom Model:openai/devstral-small-2:latest
Base URL:http://host.docker.internal:11434/v1
API‑nyckel: Valfritt platshållarvärde, som local-llm
LLM‑inställningar för en lokal Ollama‑modell
Prefixet openai/ säger åt OpenHands att prata med Ollama via dess OpenAI‑kompatibla API. API‑nyckeln används inte, men fältet kan inte vara tomt.
Öppna ett repo
OpenHands kan inte se dina filer som standard. Du måste montera projektet i sandboxen.
För det här exemplet behöver du en mapp som heter budget-tracker/project med två filer. Den första summerar utgifter per månad:
# budget.pydefmonthly_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 totalsDrivs av
Docstringen lovar YYYY-MM‑nycklar, men date[5:7] behåller bara månaden. Januari 2025 och januari 2026 hamnar i samma kategori.
Gör mappen till ett Git‑repo, så du kan se vad agenten ändrar senare:
cd budget-tracker
git init
gitadd.git commit -m"Initial commit"Drivs av
Om du kör python -m pytest nu misslyckas båda testerna:
Misslyckade tester
För att ge OpenHands åtkomst, stoppa containern och lägg till en rad i docker run‑kommandot:
-eSANDBOX_VOLUMES=$HOME/budget-tracker:/workspace:rw \Drivs av
Så hela kommandot är nu:
docker run -it--rm--pull=always \-eAGENT_SERVER_IMAGE_REPOSITORY=ghcr.io/openhands/agent-server \-eAGENT_SERVER_IMAGE_TAG=1.26.0-python \-eLOG_ALL_EVENTS=true \-eSANDBOX_VOLUMES=$HOME/Desktop/budget-tracker:/workspace:rw \-v /var/run/docker.sock:/var/run/docker.sock \-v ~/.openhands:/.openhands \-p3000:3000 \
--add-host host.docker.internal:host-gateway \--name openhands-app \
docker.openhands.dev/openhands/openhands:1.8Drivs av
Formatet är host_path:container_path:mode. Ditt projekt dyker upp i sandboxen under /workspace, och rwtillåter agenten att redigera det.
Montera bara det projekt du vill att agenten ska ändra. Allt som monteras läs‑skriv i /workspace kan modifieras av agenten.
Ge agenten en uppgift
Starta en ny konversation och beskriv problemet som du skulle skriva en buggrapport:
De månatliga totalerna slår ihop utgifter från samma månad i olika år.
Hitta orsaken, åtgärda den och kör testerna för att bekräfta att de går igenom.
Det är allt. Du behöver inte peka agenten till budget.py eller tala om vilken rad som är fel.
Konversationsutdata
Agentloopen från tidigare tar över härifrån. Agenten går igenom /workspace, läser båda filerna och kör testerna för att se vad som fallerar. Sedan redigerar den koden och kör testerna igen.
Agenten kör pytest i sandbox‑terminalen
Granska ändringarna
Agenten säger att den är klar. Du kan nu visa skillnaderna genom att öppna kodredigeraren och inspektera ändringarna i koden.
Du kan också köra en git diff‑kontroll för att se skillnaderna.
Detta ska du kontrollera:
Källkoden: Fixen ska ligga i budget.py
Tester: Kontrollera att agenten inte redigerade test_budget.py för att få assertionerna att gå igenom
Testkörningen: Kör python -m pytest själv – lita inte på agentens sammanfattning
OpenHands arkitektur
OpenHands har sex huvuddelar, och varje del har ett enda jobb.
Hur OpenHands‑komponenterna hänger ihop
AI‑modell
Modellen gör resonemanget. Den får uppgiften och konversationshistoriken, och svarar med antingen ett meddelande eller ett verktygsanrop.
Modellen ändrar inte dina filer och kör inte något. Den avgör bara vad som ska hända härnäst. Modellanrop går genom LiteLLM, så samma agent fungerar med en hostad leverantör eller en lokal modell som Devstral‑setup:en i artikeln.
Agentlogik
Agenten står mellan modellen och allt annat. Den kör resonemangs‑ och åtgärdsloopen, vilket innebär att den ber modellen om nästa åtgärd, kör verktyget och hanterar resultatet eller felet.
Den avgör också vad modellen får se. Agenten hanterar konversationshistoriken med kondenserare och lägger till färdigheter och prompts till varje modellförfrågan.
Varje steg loggas. Agenten utför handlingar och får observationer tillbaka, och konversationen behåller den händelsehistoriken. Modellen ser dessa händelser i nästa vända, så den vet vad som redan hänt.
Verktyg och åtgärder
Verktygen är hur agenten påverkar något utanför modellen. Standarduppsättningen inkluderar en terminal, en filredigerare och en uppgiftsspårare, och du kan lägga till fler via MCP‑servrar.
Modellen ber om en åtgärd, som ”kör pytest” eller ”ersätt rad 8 i budget.py.” Verktyget kör den och returnerar en observation, som testutdata eller uppdaterad fil.
Innan en åtgärd körs passerar den en säkerhetskontroll. Säkerhetsanalysatorn utvärderar varje åtgärd först och kan pausa agenten för ditt godkännande.
Utvecklingsmiljö
Verktygen körs inte på din maskin. De körs i en sandbox.
I Docker‑setupen kör OpenHands agentservern i en egen Docker‑container. Det är därför artikeln monterar Docker‑socketen – appcontainern behöver den för att starta sandboxen.
Sandboxen behöver inte vara lokal. Agenter kan också köras i efemära arbetsytor, till exempel i Docker eller Kubernetes, och Agent Server exponerar körning, verktyg och arbetsytor via REST‑ och WebSocket‑API:er. Agentlogiken är densamma oavsett var sandboxen körs.
Repository
Repot är vad agenten arbetar på. Det kommer in i sandboxen på två sätt: en lokal mapp du monterar, som i artikeln, eller ett repo anslutet via integrationer för GitHub, GitLab eller Bitbucket.
Ett repo kan också tala om för agenten hur den ska bete sig. En AGENTS.md i roten injiceras i systemprompten när konversationen startar. Mer fokuserade instruktioner läggs i .agents/skills/, där agenten först ser en sammanfattning och laddar hela innehållet först när det behövs.
Här lägger du projektregler som agenten inte kan gissa, som ”kör tester med make test, inte pytest.”
Mänsklig granskning
Du är den sista delen av arkitekturen.
OpenHands stödjer tre bekräftelsepolicyer: godkänn varje åtgärd, godkänn inget eller godkänn bara riskabla åtgärder. Den sista beror på säkerhetsanalysatorn, som märker varje åtgärd som LÅG, MEDEL, HÖG eller OKÄND risk. NeverConfirm är standard, så agenten kör utan att stanna om du inte ändrar det.
Den andra kontrollpunkten kommer i slutet. Agentens arbete är inte klart förrän du har läst diffen och kontrollerat testresultaten.
OpenHands arbetsflöden
Jag visade hur man fixar en enradig bugg, men förstås kan OpenHands hantera mycket större uppgifter.
Gemensamt för dessa uppgifter är att de kräver mer än ett steg. Här är sex typer av arbete där agentloopen är vettig.
Fixa buggar
Buggen i den här artikeln var lätt att se i en enda fil. Så är det nästan aldrig i verkligheten.
Säg att applikationsloggarna visar ett KeyError i produktion och stacktracen pekar på en funktion tre anrop från där dåliga data kommer in. Du klistrar in stacktracen i OpenHands och ber om en fix.
Agenten spårar anropskedjan tillbaka till datakällan, skriver ett test som återskapar felet och bekräftar att testet fallerar. Sedan fixar den koden och kör hela testsviten för att se att inget annat gick sönder.
Ett reproduktionstest är den del du ska leta efter. Det bevisar att agenten hittade den faktiska buggen istället för att bara se var felet visar sig.
Implementera funktioner
Funktionsarbete ändrar vanligtvis fler filer än du tror.
Säg att ett kommandoradsrapports‑skript behöver en --since‑flagga för att filtrera transaktioner efter datum. Agenten måste hitta argumentparsern, lägga till flaggan, skicka värdet till filterlogiken och uppdatera hjälptexten. Sedan skriver den tester för det nya beteendet och uppdaterar README.
Det är fyra eller fem filer för en liten funktion. Agenten håller koll på dem i sin uppgiftsspårare, så den stannar inte efter att den första fungerar.
Refaktorera kod
Refaktorering handlar om att ändra struktur utan att ändra beteende, och testsviten är hur du bevisar att beteendet inte ändrats.
Säg att ett projekt har en stor utils.py med datumhjälpare, stränghjälpare och filhjälpare blandade. Du ber OpenHands att dela upp den i tre moduler.
Agenten skapar de nya modulerna, flyttar funktionerna och uppdaterar varje import i kodbasen. Den kör testerna efter varje flytt. På så sätt, om något går sönder, vet den vilken flytt som orsakade det.
Skriva tester
Otestad kod är en vanlig startpunkt för agentarbete, eftersom uppgiften är tydlig och lätt att verifiera.
Säg att en modul för datumparsning saknar tester. Agenten läser funktionerna, skriver pytest‑fall för normala indata och edge‑case:er som tomma strängar, skottår och ogiltiga format, och kör dem.
Om ett nytt test fallerar måste agenten avgöra om testet är fel eller om koden har en bugg. Det är ett beslut du själv bör granska.
Undersöka befintliga kodbaser
Inte varje uppgift kräver kodändringar.
Du kan ställa frågor till OpenHands som ”Var validerar den här appen användarindata innan de når databasen?” Agenten söker i kodbasen, följer funktionsanrop över filer och svarar med filsökvägar och radhänvisningar.
Detta är praktiskt när du går med i ett nytt projekt eller tar upp kod du inte ändrat på månader. För läs‑endast‑arbete som detta, montera repot med läget :ro i stället för :rw, så att agenten inte kan ändra något ens av misstag.
Köra och felsöka applikationer
Vissa buggar syns bara när applikationen körs.
Säg att en API‑endpoint returnerar 500‑fel och att testerna inte täcker den. Agenten startar servern i sin terminal, skickar en förfrågan med curl och läser tracebacken från serverloggarna.
Sedan fixar den koden, startar om servern och skickar samma förfrågan igen. Om svaret fortfarande är fel fortsätter loopen därifrån.
Detta är samma redigera‑kör‑kontrollera‑cykel som du själv skulle gå igenom, förutom att agenten hanterar varje omstart och varje nytt försök.
OpenHands vs andra AI‑kodningsagenter
OpenHands är inte det enda verktyget som kan ta en uppgift och arbeta sig igenom den på egen hand. Claude Code, Cursor och GitHub Copilot har agentfunktioner nu, men de skiljer sig på viktiga sätt.
OpenHands vs Claude Code
Dessa två är närmast varandra. Båda kör en agentloop som läser kod, redigerar filer, kör kommandon och kontrollerar resultaten.
Den första skillnaden är ägarskap. Varje publikt OpenHands‑repo har sin egen öppna licens, och du kan läsa, ändra och självhosta allt. Claude Code är Anthropics proprietära agentiska kodningsverktyg, tillgängligt i terminal, IDE, skrivbordsapp och webbläsare.
Det leder till modellfrågan. Claude Code är byggt kring Anthropics Claude‑modeller. OpenHands fungerar med varje leverantör som LiteLLM stödjer, inklusive den lokala Ollama‑setupen i artikeln.
Det dagliga arbetsflödet skiljer sig också. Claude Code började som ett terminalverktyg, och där använder många utvecklare det fortfarande. OpenHands förlitar sig på sitt webbläsargränssnitt, och dess CLI är funktionskomplett men främst underhållet för stabilitet.
Båda verktygen låter dig styra agentens beteende. Claude Code läser CLAUDE.md, inställningar, hooks, färdigheter, kommandon och underagenter från katalogen .claude. OpenHands läser AGENTS.md och färdigheter från repot, och SDK:t låter dig bygga egna agenter i Python.
Autonomi fungerar olika. Claude Code styr verktygsanvändning med permission‑lägen, hooks och allow/deny‑regler, och kan sandboxa kommandon. OpenHands kör varje kommando i en Docker‑sandbox som standard och lägger till bekräftelsepolicyer ovanpå.
Kort sagt: Claude Code är det polerade alternativet du installerar och använder direkt, medan OpenHands kräver mer setup och ger mer kontroll tillbaka. De utesluter inte heller varandra. Agent Canvas kan köra Claude Code som sin agent i stället för standardagenten i OpenHands.
OpenHands vs Cursor
Cursor är en AI‑kodredigerare. OpenHands är en agentplattform. Det är huvudskillnaden, och de flesta andra följer av den.
I Cursor arbetar du i editorn, och agenten jobbar bredvid dig. Du ser ändringar dyka upp i dina filer, accepterar eller avvisar dem och fortsätter skriva. I OpenHands beskriver du en uppgift, agenten arbetar i en sandbox och du granskar resultatet. GUI:t innehåller en VS Code‑vy in i sandboxen, men det är inte där huvuddelen av arbetet sker.
Repoåtkomst följer samma uppdelning. Cursors agent arbetar på koden som är öppen i din editor. OpenHands arbetar på det du monterar in i dess sandbox eller kopplar via en Git‑integration.
Gapet är mindre med Cursors Cloud Agents. De körs obevakat i molnet och returnerar arbete via brancher och pull requests, och de kräver ett anslutet GitHub‑, GitLab‑, Azure DevOps‑ eller Bitbucket‑konto och en betald plan. Det liknar vad OpenHands gör, men på Cursors infrastruktur.
Utbyggbarhet är där de skiljer sig mest. Cursor stödjer MCP‑servrar och projektsregler, men editorn och agenten är slutna produkter. Med OpenHands kan du ändra själva agenten, hosta den var som helst och köra den på en lokal modell.
OpenHands vs GitHub Copilot
GitHub Copilot började som ett autokompletteringsverktyg i din editor och växte därifrån till agentfunktioner. OpenHands började som en agent.
Copolots största styrka är var det lever. Det fungerar i VS Code och JetBrains IDE:er, och dess molnagent arbetar direkt på GitHub. OpenHands har inte den typen av IDE‑integration.
För repo‑nivå‑uppgifter är Copilots molnagent närmast i jämförelse. Du tilldelar den ett issue, och den arbetar i sin egen efemära utvecklingsmiljö driven av GitHub Actions, där den kan köra tester och linters innan den pushar. OpenHands Cloud gör något liknande när du nämner @openhands i en kommentar i ett issue eller en pull request.
Plattformen är den stora skillnaden. Copilots molnagent är tillgänglig för alla betalda Copilot‑planer i repo:n som lagras på GitHub. OpenHands fungerar med GitHub, GitLab, Bitbucket eller en lokal mapp, och den kan köras på din egen hårdvara om du vill.
Copilot låter dig välja modell för en uppgift, men bara bland de modeller GitHub erbjuder. OpenHands har inte den begränsningen.
Här är en snabb sammanfattning:
OpenHands
Claude Code
Cursor
GitHub Copilot
Källa
Öppen källkod
Proprietär
Proprietär
Proprietär
Modeller
Vilken LiteLLM‑leverantör som helst, inklusive lokala
Claude‑modeller
Flera leverantörer plus egna modeller
Modeller som erbjuds av GitHub
Huvudgränssnitt
Webbläsar‑UI, SDK
Terminal, IDE, desktop, webbläsare
AI‑kodredigerare
IDE‑tillägg, GitHub
Var agenten körs
Docker‑sandbox, lokalt eller fjärr
Din maskin eller Anthropics moln
Din editor eller Cursors moln
Din IDE eller GitHub Actions
Självhosting
Ja
Nej
Endast Enterprise
Nej
OpenHands jämfört med andra AI‑agenter
OpenHands för mjukvaruteam
För en enskild utvecklare är OpenHands ett verktyg du öppnar när du behöver det. Så är det inte för ett team.
De flesta team organiserar redan arbetet kring issues, och OpenHands Cloud kopplar in där. Det integrerar med GitHub, GitLab och Bitbucket, plus Slack, Jira och Linear. Du kan nämna @openhands i en kommentar i ett issue eller en pull request, så plockar agenten upp uppgiften därifrån.
Sedan finns arbete ingen ber om men alla behöver. Agent Canvas‑automationer körs enligt schema eller som svar på webhook‑händelser. Till exempel kan ett team dela en Agent Server för kodgranskning och beroendeuppdateringar, medan varje utvecklare kör personliga agenter på sin egen laptop.
Testning fungerar som i artikeln. Agenten kör testsviten i sin sandbox innan den rapporterar tillbaka. Men sandbox‑körningen ersätter inte CI – din pipeline körs fortfarande på varje pull request, precis som för människoskriven kod.
Pull requests är ett annat ämne. När OpenHands Cloud arbetar med GitHub begär det kortlivade tokens som går ut efter åtta timmar, med läs‑ och skrivrättigheter till innehåll, issues, pull requests och workflows. I självhostade Enterprise‑upplägg använder agenten den GitHub‑auktorisering som tillhör användaren som triggat den, så varje ändring kan spåras till en person.
Det är så ansvar ska fungera. Agenten kan öppna pull requesten, men en utvecklare godkänner den. Branch‑skydd och obligatoriska granskningar gäller för agentens pull requests precis som för alla andras.
Isolerade miljöer får allt detta att fungera i skala. Varje uppgift körs i sin egen sandbox, så två agenter som fixar två buggar skriver inte över varandras filer eller slåss om samma port.
OpenHands säkerhet och sandboxing
Ett kodkompletteringsverktyg föreslår alltid text, och sedan är det upp till dig att acceptera den.
En agent är annorlunda. Den går igenom ditt projekt, kör kommandon, installerar paket och redigerar filer på egen hand, ofta utan att fråga. Så frågan går från ”är den här koden korrekt?” till ”vad körde agenten för att komma dit?”
Isolerade körmiljöer
Docker‑sandboxen skyddar dina värdfiler och program, värdresurser och andra containers och processer. Om agenten kör ett destruktivt kommando är det begränsat till en container.
Det finns ett undantag att se upp för i den lokala setupen. Appcontainern monterar värdens Docker‑socket för att kunna starta sandboxar, och åtkomst till den socketen innebär kontroll över Docker på din maskin.
Repo‑behörigheter
Sandboxen skyddar bara det du inte monterar. Monterade filer och kataloger kan ändras eller raderas.
Montera bara projektet du arbetar med, aldrig din hemkatalog. För läs‑endast‑uppgifter som kodundersökning, använd läget :ro. För Git‑integrationer, ge agenten åtkomst till de specifika repo:n den behöver och inget annat.
Hemligheter och inloggningsuppgifter
Om du tillhandahåller inloggningsuppgifter, som API‑nycklar eller tokens, kan agenten använda dem. Och en agent som kan läsa en hemlighet kan också skriva ut den till loggar eller skicka den någonstans.
Så montera inte mappar med .env‑filer som innehåller produktionsnycklar. Ge agenten testuppgifter med begränsad åtkomst och rotera dem ofta.
Nätverksåtkomst
Som standard kan agenten nå internet inifrån containern. Den behöver det för att installera paket, men kan också nå externa tjänster.
Det öppnar dörren för promptinjektion. En webbsida eller en issue‑kommentar kan innehålla instruktioner som agenten kan följa. GitHub begränsar denna risk för sin egen molnagent med en brandvägg som begränsar internetåtkomst som standard, och det är värt att tänka på samma begränsningar för din OpenHands‑setup.
Kommandoexekvering
Du kan styra vilka kommandon som körs utan godkännande. OpenHands stödjer tre bekräftelsepolicyer: godkänn allt, godkänn inget, eller godkänn bara riskabla åtgärder. NeverConfirm är standard.
Alternativet ”riskabla åtgärder” har en hake. Den förvalda LLM‑säkerhetsanalysatorn använder risknivån som modellen tilldelar sina egna åtgärder. En modell kan märka ett destruktivt kommando som LÅG risk, och det körs utan att fråga dig. Analysatorn klassificerar risk för policylagret – den blockerar inte något i sig, och dokumentationen rekommenderar att kombinera den med Docker‑isolering.
Granskning av genererade ändringar
Allt ovan begränsar vad agenten kan göra. Men granskningsfasen är viktig eftersom det är så du kontrollerar vad den gjorde.
Läs hela diffen, inte bara de filer du förväntade dig skulle ändras. Var extra uppmärksam på CI‑konfiguration, beroendefiler och skript. I OpenHands Cloud inkluderar agentens GitHub‑token skrivrättigheter till workflows, så en ändring i .github/workflows kan ändra vad som körs i din pipeline.
Begränsningar i OpenHands
Koden som OpenHands skriver kan fortfarande ha buggar. Att tester går igenom säger bara att koden matchar testerna, och agenten kan skriva båda. Om testerna är svaga kan koden gå igenom och ändå vara fel.
Komplexa uppgifter behöver ofta dig i loopen. Otydliga krav eller ett designbeslut som agenten inte kan ta kommer att stoppa den eller, värre, skicka den i fel riktning.
Med en stark hostad modell hanterar OpenHands flerfiliga uppgifter väl. Med en liten lokal modell ser du misslyckade verktygsanrop och chattbot‑liknande svar, och även med stort kontextfönster kan vissa lokala modeller inte använda verktyg pålitligt.
Agentloopar kostar också mer än chatt. Varje steg skickar tillbaka konversationshistoriken till modellen, och långa uppgifter tar många steg. OpenHands‑dokumentationen varnar för att agenten skickar många prompts till LLM och rekommenderar utgiftstak och användningsövervakning. Kontextkondenseraren hjälper, men den sammanfattar äldre steg, så detaljer kan gå förlorade i långa uppgifter.
Verktygsåtkomst ökar säkerhetsrisken. En agent med terminal och nätverksåtkomst kan orsaka verklig skada om den följer dåliga instruktioner, vilket är varför sandboxen och din granskning är så viktiga.
Och varje ändring behöver fortfarande att en person godkänner den. Ha alltid det i åtanke.
OpenHands och framtiden för AI‑kodningsagenter
AI‑kodningsverktyg gick från autokomplettering till chatt till agenter som arbetar igenom en hel uppgift. OpenHands är ett av ett par projekt som driver det sista steget framåt.
Riktningen syns tydligt i branschen. Cursor beskriver en framväxande era där autonoma molnagenter tar större uppgifter över längre tidsskalor. Copilot tar nu issues från GitHub och Linear. Claude Code körs i terminalen, webbläsaren och Slack.
Öppna plattformar har en särskild roll i det skiftet. Med OpenHands kan du inspektera hur agenten fungerar, köra den på din egen infrastruktur och välja modell. För team med strikta regler för data är det ofta det enda sätt de får använda agenter.
Längre uppgifter för med sig nya problem också. En agent som arbetar i en timme fattar fler beslut än en som arbetar i en minut, och varje beslut är en chans att driva bort från det du ville. Bättre modeller hjälper, men det gör också sandboxar, bekräftelsepolicyer och granskning.
Slutsats
Det som skiljer OpenHands från konkurrenterna är kontroll. Du kan läsa källkoden, hosta den på din egen hårdvara och köra den med vilken modell som helst, inklusive en lokal. Stramare kommersiella verktyg som Claude Code, Cursor och GitHub Copilot ger en bättre upplevelse, men på deras villkor.
Men en agent med åtkomst till din terminal och dina repo:n behöver fortfarande en person som kontrollerar dess arbete. Kom alltid ihåg att läsa diffen och köra testerna själv.
OpenHands är en öppen plattform för att bygga och köra AI‑agenter som arbetar med kod. Dess kodningsagent kan inspektera ett repo, redigera filer, köra kommandon och tester och iterera på resultaten tills en uppgift är klar. Du kan köra den lokalt i Docker, via SDK:t eller på OpenHands Cloud.
Är OpenHands gratis att använda?⌄
OpenHands‑mjukvaran är öppen källkod, så du kan självhosta den utan licenskostnad. Det du betalar för är modellen – hostade leverantörer som Anthropic eller OpenAI tar betalt per token, och agentloopar använder många. Om du kör en lokal modell via Ollama eller LM Studio är den enda kostnaden din hårdvara. OpenHands Cloud är en separat kommersiell tjänst.
Hur skiljer sig OpenHands från GitHub Copilot eller Cursor?⌄
Copilot och Cursor är byggda runt editorn, där AI:n arbetar tillsammans med dig när du skriver kod. OpenHands är agent‑först – du beskriver en uppgift, agenten arbetar med den i en sandbox och du granskar resultatet. Det är också öppen källkod, fungerar med alla modeller som LiteLLM stödjer och körs på din egen infrastruktur, vilket varken Copilot eller Cursor erbjuder i samma utsträckning.
Kan jag köra OpenHands med en lokal modell?⌄
Ja. OpenHands kopplar till lokala servrar som LM Studio, Ollama, vLLM och SGLang via deras OpenAI‑kompatibla API:er. Välj en modell byggd för agentisk kodning, som Devstral Small 2 eller Qwen3.6‑35B‑A3B, och ställ in kontextfönstret till minst 22000 tokens. Mindre generella modeller misslyckas ofta med verktygsanrop och svarar som en chatbot.
Är det säkert att ge OpenHands åtkomst till min kod?⌄
OpenHands kör agentens kommandon i en Docker‑sandbox, vilket skyddar ditt värdsystem från de flesta misstag. Men allt du monterar i sandboxen kan ändras eller raderas, och alla inloggningsuppgifter du tillhandahåller kan användas av agenten. Som standard ber agenten inte om godkännande innan den agerar, så montera bara projektet du behöver, använd begränsade testuppgifter och granska varje diff innan du mergar.
OpenHands är en öppen plattform för AI-driven mjukvaruutveckling, byggd kring en agent som kan inspektera ditt repo, redigera filer, köra kommandon och köra tester. Det är en del av skiftet mot agentisk mjukvaruutveckling – du ger agenten en hel uppgift, och den arbetar sig igenom den steg för steg tills den är klar eller behöver din input.
I den här artikeln går jag igenom OpenHands arkitektur och dess huvudfunktioner, visar hur du sätter upp det med en lokal modell och jämför det med Claude Code, Cursor och GitHub Copilot.
Vad är AI‑agenter? Gå vår AI Agent Fundamentals-track för att upptäcka hur AI‑agenter kan förändra hur du arbetar.
Vad är OpenHands?
OpenHands är en öppen plattform för att bygga och köra AI‑agenter som arbetar med kod.
Namnet täcker två saker. Det första är projektet – en samling repo:n med ett SDK, en server, ett webbläsargränssnitt och en hostad tjänst. Det andra är kodningsagenten som körs ovanpå allt detta.
Så här fungerar det:
När de flesta säger ”OpenHands” menar de agenten. Det är den delen jag jobbar med i den här artikeln.
Vanligtvis ger du agenten en mjukvaruuppgift, pekar den till en arbetsyta med din kod och den arbetar igenom uppgiften med de verktyg den har. Standarduppsättningen är en terminal, en filredigerare och en uppgiftsspårare.
Arbetsytan behöver inte vara din laptop. Agenter kan använda den lokala maskinen som arbetsyta eller köras i efemära arbetsytor, till exempel i Docker eller Kubernetes.
OpenHands låser dig inte heller till en modellleverantör. Du kan använda det med Claude, GPT eller någon annan LLM, inklusive lokala modeller. Agent Canvas kan till och med köra tredjepartsagenter som Claude Code och Codex i stället för standardagenten i OpenHands.
Kort sagt är OpenHands en öppen agentplattform som du kan köra på dina villkor.
Hur OpenHands fungerar
OpenHands körs i en loop.
En chattassistent tar emot din prompt och returnerar text. OpenHands‑agenten får en uppgift, vidtar en åtgärd, tittar på resultatet och bestämmer vad som ska göras härnäst.
OpenHands‑agentens loop
Detta är grundidén:
Loopen stannar antingen när uppgiften är klar, eller när agenten behöver något bara du kan ge, som en saknad autentiseringsuppgift eller ett beslut om krav.
Steg 6 gör OpenHands annorlunda än konkurrenterna. Ett kodkompletteringsverktyg ser aldrig vad som händer när dess kod körs. OpenHands gör det, så den kan reagera på ett misslyckat test och åtgärda orsaken.
Viktiga funktioner i OpenHands
Autokomplettering föreslår text, medan OpenHands agerar i ditt projekt. Så här.
Kodredigering
OpenHands redigerar filer direkt och är inte begränsad till en fil i taget.
Säg att en funktion behöver ett nytt namn. Agenten uppdaterar definitionen, hittar alla anropsställen och uppdaterar testerna som refererar till den – allt som en del av en och samma uppgift.
Terminal och verktygsanvändning
Agenten har en egen terminal. Den kan installera beroenden, köra skript, köra tester och läsa utdata från valfritt kommando.
Du kan också koppla MCP‑servrar (Model Context Protocol) för att ge agenten verktyg den inte är byggd för från början, till exempel ett ärendehanteringssystem eller en databasklient.
Förståelse av repository
De flesta kodgeneratorer ser bara det du klistrar in i prompten.
OpenHands öppnar repot och utforskar det. Den kan läsa README, följa importer och titta på befintliga tester för att förstå hur projektet är strukturerat. Det innebär att dess ändringar mer sannolikt passar den kod som redan finns.
Långa uppgifter skapar ett annat problem – konversationshistoriken växer förbi vad modellen kan hålla. OpenHands hanterar detta med en kontextkondenserare som sammanfattar äldre delar av konversationen så att agenten kan fortsätta arbeta.
Val av modell
Modellanrop går genom LiteLLM, så du kan använda vilken leverantör och modell som helst den stödjer. OpenHands‑dokumentationen rekommenderar modeller från familjerna Claude, GPT och Gemini, plus open‑weight‑modeller som får bra poäng på OpenHands Index.
Om din kod inte får lämna din maskin kan du köra en lokal modell. OpenHands kopplar till lokala servrar som LM Studio, Ollama, vLLM och SGLang.
Kom ihåg att modellen påverkar resultaten mycket. Vissa lokala modeller har svårt med pålitlig verktygsanvändning även med stort kontextfönster.
Autonom uppgiftskörning
När du lämnar över en uppgift arbetar agenten igenom loopen själv. Du behöver inte klistra in fel i en chatt eller säga vilken fil som ska öppnas härnäst.
Agent Canvas tar detta ett steg längre med automationer. De integrerar med Slack, GitHub, Linear och mer och körs enligt schema eller som svar på webhook‑händelser.
Men autonomi garanterar inte korrekthet. Du måste fortfarande granska diffen och testresultaten innan något mergas.
Så använder du OpenHands
Det bästa sättet att förstå OpenHands är att ge den en bugg och se vad den gör.
I det här avsnittet kör jag OpenHands lokalt i Docker, kopplar den till en lokal modell via Ollama och ber den fixa en bugg i ett litet Python‑projekt.
Sätt upp OpenHands
Du kan köra OpenHands på ett par sätt:
CLI‑startare: Installera med
uv tool install openhands --python 3.14, starta sedan GUI:t medopenhands serveDocker: Kör appcontainern direkt med ett enda
docker run‑kommandoAgent Canvas: Den nyare webbläsarklienten som kopplar till lokala, självhostade, Cloud‑ eller Enterprise‑backends
OpenHands Cloud: Den hostade versionen, om du hellre inte vill köra något själv
Jag använder Docker‑vägen med det lokala GUI:t. OpenHands‑dokumentationen listar det nu som den utfasade Docker‑baserade webbläsarapplikationen och pekar på Agent Canvas som ersättare, men den är fortfarande dokumenterad och det snabbaste sättet att få igång ett GUI.
Du behöver Docker Desktop på macOS, Linux eller Windows med WSL. På macOS, öppna Docker Desktop, gå till
Settings > Advancedoch aktivera standard‑Docker‑sockeln.Starta sedan appen:
OpenHands använder Docker‑socket‑mounten för att starta en separat sandbox‑container, och agenten kör sina kommandon i den sandboxen, inte på din värd.
När loggarna visar att servern är uppe, öppna
http://localhost:3000i din webbläsare.OpenHands välkomstsida
Anslut en modell
OpenHands gör ingenting förrän du ger den en modell.
Jag använder Devstral Small 2, Mistrals 24B‑modell byggd för agentisk kodning. Den är tillräckligt lätt för att köra på ett enda RTX 4090 eller en Mac med 32 GB RAM. Den kräver Ollama 0.13.3 eller senare.
Starta Ollama med ett större kontextfönster och hämta modellen:
Underskatta inte kontextlängden. Ollamas standard är 4096 tokens, vilket är för litet för att rymma ens OpenHands systemprompt. Dokumentationen ber om minst 22000.
I OpenHands, öppna
Settings, gå till flikenLLMoch slå påAdvanced. Ställ sedan in:Custom Model:
openai/devstral-small-2:latestBase URL:
http://host.docker.internal:11434/v1API‑nyckel: Valfritt platshållarvärde, som
local-llmLLM‑inställningar för en lokal Ollama‑modell
Prefixet
openai/säger åt OpenHands att prata med Ollama via dess OpenAI‑kompatibla API. API‑nyckeln används inte, men fältet kan inte vara tomt.Öppna ett repo
OpenHands kan inte se dina filer som standard. Du måste montera projektet i sandboxen.
För det här exemplet behöver du en mapp som heter
budget-tracker/projectmed två filer. Den första summerar utgifter per månad:Docstringen lovar
YYYY-MM‑nycklar, mendate[5:7]behåller bara månaden. Januari 2025 och januari 2026 hamnar i samma kategori.Den andra filen har två tester som fångar buggen:
Gör mappen till ett Git‑repo, så du kan se vad agenten ändrar senare:
Om du kör
python -m pytestnu misslyckas båda testerna:Misslyckade tester
För att ge OpenHands åtkomst, stoppa containern och lägg till en rad i
docker run‑kommandot:Så hela kommandot är nu:
Formatet är
host_path:container_path:mode. Ditt projekt dyker upp i sandboxen under/workspace, ochrwtillåter agenten att redigera det.Montera bara det projekt du vill att agenten ska ändra. Allt som monteras läs‑skriv i
/workspacekan modifieras av agenten.Ge agenten en uppgift
Starta en ny konversation och beskriv problemet som du skulle skriva en buggrapport:
De månatliga totalerna slår ihop utgifter från samma månad i olika år.
Hitta orsaken, åtgärda den och kör testerna för att bekräfta att de går igenom.
Det är allt. Du behöver inte peka agenten till
budget.pyeller tala om vilken rad som är fel.Konversationsutdata
Agentloopen från tidigare tar över härifrån. Agenten går igenom
/workspace, läser båda filerna och kör testerna för att se vad som fallerar. Sedan redigerar den koden och kör testerna igen.Agenten kör pytest i sandbox‑terminalen
Granska ändringarna
Agenten säger att den är klar. Du kan nu visa skillnaderna genom att öppna kodredigeraren och inspektera ändringarna i koden.
Den korrekta fixen är en rad i
budget.py:Fixad budget.py
Du kan också köra en
git diff‑kontroll för att se skillnaderna.Detta ska du kontrollera:
Källkoden: Fixen ska ligga i
budget.pyTester: Kontrollera att agenten inte redigerade
test_budget.pyför att få assertionerna att gå igenomTestkörningen: Kör
python -m pytestsjälv – lita inte på agentens sammanfattningOpenHands arkitektur
OpenHands har sex huvuddelar, och varje del har ett enda jobb.
Hur OpenHands‑komponenterna hänger ihop
AI‑modell
Modellen gör resonemanget. Den får uppgiften och konversationshistoriken, och svarar med antingen ett meddelande eller ett verktygsanrop.
Modellen ändrar inte dina filer och kör inte något. Den avgör bara vad som ska hända härnäst. Modellanrop går genom LiteLLM, så samma agent fungerar med en hostad leverantör eller en lokal modell som Devstral‑setup:en i artikeln.
Agentlogik
Agenten står mellan modellen och allt annat. Den kör resonemangs‑ och åtgärdsloopen, vilket innebär att den ber modellen om nästa åtgärd, kör verktyget och hanterar resultatet eller felet.
Den avgör också vad modellen får se. Agenten hanterar konversationshistoriken med kondenserare och lägger till färdigheter och prompts till varje modellförfrågan.
Varje steg loggas. Agenten utför handlingar och får observationer tillbaka, och konversationen behåller den händelsehistoriken. Modellen ser dessa händelser i nästa vända, så den vet vad som redan hänt.
Verktyg och åtgärder
Verktygen är hur agenten påverkar något utanför modellen. Standarduppsättningen inkluderar en terminal, en filredigerare och en uppgiftsspårare, och du kan lägga till fler via MCP‑servrar.
Modellen ber om en åtgärd, som ”kör
pytest” eller ”ersätt rad 8 ibudget.py.” Verktyget kör den och returnerar en observation, som testutdata eller uppdaterad fil.Innan en åtgärd körs passerar den en säkerhetskontroll. Säkerhetsanalysatorn utvärderar varje åtgärd först och kan pausa agenten för ditt godkännande.
Utvecklingsmiljö
Verktygen körs inte på din maskin. De körs i en sandbox.
I Docker‑setupen kör OpenHands agentservern i en egen Docker‑container. Det är därför artikeln monterar Docker‑socketen – appcontainern behöver den för att starta sandboxen.
Sandboxen behöver inte vara lokal. Agenter kan också köras i efemära arbetsytor, till exempel i Docker eller Kubernetes, och Agent Server exponerar körning, verktyg och arbetsytor via REST‑ och WebSocket‑API:er. Agentlogiken är densamma oavsett var sandboxen körs.
Repository
Repot är vad agenten arbetar på. Det kommer in i sandboxen på två sätt: en lokal mapp du monterar, som i artikeln, eller ett repo anslutet via integrationer för GitHub, GitLab eller Bitbucket.
Ett repo kan också tala om för agenten hur den ska bete sig. En
AGENTS.mdi roten injiceras i systemprompten när konversationen startar. Mer fokuserade instruktioner läggs i.agents/skills/, där agenten först ser en sammanfattning och laddar hela innehållet först när det behövs.Här lägger du projektregler som agenten inte kan gissa, som ”kör tester med
make test, intepytest.”Mänsklig granskning
Du är den sista delen av arkitekturen.
OpenHands stödjer tre bekräftelsepolicyer: godkänn varje åtgärd, godkänn inget eller godkänn bara riskabla åtgärder. Den sista beror på säkerhetsanalysatorn, som märker varje åtgärd som LÅG, MEDEL, HÖG eller OKÄND risk. NeverConfirm är standard, så agenten kör utan att stanna om du inte ändrar det.
Den andra kontrollpunkten kommer i slutet. Agentens arbete är inte klart förrän du har läst diffen och kontrollerat testresultaten.
OpenHands arbetsflöden
Jag visade hur man fixar en enradig bugg, men förstås kan OpenHands hantera mycket större uppgifter.
Gemensamt för dessa uppgifter är att de kräver mer än ett steg. Här är sex typer av arbete där agentloopen är vettig.
Fixa buggar
Buggen i den här artikeln var lätt att se i en enda fil. Så är det nästan aldrig i verkligheten.
Säg att applikationsloggarna visar ett
KeyErrori produktion och stacktracen pekar på en funktion tre anrop från där dåliga data kommer in. Du klistrar in stacktracen i OpenHands och ber om en fix.Agenten spårar anropskedjan tillbaka till datakällan, skriver ett test som återskapar felet och bekräftar att testet fallerar. Sedan fixar den koden och kör hela testsviten för att se att inget annat gick sönder.
Ett reproduktionstest är den del du ska leta efter. Det bevisar att agenten hittade den faktiska buggen istället för att bara se var felet visar sig.
Implementera funktioner
Funktionsarbete ändrar vanligtvis fler filer än du tror.
Säg att ett kommandoradsrapports‑skript behöver en
--since‑flagga för att filtrera transaktioner efter datum. Agenten måste hitta argumentparsern, lägga till flaggan, skicka värdet till filterlogiken och uppdatera hjälptexten. Sedan skriver den tester för det nya beteendet och uppdaterar README.Det är fyra eller fem filer för en liten funktion. Agenten håller koll på dem i sin uppgiftsspårare, så den stannar inte efter att den första fungerar.
Refaktorera kod
Refaktorering handlar om att ändra struktur utan att ändra beteende, och testsviten är hur du bevisar att beteendet inte ändrats.
Säg att ett projekt har en stor
utils.pymed datumhjälpare, stränghjälpare och filhjälpare blandade. Du ber OpenHands att dela upp den i tre moduler.Agenten skapar de nya modulerna, flyttar funktionerna och uppdaterar varje import i kodbasen. Den kör testerna efter varje flytt. På så sätt, om något går sönder, vet den vilken flytt som orsakade det.
Skriva tester
Otestad kod är en vanlig startpunkt för agentarbete, eftersom uppgiften är tydlig och lätt att verifiera.
Säg att en modul för datumparsning saknar tester. Agenten läser funktionerna, skriver pytest‑fall för normala indata och edge‑case:er som tomma strängar, skottår och ogiltiga format, och kör dem.
Om ett nytt test fallerar måste agenten avgöra om testet är fel eller om koden har en bugg. Det är ett beslut du själv bör granska.
Undersöka befintliga kodbaser
Inte varje uppgift kräver kodändringar.
Du kan ställa frågor till OpenHands som ”Var validerar den här appen användarindata innan de når databasen?” Agenten söker i kodbasen, följer funktionsanrop över filer och svarar med filsökvägar och radhänvisningar.
Detta är praktiskt när du går med i ett nytt projekt eller tar upp kod du inte ändrat på månader. För läs‑endast‑arbete som detta, montera repot med läget
:roi stället för:rw, så att agenten inte kan ändra något ens av misstag.Köra och felsöka applikationer
Vissa buggar syns bara när applikationen körs.
Säg att en API‑endpoint returnerar 500‑fel och att testerna inte täcker den. Agenten startar servern i sin terminal, skickar en förfrågan med
curloch läser tracebacken från serverloggarna.Sedan fixar den koden, startar om servern och skickar samma förfrågan igen. Om svaret fortfarande är fel fortsätter loopen därifrån.
Detta är samma redigera‑kör‑kontrollera‑cykel som du själv skulle gå igenom, förutom att agenten hanterar varje omstart och varje nytt försök.
OpenHands vs andra AI‑kodningsagenter
OpenHands är inte det enda verktyget som kan ta en uppgift och arbeta sig igenom den på egen hand. Claude Code, Cursor och GitHub Copilot har agentfunktioner nu, men de skiljer sig på viktiga sätt.
OpenHands vs Claude Code
Dessa två är närmast varandra. Båda kör en agentloop som läser kod, redigerar filer, kör kommandon och kontrollerar resultaten.
Den första skillnaden är ägarskap. Varje publikt OpenHands‑repo har sin egen öppna licens, och du kan läsa, ändra och självhosta allt. Claude Code är Anthropics proprietära agentiska kodningsverktyg, tillgängligt i terminal, IDE, skrivbordsapp och webbläsare.
Det leder till modellfrågan. Claude Code är byggt kring Anthropics Claude‑modeller. OpenHands fungerar med varje leverantör som LiteLLM stödjer, inklusive den lokala Ollama‑setupen i artikeln.
Det dagliga arbetsflödet skiljer sig också. Claude Code började som ett terminalverktyg, och där använder många utvecklare det fortfarande. OpenHands förlitar sig på sitt webbläsargränssnitt, och dess CLI är funktionskomplett men främst underhållet för stabilitet.
Båda verktygen låter dig styra agentens beteende. Claude Code läser
CLAUDE.md, inställningar, hooks, färdigheter, kommandon och underagenter från katalogen.claude. OpenHands läserAGENTS.mdoch färdigheter från repot, och SDK:t låter dig bygga egna agenter i Python.Autonomi fungerar olika. Claude Code styr verktygsanvändning med permission‑lägen, hooks och allow/deny‑regler, och kan sandboxa kommandon. OpenHands kör varje kommando i en Docker‑sandbox som standard och lägger till bekräftelsepolicyer ovanpå.
Kort sagt: Claude Code är det polerade alternativet du installerar och använder direkt, medan OpenHands kräver mer setup och ger mer kontroll tillbaka. De utesluter inte heller varandra. Agent Canvas kan köra Claude Code som sin agent i stället för standardagenten i OpenHands.
OpenHands vs Cursor
Cursor är en AI‑kodredigerare. OpenHands är en agentplattform. Det är huvudskillnaden, och de flesta andra följer av den.
I Cursor arbetar du i editorn, och agenten jobbar bredvid dig. Du ser ändringar dyka upp i dina filer, accepterar eller avvisar dem och fortsätter skriva. I OpenHands beskriver du en uppgift, agenten arbetar i en sandbox och du granskar resultatet. GUI:t innehåller en VS Code‑vy in i sandboxen, men det är inte där huvuddelen av arbetet sker.
Repoåtkomst följer samma uppdelning. Cursors agent arbetar på koden som är öppen i din editor. OpenHands arbetar på det du monterar in i dess sandbox eller kopplar via en Git‑integration.
Gapet är mindre med Cursors Cloud Agents. De körs obevakat i molnet och returnerar arbete via brancher och pull requests, och de kräver ett anslutet GitHub‑, GitLab‑, Azure DevOps‑ eller Bitbucket‑konto och en betald plan. Det liknar vad OpenHands gör, men på Cursors infrastruktur.
Utbyggbarhet är där de skiljer sig mest. Cursor stödjer MCP‑servrar och projektsregler, men editorn och agenten är slutna produkter. Med OpenHands kan du ändra själva agenten, hosta den var som helst och köra den på en lokal modell.
OpenHands vs GitHub Copilot
GitHub Copilot började som ett autokompletteringsverktyg i din editor och växte därifrån till agentfunktioner. OpenHands började som en agent.
Copolots största styrka är var det lever. Det fungerar i VS Code och JetBrains IDE:er, och dess molnagent arbetar direkt på GitHub. OpenHands har inte den typen av IDE‑integration.
För repo‑nivå‑uppgifter är Copilots molnagent närmast i jämförelse. Du tilldelar den ett issue, och den arbetar i sin egen efemära utvecklingsmiljö driven av GitHub Actions, där den kan köra tester och linters innan den pushar. OpenHands Cloud gör något liknande när du nämner
@openhandsi en kommentar i ett issue eller en pull request.Plattformen är den stora skillnaden. Copilots molnagent är tillgänglig för alla betalda Copilot‑planer i repo:n som lagras på GitHub. OpenHands fungerar med GitHub, GitLab, Bitbucket eller en lokal mapp, och den kan köras på din egen hårdvara om du vill.
Copilot låter dig välja modell för en uppgift, men bara bland de modeller GitHub erbjuder. OpenHands har inte den begränsningen.
Här är en snabb sammanfattning:
OpenHands jämfört med andra AI‑agenter
OpenHands för mjukvaruteam
För en enskild utvecklare är OpenHands ett verktyg du öppnar när du behöver det. Så är det inte för ett team.
De flesta team organiserar redan arbetet kring issues, och OpenHands Cloud kopplar in där. Det integrerar med GitHub, GitLab och Bitbucket, plus Slack, Jira och Linear. Du kan nämna
@openhandsi en kommentar i ett issue eller en pull request, så plockar agenten upp uppgiften därifrån.Sedan finns arbete ingen ber om men alla behöver. Agent Canvas‑automationer körs enligt schema eller som svar på webhook‑händelser. Till exempel kan ett team dela en Agent Server för kodgranskning och beroendeuppdateringar, medan varje utvecklare kör personliga agenter på sin egen laptop.
Testning fungerar som i artikeln. Agenten kör testsviten i sin sandbox innan den rapporterar tillbaka. Men sandbox‑körningen ersätter inte CI – din pipeline körs fortfarande på varje pull request, precis som för människoskriven kod.
Pull requests är ett annat ämne. När OpenHands Cloud arbetar med GitHub begär det kortlivade tokens som går ut efter åtta timmar, med läs‑ och skrivrättigheter till innehåll, issues, pull requests och workflows. I självhostade Enterprise‑upplägg använder agenten den GitHub‑auktorisering som tillhör användaren som triggat den, så varje ändring kan spåras till en person.
Det är så ansvar ska fungera. Agenten kan öppna pull requesten, men en utvecklare godkänner den. Branch‑skydd och obligatoriska granskningar gäller för agentens pull requests precis som för alla andras.
Isolerade miljöer får allt detta att fungera i skala. Varje uppgift körs i sin egen sandbox, så två agenter som fixar två buggar skriver inte över varandras filer eller slåss om samma port.
OpenHands säkerhet och sandboxing
Ett kodkompletteringsverktyg föreslår alltid text, och sedan är det upp till dig att acceptera den.
En agent är annorlunda. Den går igenom ditt projekt, kör kommandon, installerar paket och redigerar filer på egen hand, ofta utan att fråga. Så frågan går från ”är den här koden korrekt?” till ”vad körde agenten för att komma dit?”
Isolerade körmiljöer
Docker‑sandboxen skyddar dina värdfiler och program, värdresurser och andra containers och processer. Om agenten kör ett destruktivt kommando är det begränsat till en container.
Det finns ett undantag att se upp för i den lokala setupen. Appcontainern monterar värdens Docker‑socket för att kunna starta sandboxar, och åtkomst till den socketen innebär kontroll över Docker på din maskin.
Repo‑behörigheter
Sandboxen skyddar bara det du inte monterar. Monterade filer och kataloger kan ändras eller raderas.
Montera bara projektet du arbetar med, aldrig din hemkatalog. För läs‑endast‑uppgifter som kodundersökning, använd läget
:ro. För Git‑integrationer, ge agenten åtkomst till de specifika repo:n den behöver och inget annat.Hemligheter och inloggningsuppgifter
Om du tillhandahåller inloggningsuppgifter, som API‑nycklar eller tokens, kan agenten använda dem. Och en agent som kan läsa en hemlighet kan också skriva ut den till loggar eller skicka den någonstans.
Så montera inte mappar med
.env‑filer som innehåller produktionsnycklar. Ge agenten testuppgifter med begränsad åtkomst och rotera dem ofta.Nätverksåtkomst
Som standard kan agenten nå internet inifrån containern. Den behöver det för att installera paket, men kan också nå externa tjänster.
Det öppnar dörren för promptinjektion. En webbsida eller en issue‑kommentar kan innehålla instruktioner som agenten kan följa. GitHub begränsar denna risk för sin egen molnagent med en brandvägg som begränsar internetåtkomst som standard, och det är värt att tänka på samma begränsningar för din OpenHands‑setup.
Kommandoexekvering
Du kan styra vilka kommandon som körs utan godkännande. OpenHands stödjer tre bekräftelsepolicyer: godkänn allt, godkänn inget, eller godkänn bara riskabla åtgärder. NeverConfirm är standard.
Alternativet ”riskabla åtgärder” har en hake. Den förvalda LLM‑säkerhetsanalysatorn använder risknivån som modellen tilldelar sina egna åtgärder. En modell kan märka ett destruktivt kommando som LÅG risk, och det körs utan att fråga dig. Analysatorn klassificerar risk för policylagret – den blockerar inte något i sig, och dokumentationen rekommenderar att kombinera den med Docker‑isolering.
Granskning av genererade ändringar
Allt ovan begränsar vad agenten kan göra. Men granskningsfasen är viktig eftersom det är så du kontrollerar vad den gjorde.
Läs hela diffen, inte bara de filer du förväntade dig skulle ändras. Var extra uppmärksam på CI‑konfiguration, beroendefiler och skript. I OpenHands Cloud inkluderar agentens GitHub‑token skrivrättigheter till workflows, så en ändring i
.github/workflowskan ändra vad som körs i din pipeline.Begränsningar i OpenHands
Koden som OpenHands skriver kan fortfarande ha buggar. Att tester går igenom säger bara att koden matchar testerna, och agenten kan skriva båda. Om testerna är svaga kan koden gå igenom och ändå vara fel.
Komplexa uppgifter behöver ofta dig i loopen. Otydliga krav eller ett designbeslut som agenten inte kan ta kommer att stoppa den eller, värre, skicka den i fel riktning.
Med en stark hostad modell hanterar OpenHands flerfiliga uppgifter väl. Med en liten lokal modell ser du misslyckade verktygsanrop och chattbot‑liknande svar, och även med stort kontextfönster kan vissa lokala modeller inte använda verktyg pålitligt.
Agentloopar kostar också mer än chatt. Varje steg skickar tillbaka konversationshistoriken till modellen, och långa uppgifter tar många steg. OpenHands‑dokumentationen varnar för att agenten skickar många prompts till LLM och rekommenderar utgiftstak och användningsövervakning. Kontextkondenseraren hjälper, men den sammanfattar äldre steg, så detaljer kan gå förlorade i långa uppgifter.
Verktygsåtkomst ökar säkerhetsrisken. En agent med terminal och nätverksåtkomst kan orsaka verklig skada om den följer dåliga instruktioner, vilket är varför sandboxen och din granskning är så viktiga.
Och varje ändring behöver fortfarande att en person godkänner den. Ha alltid det i åtanke.
OpenHands och framtiden för AI‑kodningsagenter
AI‑kodningsverktyg gick från autokomplettering till chatt till agenter som arbetar igenom en hel uppgift. OpenHands är ett av ett par projekt som driver det sista steget framåt.
Riktningen syns tydligt i branschen. Cursor beskriver en framväxande era där autonoma molnagenter tar större uppgifter över längre tidsskalor. Copilot tar nu issues från GitHub och Linear. Claude Code körs i terminalen, webbläsaren och Slack.
Öppna plattformar har en särskild roll i det skiftet. Med OpenHands kan du inspektera hur agenten fungerar, köra den på din egen infrastruktur och välja modell. För team med strikta regler för data är det ofta det enda sätt de får använda agenter.
Längre uppgifter för med sig nya problem också. En agent som arbetar i en timme fattar fler beslut än en som arbetar i en minut, och varje beslut är en chans att driva bort från det du ville. Bättre modeller hjälper, men det gör också sandboxar, bekräftelsepolicyer och granskning.
Slutsats
Det som skiljer OpenHands från konkurrenterna är kontroll. Du kan läsa källkoden, hosta den på din egen hårdvara och köra den med vilken modell som helst, inklusive en lokal. Stramare kommersiella verktyg som Claude Code, Cursor och GitHub Copilot ger en bättre upplevelse, men på deras villkor.
Men en agent med åtkomst till din terminal och dina repo:n behöver fortfarande en person som kontrollerar dess arbete. Kom alltid ihåg att läsa diffen och köra testerna själv.
Om du vill lära dig hur du skapar din egen agent från grunden, se vårt webbinar Introduction to Creating AI Agents in Python.