OpenAI Agents SDK: Modal Sandboxes में एजेंट कैसे चलाएँ

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

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

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

इस गाइड में, हम एक व्यावहारिक एजेंटिक एप्लिकेशन बनाने के लिए OpenAI Agents फ़्रेमवर्क को Modal Sandboxes के साथ संयोजित करना सीखेंगे। एजेंट एक आइसोलेटेड Modal वातावरण के भीतर चल सकेगा, कमांड्स को सुरक्षित रूप से निष्पादित करेगा, फ़ाइलों के साथ काम करेगा, और मुख्य एप्लिकेशन को उपयोगी आउटपुट लौटाएगा।

सैंडबॉक्स का उपयोग किए बिना परिचय के लिए, मैं यह भी सुझाऊँगा कि आप हमारा OpenAI Agents SDK Tutorial पढ़ें। 

OpenAI Agents SDK में नया क्या है?

नया OpenAI Agents SDK वास्तविक फ़ाइलों, टूल्स और निष्पादन वातावरण के साथ काम करने वाले एजेंट बनाने का अधिक स्वच्छ तरीका जोड़ता है। हर चीज़ को एक ही प्रॉम्प्ट लूप में रखने के बजाय, SDK अब एजेंट ऑर्केस्ट्रेशन लेयर को उस सैंडबॉक्स से अलग करता है जहाँ काम होता है।

मुख्य अपडेट्स शामिल हैं:

• नेेटिव सैंडबॉक्स सपोर्ट ताकि एजेंट आइसोलेटेड वातावरण में चल सकें
• मैनिफेस्ट जिससे एजेंट किन फ़ाइलों, फ़ोल्डर्स और आउटपुट्स तक पहुँच सकता है, यह परिभाषित किया जाता है
• SandboxAgent जो एजेंट को सैंडबॉक्स्ड कार्यक्षेत्र से जोड़ता है
• SandboxRunConfig जिससे सैंडबॉक्स रन कहाँ और कैसे हो, यह नियंत्रित किया जा सकता है
• Codex-शैली के टूल्स फ़ाइल संपादन, शेल कमांड्स और प्रोजेक्ट निरीक्षण के लिए
• MCP सपोर्ट जिससे एजेंट बाहरी टूल्स और सेवाओं से कनेक्ट हो सकें
• Skills और AGENTS.md सपोर्ट ताकि एजेंट्स को प्रोजेक्ट निर्देश और स्पष्ट मिलें
• कई सैंडबॉक्स प्रदाताओं के लिए सपोर्ट, जैसे Modal, E2B, Cloudflare, Daytona, Blaxel, Runloop, और Vercel

एक साथ मिलकर, ये अपडेट्स एजेंटिक ऐप्स बनाना आसान बनाते हैं जो प्रोजेक्ट्स का निरीक्षण कर सकते हैं, कोड चला सकते हैं, फ़ाइलें संपादित कर सकते हैं, और नियंत्रित कार्यक्षेत्र से उत्पन्न आउटपुट लौटा सकते हैं।

1. प्रोजेक्ट सेटअप करना

इस डेमो प्रोजेक्ट में, हम OpenAI Agents SDK और Modal Sandboxes का उपयोग करके एक छोटा सपोर्ट टिकट ट्रायेज़ उदाहरण बनाएँगे। ऐप एक सैंडबॉक्स्ड कार्यक्षेत्र बनाएगा, उसमें कुछ प्रोजेक्ट फ़ाइलें जोड़ेगा, और फिर उत्तर देने से पहले एक GPT-5.4-mini एजेंट से उन फ़ाइलों का निरीक्षण करने के लिए कहेगा।

शुरू करने के लिए, अपने वातावरण में आवश्यक पैकेज इंस्टॉल करें:

pip install "openai-agents[modal]" modal

प्रोजेक्ट चलाने से पहले, आपको दो अकाउंट्स चाहिए:

• OpenAI अकाउंट: OpenAI Platform पर एक अकाउंट बनाएँ और क्रेडिट कार्ड से API क्रेडिट जोड़ें। सुनिश्चित करें कि आपका अकाउंट नवीनतम समर्थित मॉडलों तक पहुँच के लिए सत्यापित है।
• Modal अकाउंट: Modal पर साइन अप करें। फ्री प्लान में मासिक क्रेडिट शामिल होते हैं, जो इस गाइड का परीक्षण करने के लिए पर्याप्त हैं।

