Przejdź do głównej treści

OpenHands: wyjaśnienie otwartoźródłowego agenta do kodowania AI

Przegląd OpenHands — otwartoźródłowego agenta do kodowania AI — obejmujący jego architekturę, lokalną konfigurację z Ollamą, praktyczną naprawę błędu, bezpieczeństwo i ograniczenia oraz porównanie z Claude Code, Cursor i GitHub Copilot.
· 15 min przeczytaj

Odkryj z AI

OpenHands to otwartoźródłowa platforma do tworzenia oprogramowania z użyciem AI, zbudowana wokół agenta, który potrafi przejrzeć twoje repozytorium, edytować pliki, wykonywać polecenia i uruchamiać testy. To część zwrotu w stronę agencyjnego tworzenia oprogramowania — przekazujesz agentowi całe zadanie, a on przechodzi przez nie krok po kroku, aż je skończy albo będzie potrzebował twojego wkładu.

W tym artykule przeprowadzę cię przez architekturę OpenHands i jego najważniejsze funkcje, pokażę, jak skonfigurować go z lokalnym modelem oraz porównam z Claude Code, Cursor i GitHub Copilot.

Czym są agenci AI? Zapisz się na nasz kurs podstawowy AI Agent Fundamentals, aby odkryć, jak agenci AI mogą zmienić sposób twojej pracy.

Czym jest OpenHands?

OpenHands to otwartoźródłowa platforma do budowania i uruchamiania agentów AI pracujących z kodem.

Nazwa obejmuje dwie rzeczy. Po pierwsze projekt — zbiór repozytoriów z SDK, serwerem, interfejsem przeglądarkowym i hostowaną usługą. Po drugie — agenta do kodowania działającego na tym wszystkim.

Tak to działa:

  • Software Agent SDK: Zestaw interfejsów API w Pythonie i REST do budowania agentów pracujących z kodem oraz silnik stojący za OpenHands CLI i OpenHands Cloud
  • Agent Server: Udostępnia wykonywanie agenta, konwersacje, narzędzia i przestrzenie robocze poprzez API REST i WebSocket
  • Agent Canvas: Jeden interfejs przeglądarkowy do konwersacji, plików, wyjścia terminala, konfiguracji modelu, backendów i automatyzacji
  • OpenHands Cloud: Zarządzana usługa komercyjna dla zespołów, które nie chcą uruchamiać własnego backendu i infrastruktury sandbox

Gdy większość osób mówi „OpenHands”, ma na myśli agenta. To z nim będę pracował w tym artykule.

Zwykle przekazujesz agentowi zadanie programistyczne, wskazujesz mu przestrzeń roboczą z twoim kodem, a on realizuje zadanie narzędziami, które ma. Domyślny zestaw to terminal, edytor plików i tracker zadań.

Przestrzeń robocza nie musi być twoim laptopem. Agenci mogą używać lokalnej maszyny jako przestrzeni roboczej albo działać w efemerycznych środowiskach, np. w Dockerze lub Kubernetesie.

OpenHands nie wiąże cię też z jednym dostawcą modeli. Możesz używać Claude, GPT lub dowolnego innego LLM, także lokalnych. Agent Canvas potrafi nawet uruchamiać zewnętrznych agentów, takich jak Claude Code i Codex, zamiast domyślnego agenta OpenHands.

Krótko mówiąc, OpenHands to otwarta platforma agentowa, którą możesz uruchamiać na własnych zasadach.

Jak działa OpenHands

OpenHands działa w pętli.

Asystent czatu dostaje twój prompt i zwraca tekst. Agent OpenHands dostaje zadanie, wykonuje akcję, patrzy na wynik i decyduje, co zrobić dalej.

The OpenHands agent loop

Pętla agenta OpenHands

Ogólny zarys wygląda tak:

  • Odbierz zadanie: Opisujesz cel zwykłym językiem, np. „Napraw miesięczny raport, żeby nie łączył miesięcy z różnych lat”
  • Przejrzyj repozytorium: Agent wyświetla katalogi, otwiera pliki i wyszukuje kod związany z zadaniem
  • Ułóż plan: Dzieli zadanie na kroki i zapisuje je w swoim trackerze zadań
  • Edytuj lub twórz pliki: Zmienia kod w swoim edytorze plików
  • Uruchamiaj polecenia i testy: Uruchamia zestaw testów lub aplikację w terminalu
  • Analizuj wyniki: Czyta wyjście, w tym błędy i nieudane asercje
  • Iteruj: Jeśli coś nadal nie działa, wraca, koryguje plan i próbuje ponownie

Pętla zatrzymuje się, gdy zadanie jest skończone albo agent potrzebuje czegoś, co tylko ty możesz dostarczyć, np. brakującego uwierzytelnienia lub decyzji dotyczącej wymagań.

Krok 6 odróżnia OpenHands od konkurencji. Narzędzie do uzupełniania kodu nigdy nie widzi, co się dzieje, gdy jego kod się uruchomi. OpenHands widzi, więc może zareagować na nieudany test i naprawić przyczynę.

