OpenAI-होस्टेड सैंडबॉक्स: एक सुरक्षित AI वित्तीय विश्लेषक बनाएँ

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

लेकिन LLM हमेशा पूर्वानुमेय नहीं होते। 

स्पष्ट निर्देशों के बावजूद, कोई एजेंट अप्रत्याशित कमांड जेनरेट कर सकता है या ऐसी चीज़ बदल सकता है जिसे बदलना नहीं था। वह कोड सीधे आपकी लोकल मशीन या एप्लिकेशन सर्वर पर चलाना, इसलिए, अनावश्यक जोखिम ला सकता है।

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

वित्तीय विश्लेषक केवल एक उदाहरण है। मुख्य लक्ष्य यह समझना है कि किसी AI एजेंट को एक नियंत्रित वातावरण कैसे दें जहाँ वह सुरक्षित रूप से कोड चला सके और फाइलों के साथ काम कर सके।

OpenAI-होस्टेड सैंडबॉक्स क्या है?

सैंडबॉक्स एक पृथक (isolated) वातावरण है जहाँ कोड बिना आपकी एप्लिकेशन को होस्ट करने वाली प्रणाली तक असीमित पहुँच के चल सकता है।

AI एजेंट्स के लिए यह विशेष रूप से उपयोगी है क्योंकि उनका व्यवहार पूरी तरह से पूर्वानुमेय नहीं होता। 

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

उन कमांड्स को सीधे आपके लैपटॉप या सर्वर पर चलाने देने के बजाय, आप एजेंट को सैंडबॉक्स में रख सकते हैं।

OpenAI इस उद्देश्य के लिए अपना होस्टेड सैंडबॉक्स वातावरण प्रदान करता है। 

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

सैंडबॉक्स के अंदर, एजेंट ये कर सकता है:

• फाइलें पढ़ना और लिखना।
• स्क्रिप्ट बनाना और चलाना।
• शेल कमांड्स चलाना।
• कमांड आउटपुट का निरीक्षण करना।
• त्रुटियाँ ठीक करना और अपना कोड फिर चलाना।
• रिपोर्ट्स, डेटासेट्स, चार्ट्स और अन्य आर्टिफैक्ट्स बनाना।

आप यह भी नियंत्रित कर सकते हैं कि सैंडबॉक्स को किस चीज़ तक पहुँच मिले। 

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

OpenAI सैंडबॉक्स का उपयोग करने के अलग-अलग तरीके

OpenAI आपको एजेंट्स या मॉडलों को अलग-थलग वातावरण के अंदर चलाने के कुछ तरीके देता है। मुख्य अंतर यह है कि आप निष्पादन और एजेंट वर्कफ़्लो का कितना हिस्सा OpenAI से मैनेज कराना चाहते हैं।

1. शेल टूल

The शेल टूल सबसे सरल विकल्प है। यह एक मॉडल को रिस्पॉन्सेज API के माध्यम से OpenAI-होस्टेड कंटेनर के अंदर शेल कमांड्स चलाने देता है।

response = client.responses.create(
    model=MODEL,
    tools=[{
        "type": "shell",
        "environment": {"type": "container_auto"}
    }],
    input="Analyze the files in /mnt/data."
)संचालित द्वारा

यह तब अच्छा विकल्प है जब आपको मुख्यतः कोड निष्पादन, फाइल प्रोसेसिंग, या कमांड-लाइन कार्यों की जरूरत हो।

2. एजेंट्स API

The Agents API एक अधिक मैनेज्ड विकल्प है। OpenAI एजेंट सेशन और होस्टेड वातावरण दोनों को संभालता है।

stream = client.beta.agents.sessions.create(
    agent={
        "model": MODEL,
        "instructions": "Analyze the data and create a report."
    },
    environment={"type": "openai_hosted"},
    input="Analyze the files in the workspace.",
    stream=True,
)संचालित द्वारा

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

3. SandboxAgent

SandboxAgent एजेंट्स SDK का हिस्सा है और उन एजेंट्स के लिए बना है जहाँ सैंडबॉक्स वर्कस्पेस एप्लिकेशन का मूल भाग होता है।

from agents.sandbox import SandboxAgent
from agents.sandbox.capabilities import Shell