अगला कदम, अपनी लोकल एन्वायरनमेंट में OpenAI API key जोड़ें।

• macOS या Linux पर: export OPENAI_API_KEY="your_openai_api_key"
• Windows PowerShell पर: $env:OPENAI_API_KEY="your_openai_api_key"

फिर Modal को लोकली प्रमाणित करें:

modal setup

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

सब सेटअप होने के बाद, आपको अपने टर्मिनल में एक सफलता संदेश दिखना चाहिए जो पुष्टि करता है कि Modal प्रमाणीकरण पूरा हो गया है।

2. सैंडबॉक्स कार्यक्षेत्र परिभाषित करना

अब main.py जैसा एक Python फ़ाइल बनाएँ और आवश्यक इम्पोर्ट्स जोड़ें। ये इम्पोर्ट्स OpenAI Agents SDK, सैंडबॉक्स कॉन्फ़िगरेशन क्लासेज़ और Modal सैंडबॉक्स क्लाइंट लाते हैं। 

import asyncio

from agents import ModelSettings, Runner
from agents.run import RunConfig
from agents.sandbox import Manifest, SandboxAgent, SandboxRunConfig
from agents.sandbox.entries import File
from agents.extensions.sandbox import ModalSandboxClient, ModalSandboxClientOptions

अब हमें सैंडबॉक्स कार्यक्षेत्र को परिभाषित करने की आवश्यकता है। इस उदाहरण में, कार्यक्षेत्र में एक छोटा सपोर्ट टिकट ट्रायेज़ प्रोजेक्ट शामिल है, जिसमें README.md, एक ऐप फ़ाइल और एक रिलीज़ चेकलिस्ट है।

manifest = Manifest(
    entries={
        "README.md": File(
            content=(
                b"# Support Ticket Triage\n\n"
                b"Small service that labels customer tickets by urgency and team.\n"
            )
        ),
        "src/app.py": File(
            content=(
                b"def route_ticket(subject: str, customer_tier: str) -> dict:\n"
                b"    urgent = customer_tier == \"enterprise\" or \"outage\" in subject.lower()\n"
                b"    return {\n"
                b"        \"priority\": \"high\" if urgent else \"normal\",\n"
                b"        \"team\": \"support-ops\" if urgent else \"customer-care\",\n"
                b"    }\n"
            )
        ),
        "docs/release-checks.md": File(
            content=(
                b"# Release Checks\n\n"
                b"- Confirm routing rules match the current support escalation policy.\n"
            )
        ),
    }
)

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

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

3. सैंडबॉक्स एजेंट बनाना

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

agent = SandboxAgent(
    name="Modal Sandbox Assistant",
    model="gpt-5.4-mini",
    instructions=(
        "You are a coding assistant reviewing a small production service. "
        "Inspect the sandbox workspace before answering. "
        "Keep the answer short and practical."
    ),
    default_manifest=manifest,
    model_settings=ModelSettings(tool_choice="required"),
)

यहाँ हम एजेंट का नाम Modal Sandbox Assistant रख रहे हैं और तेज़ प्रतिक्रियाओं के लिए gpt-5.4-mini मॉडल का उपयोग कर रहे हैं। निर्देश एजेंट को उत्तर देने से पहले सैंडबॉक्स कार्यक्षेत्र का निरीक्षण करने के लिए कहते हैं, जो तब महत्वपूर्ण है जब प्रतिक्रिया प्रोजेक्ट की वास्तविक फ़ाइलों पर निर्भर हो।

default_manifest=manifest एजेंट को पहले बनाए गए कार्यक्षेत्र से जोड़ता है। tool_choice="required" सेटिंग एजेंट को केवल याददाश्त या प्रॉम्प्ट संदर्भ से जवाब देने के बजाय उपलब्ध सैंडबॉक्स टूल्स का उपयोग करने के लिए प्रेरित करती है।

4. Modal सैंडबॉक्स क्लाइंट बनाना

अब Modal सैंडबॉक्स क्लाइंट बनाएँ। यह OpenAI Agents वर्कफ़्लो और Modal सैंडबॉक्स के बीच का कनेक्शन है, जहाँ वास्तविक फ़ाइल और कमांड निष्पादन होगा।

client = ModalSandboxClient()
options = ModalSandboxClientOptions(
    app_name="openai-agents-modal-demo",
    workspace_persistence="tar",
)

