मुख्य सामग्री पर जाएँ

OpenHands: ओपन-सोर्स AI कोडिंग एजेंट का विवरण

OpenHands, ओपन-सोर्स AI कोडिंग एजेंट, का एक ओवरव्यू—इसकी आर्किटेक्चर, Ollama के साथ लोकल सेटअप, हैंड्स-ऑन बग फ़िक्स, सुरक्षा और सीमाएँ, तथा Claude Code, Cursor और GitHub Copilot से तुलना।
· 15 मि॰ पढ़ें

AI के साथ खोजें

OpenHands AI-सक्षम सॉफ्टवेयर डेवलपमेंट के लिए एक ओपन-सोर्स प्लेटफ़ॉर्म है, जो ऐसे एजेंट पर आधारित है जो आपकी रिपोजिटरी को जाँच सकता है, फाइलें संपादित कर सकता है, कमांड चला सकता है, और टेस्ट रन कर सकता है। यह एजेंटिक सॉफ्टवेयर डेवलपमेंट की ओर बदलाव का हिस्सा है — आप एजेंट को पूरा कार्य सौंपते हैं, और वह उसे चरणबद्ध तरीके से तब तक करता है जब तक काम पूरा न हो जाए या उसे आपके इनपुट की ज़रूरत न पड़े।

इस आलेख में, मैं आपको OpenHands की आर्किटेक्चर और इसके प्रमुख फीचर्स समझाऊंगा, इसे एक लोकल मॉडल के साथ सेट अप करना दिखाऊंगा, और Claude Code, Cursor, तथा GitHub Copilot से इसकी तुलना करूंगा।

AI एजेंट क्या होते हैं? हमारे AI Agent Fundamentals ट्रैक में नामांकन करें और जानें कि AI एजेंट आपके काम करने का तरीका कैसे बदल सकते हैं।

OpenHands क्या है?

OpenHands, कोड के साथ काम करने वाले AI एजेंट बनाने और चलाने का एक ओपन-सोर्स प्लेटफ़ॉर्म है।

यह नाम दो चीज़ों को कवर करता है। पहली है प्रोजेक्ट — एक SDK, सर्वर, ब्राउज़र UI, और होस्टेड सर्विस सहित रिपोज़िटरीज़ का संग्रह। दूसरी है वह कोडिंग एजेंट जो इन सबके ऊपर चलता है।

यह ऐसे काम करता है:

  • सॉफ्टवेयर एजेंट SDK: कोड के साथ काम करने वाले एजेंट बनाने के लिए Python और REST API का सेट, और OpenHands CLI व OpenHands Cloud के पीछे का इंजन
  • एजेंट सर्वर: एजेंट एक्ज़ीक्यूशन, वार्तालाप, टूल्स, और वर्कस्पेस को REST और WebSocket API के जरिए एक्सपोज़ करता है
  • एजेंट कैनवास: वार्तालाप, फाइलें, टर्मिनल आउटपुट, मॉडल कॉन्फ़िगरेशन, बैकएंड और ऑटोमेशन के लिए एक ब्राउज़र UI
  • OpenHands Cloud: वह मैनेज्ड कमर्शियल सर्विस, जो उन टीमों के लिए है जो अपना बैकएंड और सैंडबॉक्स इन्फ्रास्ट्रक्चर चलाना नहीं चाहतीं

अधिकांश लोग जब "OpenHands" कहते हैं, तो वे एजेंट का ज़िक्र करते हैं। इसी हिस्से के साथ मैं इस आलेख में काम करूंगा।

आमतौर पर, आप एजेंट को एक सॉफ्टवेयर कार्य देते हैं, अपने कोड वाले वर्कस्पेस की ओर इंगित करते हैं, और वह अपने टूल्स के साथ उस कार्य को पूरा करता है। डिफ़ॉल्ट टूल सेट में एक टर्मिनल, एक फाइल एडिटर, और एक टास्क ट्रैकर शामिल है।

वर्कस्पेस आपका लैपटॉप होना ज़रूरी नहीं। एजेंट लोकल मशीन को वर्कस्पेस की तरह इस्तेमाल कर सकता है या इफेमरल वर्कस्पेस में चल सकता है, जैसे Docker या Kubernetes में।

OpenHands आपको किसी एक मॉडल प्रोवाइडर से बाँधता नहीं है। आप इसे Claude, GPT, या किसी भी अन्य LLM के साथ चला सकते हैं, जिनमें लोकल मॉडल भी शामिल हैं। Agent Canvas डिफ़ॉल्ट OpenHands एजेंट की जगह Claude Code और Codex जैसे थर्ड-पार्टी एजेंट भी चला सकता है।

संक्षेप में, OpenHands एक खुला एजेंट प्लेटफ़ॉर्म है जिसे आप अपनी शर्तों पर चला सकते हैं।

OpenHands कैसे काम करता है

OpenHands एक लूप में चलता है।

एक चैट असिस्टेंट आपका प्रॉम्प्ट लेता है और टेक्स्ट लौटाता है। OpenHands एजेंट एक टास्क लेता है, कोई एक्शन करता है, परिणाम देखता है, और अगला कदम तय करता है।

The OpenHands agent loop

OpenHands एजेंट लूप

आम विचार यह है:

  • टास्क प्राप्त करें: आप लक्ष्य को साधारण भाषा में बताते हैं, उदाहरण के लिए "मंथली रिपोर्ट को ऐसे ठीक करें कि अलग-अलग सालों के महीने मर्ज न हों"
  • रिपोजिटरी का निरीक्षण करें: एजेंट डायरेक्टरी लिस्ट करता है, फाइलें खोलता है, और टास्क से जुड़े कोड को खोजता है
  • एक प्लान बनाएँ: वह टास्क को चरणों में बाँटता है और उन्हें अपने टास्क ट्रैकर में दर्ज करता है
  • फाइलें संपादित या बनाएँ: वह अपने फाइल एडिटर से कोड बदलता है
  • कमांड और टेस्ट चलाएँ: वह टर्मिनल में टेस्ट सूट या ऐप चलाता है
  • परिणाम जाँचें: वह आउटपुट पढ़ता है, जिनमें त्रुटियाँ और असफल एसेर्शन शामिल हैं
  • दोहराएँ: अगर कुछ अभी भी टूटा है, तो वह वापस जाकर प्लान समायोजित करता है और फिर कोशिश करता है

लूप तब रुकता है जब या तो टास्क पूरा हो जाता है, या एजेंट को कोई ऐसी चीज़ चाहिए जो केवल आप दे सकते हैं, जैसे कोई गायब क्रेडेंशियल या आवश्यकताओं पर निर्णय।

कदम 6 OpenHands को प्रतियोगिता से अलग बनाता है। कोड कंप्लीशन टूल यह नहीं देखता कि उसका कोड चलने पर क्या होता है। OpenHands देखता है, इसलिए वह असफल टेस्ट पर प्रतिक्रिया दे सकता है और कारण को ठीक कर सकता है।

OpenHands की प्रमुख विशेषताएँ

