Sari la conținutul principal

OpenHands: Agentul open-source de programare cu AI, explicat

O prezentare a OpenHands, agentul open-source de programare cu AI, care acoperă arhitectura, o configurare locală cu Ollama, un fix practic de bug, securitatea și limitările, și comparația cu Claude Code, Cursor și GitHub Copilot.
· 15 min. citește

Descoperă cu AI

OpenHands este o platformă open-source pentru dezvoltare software asistată de AI, construită în jurul unui agent care poate inspecta depozitul tău, edita fișiere, executa comenzi și rula teste. Face parte din schimbarea către dezvoltarea software agentică — îi dai agentului o sarcină completă, iar acesta lucrează pas cu pas până când o finalizează sau are nevoie de inputul tău.

În acest articol, te ghidez prin arhitectura OpenHands și principalele sale funcționalități, îți arăt cum să-l configurezi cu un model local și îl compar cu Claude Code, Cursor și GitHub Copilot.

Ce sunt agenții AI? Înscrie-te la parcursul AI Agent Fundamentals ca să descoperi cum îți pot schimba agenții AI modul de lucru.

Ce este OpenHands?

OpenHands este o platformă open-source pentru construirea și rularea de agenți AI care lucrează cu cod.

Numele acoperă două lucruri. Primul este proiectul — o colecție de depozite cu un SDK, un server, o interfață de browser și un serviciu găzduit. Al doilea este agentul de programare care rulează peste toate acestea.

Iată cum funcționează:

  • Software Agent SDK: Un set de API-uri Python și REST pentru a construi agenți care lucrează cu cod și motorul din spatele OpenHands CLI și OpenHands Cloud
  • Agent Server: Expune execuția agentului, conversațiile, uneltele și spațiile de lucru prin API-uri REST și WebSocket
  • Agent Canvas: O interfață de browser pentru conversații, fișiere, ieșirea din terminal, configurarea modelului, backend-uri și automatizări
  • OpenHands Cloud: Serviciul comercial gestionat pentru echipele care nu vor să își ruleze propriul backend și infrastructura de sandbox

Când majoritatea oamenilor spun „OpenHands”, se referă la agent. Despre această parte voi vorbi în acest articol.

De obicei, îi dai agentului o sarcină software, îl indici către un workspace cu codul tău, iar el parcurge sarcina cu uneltele pe care le are. Setul implicit include un terminal, un editor de fișiere și un tracker de sarcini.

Workspace-ul nu trebuie să fie laptopul tău. Agenții pot folosi mașina locală ca spațiu de lucru sau pot rula în spații de lucru efemere, de exemplu în Docker sau Kubernetes.

OpenHands nu te leagă nici de un singur furnizor de modele. Îl poți folosi cu Claude, GPT sau orice alt LLM, inclusiv modele locale. Agent Canvas rulează chiar și agenți terți precum Claude Code și Codex în locul agentului implicit OpenHands.

Pe scurt, OpenHands este o platformă de agenți deschisă pe care o poți rula în termenii tăi.

Cum funcționează OpenHands

OpenHands rulează într-o buclă.

Un asistent tip chat primește promptul tău și returnează text. Agentul OpenHands primește o sarcină, ia o acțiune, se uită la rezultat și decide ce face mai departe.

Bucla agentului OpenHands

Bucla agentului OpenHands

Iată ideea generală:

  • Primește sarcina: Descrii obiectivul în limbaj natural, de exemplu „Repară raportul lunar astfel încât să nu unească lunile din ani diferiți”
  • Inspectează depozitul: Agentul listează directoare, deschide fișiere și caută cod legat de sarcină
  • Formează un plan: Împarte sarcina în pași și îi înregistrează în trackerul său
  • Editează sau creează fișiere: Modifică codul cu editorul său de fișiere
  • Rulează comenzi și teste: Rulează suita de teste sau aplicația în terminal
  • Inspectează rezultatele: Citește outputul, inclusiv erorile și aserțiile eșuate
  • Iterează: Dacă ceva încă e stricat, se întoarce, ajustează planul și încearcă din nou

Bucla se oprește fie când sarcina e gata, fie când agentul are nevoie de ceva ce doar tu poți oferi, cum ar fi un credential lipsă sau o decizie de cerințe.

Pasul 6 îl diferențiază pe OpenHands de competiție. Un instrument de completare a codului nu vede niciodată ce se întâmplă când codul generat rulează. OpenHands vede, așa că poate reacționa la un test eșuat și să repare cauza.

Funcționalități cheie ale OpenHands