agent = SandboxAgent(
    name="Financial Analyst",
    model=MODEL,
    capabilities=[Shell()],
)संचालित द्वारा

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

4. एजेंट्स SDK + ShellTool

यही तरीका हम इस गाइड में उपयोग करते हैं।

हम स्वयं OpenAI-होस्टेड कंटेनर बनाते हैं और फिर ShellTool का उपयोग करके एजेंट को उसी विशिष्ट वातावरण से जोड़ते हैं।

sandbox_shell = ShellTool(
    environment={
        "type": "container_reference",
        "container_id": container.id,
    }
)संचालित द्वारा

हमने यह तरीका इसलिए चुना क्योंकि यह सादगी और नियंत्रण के बीच अच्छा संतुलन देता है। 

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

OpenAI-होस्टेड सैंडबॉक्स का उपयोग कैसे करें

आइए OpenAI-होस्टेड सैंडबॉक्स का उपयोग करके एक सुरक्षित वित्तीय विश्लेषक एजेंट बनाना सीखें। 

1. वातावरण और प्रोजेक्ट सेट अप करें

हम सेटअप और वर्कफ़्लो परीक्षण के लिए Jupyter Notebook का उपयोग करेंगे। 

नोटबुक आवश्यक SDK इंस्टॉल करने, डेटासेट अपलोड करने, सैंडबॉक्स बनाने, एजेंट शुरू करने, और अंतिम आर्टिफैक्ट्स डाउनलोड करने जैसे कार्य संभालेगी।

हालाँकि, महत्वपूर्ण भेद यह है कि स्वयं वित्तीय विश्लेषण Jupyter के अंदर नहीं चलेगा। 

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

Jupyter को नियंत्रण परत के रूप में समझें, जबकि सैंडबॉक्स निष्पादन वातावरण है।

OpenAI Python SDK और OpenAI Agents SDK इंस्टॉल करने से शुरू करें:

%pip install -q -U openai openai-agentsसंचालित द्वारा

आपको OPENAI_API_KEY एनवायरनमेंट वेरिएबल के जरिए उपलब्ध OpenAI API कुंजी की भी जरूरत होगी।

इस ट्यूटोरियल के लिए, हम एक काल्पनिक कंपनी का डेटासेट इस्तेमाल करेंगे जो यहाँ संग्रहीत है:

financial_data/northstar_cloud_financial_statements.csvसंचालित द्वारा

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

import json
import os
from pathlib import Path

from IPython.display import Markdown, SVG, display


MODEL = os.getenv("OPENAI_MODEL", "gpt-6-luna")

STATEMENT_CSV = Path(
    "financial_data/northstar_cloud_financial_statements.csv"
)

OUTPUT_DIR = Path("financial_analysis_output")
OUTPUT_DIR.mkdir(exist_ok=True)

EXPECTED_ARTIFACTS = [
    "analyze_financials.py",
    "calculated_metrics.csv",
    "unusual_movements.csv",
    "financial_trends.svg",
    "investment_analysis.md",
    "analysis_run.json",
]

assert os.getenv("OPENAI_API_KEY"), \
    "Set OPENAI_API_KEY before continuing."

assert STATEMENT_CSV.exists(), \
    f"Missing input: {STATEMENT_CSV.resolve()}"

print(f"Model: {MODEL}")
print(
    f"Input: {STATEMENT_CSV} "
    f"({STATEMENT_CSV.stat().st_size:,} bytes)"
)संचालित द्वारा

आउटपुट:

Model: gpt-6-luna
Input: financial_data\northstar_cloud_financial_statements.csv (1,480 bytes)संचालित द्वारा

असर्शन किसी भी OpenAI संसाधन को बनाने से पहले एक त्वरित जाँच देते हैं। यदि API कुंजी गायब है या डेटासेट नहीं मिल रहा, तो वर्कफ़्लो में बाद में फेल होने के बजाय नोटबुक तुरंत रुक जाती है।

OUTPUT_DIR एक लोकल Jupyter डायरेक्टरी है जहाँ हम अंततः सैंडबॉक्स से डाउनलोड की गई फाइलें सहेजेंगे। 

EXPECTED_ARTIFACTS दूसरी ओर, उन फाइलों को परिभाषित करता है जिन्हें हम उम्मीद करते हैं कि एजेंट सैंडबॉक्स के अंदर बनाएगा।