ModalSandboxClient() एजेंट को बताता है कि सैंडबॉक्स प्रदाता के रूप में Modal का उपयोग करना है। इसका मतलब है कि एजेंट आपके लोकल मशीन पर सीधे चलने के बजाय एक आइसोलेटेड Modal वातावरण में चल सकता है।

ModalSandboxClientOptions यह नियंत्रित करता है कि Modal सैंडबॉक्स कैसे कॉन्फ़िगर होगा। यहाँ, app_name Modal ऐप को एक स्पष्ट नाम देता है, जबकि workspace_persistence="tar" Modal को बताता है कि रन के दौरान कार्यक्षेत्र फ़ाइलों को कैसे पैकेज और बनाए रखा जाए।

5. सैंडबॉक्स सत्र शुरू करना

अब जब क्लाइंट और विकल्प तैयार हैं, तो manifest से सैंडबॉक्स बनाएँ और सत्र शुरू करें। 

sandbox = await client.create(
    manifest=manifest,
    options=options,
)

await sandbox.start()

client.create() कॉल हमारे द्वारा Manifest में परिभाषित फ़ाइलों का उपयोग करके एक नया Modal सैंडबॉक्स बनाता है। इसका मतलब है कि सैंडबॉक्स उसी प्रोजेक्ट संरचना के साथ शुरू होता है, जिसमें README.md, src/app.py, और docs/release-checks.md शामिल हैं।

फिर, await sandbox.start() सैंडबॉक्स सत्र शुरू करता है। इस बिंदु पर, आपके पास Modal पर चल रहा एक लाइव आइसोलेटेड कार्यक्षेत्र है, जो एजेंट के लिए फ़ाइलों का निरीक्षण करने, कमांड्स चलाने और प्रोजेक्ट के साथ काम करने के लिए तैयार है।

6. सैंडबॉक्स में एजेंट चलाना

एक बार सैंडबॉक्स सक्रिय हो जाए, तो लाइव सैंडबॉक्स सत्र को SandboxRunConfig के माध्यम से पास करके एजेंट चलाएँ। यह OpenAI Agents SDK को बताता है कि रन के दौरान एजेंट को Modal सैंडबॉक्स कार्यक्षेत्र का उपयोग करना चाहिए। 

result = await Runner.run(
    agent,
    (
        "Explain what this service does and name one production check "
        "before release. Keep it under 3 sentences."
    ),
    run_config=RunConfig(
        sandbox=SandboxRunConfig(session=sandbox),
        workflow_name="Modal sandbox example",
    ),
)

print(result.final_output)

यहीं सब कुछ एक साथ जुड़ता है। मॉडल तर्क का काम संभालता है, जबकि सैंडबॉक्स उसे वास्तविक कार्यक्षेत्र फ़ाइलों तक पहुँच देता है।

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

7. सैंडबॉक्स की सफाई

एजेंट रन समाप्त होने के बाद, सैंडबॉक्स को डिलीट कर दें ताकि Modal में अनुपयोगी सत्र चालू न रहें।

await client.aclose(sandbox)

यह काम पूरा होने के बाद सैंडबॉक्स सत्र हटा देता है। यह एक अच्छी आदत है क्योंकि सक्रिय रहते समय सैंडबॉक्स सत्र कंप्यूट संसाधनों का उपयोग कर सकते हैं।

किसी वास्तविक प्रोजेक्ट में, आपको इसे finally ब्लॉक के अंदर रखना चाहिए। इस तरह, सफाई तब भी चलती है जब एजेंट कॉल विफल हो जाए या स्क्रिप्ट में कोई त्रुटि आ जाए।

8. पूरा कोड उदाहरण

यहाँ एक ही जगह पूरा स्क्रिप्ट है। यह कार्यक्षेत्र बनाता है, Modal सैंडबॉक्स शुरू करता है, उसके अंदर एजेंट चलाता है, अंतिम आउटपुट प्रिंट करता है, और फिर सैंडबॉक्स सत्र की सफाई करता है। 

import asyncio

from agents import ModelSettings, Runner
from agents.extensions.sandbox import ModalSandboxClient, ModalSandboxClientOptions
from agents.run import RunConfig
from agents.sandbox import Manifest, SandboxAgent, SandboxRunConfig
from agents.sandbox.entries import File