Autocomplete sugerează text, iar OpenHands acționează asupra proiectului tău. Iată cum.

Editare de cod

OpenHands editează fișiere direct și nu este limitat la un singur fișier pe rând.

Să zicem că o funcție are nevoie de un nume nou. Agentul actualizează definiția, găsește fiecare loc unde e apelată și actualizează testele care o referențiază — toate ca parte a unei singure sarcini.

Terminal și utilizarea uneltelor

Agentul are propriul terminal. Poate instala dependențe, rula scripturi, executa teste și citi outputul oricărei comenzi.

Poți conecta și servere MCP (Model Context Protocol) pentru a-i oferi agentului unelte cu care nu a fost proiectat să lucreze, de exemplu un tracker de issues sau un client de baze de date.

Înțelegerea depozitului

Majoritatea generatorilor de cod văd doar ce lipești în prompt.

OpenHands deschide depozitul și îl explorează. Poate citi README-ul, urmări importurile și se uita la testele existente pentru a înțelege cum e structurat proiectul. Asta înseamnă că modificările sale au șanse mai mari să se potrivească cu codul deja existent.

Sarcinile lungi creează o altă problemă — istoricul conversației crește peste ce poate ține modelul. OpenHands rezolvă asta cu un condensator de context, care rezumă părțile mai vechi ale conversației ca agentul să poată continua să lucreze.

Alegerea modelului

Apelurile către model trec prin LiteLLM, deci poți folosi orice furnizor și model pe care îl suportă. Documentația OpenHands recomandă modele din familiile Claude, GPT și Gemini, plus modele open-weight care obțin scoruri bune în OpenHands Index.

Dacă nu poți scoate codul de pe mașina ta, poți rula un model local. OpenHands se conectează la servere locale precum LM Studio, Ollama, vLLM și SGLang.

De reținut că modelul influențează mult rezultatele. Unele modele locale se chinuie cu utilizarea fiabilă a uneltelor, chiar și cu o fereastră de context mare.

Execuție autonomă a sarcinilor

După ce predai o sarcină, agentul parcurge bucla pe cont propriu. Nu mai lipești erorile într-un chat și nu îi spui ce fișier să deschidă în continuare.

Agent Canvas duce asta mai departe cu automatizări. Acestea se integrează cu Slack, GitHub, Linear și altele și rulează la program sau ca răspuns la webhook-uri.

Dar autonomia nu garantează corectitudinea. Trebuie totuși să verifici diff-ul și rezultatele testelor înainte de orice merge.

Cum să folosești OpenHands

Cel mai bun mod de a înțelege OpenHands este să-i dai un bug și să vezi ce face.

În această secțiune, voi rula OpenHands local în Docker, îl voi conecta la un model local prin Ollama și îi voi cere să repare un bug într-un mic proiect Python.

Configurează OpenHands

Poți rula OpenHands în câteva moduri:

  • Lansator CLI: Instalează-l cu uv tool install openhands --python 3.14, apoi pornește GUI-ul cu openhands serve

  • Docker: Rulează direct containerul aplicației cu o singură comandă docker run

  • Agent Canvas: Clientul de browser mai nou care se conectează la backend-uri locale, self-hosted, Cloud sau Enterprise

  • OpenHands Cloud: Versiunea găzduită, dacă preferi să nu rulezi nimic local

Voi folosi varianta Docker cu Local GUI. Documentația OpenHands o listează acum ca aplicație de browser pe bază de Docker, depreciată, și indică Agent Canvas ca înlocuitor, dar încă este documentată și e cel mai rapid mod de a porni un GUI.

Ai nevoie de Docker Desktop pe macOS, Linux sau Windows cu WSL. Pe macOS, deschide Docker Desktop, mergi la Settings > Advanced și activează socketul Docker implicit.

Apoi pornește aplicația:

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 folosește montarea socketului Docker pentru a porni un container sandbox separat, iar agentul rulează comenzile în acel sandbox, nu pe hostul tău.

După ce logurile arată că serverul a pornit, deschide http://localhost:3000 în browser.

Pagina de întâmpinare OpenHands

Pagina de întâmpinare OpenHands

Conectează un model

OpenHands nu va face nimic până nu îi dai un model.

Folosesc Devstral Small 2, modelul de 24B de la Mistral, construit pentru programare agentică. E suficient de ușor pentru a rula pe un singur RTX 4090 sau pe un Mac cu 32GB RAM. Necesită Ollama 0.13.3 sau mai nou.

Pornește Ollama cu o fereastră de context mai mare și descarcă modelul:

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