2. वित्तीय डेटा अपलोड करें

सैंडबॉक्स हमारे वित्तीय डेटा के साथ काम कर सके, उससे पहले हमें CSV को OpenAI पर अपलोड करना होगा।

Jupyter Notebook यह चरण संभालता है। यह लोकल फाइल पढ़ता है और OpenAI Files API के जरिए भेजता है।

from openai import OpenAI

client = OpenAI()

with STATEMENT_CSV.open("rb") as handle:
    uploaded_input = client.files.create(
        file=handle,
        purpose="user_data",
    )

print(f"Uploaded raw statements: {uploaded_input.id}")संचालित द्वारा

आउटपुट:

Uploaded raw statements: file-C6Pb6RhZrVPR4Fiq9tZ6Hnसंचालित द्वारा

आपकी फाइल ID अलग होगी।

रिटर्न हुई फाइल ID महत्वपूर्ण है क्योंकि हम इसे सैंडबॉक्स बनाते समय उपयोग करेंगे। CSV की सामग्री को प्रॉम्प्ट में कॉपी करने के बजाय, हम मूल फाइल को सीधे एजेंट के वर्किंग वातावरण से जोड़ सकते हैं।

इस बिंदु पर, Northstar के वित्तीय स्टेटमेंट OpenAI के साथ संग्रहीत हैं, लेकिन एजेंट के पास अभी निष्पादन वातावरण नहीं है।

अब हम वह बनाएँगे।

3. OpenAI-होस्टेड सैंडबॉक्स बनाएँ

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

Containers API का उपयोग करके नया सैंडबॉक्स बनाएँ और अपलोड किए गए CSV को उसकी फाइल ID से संलग्न करें:

container = client.containers.create(
    name="northstar-financial-analysis",
    file_ids=[uploaded_input.id],
    memory_limit="4g",
    network_policy={"type": "disabled"},
)

print(f"OpenAI sandbox: {container.id}")संचालित द्वारा

आउटपुट:

OpenAI sandbox: cntr_6ab7a1080b4081938d8d08ab67ac963c084798905ec997e9संचालित द्वारा

सैंडबॉक्स 4 GB मेमोरी के साथ बनाया गया है, और अपलोड किए गए वित्तीय स्टेटमेंट शुरू से ही उसके अंदर उपलब्ध करा दिए गए हैं।

हम नेटवर्क एक्सेस भी अक्षम करते हैं:

network_policy={"type": "disabled"}संचालित द्वारा

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

4. वित्तीय विश्लेषक का कार्य परिभाषित करें

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

मॉडल को "इस कंपनी का विश्लेषण करें" जैसे अस्पष्ट निर्देश देने के बजाय, हम एक विस्तृत कार्य देते हैं जो गणनाओं, वैलिडेशन चेक्स, जेनरेट की जाने वाली फाइलों, और एजेंट को अपना काम कैसे सत्यापित करना चाहिए—सबका वर्णन करता है।

ANALYST_INSTRUCTIONS = """
You are a skeptical senior buy-side financial analyst preparing an investment-committee memo.

Every analytical operation must occur in the hosted shell container under /mnt/data. Do not
estimate results mentally or ask the caller to calculate anything.

Find the uploaded Northstar statement CSV. Write analyze_financials.py using only the Python
standard library and execute it. Validate required columns, numeric values, unique ordered years,
and total_assets = total_liabilities + equity for every row. Calculate revenue growth, gross/
operating/net margins, current and quick ratios, total-liabilities-to-equity, average-balance ROA
and ROE, interest coverage, free cash flow, FCF margin, cash conversion, receivables growth, and
inventory growth. Leave a ratio blank when its denominator makes it undefined.

Flag absolute year-over-year movements of at least 15%, operating-margin moves of at least two
percentage points, and receivables growth exceeding revenue growth by at least ten points. Create
calculated_metrics.csv, unusual_movements.csv, financial_trends.svg, investment_analysis.md, and
analysis_run.json in /mnt/data. The SVG must contain four readable chart panels without external
packages.

The report must cover Executive view, KPI table, Profitability, Liquidity and leverage, Cash flow
and earnings quality, Unusual movements, Bull case, Bear case, Diligence questions, Data
limitations, and Conclusion. Tie receivables, deferred revenue, stock compensation, capex, and
interest expense to evidence; separate facts from hypotheses and cite filenames and years.

analysis_run.json must contain input_filename, row_count, year_range, validation_results,
generated_filenames, and execution_directory='/mnt/data'. validation_results must include
accounting_equation_passed_every_row=true. Run the script, inspect every artifact, independently
recompute at least three 2025 metrics in a second command, and fix discrepancies. Do not finish
until all six required files exist and are non-empty.
"""संचालित द्वारा