async def main():
    manifest = Manifest(
        entries={
            "README.md": File(
                content=(
                    b"# Support Ticket Triage\n\n"
                    b"Small service that labels customer tickets by urgency and team.\n"
                )
            ),
            "src/app.py": File(
                content=(
                    b"def route_ticket(subject: str, customer_tier: str) -> dict:\n"
                    b"    urgent = customer_tier == \"enterprise\" or \"outage\" in subject.lower()\n"
                    b"    return {\n"
                    b"        \"priority\": \"high\" if urgent else \"normal\",\n"
                    b"        \"team\": \"support-ops\" if urgent else \"customer-care\",\n"
                    b"    }\n"
                )
            ),
            "docs/release-checks.md": File(
                content=(
                    b"# Release Checks\n\n"
                    b"- Confirm routing rules match the current support escalation policy.\n"
                )
            ),
        }
    )

    agent = SandboxAgent(
        name="Modal Sandbox Assistant",
        model="gpt-5.4-mini",
        instructions=(
            "You are a coding assistant reviewing a small production service. "
            "Inspect the sandbox workspace before answering. "
            "Keep the answer short and practical."
        ),
        default_manifest=manifest,
        model_settings=ModelSettings(tool_choice="required"),
    )

    client = ModalSandboxClient()
    options = ModalSandboxClientOptions(
        app_name="openai-agents-modal-demo",
        workspace_persistence="tar",
    )

    sandbox = await client.create(
        manifest=manifest,
        options=options,
    )

    await sandbox.start()

    try:
        result = await Runner.run(
            agent,
            (
                "Explain what this service does and name one production check "
                "before release. Keep it under 3 sentences."
            ),
            run_config=RunConfig(
                sandbox=SandboxRunConfig(session=sandbox),
                workflow_name="Modal sandbox example",
            ),
        )

        print(result.final_output)

    finally:
        await sandbox.aclose()

if __name__ == "__main__":
    asyncio.run(main())

यह स्क्रिप्ट वर्तमान OpenAI सैंडबॉक्स संरचना का पालन करती है और निष्पादन बैकएंड के रूप में Modal का उपयोग करती है। एजेंट लॉजिक आपके Python ऐप में रहता है, जबकि वास्तविक कार्यक्षेत्र Modal सैंडबॉक्स के अंदर चलता है।

finally ब्लॉक महत्वपूर्ण है क्योंकि यह एजेंट रन विफल होने पर भी सैंडबॉक्स को बंद और डिलीट कर देता है। इससे आपका Modal वातावरण साफ़ रहता है और अनुपयोगी सत्र चालू नहीं रहते।

9. ऐप का लोकल परीक्षण

जब आपकी स्क्रिप्ट तैयार हो जाए, तो उसी फ़ोल्डर में टर्मिनल से लोकली चलाएँ जहाँ main.py सेव है:

python main.py

यदि सब कुछ ठीक से कॉन्फ़िगर है, तो स्क्रिप्ट एक Modal सैंडबॉक्स बनाएगी, उसमें मैनिफेस्ट लोड करेगी, OpenAI एजेंट को कार्यक्षेत्र के खिलाफ चलाएगी, प्रतिक्रिया प्रिंट करेगी, और फिर सैंडबॉक्स की सफाई करेगी।

आपको इससे मिलता-जुलता आउटपुट दिखना चाहिए:

This service triages customer support tickets by assigning urgency and routing them to the right team. One production check before release is to confirm the routing rules still match the current support escalation policy.

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

10. एक इंटरैक्टिव वेब ऐप बनाना 

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

पहले, Gradio का नवीनतम संस्करण इंस्टॉल करें:

pip install gradio

फिर app.py नाम की नई फ़ाइल बनाएँ और उसमें Gradio ऐप कोड (OpenAI-Agents-in-Modal/app.py) कॉपी करें। यह ऐप वही OpenAI Agents और Modal Sandbox सेटअप उपयोग करता है, लेकिन उसे एक चैट इंटरफ़ेस में लपेटता है। कोड जहाँ संभव हो, सैंडबॉक्स सत्र को फिर से उपयोग भी करता है, ताकि हर संदेश पर बिल्कुल नया सैंडबॉक्स शून्य से न बनाना पड़े।

ऐप को इस तरह चलाएँ:

python app.py

आपको अपने टर्मिनल में एक लोकल URL दिखेगा:

* Running on local URL:  http://127.0.0.1:7860
* To create a public link, set share=True in launch().

चैट ऐप का उपयोग करने के लिए अपने ब्राउज़र में लोकल URL खोलें। आप एजेंट से प्रोजेक्ट का निरीक्षण करने, सर्विस क्या करती है समझाने, नई हेल्पर फ़ाइलें बनाने, मौजूदा फ़ाइलें संपादित करने, या Modal सैंडबॉक्स के अंदर टेस्ट चलाने के लिए कह सकते हैं।