Nu ignora lungimea contextului. Implicitul Ollama este 4096 tokeni, prea mic pentru a încăpea chiar și promptul de sistem OpenHands. Documentația cere cel puțin 22000.

În OpenHands, deschide Settings, mergi la fila LLM și activează Advanced. Apoi setează:

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

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

  3. API Key: Orice valoare placeholder, de exemplu local-llm

Setări LLM pentru un model Ollama local

Setări LLM pentru un model Ollama local

Prefixul openai/ îi spune lui OpenHands să vorbească cu Ollama prin API-ul său compatibil OpenAI. Cheia API nu este folosită, dar câmpul nu poate fi gol.

Deschide un depozit

Implicit, OpenHands nu îți poate vedea fișierele. Trebuie să montezi proiectul în sandbox.

Pentru acest exemplu, ai nevoie de un folder numit budget-tracker/project cu două fișiere. Primul însumează cheltuielile pe lună:

# 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

Docstring-ul promite chei YYYY-MM, dar date[5:7] păstrează doar luna. Ianuarie 2025 și ianuarie 2026 vor ajunge în același coș.

Al doilea fișier are două teste care prind bugul:

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

Transformă folderul într-un depozit Git, ca să poți vedea ce modifică agentul mai târziu:

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

Dacă rulezi acum python -m pytest, ambele teste eșuează:

Teste eșuate

Teste eșuate

Pentru a oferi acces lui OpenHands, oprește containerul și adaugă o linie în comanda docker run:

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

Deci comanda completă este acum:

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

Formatul este host_path:container_path:mode. Proiectul tău apare în sandbox sub /workspace, iar rw permite agentului să îl editeze.

Montează doar proiectul pe care vrei ca agentul să îl schimbe. Orice e montat read-write în /workspace poate fi modificat de agent.

Dă-i agentului o sarcină

Începe o conversație nouă și descrie problema așa cum ai scrie un bug report:

Totalurile lunare unesc cheltuielile din aceeași lună din ani diferiți.

Găsește cauza, repar-o și rulează testele ca să confirmi că trec.

Atât. Nu trebuie să îl indici pe agent către budget.py sau să-i spui ce linie e greșită.

Outputul conversației

Outputul conversației

De aici preia bucla agentului prezentată mai devreme. Agentul caută în /workspace, citește ambele fișiere și rulează testele ca să vadă ce eșuează. Apoi editează codul și rulează din nou testele.

Agentul rulând pytest în terminalul sandbox-ului

Agentul rulând pytest în terminalul sandbox-ului

Revizuiește modificările

Agentul spune că a terminat. Acum poți vedea diferențele deschizând editorul de cod și inspectând modificările din cod.

Corecția corectă este o singură linie în budget.py:

month = date[:7]

budget.py reparat

budget.py reparat

Poți face și un git diff ca să vezi diferențele.

Iată ce ar trebui să verifici:

  • Codul sursă: Corecția ar trebui să fie în budget.py

  • Testele: Asigură-te că agentul nu a editat test_budget.py ca să facă aserțiile să treacă

  • Rularea testelor: Rulează tu python -m pytest — nu te baza pe sumarul agentului

Arhitectura OpenHands

OpenHands are șase părți principale, fiecare cu un singur rol.

Cum se conectează componentele OpenHands

Cum se conectează componentele OpenHands

Modelul AI

Modelul face raționamentul. Primește sarcina și istoricul conversației și răspunde fie cu un mesaj, fie cu un apel de unealtă.

Modelul nu îți schimbă fișierele și nu rulează nimic. Doar decide ce ar trebui să se întâmple în continuare. Apelurile la model trec prin LiteLLM, astfel încât același agent funcționează cu un furnizor găzduit sau cu un model local precum configurația Devstral din articol.

Logica agentului

Agentul este între model și restul. Rulează bucla raționament–acțiune, ceea ce înseamnă că cere modelului următoarea acțiune, rulează unealta și gestionează rezultatul sau eroarea.

De asemenea, decide ce vede modelul. Agentul gestionează istoricul conversației cu condensatoare și adaugă abilități și prompturi fiecărei interogări către model.

Fiecare pas este înregistrat. Agentul execută acțiuni și primește observații înapoi, iar conversația păstrează acest istoric de evenimente. Modelul vede aceste evenimente la tura următoare, deci știe ce s-a întâmplat deja.

Unelte și acțiuni

Uneltele sunt modul în care agentul influențează orice e în afara modelului. Setul standard include un terminal, un editor de fișiere și un tracker de sarcini, iar alte unelte pot fi adăugate prin servere MCP.