यहाँ एक महत्वपूर्ण डिज़ाइन विकल्प है।

हम मॉडल से केवल अपनी प्रतिक्रिया में वित्तीय विश्लेषण के बारे में तर्क करने के लिए नहीं कह रहे हैं। 

निर्देश उसे स्पष्ट रूप से बताते हैं कि कोड लिखो, उस कोड को चलाओ, परिणामों का निरीक्षण करो, चयनित गणनाओं को सत्यापित करो, और कोई अंतर मिले तो सुधारो।

हम एजेंट को यह भी बताते हैं कि हर विश्लेषणात्मक ऑपरेशन होस्टेड सैंडबॉक्स के अंदर /mnt/data के अंतर्गत होना चाहिए।

यह एजेंट को एक स्पष्ट वर्कफ़्लो देता है:

डेटा ढूँढें → वैलिडेट करें → विश्लेषण स्क्रिप्ट लिखें → चलाएँ → आर्टिफैक्ट्स बनाएँ → परिणामों का निरीक्षण करें → गणनाओं को सत्यापित करें → जरूरत हो तो त्रुटियाँ ठीक करें।

इससे सैंडबॉक्स केवल अस्थायी फाइल स्टोरेज न रहकर एक वास्तविक कार्य वातावरण बन जाता है।

5. एजेंट को सैंडबॉक्स से जोड़ें

अब, हम पहले बनाए गए कंटेनर से एक OpenAI एजेंट को जोड़ते हैं।

हम यह ShellTool के जरिए करते हैं।

from agents import Agent, ModelSettings, Runner, ShellTool

sandbox_shell = ShellTool(
    environment={
        "type": "container_reference",
        "container_id": container.id,
    }
)

analyst = Agent(
    name="Sandbox Financial Analyst",
    model=MODEL,
    instructions=ANALYST_INSTRUCTIONS,
    tools=[sandbox_shell],
    model_settings=ModelSettings(tool_choice="required"),
)संचालित द्वारा

महत्वपूर्ण भाग है:

"type": "container_reference",
"container_id": container.id,संचालित द्वारा

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

हम यह भी सेट करते हैं:

tool_choice="required"संचालित द्वारा

यह एजेंट को रन के दौरान टूल का उपयोग करने के लिए बाध्य करता है, बजाय इसके कि वह केवल एक सामान्य टेक्स्ट प्रतिक्रिया से कार्य पूरा करे।

इस ट्यूटोरियल के लिए, हमें ठीक यही चाहिए। 

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

6. एजेंट को विश्लेषण करने दें

डेटासेट अपलोड, सैंडबॉक्स चालू, और ShellTool के जरिए एजेंट कनेक्ट होने के बाद, हम अब विश्लेषण शुरू कर सकते हैं।

result = await Runner.run(
    analyst,
    "Analyze Northstar entirely inside the sandbox and produce every required artifact.",
    max_turns=30,
)

display(Markdown(result.final_output))संचालित द्वारा

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

एजेंट का अंतिम आउटपुट पुष्टि करता है कि विश्लेषण /mnt/data के अंदर सफलतापूर्वक पूरा हुआ, जिसमें डेटा वैलिडेशन, मेट्रिक जाँच, और सभी छह आवश्यक आर्टिफैक्ट्स का निर्माण शामिल है।

7. जेनरेट किए गए आर्टिफैक्ट्स डाउनलोड करें

विश्लेषण पूरा हो गया है, लेकिन जेनरेट की गई फाइलें अभी भी OpenAI सैंडबॉक्स के अंदर हैं।

अगले चरण में, हम कंटेनर में फाइलों की सूची निकालेंगे, जाँचेंगे कि सभी अपेक्षित आर्टिफैक्ट्स बने हैं, और उन्हें अपनी लोकल डायरेक्टरी में डाउनलोड करेंगे।