ऑटोकम्प्लीट टेक्स्ट सुझाता है, और OpenHands आपके प्रोजेक्ट पर कार्रवाई करता है। ऐसे करें।

कोड संपादन

OpenHands सीधे फाइलें एडिट करता है, और यह एक समय में एक ही फाइल तक सीमित नहीं है।

मान लें कि किसी फ़ंक्शन को नया नाम चाहिए। एजेंट डेफ़िनिशन अपडेट करता है, हर कॉल साइट ढूँढता है, और उससे संदर्भित टेस्ट भी अपडेट करता है — ये सब एक ही टास्क के हिस्से के रूप में।

टर्मिनल और टूल का उपयोग

एजेंट के पास अपना टर्मिनल होता है। यह डिपेंडेंसी इंस्टॉल कर सकता है, स्क्रिप्ट चला सकता है, टेस्ट एक्ज़ीक्यूट कर सकता है, और किसी भी कमांड का आउटपुट पढ़ सकता है।

आप MCP (Model Context Protocol) सर्वर भी कनेक्ट कर सकते हैं ताकि एजेंट को वे टूल दिए जा सकें जिनके साथ इसे मूल रूप से काम करने के लिए डिज़ाइन नहीं किया गया था, जैसे कोई इश्यू ट्रैकर या डेटाबेस क्लाइंट।

रिपोजिटरी की समझ

अधिकांश कोड जनरेटर केवल वही देखते हैं जो आप प्रॉम्प्ट में पेस्ट करते हैं।

OpenHands रिपोजिटरी खोलता है और उसे एक्सप्लोर करता है। यह README पढ़ सकता है, इम्पोर्ट्स फॉलो कर सकता है, और मौजूदा टेस्ट देखकर समझ सकता है कि प्रोजेक्ट कैसे संरचित है। इसका मतलब है कि इसके बदलाव मौजूदा कोड में फिट होने की अधिक संभावना रखते हैं।

लंबे टास्क एक अलग समस्या पैदा करते हैं — वार्तालाप इतिहास मॉडल की सीमा से आगे बढ़ जाता है। OpenHands इसे कॉन्टेक्स्ट कंडेंसर से संभालता है, जो वार्तालाप के पुराने हिस्सों का सारांश बनाता है ताकि एजेंट काम जारी रख सके।

मॉडल का चुनाव

मॉडल कॉल LiteLLM के जरिए होती हैं, इसलिए आप कोई भी प्रोवाइडर और मॉडल इस्तेमाल कर सकते हैं जिसे वह सपोर्ट करता है। OpenHands के डॉक्यूमेंटेशन Claude, GPT, और Gemini परिवारों के मॉडल, साथ ही OpenHands Index पर अच्छा स्कोर करने वाले ओपन-वेट मॉडल सुझाते हैं।

अगर आपका कोड आपकी मशीन से बाहर नहीं जा सकता, तो आप लोकल मॉडल चला सकते हैं। OpenHands, LM Studio, Ollama, vLLM, और SGLang जैसे लोकल सर्वर से कनेक्ट होता है।

यहाँ याद रखने वाली बात यह है कि मॉडल परिणामों को बहुत बदल देता है। कुछ लोकल मॉडल बड़े कॉन्टेक्स्ट विंडो के बावजूद विश्वसनीय टूल उपयोग में संघर्ष करते हैं।

स्वायत्त टास्क निष्पादन

एक बार जब आप टास्क सौंप देते हैं, एजेंट अपने आप लूप के माध्यम से काम करता है। आपको त्रुटियाँ कॉपी-पेस्ट कर के चैट में वापस भेजने या उसे अगली फाइल खोलने के लिए बताने की ज़रूरत नहीं।

Agent Canvas इसे ऑटोमेशन के साथ एक कदम आगे ले जाता है। ये Slack, GitHub, Linear, आदि के साथ इंटीग्रेट होते हैं, और शेड्यूल पर या वेबहुक इवेंट्स के जवाब में चलते हैं।

लेकिन स्वायत्तता शुद्धता की गारंटी नहीं देती। मर्ज होने से पहले आपको फिर भी डिफ़ और टेस्ट परिणामों की समीक्षा करनी होगी।

OpenHands का उपयोग कैसे करें

OpenHands को समझने का सबसे अच्छा तरीका है इसे एक बग दें और देखें यह क्या करता है।

इस भाग में, मैं OpenHands को लोकली Docker में चलाऊँगा, उसे Ollama के जरिए एक लोकल मॉडल से जोड़ूँगा, और एक छोटे-से Python प्रोजेक्ट में बग ठीक करने के लिए कहूँगा।

OpenHands सेट अप करें

आप OpenHands को कुछ तरीकों से चला सकते हैं:

  • CLI लॉन्चर: इसे uv tool install openhands --python 3.14 से इंस्टॉल करें, फिर openhands serve से GUI शुरू करें

  • Docker: एक docker run कमांड से सीधे ऐप कंटेनर चलाएँ

  • Agent Canvas: नया ब्राउज़र क्लाइंट जो लोकल, सेल्फ-होस्टेड, क्लाउड या एंटरप्राइज बैकएंड से कनेक्ट होता है

  • OpenHands Cloud: होस्टेड वर्ज़न, अगर आप खुद कुछ नहीं चलाना चाहते

मैं Docker रूट और लोकल GUI का उपयोग करूँगा। OpenHands डॉक्यूमेंटेशन इसे अब डिप्रिकेटेड Docker-आधारित ब्राउज़र एप्लिकेशन के रूप में सूचीबद्ध करता है और Agent Canvas को इसका रिप्लेसमेंट बताता है, पर यह अब भी प्रलेखित है और GUI चलाने का सबसे तेज़ तरीका है।

आपको macOS, Linux, या Windows (WSL के साथ) पर Docker Desktop की आवश्यकता होगी। macOS पर, Docker Desktop खोलें, Settings > Advanced में जाएँ, और डिफ़ॉल्ट Docker सॉकेट सक्षम करें।

फिर ऐप शुरू करें:

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 सैंडबॉक्स कंटेनर शुरू करने के लिए Docker सॉकेट माउंट का उपयोग करता है, और एजेंट आपकी होस्ट मशीन पर नहीं, बल्कि उसी सैंडबॉक्स के अंदर अपने कमांड चलाता है।

जब लॉग में दिखे कि सर्वर चालू है, तो ब्राउज़र में http://localhost:3000 खोलें।

OpenHands welcome page

OpenHands वेलकम पेज

मॉडल कनेक्ट करें

जब तक आप कोई मॉडल नहीं देंगे, OpenHands कुछ नहीं करेगा।

मैं Devstral Small 2 का उपयोग कर रहा हूँ, जो Mistral का 24B मॉडल है, एजेंटिक कोडिंग के लिए बना हुआ। यह एक RTX 4090 या 32GB RAM वाले Mac पर चलाने के लिए पर्याप्त हल्का है। इसे Ollama 0.13.3 या बाद का वर्ज़न चाहिए।

Ollama को बड़े कॉन्टेक्स्ट विंडो के साथ शुरू करें और मॉडल पुल करें:

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