Kluczowe funkcje OpenHands

Autocomplete podpowiada tekst, a OpenHands działa na twoim projekcie. Oto jak.

Edycja kodu

OpenHands edytuje pliki bezpośrednio i nie ogranicza się do jednego pliku naraz.

Załóżmy, że funkcja potrzebuje nowej nazwy. Agent aktualizuje definicję, znajduje każde miejsce wywołania i aktualizuje testy, które do niej się odwołują — wszystko w ramach jednego zadania.

Terminal i korzystanie z narzędzi

Agent ma własny terminal. Potrafi instalować zależności, uruchamiać skrypty, wykonywać testy i czytać wyjście dowolnego polecenia.

Możesz też podłączyć serwery MCP (Model Context Protocol), aby dać agentowi narzędzia, do których nie był projektowany, np. tracker zgłoszeń czy klient bazy danych.

Rozumienie repozytorium

Większość generatorów kodu widzi tylko to, co wkleisz do promptu.

OpenHands otwiera repozytorium i je eksploruje. Potrafi czytać README, śledzić importy i zaglądać do istniejących testów, aby zrozumieć strukturę projektu. Dzięki temu jego zmiany częściej pasują do zastanego kodu.

Długie zadania tworzą inny problem — historia konwersacji rośnie ponad to, co model może utrzymać. OpenHands radzi sobie z tym za pomocą kondensatora kontekstu, który streszcza starsze części rozmowy, aby agent mógł kontynuować pracę.

Wybór modelu

Wywołania modelu przechodzą przez LiteLLM, więc możesz używać dowolnego dostawcy i modelu, które wspiera. Dokumentacja OpenHands poleca modele z rodzin Claude, GPT i Gemini, a także modele open-weight z dobrymi wynikami w OpenHands Index.

Jeśli twój kod nie może opuszczać twojej maszyny, możesz uruchomić lokalny model. OpenHands łączy się z lokalnymi serwerami takimi jak LM Studio, Ollama, vLLM i SGLang.

Warto pamiętać, że wybór modelu mocno wpływa na rezultaty. Niektóre lokalne modele mają problem z niezawodnym użyciem narzędzi, nawet przy dużym oknie kontekstu.

Autonomiczne wykonywanie zadań

Gdy przekażesz zadanie, agent sam przechodzi przez pętlę. Nie wklejasz błędów do czatu ani nie mówisz mu, który plik otworzyć dalej.

Agent Canvas idzie o krok dalej dzięki automatyzacjom. Integrują się ze Slackiem, GitHubem, Linear i innymi, działają według harmonogramu lub w odpowiedzi na zdarzenia z webhooków.

Ale autonomia nie gwarantuje poprawności. Nadal musisz przejrzeć diff i wyniki testów, zanim cokolwiek zostanie zmergowane.

Jak używać OpenHands

Najlepszym sposobem na zrozumienie OpenHands jest dać mu buga i zobaczyć, co zrobi.

W tej części uruchomię OpenHands lokalnie w Dockerze, podłączę go do lokalnego modelu przez Ollama i poproszę o naprawienie buga w małym projekcie Pythona.

Skonfiguruj OpenHands

OpenHands możesz uruchomić na kilka sposobów:

  • Launcher CLI: Zainstaluj poleceniem uv tool install openhands --python 3.14, a następnie uruchom GUI poleceniem openhands serve

  • Docker: Uruchom kontener aplikacji bezpośrednio jednym poleceniem docker run

  • Agent Canvas: Nowszy klient przeglądarkowy łączący się z lokalnymi, self‑hosted, Cloud lub Enterprise backendami

  • OpenHands Cloud: Wersja hostowana, jeśli wolisz niczego samodzielnie nie uruchamiać

Użyję ścieżki Docker z Lokalnym GUI. Dokumentacja OpenHands określa to jako przestarzałą aplikację przeglądarkową opartą na Dockerze i wskazuje Agent Canvas jako jej następcę, ale nadal jest udokumentowana i to najszybszy sposób, by uruchomić GUI.

Potrzebujesz Docker Desktop na macOS, Linux lub Windows z WSL. Na macOS otwórz Docker Desktop, przejdź do Settings > Advanced i włącz domyślny socket Dockera.

Następnie uruchom aplikację:

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 używa zamontowanego gniazda Dockera, aby uruchomić osobny kontener sandbox, a agent wykonuje swoje polecenia wewnątrz tego sandboxa, nie na twoim hoście.

Gdy logi pokażą, że serwer działa, otwórz w przeglądarce http://localhost:3000.

OpenHands welcome page

Strona powitalna OpenHands

Podłącz model

OpenHands nic nie zrobi, dopóki nie dasz mu modelu.