Modelul cere o acțiune, cum ar fi „rulează pytest” sau „înlocuiește linia 8 din budget.py.” Unealta o execută și returnează o observație, cum ar fi outputul testului sau fișierul actualizat.

Înainte să ruleze o acțiune, trece printr-un control de securitate. Analizorul de securitate evaluează fiecare acțiune și poate pune agentul pe pauză pentru aprobarea ta.

Mediul de dezvoltare

Uneltele nu rulează pe mașina ta. Ele rulează într-un sandbox.

În configurația Docker, OpenHands rulează serverul agent într-un container Docker propriu. De aceea articolul montează socketul Docker — containerul aplicației are nevoie de el pentru a porni sandbox-ul.

Sandbox-ul nu trebuie să fie local. Agenții pot rula și în spații de lucru efemere, de exemplu în Docker sau Kubernetes, iar Agent Server expune execuția, uneltele și spațiile de lucru prin API-uri REST și WebSocket. Logica agentului rămâne aceeași indiferent unde rulează sandbox-ul.

Depozitul

Depozitul este ceea ce lucrează agentul. Ajunge în sandbox în două moduri: un folder local pe care îl montezi, ca în articol, sau un repo conectat prin integrările GitHub, GitLab sau Bitbucket.

Un depozit îi poate spune agentului și cum să se comporte. Un fișier AGENTS.md la rădăcină este injectat în promptul de sistem la începutul conversației. Instrucțiunile mai focalizate merg în .agents/skills/, unde agentul vede mai întâi un rezumat și încarcă conținutul complet doar când are nevoie.

Aici pui reguli de proiect pe care agentul nu le poate ghici, precum „rulează testele cu make test, nu cu pytest.”

Revizuirea umană

Tu ești ultima parte a arhitecturii.

OpenHands suportă trei politici de confirmare: aprobă fiecare acțiune, nu aproba nimic sau aprobă doar acțiunile riscante. Ultima depinde de analizorul de securitate, care etichetează fiecare acțiune ca având risc LOW, MEDIUM, HIGH sau UNKNOWN. Implicit este NeverConfirm, deci agentul rulează fără opriri dacă nu schimbi tu asta.

Al doilea punct de control vine la final. Munca agentului nu e gata până când nu ai citit diff-ul și nu ai verificat rezultatele testelor.

Fluxuri de lucru în OpenHands

Ți-am arătat cum să repari un bug de o linie, dar, desigur, OpenHands poate gestiona sarcini mult mai mari.

Ce au în comun aceste sarcini este că necesită mai mulți pași. Iată șase tipuri de activități unde bucla agentului are sens.

Remedierea bugurilor

Bugul din acest articol a fost ușor de văzut într-un singur fișier. În realitate, aproape niciodată nu e așa.

Să zicem că logurile aplicației arată un KeyError în producție, iar stack trace-ul indică o funcție la trei apeluri de locul unde intră datele greșite. Lipești stack trace-ul în OpenHands și ceri o rezolvare.

Agentul urmărește lanțul de apeluri până la sursa datelor, scrie un test care reproduce eroarea și confirmă că testul eșuează. Apoi repară codul și rulează toată suita de teste pentru a verifica că nu s-a stricat altceva.

Un test de reproducere e elementul de urmărit. Dovedește că agentul a găsit bugul real, nu doar locul unde apare eroarea.

Implementarea de funcționalități

Lucrul pe funcționalități modifică de obicei mai multe fișiere decât te aștepți.

Să zicem că un script de raportare în linie de comandă are nevoie de un flag --since pentru a filtra tranzacțiile după dată. Agentul trebuie să găsească parserul de argumente, să adauge flagul, să transmită valoarea către logica de filtrare și să actualizeze textul de ajutor. Apoi scrie teste pentru noul comportament și actualizează README-ul.

Asta înseamnă patru sau cinci fișiere pentru o singură funcționalitate mică. Agentul le ține evidența în trackerul său, astfel încât nu se oprește după ce primul funcționează.

Refactorizarea codului

Refactorizarea înseamnă schimbarea structurii fără a schimba comportamentul, iar suita de teste este modul în care dovedești că comportamentul nu s-a schimbat.

Să zicem că un proiect are un fișier mare utils.py cu helperi pentru date, stringuri și fișiere amestecați. Ceri OpenHands să îl împartă în trei module.

Agentul creează noile module, mută funcțiile și actualizează fiecare import din cod. Rulează testele după fiecare mutare. Astfel, dacă ceva se rupe, știe ce mutare a cauzat-o.

Scrierea de teste