कॉन्टेक्स्ट लंबाई को नज़रअंदाज़ न करें। Ollama का डिफ़ॉल्ट 4096 टोकन है, जो OpenHands के सिस्टम प्रॉम्प्ट के लिए भी बहुत छोटा है। डॉक्यूमेंट्स कम से कम 22000 की मांग करते हैं।

OpenHands में, Settings खोलें, LLM टैब पर जाएँ, और Advanced चालू करें। फिर यह सेट करें:

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

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

  3. API Key: कोई भी प्लेसहोल्डर वैल्यू, जैसे local-llm

LLM settings for a local Ollama model

लोकल Ollama मॉडल के लिए LLM सेटिंग्स

openai/ प्रीफ़िक्स OpenHands को Ollama से उसके OpenAI-कम्पैटिबल API के जरिए बात करने को कहता है। API की का उपयोग नहीं होता, लेकिन फील्ड खाली नहीं रह सकती।

रिपोजिटरी खोलें

OpenHands डिफ़ॉल्ट रूप से आपकी फाइलें नहीं देख सकता। आपको प्रोजेक्ट को सैंडबॉक्स में माउंट करना होगा।

इस उदाहरण के लिए, आपको budget-tracker/project नाम का एक फ़ोल्डर चाहिए जिसमें दो फाइलें हों। पहली फाइल प्रति माह खर्च का योग करती है:

# 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

डॉकस्ट्रिंग YYYY-MM कीज का वादा करती है, पर date[5:7] केवल महीना रखता है। जनवरी 2025 और जनवरी 2026 एक ही बकेट में आ जाएँगे।

दूसरी फाइल में दो टेस्ट हैं जो बग पकड़ते हैं:

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

फ़ोल्डर को एक Git रिपोजिटरी में बदलें, ताकि आप बाद में देख सकें एजेंट ने क्या बदला:

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

अगर आप अभी python -m pytest चलाते हैं, तो दोनों टेस्ट असफल होते हैं:

Failing tests

असफल टेस्ट

OpenHands को एक्सेस देने के लिए, कंटेनर रोकें और docker run कमांड में एक लाइन जोड़ें:

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

तो अब पूरा कमांड यह है:

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

फ़ॉर्मेट है host_path:container_path:mode। आपका प्रोजेक्ट सैंडबॉक्स में /workspace के तहत दिखेगा, और rw एजेंट को उसे एडिट करने देता है।

केवल वही प्रोजेक्ट माउंट करें जिसे आप एजेंट से बदलवाना चाहते हैं। /workspace में रीड-राइट के साथ माउंट की गई कोई भी चीज़ एजेंट द्वारा संशोधित की जा सकती है।

एजेंट को टास्क दें

नई वार्तालाप शुरू करें और समस्या को वैसे ही वर्णित करें जैसे आप बग रिपोर्ट लिखते हैं:

मंथली टोटल अलग-अलग सालों के एक ही महीने का खर्चा मर्ज कर देता है।

कारण ढूँढें, उसे ठीक करें, और टेस्ट चलाकर पुष्टि करें कि वे पास होते हैं।

बस इतना ही। आपको एजेंट को budget.py की ओर इंगित करने या गलत लाइन बताने की ज़रूरत नहीं।

Conversation output

वार्तालाप आउटपुट

यहाँ से पहले वाला एजेंट लूप नियंत्रण अपने हाथ में लेता है। एजेंट /workspace में देखता है, दोनों फाइलें पढ़ता है, और क्या फेल हो रहा है यह देखने के लिए टेस्ट चलाता है। फिर कोड एडिट करता है और टेस्ट दोबारा चलाता है।

The agent running pytest in the sandbox terminal

एजेंट सैंडबॉक्स टर्मिनल में pytest चला रहा है

परिवर्तनों की समीक्षा करें

एजेंट कहता है कि काम हो गया। अब आप कोड एडिटर खोलकर और कोड में बदलावों का निरीक्षण करके अंतर देख सकते हैं।

सही फ़िक्स budget.py में एक लाइन है:

month = date[:7]

Fixed budget.py

Fixed budget.py

आप git diff करके भी अंतर देख सकते हैं।

यहाँ किन बातों की जाँच करनी चाहिए:

  • सोर्स कोड: फ़िक्स budget.py में होना चाहिए

  • टेस्ट: सुनिश्चित करें कि एजेंट ने एसेर्शन पास कराने के लिए test_budget.py में बदलाव नहीं किया

  • टेस्ट रन: python -m pytest खुद चलाएँ — केवल एजेंट के सारांश पर भरोसा न करें

OpenHands आर्किटेक्चर

OpenHands के छह मुख्य हिस्से हैं, और हर एक का एक ही काम है।

How the OpenHands components connect

OpenHands कंपोनेंट्स कैसे कनेक्ट होते हैं

AI मॉडल

मॉडल तर्क करता है। उसे टास्क और वार्तालाप इतिहास मिलता है, और वह या तो कोई संदेश देता है या कोई टूल कॉल।

मॉडल आपकी फाइलें नहीं बदलता और न ही कुछ चलाता है। वह केवल तय करता है कि आगे क्या होना चाहिए। मॉडल कॉल LiteLLM के जरिए होती हैं, इसलिए वही एजेंट होस्टेड प्रोवाइडर या इस आलेख के Devstral सेटअप जैसे लोकल मॉडल — दोनों के साथ काम करता है।

एजेंट लॉजिक

एजेंट मॉडल और बाकी सबके बीच होता है। यह रीजनिंग-एक्शन लूप चलाता है, यानी मॉडल से अगला एक्शन पूछता है, टूल चलाता है, और परिणाम या त्रुटि को संभालता है।

यह यह भी तय करता है कि मॉडल क्या देखेगा। एजेंट कंडेंसर के साथ वार्तालाप इतिहास को मैनेज करता है और हर मॉडल क्वेरी में स्किल्स व प्रॉम्प्ट जोड़ता है।

हर कदम रिकॉर्ड होता है। एजेंट एक्शन एक्ज़ीक्यूट करता है और ऑब्ज़र्वेशन वापस मिलते हैं, और वार्तालाप उस इवेंट हिस्ट्री को रखता है। मॉडल अगली बारी में इन्हें देखता है, ताकि उसे पता रहे कि पहले क्या हो चुका है।

टूल्स और एक्शन

टूल्स वे माध्यम हैं जिनसे एजेंट मॉडल के बाहर किसी चीज़ पर असर डालता है। स्टैंडर्ड सेट में टर्मिनल, फाइल एडिटर, और टास्क ट्रैकर शामिल हैं, और आप MCP सर्वर के जरिए और जोड़ सकते हैं।

मॉडल कोई एक्शन माँगता है, जैसे "pytest चलाएँ" या "budget.py में लाइन 8 बदलें।" टूल उसे एक्ज़ीक्यूट करता है और ऑब्ज़र्वेशन लौटाता है, जैसे टेस्ट आउटपुट या अपडेटेड फाइल।