Używam Devstral Small 2, 24‑miliardowego modelu Mistrala zbudowanego do agencyjnego kodowania. Jest na tyle lekki, że działa na pojedynczym RTX 4090 lub Macu z 32 GB RAM. Wymaga Ollama 0.13.3 lub nowszej.

Uruchom Ollama z większym oknem kontekstu i pobierz model:

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

Nie lekceważ długości kontekstu. Domyślnie Ollama ma 4096 tokenów, co jest zbyt mało, by zmieścić nawet prompt systemowy OpenHands. Dokumentacja wymaga co najmniej 22000.

W OpenHands otwórz Settings, przejdź do karty LLM i włącz Advanced. Następnie ustaw:

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

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

  3. API Key: Dowolna wartość zastępcza, np. local-llm

LLM settings for a local Ollama model

Ustawienia LLM dla lokalnego modelu Ollama

Prefix openai/ mówi OpenHands, by rozmawiał z Ollamą przez jej API kompatybilne z OpenAI. Klucz API nie jest używany, ale to pole nie może być puste.

Otwórz repozytorium

Domyślnie OpenHands nie widzi twoich plików. Musisz zamontować projekt do sandboxa.

Do tego przykładu potrzebujesz folderu budget-tracker/project z dwoma plikami. Pierwszy sumuje wydatki w podziale na miesiące:

# 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 obiecuje klucze YYYY-MM, ale date[5:7] zachowuje tylko miesiąc. Styczeń 2025 i styczeń 2026 trafią do tego samego kubełka.

Drugi plik ma dwa testy wyłapujące błąd:

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

Zamień folder w repozytorium Git, żebyś później zobaczył, co agent zmienił:

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

Jeśli teraz uruchomisz python -m pytest, oba testy zawiodą:

Failing tests

Nieskuteczne testy

Aby dać OpenHands dostęp, zatrzymaj kontener i dodaj jedną linię do polecenia docker run:

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

Pełne polecenie wygląda teraz tak:

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

Format to host_path:container_path:mode. Twój projekt pojawi się w sandboxie pod /workspace, a rw pozwala agentowi go edytować.

Montuj tylko projekt, który agent ma zmieniać. Wszystko zamontowane z prawami zapisu do /workspace może zostać zmodyfikowane przez agenta.

Daj agentowi zadanie

Rozpocznij nową konwersację i opisz problem tak, jak napisałbyś zgłoszenie błędu:

Suma miesięczna łączy wydatki z tego samego miesiąca w różnych latach.

Znajdź przyczynę, napraw to i uruchom testy, aby potwierdzić, że przechodzą.

I tyle. Nie musisz wskazywać agentowi budget.py ani mówić, która linia jest błędna.

Conversation output

Wynik konwersacji

Od tego momentu przejmuje pętla agenta z wcześniejszego opisu. Agent przegląda /workspace, czyta oba pliki i uruchamia testy, by zobaczyć, co nie przechodzi. Następnie edytuje kod i ponownie uruchamia testy.

The agent running pytest in the sandbox terminal

Agent uruchamiający pytest w terminalu sandboxa

Przejrzyj zmiany

Agent twierdzi, że skończył. Teraz możesz zobaczyć różnice, otwierając edytor kodu i przeglądając zmiany w kodzie.

Poprawka to jedna linia w budget.py:

month = date[:7]

Fixed budget.py

Naprawiony budget.py

Możesz też wykonać git diff, żeby zobaczyć różnice.

Na co zwrócić uwagę:

  • Kod źródłowy: Poprawka powinna być w budget.py

  • Testy: Upewnij się, że agent nie edytował test_budget.py, aby wymusić przejście asercji

  • Uruchomienie testów: Uruchom sam python -m pytest — nie polegaj na podsumowaniu agenta

Architektura OpenHands

OpenHands ma sześć głównych części i każda ma jedno zadanie.

How the OpenHands components connect

Jak łączą się komponenty OpenHands

Model AI

Model wykonuje rozumowanie. Dostaje zadanie i historię rozmowy, a odpowiada wiadomością lub wywołaniem narzędzia.

Model nie zmienia twoich plików ani niczego nie uruchamia. Tylko decyduje, co powinno stać się dalej. Wywołania modelu przechodzą przez LiteLLM, więc ten sam agent działa z hostowanym dostawcą albo z lokalnym modelem jak Devstral z artykułu.

Logika agenta

Agent jest pomiędzy modelem a resztą. Uruchamia pętlę rozumowanie‑akcja, czyli prosi model o kolejną akcję, uruchamia narzędzie i obsługuje wynik lub błąd.

Decyduje też, co model zobaczy. Agent zarządza historią rozmowy za pomocą kondensatorów i dodaje umiejętności oraz prompty do każdego zapytania do modelu.

Każdy krok jest rejestrowany. Agent wykonuje akcje i dostaje obserwacje zwrotne, a konwersacja zachowuje tę historię zdarzeń. Model widzi te zdarzenia w kolejnej turze, więc wie, co już się wydarzyło.

Narzędzia i akcje