Codul netestat este un punct de plecare obișnuit pentru munca unui agent, pentru că sarcina e clară și ușor de verificat.

Să zicem că un modul de parsare a datelor nu are teste. Agentul citește funcțiile, scrie cazuri pytest pentru inputuri normale și cazuri-limită precum stringuri goale, ani bisecți și formate invalide și le rulează.

Dacă un test nou eșuează, agentul trebuie să decidă dacă testul e greșit sau codul are un bug. Asta e o decizie pe care ar trebui s-o verifici tu.

Investigarea codurilor existente

Nu fiecare sarcină cere modificări de cod.

Îi poți pune lui OpenHands întrebări precum „Unde validează această aplicație inputul utilizatorului înainte să ajungă la baza de date?” Agentul caută în baza de cod, urmărește apeluri de funcții între fișiere și răspunde cu căi de fișiere și referințe de linii.

E util când te alături unui proiect nou sau reiei cod pe care nu l-ai mai modificat de luni. Pentru muncă doar în citire, montează depozitul cu modul :ro în loc de :rw, astfel încât agentul să nu poată schimba nimic nici accidental.

Rularea și depanarea aplicațiilor

Unele buguri apar doar când aplicația rulează.

Să zicem că un endpoint API întoarce o eroare 500 și testele nu îl acoperă. Agentul pornește serverul în terminalul său, trimite o cerere cu curl și citește traceback-ul din logurile serverului.

Apoi repară codul, repornește serverul și trimite aceeași cerere din nou. Dacă răspunsul tot e greșit, bucla continuă de acolo.

Este același ciclu editează–rulează–verifică prin care ai trece tu, doar că agentul gestionează fiecare restart și fiecare retry.

OpenHands vs alți agenți AI pentru programare

OpenHands nu este singura unealtă care poate prelua o sarcină și o poate parcurge singur. Claude Code, Cursor și GitHub Copilot au acum funcții de tip agent, dar diferă în câteva moduri importante.

OpenHands vs Claude Code

Aceste două se aseamănă cel mai mult. Ambele rulează o buclă de agent care citește cod, editează fișiere, rulează comenzi și verifică rezultatele.

Prima diferență este proprietatea. Fiecare depozit public OpenHands are propria licență open-source și poți citi, modifica și găzdui tu însuți totul. Claude Code este instrumentul proprietar de programare agentică al Anthropic, disponibil în terminal, IDE, aplicație desktop și browser.

Asta duce la întrebarea despre model. Claude Code este construit în jurul modelelor Claude ale Anthropic. OpenHands funcționează cu orice furnizor suportat de LiteLLM, inclusiv configurația locală Ollama din articol.

Fluxul de lucru zilnic diferă și el. Claude Code a pornit ca unealtă de terminal și acolo îl folosesc încă mulți dezvoltatori. OpenHands se bazează pe interfața sa de browser, iar CLI-ul este complet funcțional, dar menținut în principal pentru stabilitate.

Ambele instrumente îți permit să controlezi comportamentul agentului. Claude Code citește CLAUDE.md, setări, hooks, abilități, comenzi și subagenți din directorul .claude. OpenHands citește AGENTS.md și abilități din depozit, iar SDK-ul îți permite să îți construiești propriii agenți în Python.

Autonomia funcționează diferit. Claude Code controlează utilizarea uneltelor cu moduri de permisiune, hooks și reguli de allow/deny și poate sandboxa comenzile. OpenHands rulează implicit fiecare comandă într-un sandbox Docker și adaugă politici de confirmare pe deasupra.

Pe scurt, Claude Code este opțiunea finisată pe care o instalezi și o folosești imediat, în timp ce OpenHands cere mai multă configurare și îți oferă mai mult control în schimb. Nici nu sunt mutual exclusive. Agent Canvas poate rula Claude Code ca agent în locul agentului implicit OpenHands.

OpenHands vs Cursor

Cursor este un editor de cod cu AI. OpenHands este o platformă de agenți. Aceasta e diferența principală, iar celelalte derivă din ea.

În Cursor, lucrezi în editor, iar agentul lucrează lângă tine. Vezi modificările apărând în fișiere, le accepți sau le respingi și continui să scrii. În OpenHands, descrii o sarcină, agentul lucrează într-un sandbox, iar tu revizuiești rezultatul. GUI-ul include o vedere VS Code în sandbox, dar nu acolo are loc majoritatea muncii.

Accesul la depozit urmează aceeași diferențiere. Agentul Cursor lucrează pe codul deschis în editorul tău. OpenHands lucrează pe ceea ce montezi în sandbox sau conectezi printr-o integrare Git.