एक्शन चलने से पहले यह सुरक्षा जाँच से गुजरता है। सिक्योरिटी एनालाइज़र हर एक्शन का पहले मूल्यांकन करता है और आपकी स्वीकृति के लिए एजेंट को रोक सकता है।

डेवलपमेंट एनवायरनमेंट

टूल्स आपकी मशीन पर नहीं, सैंडबॉक्स के भीतर चलते हैं।

Docker सेटअप में, OpenHands एजेंट सर्वर को अपने Docker कंटेनर में चलाता है। इसी वजह से आलेख में Docker सॉकेट माउंट किया जाता है — ऐप कंटेनर को सैंडबॉक्स शुरू करने के लिए इसकी ज़रूरत होती है।

सैंडबॉक्स लोकल होना ज़रूरी नहीं। एजेंट Docker या Kubernetes जैसे इफेमरल वर्कस्पेस में भी चल सकते हैं, और Agent Server एक्ज़ीक्यूशन, टूल्स, और वर्कस्पेस को REST और WebSocket API के जरिए एक्सपोज़ करता है। सैंडबॉक्स कहीं भी चले, एजेंट लॉजिक एक जैसा रहता है।

रिपोजिटरी

रिपोजिटरी वही है जिस पर एजेंट काम करता है। यह सैंडबॉक्स में दो तरीकों से आता है: आपके लोकल फ़ोल्डर के माउंट से (जैसा आलेख में है), या GitHub, GitLab, या Bitbucket इंटीग्रेशन के जरिए जुड़ी रिपोज से।

रिपोजिटरी एजेंट को यह भी बता सकती है कि कैसे व्यवहार करना है। रूट-लेवल AGENTS.md वार्तालाप शुरू होने पर सिस्टम प्रॉम्प्ट में इंजेक्ट हो जाता है। अधिक केंद्रित निर्देश .agents/skills/ में जाते हैं, जहाँ एजेंट पहले सारांश देखता है और जरूरत पड़ने पर ही पूरा कंटेंट लोड करता है।

यहीं आप वे प्रोजेक्ट नियम रखते हैं जिन्हें एजेंट अनुमान नहीं लगा सकता, जैसे "टेस्ट make test से चलाओ, pytest से नहीं।"

मानव समीक्षा

आप इस आर्किटेक्चर का अंतिम हिस्सा हैं।

OpenHands तीन कन्फ़र्मेशन नीतियाँ सपोर्ट करता है: हर एक्शन मंज़ूर करें, कुछ भी मंज़ूर न करें, या केवल जोखिमपूर्ण एक्शन मंज़ूर करें। आख़िरी वाली सिक्योरिटी एनालाइज़र पर निर्भर करती है, जो हर एक्शन को LOW, MEDIUM, HIGH, या UNKNOWN जोखिम के रूप में लेबल करता है। डिफ़ॉल्ट NeverConfirm है, इसलिए एजेंट तब तक बिना रुके चलता है जब तक आप इसे बदलते नहीं।

दूसरा चेकपॉइंट अंत में आता है। जब तक आप डिफ़ नहीं पढ़ लेते और टेस्ट परिणाम जाँच नहीं लेते, एजेंट का काम पूरा नहीं होता।

OpenHands वर्कफ़्लो

मैंने आपको एक-लाइन वाले बग को ठीक करना दिखाया, लेकिन बेशक, OpenHands इससे कहीं बड़े टास्क संभाल सकता है।

इन टास्क में समानता यह है कि ये एक से अधिक चरण लेते हैं। यहाँ छह तरह के काम हैं जहाँ एजेंट लूप समझ में आता है।

बग ठीक करना

आलेख में दिखाया गया बग एक ही फाइल में आसानी से दिख रहा था। असल दुनिया में ऐसा शायद ही होता है।

मान लें कि एप्लिकेशन लॉग्स प्रोडक्शन में KeyError दिखाते हैं, और स्टैक ट्रेस उस फ़ंक्शन की ओर इशारा करता है जो खराब डेटा आने की जगह से तीन कॉल दूर है। आप स्टैक ट्रेस OpenHands में पेस्ट करते हैं और फ़िक्स माँगते हैं।

एजेंट कॉल चेन को डेटा के स्रोत तक ट्रेस करता है, वह टेस्ट लिखता है जो त्रुटि को पुन: उत्पन्न करता है, और पुष्टि करता है कि टेस्ट फेल होता है। फिर वह कोड ठीक करता है और यह जाँचने के लिए पूरा टेस्ट सूट चलाता है कि और कुछ नहीं टूटा।

यहाँ पुनरुत्पादन टेस्ट देखने योग्य चीज़ है। यह साबित करता है कि एजेंट ने असली बग ढूँढा, न कि सिर्फ़ वह जगह जहाँ त्रुटि दिख रही थी।

फ़ीचर्स लागू करना

फ़ीचर वर्क आमतौर पर आपकी अपेक्षा से अधिक फाइलें बदलता है।

मान लें कि किसी कमांड-लाइन रिपोर्ट स्क्रिप्ट को तारीख़ के आधार पर ट्रांज़ैक्शन फ़िल्टर करने के लिए --since फ़्लैग चाहिए। एजेंट को आर्गुमेंट पार्सर ढूँढना होगा, फ़्लैग जोड़ना होगा, वैल्यू को फ़िल्टर लॉजिक तक पास करना होगा, और हेल्प टेक्स्ट अपडेट करना होगा। फिर वह नए व्यवहार के लिए टेस्ट लिखता है और README अपडेट करता है।

एक छोटे-से फ़ीचर के लिए यह चार-पाँच फाइलें हो जाती हैं। एजेंट इन्हें अपने टास्क ट्रैकर में संभालता है, ताकि पहली फाइल के काम करने पर वह रुक न जाए।

रीफ़ैक्टरिंग

रीफ़ैक्टरिंग का मतलब व्यवहार बदले बिना संरचना बदलना होता है, और टेस्ट सूट यह साबित करने का तरीका है कि व्यवहार नहीं बदला।

मान लें कि किसी प्रोजेक्ट में एक बड़ा utils.py है जिसमें डेट हेल्पर्स, स्ट्रिंग हेल्पर्स और फाइल हेल्पर्स सब एक साथ मिले हुए हैं। आप OpenHands को इसे तीन मॉड्यूल में बाँटने को कहते हैं।

एजेंट नए मॉड्यूल बनाता है, फ़ंक्शन स्थानांतरित करता है, और कोडबेस में हर इम्पोर्ट अपडेट करता है। वह हर मूव के बाद टेस्ट चलाता है। इस तरह, अगर कुछ टूटता है, तो उसे पता रहता है कि किस मूव से हुआ।

टेस्ट लिखना

बिना टेस्ट वाला कोड एजेंट वर्क के लिए आम शुरुआती बिंदु है, क्योंकि टास्क स्पष्ट और जाँचने में आसान होता है।

मान लें कि किसी डेट-पार्सिंग मॉड्यूल में टेस्ट नहीं हैं। एजेंट फ़ंक्शन्स पढ़ता है, सामान्य इनपुट और एज केस (खाली स्ट्रिंग, लीप ईयर, अमान्य फ़ॉर्मेट) के लिए pytest केस लिखता है, और उन्हें चलाता है।