Narzędzia to sposób, w jaki agent wpływa na coś poza modelem. Standardowy zestaw obejmuje terminal, edytor plików i tracker zadań, a więcej możesz dodać przez serwery MCP.

Model prosi o akcję, np. „uruchom pytest” albo „zamień linię 8 w budget.py.” Narzędzie ją wykonuje i zwraca obserwację, np. wyjście testów albo zaktualizowany plik.

Przed uruchomieniem akcji przechodzi ona przez kontrolę bezpieczeństwa. Analizator bezpieczeństwa ocenia każdą akcję i może wstrzymać agenta do twojej akceptacji.

Środowisko deweloperskie

Narzędzia nie działają na twojej maszynie. Działają w sandboxie.

W konfiguracji Docker OpenHands uruchamia serwer agenta w swoim własnym kontenerze Dockera. Dlatego artykuł montuje gniazdo Dockera — kontener aplikacji go potrzebuje, aby uruchamiać sandboxy.

Sandbox nie musi być lokalny. Agenci mogą działać w efemerycznych przestrzeniach roboczych, np. w Dockerze lub Kubernetesie, a Agent Server udostępnia wykonywanie, narzędzia i przestrzenie robocze przez API REST i WebSocket. Logika agenta jest taka sama niezależnie od miejsca działania sandboxa.

Repozytorium

Repozytorium to to, nad czym agent pracuje. Trafia do sandboxa na dwa sposoby: lokalny folder, który montujesz (jak w artykule), lub repo podłączone przez integracje z GitHub, GitLab lub Bitbucket.

Repozytorium może też instruować agenta, jak ma się zachowywać. Plik AGENTS.md w katalogu głównym jest wstrzykiwany do promptu systemowego na początku rozmowy. Bardziej ukierunkowane instrukcje trafiają do .agents/skills/, gdzie agent najpierw widzi podsumowanie, a pełną treść ładuje tylko wtedy, gdy jej potrzebuje.

Tu umieszczasz reguły projektu, których agent nie odgadnie sam, np. „uruchamiaj testy poleceniem make test, nie pytest.”

Przegląd przez człowieka

Ty jesteś ostatnią częścią architektury.

OpenHands obsługuje trzy polityki potwierdzania: zatwierdzaj każdą akcję, nie zatwierdzaj żadnej albo zatwierdzaj tylko ryzykowne akcje. Ostatnia zależy od analizatora bezpieczeństwa, który oznacza każdą akcję jako LOW, MEDIUM, HIGH lub UNKNOWN risk. Domyślnie jest NeverConfirm, więc agent działa bez zatrzymywania się, dopóki tego nie zmienisz.

Drugi punkt kontrolny jest na końcu. Praca agenta nie jest skończona, dopóki nie przeczytasz diffu i nie sprawdzisz wyników testów.

Workflowy OpenHands

Pokazałem, jak naprawić błąd jedną linią, ale oczywiście OpenHands poradzi sobie z dużo większymi zadaniami.

Wspólne dla nich jest to, że wymagają więcej niż jednego kroku. Oto sześć typów pracy, w których pętla agenta ma sens.

Naprawianie błędów

Błąd pokazany w tym artykule łatwo było zauważyć w jednym pliku. W prawdziwym świecie prawie nigdy tak nie jest.

Załóżmy, że logi aplikacji pokazują KeyError na produkcji, a stack trace wskazuje na funkcję oddaloną o trzy wywołania od miejsca, gdzie wchodzą złe dane. Wklejasz stack trace do OpenHands i prosisz o poprawkę.

Agent śledzi łańcuch wywołań do źródła danych, pisze test odtwarzający błąd i potwierdza, że test nie przechodzi. Potem naprawia kod i uruchamia pełny zestaw testów, by sprawdzić, czy nic innego się nie zepsuło.

Test reprodukcji to element, na który warto patrzeć. Dowodzi, że agent znalazł właściwą usterkę, a nie tylko miejsce, gdzie pojawia się błąd.

Implementacja funkcji

Praca nad funkcją zwykle modyfikuje więcej plików, niż byś się spodziewał.

Załóżmy, że skrypt raportu wiersza poleceń potrzebuje flagi --since do filtrowania transakcji po dacie. Agent musi znaleźć parser argumentów, dodać flagę, przekazać wartość do logiki filtra i zaktualizować tekst pomocy. Potem pisze testy dla nowego zachowania i aktualizuje README.

To cztery lub pięć plików dla jednej małej funkcji. Agent śledzi je w swoim trackerze zadań, więc nie kończy po tym, jak pierwszy element zadziała.

Refaktoryzacja kodu

Refaktoryzacja polega na zmianie struktury bez zmiany zachowania, a zestaw testów dowodzi, że zachowanie się nie zmieniło.

Załóżmy, że projekt ma jeden duży plik utils.py z mieszanką helperów dat, stringów i plików. Prosisz OpenHands o podział na trzy moduły.