Diferența e mai mică cu Cloud Agents de la Cursor. Acestea rulează nesupravegheate în cloud și returnează munca prin branch-uri și pull request-uri și au nevoie de un cont conectat GitHub, GitLab, Azure DevOps sau Bitbucket și de un plan plătit. Asta e aproape ceea ce face OpenHands, dar pe infrastructura Cursor.

Extensibilitatea este unde diferă cel mai mult. Cursor suportă servere MCP și reguli de proiect, dar editorul și agentul sunt produse închise. Cu OpenHands, poți schimba chiar agentul, îl poți găzdui oriunde și îl poți rula pe un model local.

OpenHands vs GitHub Copilot

GitHub Copilot a pornit ca un instrument de autocomplete în editor și de acolo a crescut către funcții de agent. OpenHands a pornit ca un agent.

Cel mai mare punct forte al lui Copilot este locul unde trăiește. Funcționează în VS Code și IDE-urile JetBrains, iar agentul cloud lucrează direct pe GitHub. OpenHands nu are o astfel de integrare cu IDE-uri.

Pentru sarcini la nivel de depozit, agentul cloud Copilot este comparația cea mai apropiată. Îi atribui un issue, iar acesta lucrează într-un mediu de dezvoltare efemer alimentat de GitHub Actions, unde poate rula teste și lintere înainte să împingă schimbările. OpenHands Cloud face ceva similar când menționezi @openhands într-un comentariu de issue sau pull request.

Platforma este principala diferență. Agentul cloud Copilot este disponibil pentru toate planurile Copilot plătite în depozite stocate pe GitHub. OpenHands funcționează cu GitHub, GitLab, Bitbucket sau un folder local și rulează pe hardware-ul tău dacă vrei.

Copilot îți permite să alegi un model pentru o sarcină, dar doar dintre modelele oferite de GitHub. OpenHands nu are această restricție.

Iată un scurt rezumat:

 OpenHandsClaude CodeCursorGitHub Copilot
SursăOpen sourceProprietarProprietarProprietar
ModeleOrice furnizor LiteLLM, inclusiv localModele ClaudeMultipli furnizori plus modele propriiModele oferite de GitHub
Interfața principalăInterfață de browser, SDKTerminal, IDE, desktop, browserEditor de cod cu AIExtensie IDE, GitHub
Unde rulează agentulSandbox Docker, local sau remotePe mașina ta sau în cloudul AnthropicÎn editorul tău sau în cloudul CursorÎn IDE-ul tău sau GitHub Actions
Self-hostingDaNuDoar EnterpriseNu

OpenHands comparat cu alți agenți AI

OpenHands pentru echipe de inginerie software

Pentru un singur dezvoltator, OpenHands este o unealtă pe care o deschizi când ai nevoie. Pentru o echipă, nu e la fel.

Majoritatea echipelor organizează deja munca în jurul issue-urilor, iar OpenHands Cloud se integrează cu asta. Se integrează cu GitHub, GitLab și Bitbucket, plus Slack, Jira și Linear. Poți menționa @openhands într-un comentariu de issue sau pull request, iar agentul preia sarcina de acolo.

Apoi există munci pe care nimeni nu le cere direct, dar de care toți au nevoie. Automatizările din Agent Canvas rulează la program sau ca răspuns la webhook-uri. De exemplu, o echipă poate partaja un singur Agent Server pentru code review și actualizări de dependențe, în timp ce fiecare dezvoltator rulează agenți personali pe propriul laptop.

Testarea funcționează la fel ca în articol. Agentul rulează suita de teste în sandbox-ul său înainte să raporteze înapoi. Dar rularea în sandbox nu înlocuiește CI — pipeline-ul tău tot rulează la fiecare pull request, la fel ca pentru codul scris de oameni.

Pull request-urile sunt un alt subiect. Când OpenHands Cloud lucrează cu GitHub, solicită tokenuri cu durată scurtă de viață care expiră după opt ore, cu acces de citire și scriere la conținut, issue-uri, pull request-uri și workflow-uri. În configurațiile Enterprise self-hosted, agentul folosește autorizarea GitHub a utilizatorului care l-a declanșat, deci fiecare schimbare se leagă de o persoană.

Așa ar trebui să funcționeze responsabilitatea. Agentul poate deschide pull request-ul, dar un dezvoltator îl aprobă. Protecția pe branch și review-urile obligatorii se aplică pull request-urilor agentului la fel ca tuturor celorlalți.