उदाहरण के लिए, मैंने सबसे पहले इसे समझाने के लिए कहा कि प्रोजेक्ट सर्विस क्या करती है, और कुछ ही सेकंड में, इसने सैंडबॉक्स फ़ाइलों के आधार पर विस्तृत उत्तर लौटाया।

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

एजेंट ने src/routing_rules.py बनाया, tests/test_routing_rules.py पर एक नई टेस्ट फ़ाइल जोड़ी, और pytest के साथ बदलावों को सत्यापित किया। सभी 6 टेस्ट पास हुए, जिससे पुष्टि हुई कि नया हेल्पर सही तरह से काम कर रहा है और मौजूदा टिकट रूटिंग लॉजिक अभी भी यथावत है।

उच्च स्तर पर, यह Gradio ऐप आपको Modal-बैक्ड OpenAI एजेंट के साथ काम करने के लिए एक सरल फ्रंटएंड देता है। उपयोगकर्ता ब्राउज़र के माध्यम से संदेश भेजता है, ऐप उसे SandboxAgent तक पहुँचाता है, एजेंट Modal सैंडबॉक्स के अंदर काम करता है, और अंतिम प्रतिक्रिया चैट इंटरफ़ेस में दिखाई जाती है।

अंतिम विचार

Modal Sandboxes के साथ OpenAI Agents हमें एजेंटिक ऐप्स बनाने का एक स्वच्छ तरीका देते हैं, जो वास्तविक फ़ाइलों के साथ काम कर सकते हैं, कमांड्स चला सकते हैं, और एक आइसोलेटेड वातावरण से उपयोगी आउटपुट लौटा सकते हैं। 

Modal के लिए सेटअप प्रक्रिया सुचारू थी, और सैंडबॉक्स बनाना भी सीधा था। सब कुछ कनेक्ट होने के बाद, एजेंट प्रोजेक्ट का निरीक्षण करने, नया रूटिंग हेल्पर फ़ाइल बनाने, टेस्ट जोड़ने, और यह पुष्टि करने में सक्षम था कि सभी 6 टेस्ट पास हुए।

फिर भी, इंटरैक्टिव ऐप बनाना और मॉडल को कॉन्फ़िगर करना उम्मीद से अधिक काम का था। फ़ाइल निर्माण और परीक्षण चरणों में भी अधिक समय लगा क्योंकि कुछ समय पर Modal सैंडबॉक्स टाइम आउट हो जाता था। मुझे सैंडबॉक्स टाइमआउट को 300 सेकंड से बढ़ाकर 600 सेकंड करना पड़ा ताकि एजेंट के पास पूरा वर्कफ़्लो समाप्त करने के लिए पर्याप्त समय हो।

एक और कठिनाई लॉगिंग और दृश्यता थी। एजेंट के खत्म होने की प्रतीक्षा करते समय, हमेशा स्पष्ट नहीं था कि Agents SDK पृष्ठभूमि में क्या कर रहा है। यहाँ तक कि Modal लॉग्स भी हमेशा इतने विस्तृत नहीं थे कि समझ सकें कि एजेंट फ़ाइलों का निरीक्षण कर रहा है, कोड संपादित कर रहा है, या टेस्ट चला रहा है। 

भविष्य में, अधिक विस्तृत एजेंट लॉग्स उपयोगी होंगे, जैसे Claude Code जैसे टूल्स के साथ काम करते समय दिखते हैं, जहाँ आप हर चरण को अधिक स्पष्टता से फॉलो कर सकते हैं।

कुल मिलाकर, यह सैंडबॉक्स्ड एजेंट ऐप्स बनाने के लिए एक मजबूत वर्कफ़्लो है, खासकर यदि आपका एजेंट फ़ाइलों, कोड और उत्पन्न आउटपुट्स के साथ काम करने की आवश्यकता रखता है। आप पूरा प्रोजेक्ट GitHub पर पा सकते हैं, उसे लोकली क्लोन करें, और खुद चलाएँ: kingabzpro/OpenAI-Agents-in-Modal.

यदि आप उन्नत AI सिस्टम बनाने की बारीकियाँ सीखना चाहते हैं, तो मैं हमारा Building Scalable Agentic Systems कोर्स लेने की सलाह देता हूँ।