Agent tworzy nowe moduły, przenosi funkcje i aktualizuje każdy import w całej bazie kodu. Uruchamia testy po każdym przeniesieniu. Dzięki temu, jeśli coś pęknie, wie, który ruch to spowodował.

Pisanie testów

Nietestowany kod to częsty punkt startowy pracy agenta, bo zadanie jest jasne i łatwe do weryfikacji.

Załóżmy, że moduł parsowania dat nie ma testów. Agent czyta funkcje, pisze przypadki pytest dla normalnych wejść i krawędziowych, jak puste stringi, lata przestępne i nieprawidłowe formaty, i je uruchamia.

Jeśli nowy test zawiedzie, agent musi zdecydować, czy test jest zły, czy kod ma błąd. To decyzja, którą powinieneś sprawdzić sam.

Badanie istniejących baz kodu

Nie każde zadanie wymaga zmian w kodzie.

Możesz pytać OpenHands o rzeczy w stylu „Gdzie ta aplikacja waliduje dane wejściowe użytkownika, zanim trafią do bazy danych?”. Agent przeszukuje bazę kodu, śledzi wywołania funkcji między plikami i odpowiada ścieżkami plików oraz referencjami do linii.

To przydatne, gdy dołączasz do nowego projektu lub wracasz do kodu po miesiącach. Do pracy tylko do odczytu zamontuj repo w trybie :ro zamiast :rw, by agent nie mógł nic zmienić nawet przypadkiem.

Uruchamianie i debugowanie aplikacji

Niektóre błędy ujawniają się tylko podczas działania aplikacji.

Załóżmy, że endpoint API zwraca błąd 500, a testy go nie obejmują. Agent uruchamia serwer w swoim terminalu, wysyła żądanie curl i czyta traceback z logów serwera.

Potem naprawia kod, restartuje serwer i wysyła to samo żądanie ponownie. Jeśli odpowiedź nadal jest zła, pętla toczy się dalej.

To ten sam cykl edytuj‑uruchom‑sprawdź, przez który sam byś przechodził, tylko że agent obsługuje każdy restart i każdą próbę.

OpenHands vs inne agenty do kodowania AI

OpenHands nie jest jedynym narzędziem, które potrafi wziąć zadanie i samodzielnie je przepracować. Claude Code, Cursor i GitHub Copilot mają dziś funkcje agentowe, ale różnią się w ważnych aspektach.

OpenHands vs Claude Code

Te dwa są do siebie najbliższe. Oba uruchamiają pętlę agenta, która czyta kod, edytuje pliki, uruchamia polecenia i sprawdza wyniki.

Pierwsza różnica to własność. Każde publiczne repozytorium OpenHands ma własną licencję open source i możesz wszystko czytać, modyfikować i samodzielnie hostować. Claude Code to własnościowe narzędzie agentowe Anthropic, dostępne w terminalu, IDE, aplikacji desktopowej i przeglądarce.

To prowadzi do kwestii modelu. Claude Code jest zbudowany wokół modeli Claude Anthropic. OpenHands działa z dowolnym dostawcą wspieranym przez LiteLLM, w tym z lokalną konfiguracją Ollama z artykułu.

Codzienny workflow też się różni. Claude Code zaczynał jako narzędzie terminalowe i tam wielu deweloperów nadal go używa. OpenHands opiera się na interfejsie przeglądarkowym, a jego CLI jest kompletne funkcjonalnie, ale utrzymywane głównie dla stabilności.

Oba narzędzia pozwalają sterować zachowaniem agenta. Claude Code czyta CLAUDE.md, ustawienia, hooki, umiejętności, komendy i sub‑agentów z katalogu .claude. OpenHands czyta AGENTS.md i umiejętności z repozytorium, a SDK pozwala budować własnych agentów w Pythonie.

Autonomia działa w każdym z nich inaczej. Claude Code kontroluje użycie narzędzi trybami uprawnień, hookami i regułami allow/deny i potrafi izolować polecenia. OpenHands domyślnie uruchamia każde polecenie w sandboxie Dockera i dodaje na to polityki potwierdzania.

W skrócie, Claude Code to dopracowana opcja, którą instalujesz i od razu używasz, podczas gdy OpenHands wymaga więcej konfiguracji, ale daje w zamian większą kontrolę. Nie są też wzajemnie wykluczające się. Agent Canvas może uruchomić Claude Code jako swojego agenta zamiast domyślnego agenta OpenHands.

OpenHands vs Cursor

Cursor to edytor kodu z AI. OpenHands to platforma agentowa. To główna różnica i większość pozostałych z niej wynika.

W Cursor pracujesz w edytorze, a agent działa obok ciebie. Widzisz edycje pojawiające się w twoich plikach, akceptujesz lub odrzucasz je i piszesz dalej. W OpenHands opisujesz zadanie, agent pracuje w sandboxie, a ty przeglądasz wynik. GUI zawiera widok VS Code do sandboxa, ale to nie tam dzieje się większość pracy.