Mediile izolate fac ca toate acestea să funcționeze la scară. Fiecare sarcină rulează în propriul sandbox, astfel încât doi agenți care repară două buguri nu își suprascriu fișierele și nu se luptă pentru același port.

Securitate și sandboxing în OpenHands

Un instrument de completare a codului sugerează întotdeauna text, iar apoi depinde de tine dacă îl accepți.

Un agent e diferit. Îți parcurge proiectul, execută comenzi, instalează pachete și editează fișiere de unul singur, adesea fără să întrebe. Așa că întrebarea trece de la „este corect acest cod?” la „ce a rulat agentul ca să ajungă aici?”

Mediile de execuție izolate

Sandbox-ul Docker îți protejează fișierele și programele de pe host, resursele hostului și alte containere și procese. Dacă agentul rulează o comandă distructivă, e limitată la un container.

Există o excepție de urmărit în configurația locală. Containerul aplicației montează socketul Docker al hostului pentru a putea porni sandbox-uri, iar accesul la acel socket înseamnă control asupra Docker pe mașina ta.

Permisiuni pe depozit

Sandbox-ul protejează doar ce nu montezi. Fișierele și directoarele montate pot fi modificate sau șterse.

Montează doar proiectul la care lucrezi, niciodată directorul tău home. Pentru sarcini doar în citire precum investigarea codului, folosește modul :ro . Pentru integrări Git, oferă agentului acces doar la depozitele de care are nevoie și nimic altceva.

Secrete și credentiale

Dacă furnizezi credentiale, precum chei API sau tokenuri, agentul le poate folosi. Iar un agent care poate citi un secret îl poate și tipări în loguri sau trimite undeva.

Așadar, nu monta foldere cu fișiere .env care conțin chei de producție. Dă-i agentului credentiale de test cu domeniu limitat și rotește-le frecvent.

Acces la rețea

Implicit, agentul poate accesa internetul din container. Are nevoie pentru a instala pachete, dar poate, de asemenea, ajunge la orice serviciu extern.

Asta deschide ușa pentru prompt injection. O pagină web sau un comentariu de issue poate include instrucțiuni pe care agentul le-ar putea urma. GitHub limitează acest risc pentru propriul său agent cloud cu un firewall care restricționează implicit accesul la internet și merită să te gândești la aceleași limitări pentru configurația ta OpenHands.

Executarea comenzilor

Poți controla ce comenzi rulează fără aprobare. OpenHands suportă trei politici de confirmare: aprobă tot, nu aproba nimic sau aprobă doar acțiunile riscante. Implicit este NeverConfirm.

Opțiunea „acțiuni riscante” are un neajuns. Analizorul de securitate LLM implicit folosește nivelul de risc pe care modelul îl atribuie propriilor acțiuni. Un model poate eticheta o comandă distructivă ca risc LOW, iar ea va rula fără să te întrebe. Analizorul clasifică riscul pentru stratul de politică — nu blochează nimic de unul singur, iar documentația recomandă combinarea cu izolarea Docker.

Revizuirea schimbărilor generate

Tot ce e de mai sus limitează ce poate face agentul. Dar faza de revizuire este importantă pentru că așa verifici ce a făcut.

Citește diff-ul complet, nu doar fișierele la care te așteptai să se schimbe. Acordă atenție sporită configurației CI, fișierelor de dependențe și scripturilor. În OpenHands Cloud, tokenul GitHub al agentului include permisiune de scriere la workflows, astfel încât o schimbare în .github/workflows poate altera ce rulează în pipeline-ul tău.

Limitările OpenHands

Codul scris de OpenHands poate avea în continuare buguri. Trecerea testelor îți spune doar că codul se potrivește cu testele, iar agentul le poate scrie pe ambele. Dacă testele sunt slabe, codul poate trece și totuși să fie greșit.

Sarcinile complexe adesea au nevoie de tine „în buclă”. Cerințele vagi sau o decizie de design pe care agentul nu o poate lua îl vor opri sau, mai rău, îl vor trimite în direcția greșită.

Cu un model găzduit puternic, OpenHands gestionează bine sarcini pe mai multe fișiere. Cu un model local mic, vei vedea apeluri de unelte eșuate și răspunsuri de tip chatbot, iar chiar și cu o fereastră mare de context, unele modele locale nu folosesc uneltele în mod fiabil.

Buclele agentului costă și mai mult decât chatul. Fiecare pas trimite istoricul conversației înapoi către model, iar sarcinile lungi au mulți pași. Documentația OpenHands avertizează că agentul emite multe prompturi către LLM și recomandă limite de cheltuieli și monitorizarea utilizării. Condensatorul de context ajută, dar rezumă pașii mai vechi, astfel încât detaliile se pot pierde în sarcini lungi.