अगर कोई नया टेस्ट फेल होता है, तो एजेंट को तय करना पड़ता है कि टेस्ट गलत है या कोड में बग है। यह निर्णय आपको स्वयं जाँचना चाहिए।

मौजूदा कोडबेस की जाँच

हर टास्क में कोड बदलाव ज़रूरी नहीं होते।

आप OpenHands से ऐसे सवाल पूछ सकते हैं: "यह ऐप यूज़र इनपुट को डेटाबेस तक पहुँचने से पहले कहाँ वैलिडेट करता है?" एजेंट कोडबेस खोजता है, फाइलों के पार फ़ंक्शन कॉल्स फॉलो करता है, और फाइल पाथ और लाइन रेफ़रेंस के साथ जवाब देता है।

यह तब उपयोगी है जब आप किसी नए प्रोजेक्ट से जुड़ते हैं या महीनों बाद ऐसा कोड उठाते हैं जिसे आपने संशोधित नहीं किया। ऐसे केवल-पठन कार्यों के लिए, रिपोजिटरी को :rw की जगह :ro मोड में माउंट करें, ताकि एजेंट गलती से भी कुछ न बदल सके।

एप्लिकेशन चलाना और डिबग करना

कुछ बग केवल तब दिखते हैं जब एप्लिकेशन चलता है।

मान लें कि कोई API एंडपॉइंट 500 त्रुटि लौटाता है, और टेस्ट उसे कवर नहीं करते। एजेंट अपने टर्मिनल में सर्वर शुरू करता है, curl से एक रिक्वेस्ट भेजता है, और सर्वर लॉग्स से ट्रेसबैक पढ़ता है।

फिर वह कोड ठीक करता है, सर्वर रीस्टार्ट करता है, और वही रिक्वेस्ट फिर भेजता है। अगर प्रतिक्रिया अब भी गलत है, तो लूप वहीं से जारी रहता है।

यह वही एडिट-रन-जाँच चक्र है जिसे आप खुद अपनाते, बस एजेंट हर रीस्टार्ट और हर रीट्राई संभालता है।

OpenHands बनाम अन्य AI कोडिंग एजेंट

OpenHands अकेला ऐसा टूल नहीं है जो टास्क लेकर उसे खुद पूरा कर सके। Claude Code, Cursor, और GitHub Copilot में अब एजेंट फीचर्स हैं, लेकिन कुछ महत्वपूर्ण तरीकों में ये अलग हैं।

OpenHands बनाम Claude Code

ये दोनों सबसे नज़दीकी मेल हैं। दोनों एक एजेंट लूप चलाते हैं जो कोड पढ़ता है, फाइलें एडिट करता है, कमांड चलाता है, और परिणाम जाँचता है।

पहला अंतर स्वामित्व का है। हर सार्वजनिक OpenHands रिपोजिटरी की अपनी ओपन-सोर्स लाइसेंस है, और आप सब कुछ पढ़, बदल, और सेल्फ-होस्ट कर सकते हैं। Claude Code Anthropic का प्रोप्रायटरी एजेंटिक कोडिंग टूल है, जो टर्मिनल, IDE, डेस्कटॉप ऐप, और ब्राउज़र में उपलब्ध है।

यह हमें मॉडल के सवाल तक ले जाता है। Claude Code, Anthropic के Claude मॉडलों पर आधारित है। OpenHands किसी भी LiteLLM-सपोर्टेड प्रोवाइडर के साथ काम करता है, जिनमें आलेख के लोकल Ollama सेटअप जैसे विकल्प भी शामिल हैं।

रोज़मर्रा का वर्कफ़्लो भी अलग है। Claude Code एक टर्मिनल टूल के रूप में शुरू हुआ, और आज भी बहुत से डेवलपर वहीं इसका उपयोग करते हैं। OpenHands अपने ब्राउज़र UI पर निर्भर करता है, और इसका CLI फ़ीचर-पूर्ण है लेकिन मुख्य रूप से स्थिरता के लिए मेंटेन किया जाता है।

दोनों टूल आपको एजेंट के व्यवहार को नियंत्रित करने देते हैं। Claude Code CLAUDE.md, सेटिंग्स, हुक्स, स्किल्स, कमांड्स, और .claude डायरेक्टरी से सबएजेंट पढ़ता है। OpenHands रिपोजिटरी से AGENTS.md और स्किल्स पढ़ता है, और SDK आपको Python में अपने एजेंट बनाने देता है।

स्वायत्तता दोनों में अलग तरह से काम करती है। Claude Code अनुमति मोड, हुक्स, और अलाऊ/डिनाय नियमों से टूल उपयोग को नियंत्रित करता है, और कमांड्स को सैंडबॉक्स कर सकता है। OpenHands डिफ़ॉल्ट रूप से हर कमांड Docker सैंडबॉक्स में चलाता है और ऊपर से कन्फ़र्मेशन नीतियाँ जोड़ता है।

संक्षेप में, Claude Code पॉलिश्ड विकल्प है जिसे आप तुरंत इंस्टॉल करके इस्तेमाल कर लेते हैं, जबकि OpenHands अधिक सेटअप मांगता है और बदले में आपको अधिक नियंत्रण देता है। ये एक-दूसरे के विरोधी भी नहीं हैं। Agent Canvas डिफ़ॉल्ट OpenHands एजेंट की जगह Claude Code को भी अपना एजेंट बना कर चला सकता है।

OpenHands बनाम Cursor

Cursor एक AI कोड एडिटर है। OpenHands एक एजेंट प्लेटफ़ॉर्म है। यही मुख्य अंतर है, और अधिकांश अन्य अंतर यहीं से निकलते हैं।

Cursor में, आप एडिटर के अंदर काम करते हैं, और एजेंट आपके साथ काम करता है। आप अपनी फाइलों में एडिट्स को आते देखते हैं, उन्हें स्वीकार या अस्वीकार करते हैं, और टाइपिंग जारी रखते हैं। OpenHands में, आप टास्क का वर्णन करते हैं, एजेंट सैंडबॉक्स में काम करता है, और आप परिणाम की समीक्षा करते हैं। GUI में सैंडबॉक्स का VS Code व्यू शामिल है, लेकिन अधिकतर काम वहीं नहीं होता।

रिपोजिटरी एक्सेस भी इसी विभाजन का अनुसरण करता है। Cursor का एजेंट आपके एडिटर में खुली फाइलों पर काम करता है। OpenHands उस पर काम करता है जिसे आप उसके सैंडबॉक्स में माउंट करें या Git इंटीग्रेशन से जोड़ें।

Cursor के Cloud Agents के साथ यह अंतर कम हो जाता है। वे क्लाउड में बिना निगरानी के चलते हैं और ब्रांच और पुल रिक्वेस्ट के जरिए काम लौटाते हैं, और उन्हें जुड़े हुए GitHub, GitLab, Azure DevOps, या Bitbucket अकाउंट और पेड प्लान की ज़रूरत होती है। यह OpenHands जैसा ही है, बस Cursor के इन्फ्रास्ट्रक्चर पर।