Dostęp do repozytorium działa podobnie. Agent Cursora pracuje na kodzie otwartym w twoim edytorze. OpenHands pracuje na tym, co zamontujesz w jego sandboxie lub podłączysz przez integrację Git.

Różnica jest mniejsza przy Cloud Agents Cursora. Działają bez nadzoru w chmurze i zwracają pracę przez branche i pull requesty, potrzebują połączonego konta GitHub, GitLab, Azure DevOps lub Bitbucket i płatnego planu. To zbliżone do OpenHands, ale na infrastrukturze Cursora.

Największa różnica jest w rozszerzalności. Cursor wspiera serwery MCP i reguły projektu, ale edytor i agent są produktami zamkniętymi. W OpenHands możesz zmienić samego agenta, hostować go gdzie chcesz i uruchamiać na lokalnym modelu.

OpenHands vs GitHub Copilot

GitHub Copilot zaczął jako narzędzie autouzupełniania w edytorze i z czasem zyskał funkcje agentowe. OpenHands od początku był agentem.

Największą siłą Copilota jest miejsce działania. Działa w VS Code i IDE JetBrains, a jego agent chmurowy działa bezpośrednio na GitHubie. OpenHands nie ma takiej integracji z IDE.

Dla zadań na poziomie repo najbliższe porównanie to agent chmurowy Copilota. Przypisujesz mu issue, a on pracuje w własnym efemerycznym środowisku deweloperskim zasilanym przez GitHub Actions, gdzie może uruchamiać testy i lintery przed wypchnięciem zmian. OpenHands Cloud robi coś podobnego, gdy wspomnisz @openhands w komentarzu do issue lub pull requesta.

Główna różnica to platforma. Agent chmurowy Copilota jest dostępny we wszystkich płatnych planach Copilota w repozytoriach na GitHubie. OpenHands działa z GitHub, GitLab, Bitbucket lub lokalnym folderem i może działać na twoim własnym sprzęcie, jeśli tego chcesz.

Copilot pozwala wybrać model dla zadania, ale tylko spośród modeli oferowanych przez GitHub. OpenHands nie ma tego ograniczenia.

Oto szybkie podsumowanie:

 OpenHandsClaude CodeCursorGitHub Copilot
ŹródłaOpen sourceWłasnościoweWłasnościoweWłasnościowe
ModeleDowolny dostawca LiteLLM, w tym lokalneModele ClaudeWielu dostawców plus modele własneModele oferowane przez GitHub
Główny interfejsInterfejs przeglądarkowy, SDKTerminal, IDE, desktop, przeglądarkaEdytor kodu z AIWtyczka IDE, GitHub
Gdzie działa agentSandbox Dockera, lokalnie lub zdalnieTwoja maszyna lub chmura AnthropicTwój edytor lub chmura CursoraTwoje IDE lub GitHub Actions
Self‑hostingTakNieTylko EnterpriseNie

OpenHands w porównaniu z innymi agentami AI

OpenHands dla zespołów inżynierii oprogramowania

Dla pojedynczego dewelopera OpenHands to narzędzie, które otwierasz, gdy go potrzebujesz. W zespole jest inaczej.

Większość zespołów już organizuje pracę wokół issue, a OpenHands Cloud się w to wplata. Integruje się z GitHub, GitLab i Bitbucket, a także Slack, Jira i Linear. Możesz wspomnieć @openhands w komentarzu do issue lub pull requesta, a agent podejmie zadanie stamtąd.

Jest też praca, o którą nikt nie prosi, ale każdy jej potrzebuje. Automatyzacje Agent Canvas działają według harmonogramu lub w odpowiedzi na webhooki. Na przykład zespół może współdzielić jeden Agent Server do code review i aktualizacji zależności, podczas gdy każdy deweloper uruchamia osobistych agentów na swoim laptopie.

Testowanie działa tak samo jak w artykule. Agent uruchamia zestaw testów w swoim sandboxie, zanim zda raport. Ale uruchomienie w sandboxie nie zastępuje CI — twoja pipeline nadal działa przy każdym pull requeście, tak jak dla kodu pisanego przez ludzi.

Pull requesty to kolejny temat. Gdy OpenHands Cloud działa z GitHubem, żąda krótkotrwałych tokenów, które wygasają po ośmiu godzinach, z prawem odczytu i zapisu do contents, issues, pull requests i workflows. W self‑hosted Enterprise agent używa autoryzacji GitHub użytkownika, który go wywołał, więc każdą zmianę można przypisać do osoby.

Tak powinna działać odpowiedzialność. Agent może otworzyć pull request, ale to deweloper go zatwierdza. Ochrona branchy i wymagane recenzje dotyczą PR‑ów agenta tak samo jak wszystkich innych.

Izolowane środowiska sprawiają, że to wszystko działa w skali. Każde zadanie działa w swoim sandboxie, więc dwaj agenci naprawiający dwa bugi nie nadpisują sobie nawzajem plików ani nie walczą o ten sam port.