remote_files = {
    Path(item.path).name: item
    for item in client.containers.files.list(container.id)
}

missing = [
    name for name in EXPECTED_ARTIFACTS
    if name not in remote_files
]

assert not missing, f"Sandbox did not create: {missing}"

for name in EXPECTED_ARTIFACTS:
    remote = remote_files[name]
    destination = OUTPUT_DIR / name

    client.containers.files.content.retrieve(
        remote.id,
        container_id=container.id,
    ).write_to_file(destination)

    assert destination.stat().st_size > 0, \
        f"Empty artifact: {destination}"

    print(
        f"Downloaded {name}: "
        f"{destination.stat().st_size:,} bytes"
    )संचालित द्वारा

आउटपुट:

Downloaded analyze_financials.py: 22,778 bytes
Downloaded calculated_metrics.csv: 3,740 bytes
Downloaded unusual_movements.csv: 25,405 bytes
Downloaded financial_trends.svg: 13,846 bytes
Downloaded investment_analysis.md: 12,159 bytes
Downloaded analysis_run.json: 1,522 bytesसंचालित द्वारा

इस बिंदु पर, आप लोकल financial_analysis_output डायरेक्टरी खोलकर एजेंट द्वारा बनाए गए सब कुछ जाँच सकते हैं।

फ़ोल्डर में विश्लेषण स्क्रिप्ट, कैल्कुलेटेड मेट्रिक्स, असामान्य-गति फ़्लैग्स, पूरा निवेश मेमो, वैलिडेशन मैनिफेस्ट, और वित्तीय रुझानों का एक SVG विज़ुअलाइज़ेशन शामिल है।

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

आप financial_trends.svg भी खोलकर दृश्य परिणामों का निरीक्षण कर सकते हैं। 

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

एक महत्वपूर्ण बात यह है कि हम केवल वे फाइलें डाउनलोड नहीं करते जो एजेंट ने बना दी हों। 

नोटबुक पहले सैंडबॉक्स की सामग्री की तुलना EXPECTED_ARTIFACTS से करती है।

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

यह एजेंट के आउटपुट को स्वीकार करने से पहले एक सरल सत्यापन चरण देता है।

8. सैंडबॉक्स को साफ करें

एक बार फाइलें डाउनलोड और सत्यापित हो जाएँ, तो हमें अस्थायी सैंडबॉक्स या अपलोड की गई सोर्स फाइल की अब जरूरत नहीं रहती।

दोनों संसाधन हटाएँ:

client.containers.delete(container.id)
client.files.delete(uploaded_input.id)संचालित द्वारा

यह वर्कफ़्लो पूरा होने के बाद होस्टेड कंटेनर और अपलोड किया हुआ वित्तीय डेटासेट हटा देता है।

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

अंतिम विचार

OpenAI-होस्टेड सैंडबॉक्स का सबसे बड़ा लाभ यह है कि पूरा वर्कफ़्लो एक ही ईकोसिस्टम के अंदर रहता है।

आपको अलग सैंडबॉक्स प्रोवाइडर से कनेक्ट होने, अपना क्लाउड वातावरण प्रोविजन करने, या अपनी कंटेनर इन्फ्रास्ट्रक्चर बनाने और बनाए रखने की जरूरत नहीं होती। 

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

इससे वर्कफ़्लो मैनेज करना काफी सरल हो जाता है।

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

OpenAI के ईकोसिस्टम के भीतर इसी तरह के वर्कफ़्लो बनाने के और भी तरीके हैं, जिनमें अधिक डायरेक्ट एजेंट APIs और उच्च-स्तरीय सैंडबॉक्स एब्स्ट्रैक्शंस शामिल हैं। 

हालाँकि, इस उदाहरण में Agents SDK सादगी और नियंत्रण के बीच सही संतुलन लगा।

मुख्य सीख यह है कि अब आप OpenAI ईकोसिस्टम से बाहर गए बिना किसी AI एजेंट को एक वास्तविक निष्पादन वातावरण दे सकते हैं:

सैंडबॉक्स बनाएँ → डेटा संलग्न करें → एजेंट जोड़ें → कार्य चलाएँ → आर्टिफैक्ट्स प्राप्त करें → सैंडबॉक्स हटाएँ।

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