विस्तार-क्षमता (Extensibility) सबसे बड़ा अंतर है। Cursor MCP सर्वर और प्रोजेक्ट नियम सपोर्ट करता है, लेकिन एडिटर और एजेंट दोनों क्लोज़्ड प्रोडक्ट हैं। OpenHands में, आप खुद एजेंट बदल सकते हैं, इसे कहीं भी होस्ट कर सकते हैं, और लोकल मॉडल पर चला सकते हैं।

OpenHands बनाम GitHub Copilot

GitHub Copilot एडिटर में एक ऑटोकम्प्लीट टूल के रूप में शुरू हुआ और वहाँ से एजेंट फीचर्स तक बढ़ा। OpenHands की शुरुआत एक एजेंट के रूप में हुई।

Copilot की सबसे बड़ी ताकत है जहाँ यह रहता है। यह VS Code और JetBrains IDEs के अंदर काम करता है, और इसका क्लाउड एजेंट सीधे GitHub पर काम करता है। OpenHands के पास ऐसा IDE इंटीग्रेशन नहीं है।

रिपोजिटरी-स्तरीय टास्क के लिए, Copilot क्लाउड एजेंट सबसे नज़दीकी तुलना है। आप उसे कोई इश्यू असाइन करते हैं, और वह GitHub Actions द्वारा समर्थित अपने इफेमरल डेवलपमेंट एनवायरनमेंट में काम करता है, जहाँ वह पुश करने से पहले टेस्ट और लिंटर्स चला सकता है। जब आप किसी इश्यू या पुल रिक्वेस्ट कमेंट में @openhands का उल्लेख करते हैं, तो OpenHands Cloud कुछ समान करता है।

प्लेटफ़ॉर्म मुख्य अंतर है। Copilot क्लाउड एजेंट GitHub पर स्टोर की गई रिपोज के लिए सभी पेड Copilot प्लानों में उपलब्ध है। OpenHands GitHub, GitLab, Bitbucket या लोकल फ़ोल्डर के साथ काम करता है, और अगर आप चाहें तो आपके अपने हार्डवेयर पर चलता है।

Copilot आपको किसी टास्क के लिए मॉडल चुनने देता है, लेकिन केवल उन्हीं मॉडलों में से जो GitHub ऑफर करता है। OpenHands पर यह पाबंदी नहीं है।

संक्षिप्त पुनरावलोकन:

 OpenHandsClaude CodeCursorGitHub Copilot
Sourceओपन सोर्सप्रोप्रायटरीप्रोप्रायटरीप्रोप्रायटरी
Modelsकोई भी LiteLLM प्रोवाइडर, लोकल सहितClaude मॉडलकई प्रोवाइडर और इन-हाउस मॉडलGitHub द्वारा ऑफ़र किए गए मॉडल
Main interfaceब्राउज़र UI, SDKटर्मिनल, IDE, डेस्कटॉप, ब्राउज़रAI कोड एडिटरIDE एक्सटेंशन, GitHub
Where the agent runsDocker सैंडबॉक्स, लोकल या रिमोटआपकी मशीन या Anthropic का क्लाउडआपका एडिटर या Cursor का क्लाउडआपका IDE या GitHub Actions
Self-hostingहाँनहींकेवल एंटरप्राइजनहीं

OpenHands की तुलना अन्य AI एजेंट से

सॉफ्टवेयर इंजीनियरिंग टीमों के लिए OpenHands

एकल डेवलपर के लिए, OpenHands वह टूल है जिसे ज़रूरत पड़ने पर खोलते हैं। टीम के लिए ऐसा नहीं है।

अधिकांश टीमें पहले से ही काम को इश्यूज़ के आसपास संगठित करती हैं, और OpenHands Cloud उससे जुड़ता है। यह GitHub, GitLab, और Bitbucket के अलावा Slack, Jira, और Linear से इंटीग्रेट होता है। आप किसी इश्यू या पुल रिक्वेस्ट कमेंट में @openhands का उल्लेख कर सकते हैं, और एजेंट वहीं से टास्क उठा लेता है।

फिर वह काम आता है जिसे कोई माँगता नहीं पर सबको चाहिए। Agent Canvas ऑटोमेशन शेड्यूल पर या वेबहुक इवेंट्स के जवाब में चलते हैं। उदाहरण के लिए, कोई टीम कोड रिव्यू और डिपेंडेंसी अपडेट्स के लिए एक Agent Server साझा कर सकती है, जबकि हर डेवलपर अपने लैपटॉप पर पर्सनल एजेंट चला सकता है।

टेस्टिंग उसी तरह काम करती है जैसा आलेख में। एजेंट रिपोर्ट करने से पहले अपने सैंडबॉक्स में टेस्ट सूट चलाता है। लेकिन सैंडबॉक्स रन CI का विकल्प नहीं है — आपकी पाइपलाइन हर पुल रिक्वेस्ट पर वैसे ही चलती है जैसे मानव-लिखित कोड के लिए चलती है।

पुल रिक्वेस्ट एक अन्य विषय है। जब OpenHands Cloud GitHub के साथ काम करता है, तो यह आठ घंटे में एक्सपायर होने वाले शॉर्ट-लिव्ड टोकन रिक्वेस्ट करता है, जिनमें कंटेंट्स, इश्यूज़, पुल रिक्वेस्ट्स, और वर्कफ़्लोज़ पर रीड-राइट एक्सेस होता है। सेल्फ-होस्टेड एंटरप्राइज सेटअप में, एजेंट उस यूज़र के GitHub ऑथराइजेशन का उपयोग करता है जिसने उसे ट्रिगर किया, इसलिए हर बदलाव किसी व्यक्ति तक ट्रेस हो जाता है।

जिम्मेदारी इसी तरह काम करनी चाहिए। एजेंट पुल रिक्वेस्ट खोल सकता है, लेकिन उसे डेवलपर मंज़ूरी देता है। ब्रांच प्रोटेक्शन और आवश्यक रिव्यूज़ एजेंट की पुल रिक्वेस्ट्स पर भी वैसे ही लागू होते हैं जैसे बाकी सभी पर।

आइसोलेटेड एनवायरनमेंट्स इस सबको स्केल पर काम करने लायक बनाते हैं। हर टास्क अपने अलग सैंडबॉक्स में चलता है, इसलिए दो एजेंट जो दो बग ठीक कर रहे हों, एक-दूसरे की फाइलें ओवरराइट नहीं करते या एक ही पोर्ट के लिए नहीं लड़ते।

OpenHands सुरक्षा और सैंडबॉक्सिंग

कोड कंप्लीशन टूल हमेशा टेक्स्ट सुझाता है, और फिर उसे स्वीकार करना आपके ऊपर होता है।

एजेंट अलग है। वह आपके प्रोजेक्ट से होकर गुजरता है, कमांड चलाता है, पैकेज इंस्टॉल करता है, और फाइलें अपने आप एडिट करता है, अक्सर बिना पूछे। इसलिए सवाल "क्या यह कोड सही है?" से बदलकर "एजेंट वहाँ तक पहुँचने के लिए क्या चलाया?" हो जाता है।