Bezpieczeństwo i sandboxing w OpenHands

Narzędzie do uzupełniania kodu zawsze sugeruje tekst, a ty decydujesz o akceptacji.

Agent działa inaczej. Samodzielnie przegląda projekt, wykonuje polecenia, instaluje pakiety i edytuje pliki, często bez pytania. Pytanie przesuwa się więc z „czy ten kod jest poprawny?” na „co agent uruchomił, by to osiągnąć?”.

Izolowane środowiska wykonawcze

Sandbox Dockera chroni twoje pliki i programy hosta, zasoby hosta oraz inne kontenery i procesy. Jeśli agent uruchomi destrukcyjne polecenie, jest ograniczony do kontenera.

Jeden wyjątek w konfiguracji lokalnej wymaga uwagi. Kontener aplikacji montuje gniazdo Dockera hosta, aby mógł uruchamiać sandboxy, a dostęp do tego gniazda oznacza kontrolę nad Dockerem na twojej maszynie.

Uprawnienia do repozytorium

Sandbox chroni tylko to, czego nie montujesz. Zamontowane pliki i katalogi mogą być modyfikowane lub usuwane.

Montuj tylko projekt, nad którym pracujesz, nigdy katalog domowy. Do zadań tylko do odczytu używaj trybu :ro . Dla integracji Git daj agentowi dostęp tylko do konkretnych potrzebnych repozytoriów i niczego więcej.

Sekrety i poświadczenia

Jeśli dostarczysz poświadczenia, np. klucze API lub tokeny, agent może ich użyć. A agent, który może odczytać sekret, może też go wydrukować w logach lub gdzieś wysłać.

Dlatego nie montuj folderów z plikami .env zawierającymi klucze produkcyjne. Daj agentowi testowe poświadczenia o ograniczonym zakresie i rotuj je często.

Dostęp do sieci

Domyślnie agent ma dostęp do internetu z wnętrza kontenera. Potrzebuje go do instalacji pakietów, ale może też łączyć się z dowolnymi zewnętrznymi usługami.

To otwiera drogę do wstrzyknięć promptów. Strona WWW lub komentarz w issue mogą zawierać instrukcje, które agent może wykonać. GitHub ogranicza to ryzyko dla swojego agenta chmurowego firewallem, który domyślnie ogranicza dostęp do internetu, i warto rozważyć podobne ograniczenia w twojej konfiguracji OpenHands.

Wykonywanie poleceń

Możesz kontrolować, które polecenia uruchamiają się bez zatwierdzenia. OpenHands obsługuje trzy polityki potwierdzania: zatwierdzaj wszystko, nic albo tylko ryzykowne akcje. Domyślna to NeverConfirm.

Opcja „ryzykowne akcje” ma haczyk. Domyślny analizator bezpieczeństwa LLM używa poziomu ryzyka, który model przypisuje swoim własnym akcjom. Model może oznaczyć destrukcyjne polecenie jako LOW risk i wykona je bez pytania. Analizator klasyfikuje ryzyko dla warstwy polityk — sam niczego nie blokuje, a dokumentacja zaleca łączyć go z izolacją Dockera.

Przegląd wygenerowanych zmian

Wszystko powyżej ogranicza to, co agent może zrobić. Ale faza przeglądu jest ważna, bo dzięki niej sprawdzasz, co zrobił.

Przeczytaj pełny diff, nie tylko pliki, które spodziewałeś się zmienić. Zwróć szczególną uwagę na konfigurację CI, pliki zależności i skrypty. W OpenHands Cloud token GitHuba agenta obejmuje zapisy do workflows, więc zmiana w .github/workflows może zmienić to, co uruchamia się w twojej pipeline.

Ograniczenia OpenHands

Kod pisany przez OpenHands nadal może mieć błędy. Przechodzące testy mówią tylko, że kod zgadza się z testami, a agent może napisać jedno i drugie. Jeśli testy są słabe, kod może przejść i nadal być błędny.

Złożone zadania często wymagają twojego udziału. Niejasne wymagania lub decyzja projektowa, której agent nie może podjąć, zatrzymają go albo — co gorsza — wyślą w złą stronę.

Ze silnym modelem hostowanym OpenHands dobrze radzi sobie z zadaniami wieloplikowymi. Ze słabym lokalnym modelem zobaczysz nieudane wywołania narzędzi i odpowiedzi jak z chatbota, a nawet przy dużym oknie kontekstu niektóre lokalne modele nie potrafią niezawodnie używać narzędzi.

Pętle agenta kosztują też więcej niż czat. Każdy krok wysyła historię rozmowy z powrotem do modelu, a długie zadania mają wiele kroków. Dokumentacja OpenHands ostrzega, że agent wysyła wiele promptów do LLM i zaleca limity wydatków oraz monitorowanie użycia. Kondensator kontekstu pomaga, ale streszcza starsze kroki, więc przy długich zadaniach szczegóły mogą się zgubić.