Accesul la unelte adaugă risc de securitate. Un agent cu terminal și acces la rețea poate produce pagube reale dacă urmează instrucțiuni proaste, motiv pentru care sandbox-ul și revizuirea ta contează atât de mult.

Și fiecare schimbare are în continuare nevoie de o persoană care să o aprobe. Ține minte mereu asta.

OpenHands și viitorul agenților AI pentru programare

Uneltele AI pentru programare au evoluat de la autocomplete la chat, apoi la agenți care parcurg o sarcină întreagă. OpenHands este unul dintre puținele proiecte care împing înainte acest ultim pas.

Direcția este ușor de văzut în industrie. Cursor descrie o eră emergentă în care agenți cloud autonomi preiau sarcini mai mari pe perioade mai lungi. Copilot preia acum issue-uri din GitHub și Linear. Claude Code rulează în terminal, browser și Slack.

Platformele open-source au un rol specific în această schimbare. Cu OpenHands, poți inspecta cum funcționează agentul, îl poți rula pe propria infrastructură și poți alege modelul. Pentru echipe cu reguli stricte de date, adesea este singura modalitate permisă de a folosi agenți.

Sarcinile mai lungi aduc și probleme noi. Un agent care lucrează o oră ia mai multe decizii decât unul care lucrează un minut, iar fiecare decizie e o șansă să devieze de la ce ai vrut. Modelele mai bune ajută, dar la fel și sandbox-urile, politicile de confirmare și revizuirea.

Concluzie

Ceea ce diferențiază OpenHands de competitori este controlul. Poți citi sursa, o poți găzdui pe propriul hardware și o poți rula cu orice model, inclusiv unul local. Uneltele comerciale mai stricte precum Claude Code, Cursor și GitHub Copilot îți oferă o experiență mai bună, dar în termenii lor.

Dar un agent cu acces la terminalul și depozitele tale are în continuare nevoie de o persoană care să-i verifice munca. Amintește-ți mereu să citești diff-ul și să rulezi tu testele.

Dacă vrei să înveți cum să creezi agentul tău de la zero, urmărește webinarul nostru Introduction to Creating AI Agents in Python.

Întrebări frecvente

Ce este OpenHands?

OpenHands este o platformă open-source pentru construirea și rularea de agenți AI care lucrează cu cod. Agentul său de programare poate inspecta un depozit, edita fișiere, rula comenzi și teste și itera pe rezultate până când o sarcină este gata. Îl poți rula local în Docker, prin SDK sau pe OpenHands Cloud.

OpenHands este gratuit de utilizat?

Software-ul OpenHands este open-source, deci îl poți găzdui singur fără a plăti o licență. Ce plătești este modelul — furnizorii găzduiți precum Anthropic sau OpenAI taxează per token, iar buclele agentului folosesc multe. Dacă rulezi un model local prin Ollama sau LM Studio, singurul cost este hardware-ul tău. OpenHands Cloud este un serviciu comercial separat.

Cu ce este diferit OpenHands față de GitHub Copilot sau Cursor?

Copilot și Cursor sunt construite în jurul editorului, unde AI lucrează alături de tine în timp ce scrii cod. OpenHands este „agent-first” — descrii o sarcină, agentul lucrează la ea într-un sandbox, iar tu revizuiești rezultatul. Este, de asemenea, open-source, funcționează cu orice model suportat de LiteLLM și rulează pe propria infrastructură, lucru pe care nici Copilot, nici Cursor nu îl oferă în aceeași măsură.

Pot rula OpenHands cu un model local?

Da. OpenHands se conectează la servere locale precum LM Studio, Ollama, vLLM și SGLang prin API-urile lor compatibile OpenAI. Alege un model construit pentru programare agentică, precum Devstral Small 2 sau Qwen3.6-35B-A3B, și setează fereastra de context la cel puțin 22000 de tokeni. Modelele generale mai mici eșuează adesea la apelurile de unelte și răspund ca un chatbot.

Este sigur să îi ofer OpenHands acces la codul meu?

OpenHands rulează comenzile agentului într-un sandbox Docker, care îți protejează sistemul gazdă de majoritatea greșelilor. Dar orice montezi în sandbox poate fi modificat sau șters, iar orice credentiale furnizezi pot fi folosite de agent. Implicit, agentul nu cere aprobare înainte să acționeze, așa că montează doar proiectul de care ai nevoie, folosește credentiale de test limitate și revizuiește fiecare diff înainte să îl faci merge.

Subiecte