आइसोलेटेड एक्ज़ीक्यूशन एनवायरनमेंट

Docker सैंडबॉक्स आपकी होस्ट फाइलें और प्रोग्राम, होस्ट संसाधन, और अन्य कंटेनर व प्रोसेस को सुरक्षित रखता है। अगर एजेंट कोई विध्वंसक कमांड चलाता है, तो वह एक कंटेनर तक सीमित रहता है।

लोकल सेटअप में एक अपवाद पर ध्यान दें। ऐप कंटेनर सैंडबॉक्स शुरू करने के लिए होस्ट का Docker सॉकेट माउंट करता है, और उस सॉकेट तक पहुँच का मतलब आपकी मशीन पर Docker का नियंत्रण है।

रिपोजिटरी परमिशन

सैंडबॉक्स केवल वही बचाता है जिसे आप माउंट नहीं करते। माउंट की गई फाइलें और डायरेक्टरियाँ संशोधित या हटाई जा सकती हैं।

केवल वही प्रोजेक्ट माउंट करें जिस पर आप काम कर रहे हैं, कभी भी अपना होम डायरेक्टरी नहीं। केवल-पठन टास्क (जैसे कोड जाँच) के लिए :ro मोड का उपयोग करें। Git इंटीग्रेशन के लिए, एजेंट को केवल उन्हीं रिपोज तक एक्सेस दें जिनकी उसे ज़रूरत है — और कुछ नहीं।

सीक्रेट्स और क्रेडेंशियल

अगर आप क्रेडेंशियल (जैसे API की या टोकन) देते हैं, तो एजेंट उनका उपयोग कर सकता है। और कोई एजेंट जो कोई सीक्रेट पढ़ सकता है, वह उसे लॉग में प्रिंट भी कर सकता है या कहीं भेज भी सकता है।

इसलिए उन फ़ोल्डरों को माउंट न करें जिनमें प्रोडक्शन कीज़ रखने वाली .env फाइलें हों। एजेंट को सीमित स्कोप वाले टेस्ट क्रेडेंशियल दें, और उन्हें बार-बार रोटेट करें।

नेटवर्क एक्सेस

डिफ़ॉल्ट रूप से, एजेंट कंटेनर के भीतर से इंटरनेट तक पहुँच सकता है। पैकेज इंस्टॉल करने के लिए यह ज़रूरी है, लेकिन इससे वह किसी भी बाहरी सेवा तक भी पहुँच सकता है।

यह प्रॉम्प्ट इंजेक्शन का दरवाज़ा खोलता है। कोई वेब पेज या इश्यू कमेंट ऐसे निर्देश शामिल कर सकता है जिन्हें एजेंट मान सकता है। GitHub अपने क्लाउड एजेंट के लिए इसे डिफ़ॉल्ट रूप से इंटरनेट एक्सेस को सीमित करने वाले फ़ायरवॉल से घटाता है, और अपने OpenHands सेटअप के लिए भी ऐसे ही प्रतिबंधों पर सोचना उचित है।

कमांड एक्ज़ीक्यूशन

आप नियंत्रित कर सकते हैं कि कौन-से कमांड बिना मंज़ूरी के चलें। OpenHands तीन कन्फ़र्मेशन नीतियाँ सपोर्ट करता है: सब मंज़ूर करें, कुछ भी नहीं, या केवल जोखिमपूर्ण एक्शन। डिफ़ॉल्ट NeverConfirm है।

"जोखिमपूर्ण एक्शन" विकल्प की एक पेच है। डिफ़ॉल्ट LLM सिक्योरिटी एनालाइज़र वही जोखिम स्तर उपयोग करता है जो मॉडल अपने एक्शनों को देता है। कोई मॉडल किसी विध्वंसक कमांड को LOW जोखिम लेबल दे सकता है, और वह बिना पूछे चल जाएगा। एनालाइज़र नीति लेयर के लिए जोखिम वर्गीकृत करता है — यह अपने आप कुछ नहीं रोकता, और डॉक्यूमेंटेशन इसे Docker आइसोलेशन के साथ जोड़ने की सिफारिश करता है।

जनरेटेड बदलावों की समीक्षा

ऊपर की सारी बातें इस बात को सीमित करती हैं कि एजेंट क्या कर सकता है। लेकिन रिव्यू चरण इसलिए महत्वपूर्ण है कि आप इससे पता लगाते हैं कि उसने क्या किया।

पूरा डिफ़ पढ़ें, केवल वे फाइलें नहीं जिन्हें आप बदलने की उम्मीद कर रहे थे। CI कॉन्फ़िगरेशन, डिपेंडेंसी फाइलें, और स्क्रिप्ट्स पर विशेष ध्यान दें। OpenHands Cloud में, एजेंट का GitHub टोकन वर्कफ़्लोज़ पर राइट एक्सेस शामिल करता है, इसलिए .github/workflows में बदलाव आपकी पाइपलाइन में क्या चलता है उसे बदल सकते हैं।

OpenHands की सीमाएँ

OpenHands जो कोड लिखता है उसमें अब भी बग हो सकते हैं। पास होते टेस्ट केवल यह बताते हैं कि कोड टेस्ट से मेल खाता है, और एजेंट दोनों लिख सकता है। अगर टेस्ट कमजोर हैं, तो कोड पास होकर भी गलत हो सकता है।

जटिल टास्क में अक्सर आपको बीच-बीच में रहना पड़ता है। अस्पष्ट आवश्यकताएँ या कोई ऐसा डिज़ाइन निर्णय जिसे एजेंट नहीं ले सकता, उसे रोक देगा या, बदतर, गलत दिशा में भेज देगा।

किसी ताकतवर होस्टेड मॉडल के साथ, OpenHands मल्टी-फाइल टास्क अच्छी तरह संभालता है। किसी छोटे लोकल मॉडल के साथ, आप असफल टूल कॉल्स और चैटबॉट-जैसे उत्तर देखेंगे, और बड़े कॉन्टेक्स्ट विंडो के बावजूद कुछ लोकल मॉडल टूल्स का विश्वसनीय उपयोग नहीं कर पाते।

एजेंट लूप चैट से अधिक महँगा भी पड़ता है। हर कदम वार्तालाप इतिहास को फिर से मॉडल को भेजता है, और लंबे टास्क कई कदम लेते हैं। OpenHands डॉक्यूमेंटेशन चेतावनी देता है कि एजेंट LLM को बहुत से प्रॉम्प्ट भेजता है और खर्च सीमा और उपयोग मॉनिटरिंग की सिफारिश करता है। कॉन्टेक्स्ट कंडेंसर मदद करता है, लेकिन वह पुराने चरणों का सारांश बनाता है, इसलिए लंबे टास्क में विवरण खो सकते हैं।