Dostęp do narzędzi zwiększa ryzyko bezpieczeństwa. Agent z terminalem i dostępem do sieci może wyrządzić realne szkody, jeśli podąży za złymi instrukcjami — dlatego sandbox i twój przegląd są tak ważne.

I każda zmiana nadal potrzebuje akceptacji człowieka. Zawsze o tym pamiętaj.

OpenHands i przyszłość agentów do kodowania AI

Narzędzia do kodowania AI przeszły drogę od autouzupełniania przez czat do agentów, którzy przechodzą przez całe zadanie. OpenHands jest jednym z kilku projektów, które pchają ten ostatni krok naprzód.

Kierunek widać w całej branży. Cursor opisuje wyłaniającą się erę, w której autonomiczni agenci chmurowi biorą większe zadania na dłuższe okresy. Copilot teraz bierze issue z GitHuba i Linear. Claude Code działa w terminalu, przeglądarce i Slacku.

Platformy open source mają w tym zwrocie szczególną rolę. Z OpenHands możesz sprawdzić, jak działa agent, uruchomić go na własnej infrastrukturze i wybrać model. Dla zespołów z rygorystycznymi zasadami dot. danych to często jedyny dopuszczalny sposób używania agentów.

Dłuższe zadania niosą też nowe problemy. Agent pracujący godzinę podejmuje więcej decyzji niż ten pracujący minutę, a każda decyzja to szansa na odejście od twojej intencji. Lepsze modele pomagają, ale tak samo sandboxy, polityki potwierdzania i przegląd.

Wnioski

To, co wyróżnia OpenHands na tle konkurencji, to kontrola. Możesz czytać źródła, hostować na własnym sprzęcie i uruchamiać z dowolnym modelem, także lokalnym. Bardziej „sklejone” narzędzia komercyjne jak Claude Code, Cursor i GitHub Copilot dają lepsze doświadczenie, ale na własnych warunkach.

Ale agent z dostępem do twojego terminala i repozytoriów nadal potrzebuje człowieka, który sprawdzi jego pracę. Zawsze pamiętaj, by czytać diff i samemu uruchamiać testy.

Jeśli chcesz nauczyć się tworzyć własnego agenta od podstaw, obejrzyj nasz webinar Introduction to Creating AI Agents in Python.

FAQs

Czym jest OpenHands?

OpenHands to otwartoźródłowa platforma do budowania i uruchamiania agentów AI pracujących z kodem. Jego agent do kodowania potrafi przejrzeć repozytorium, edytować pliki, uruchamiać polecenia i testy oraz iterować nad wynikami, aż zadanie zostanie skończone. Możesz uruchomić go lokalnie w Dockerze, przez SDK lub w OpenHands Cloud.

Czy OpenHands jest darmowy?

Oprogramowanie OpenHands jest open source, więc możesz hostować je samodzielnie bez opłat licencyjnych. Płacisz za model — dostawcy hostowani, tacy jak Anthropic czy OpenAI, rozliczają za tokeny, a pętle agenta zużywają ich sporo. Jeśli uruchamiasz lokalny model przez Ollama lub LM Studio, jedynym kosztem jest twój sprzęt. OpenHands Cloud to oddzielna, komercyjna usługa.

Czym OpenHands różni się od GitHub Copilot lub Cursor?

Copilot i Cursor są zbudowane wokół edytora, gdzie AI pracuje obok ciebie podczas pisania kodu. OpenHands jest agent‑first — opisujesz zadanie, agent pracuje nad nim w sandboxie, a ty przeglądasz wynik. Jest też open source, działa z dowolnym modelem wspieranym przez LiteLLM i może działać na twojej infrastrukturze, czego ani Copilot, ani Cursor nie oferują w takim stopniu.

Czy mogę uruchomić OpenHands z lokalnym modelem?

Tak. OpenHands łączy się z lokalnymi serwerami takimi jak LM Studio, Ollama, vLLM i SGLang przez ich API kompatybilne z OpenAI. Wybierz model zbudowany do agencyjnego kodowania, np. Devstral Small 2 lub Qwen3.6-35B-A3B, i ustaw okno kontekstu na co najmniej 22000 tokenów. Mniejsze modele ogólnego przeznaczenia często zawodzą przy wywołaniach narzędzi i odpowiadają jak chatbot.

Czy bezpiecznie jest dać OpenHands dostęp do mojego kodu?

OpenHands uruchamia polecenia agenta w sandboxie Dockera, co chroni twój system hosta przed większością pomyłek. Ale wszystko, co zamontujesz do sandboxa, może być modyfikowane lub usuwane, a każde dostarczone poświadczenia mogą zostać użyte przez agenta. Domyślnie agent nie prosi o zgodę przed działaniem, więc montuj tylko potrzebny projekt, używaj ograniczonych poświadczeń testowych i przeglądaj każdy diff przed mergem.

Tematy