टूल एक्सेस सुरक्षा जोखिम बढ़ाता है। टर्मिनल और नेटवर्क एक्सेस वाला एजेंट अगर खराब निर्देशों का पालन करे, तो असली नुकसान कर सकता है — इसलिए सैंडबॉक्स और आपकी समीक्षा बहुत मायने रखते हैं।

और हर बदलाव पर अंततः किसी व्यक्ति की स्वीकृति ज़रूरी है। इसे हमेशा ध्यान में रखें।

OpenHands और AI कोडिंग एजेंट्स का भविष्य

AI कोडिंग टूल्स ऑटोकम्प्लीट से चैट तक और फिर पूरे टास्क पर काम करने वाले एजेंट तक पहुँच गए हैं। OpenHands उन कुछ प्रोजेक्ट्स में से है जो इस आख़िरी कदम को आगे बढ़ा रहे हैं।

यह दिशा इंडस्ट्री भर में साफ़ दिखती है। Cursor एक ऐसे उभरते युग का वर्णन करता है जिसमें स्वायत्त क्लाउड एजेंट लंबे समयांतराल पर बड़े टास्क लेते हैं। Copilot अब GitHub और Linear से इश्यू लेता है। Claude Code टर्मिनल, ब्राउज़र और Slack में चलता है।

ओपन-सोर्स प्लेटफ़ॉर्म उस बदलाव में विशेष भूमिका निभाते हैं। OpenHands के साथ, आप देख सकते हैं कि एजेंट कैसे काम करता है, इसे अपने इन्फ्रास्ट्रक्चर पर चला सकते हैं, और मॉडल चुन सकते हैं। कड़े डेटा नियमों वाली टीमों के लिए, अक्सर यही एकमात्र तरीका होता है जिससे वे एजेंट का उपयोग कर सकती हैं।

लंबे टास्क नई समस्याएँ भी लाते हैं। एक घंटा काम करने वाला एजेंट, एक मिनट काम करने वाले एजेंट से अधिक निर्णय लेता है, और हर निर्णय आपके चाहने से भटकने का मौका होता है। बेहतर मॉडल मदद करते हैं, लेकिन सैंडबॉक्स, कन्फ़र्मेशन नीतियाँ, और समीक्षा भी उतनी ही ज़रूरी हैं।

निष्कर्ष

OpenHands को उसके प्रतिस्पर्धियों से अलग जो चीज़ बनाती है, वह है नियंत्रण। आप सोर्स पढ़ सकते हैं, इसे अपने हार्डवेयर पर होस्ट कर सकते हैं, और किसी भी मॉडल — लोकल सहित — के साथ चला सकते हैं। Claude Code, Cursor, और GitHub Copilot जैसे अधिक कसे हुए कमर्शियल टूल बेहतर अनुभव देते हैं, पर अपनी शर्तों पर।

लेकिन आपके टर्मिनल और रिपोजिटरीज़ तक पहुँच वाला एजेंट फिर भी किसी व्यक्ति से अपने काम की जाँच की माँग करता है। हमेशा डिफ़ पढ़ना और टेस्ट खुद चलाना याद रखें।

अगर आप शून्य से अपना एजेंट बनाना सीखना चाहते हैं, तो हमारा Introduction to Creating AI Agents in Python वेबिनार देखें।

Dario Radečić

लेखक

Dario Radečić

क्रोएशिया में स्थित सीनियर डेटा साइंटिस्ट। 700 से अधिक प्रकाशित लेखों के साथ टॉप टेक राइटर, जिनसे 10M+ व्यूज़ प्राप्त हुए। Machine Learning Automation with TPOT के पुस्तक लेखक।

FAQs

OpenHands क्या है?

OpenHands कोड के साथ काम करने वाले AI एजेंट बनाने और चलाने के लिए एक ओपन-सोर्स प्लेटफ़ॉर्म है। इसका कोडिंग एजेंट रिपोजिटरी का निरीक्षण कर सकता है, फाइलें एडिट कर सकता है, कमांड और टेस्ट चला सकता है, और जब तक टास्क पूरा न हो जाए तब तक परिणामों पर इटरेट कर सकता है। आप इसे लोकली Docker में, SDK के जरिए, या OpenHands Cloud पर चला सकते हैं।

क्या OpenHands का उपयोग मुफ़्त है?

OpenHands सॉफ्टवेयर ओपन सोर्स है, इसलिए आप इसे लाइसेंस दिए बिना सेल्फ-होस्ट कर सकते हैं। जिसकी कीमत लगती है, वह है मॉडल — Anthropic या OpenAI जैसे होस्टेड प्रोवाइडर प्रति टोकन शुल्क लेते हैं, और एजेंट लूप उनमें बहुत-से टोकन खर्च करते हैं। अगर आप Ollama या LM Studio के जरिए लोकल मॉडल चलाते हैं, तो लागत केवल आपका हार्डवेयर है। OpenHands Cloud एक अलग, कमर्शियल सर्विस है।

OpenHands GitHub Copilot या Cursor से कैसे अलग है?

Copilot और Cursor एडिटर के इर्द-गिर्द बने हैं, जहाँ AI आपके साथ-साथ काम करता है। OpenHands एजेंट-फर्स्ट है — आप टास्क बताते हैं, एजेंट उसे सैंडबॉक्स में पूरा करता है, और आप परिणाम की समीक्षा करते हैं। यह ओपन सोर्स भी है, किसी भी LiteLLM-सपोर्टेड मॉडल के साथ काम करता है, और आपके अपने इन्फ्रास्ट्रक्चर पर चलता है — जो स्तर Copilot या Cursor पर उपलब्ध नहीं।

क्या मैं OpenHands को लोकल मॉडल के साथ चला सकता/सकती हूँ?

हाँ। OpenHands, LM Studio, Ollama, vLLM, और SGLang जैसे लोकल सर्वर से उनके OpenAI-कम्पैटिबल API के जरिए कनेक्ट होता है। एजेंटिक कोडिंग के लिए बने मॉडल चुनें, जैसे Devstral Small 2 या Qwen3.6-35B-A3B, और कॉन्टेक्स्ट विंडो कम से कम 22000 टोकन सेट करें। छोटे जनरल-पर्पज़ मॉडल अक्सर टूल कॉल्स में फेल होते हैं और चैटबॉट जैसी प्रतिक्रियाएँ देते हैं।

क्या OpenHands को मेरे कोड तक पहुँच देना सुरक्षित है?

OpenHands एजेंट के कमांड्स को Docker सैंडबॉक्स के अंदर चलाता है, जो आपकी होस्ट सिस्टम को अधिकतर गलतियों से बचाता है। पर जो कुछ भी आप सैंडबॉक्स में माउंट करते हैं, उसे बदला या हटाया जा सकता है, और कोई भी क्रेडेंशियल जो आप देते हैं, एजेंट उपयोग कर सकता है। डिफ़ॉल्ट रूप से, एजेंट कार्रवाई से पहले अनुमति नहीं माँगता, इसलिए केवल ज़रूरी प्रोजेक्ट ही माउंट करें, सीमित टेस्ट क्रेडेंशियल का उपयोग करें, और मर्ज करने से पहले हर डिफ़ की समीक्षा करें।

विषय