Claude Sonnet 5 के साथ Claude Managed Agents कैसे बनाएँ

क्या आपने कभी Python स्क्रिप्ट से Claude Code–स्टाइल वर्कफ़्लो चलाना चाहा है, जहाँ मॉडल एक मैनेज्ड वातावरण में टूल्स, फ़ाइलों, स्किल्स, और निर्देशों तक पहुँच के साथ काम कर सके?

Claude Managed Agents इसी तरह के वर्कफ़्लो के लिए बनाए गए हैं, जो आपको ऐसे एजेंट बनाने में मदद करते हैं जो नियंत्रित वातावरण में बहु-चरणीय कार्य कर सकें।

इस ट्यूटोरियल में, मैं आपको Claude Sonnet 5 उपयोग करना सिखाऊँगा, जो Anthropic का एक हालिया मॉडल है, उन्नत तर्क, कोडिंग, और डेटा विश्लेषण कार्यों के लिए डिज़ाइन किया गया है। यह एजेंट को डेटा निरीक्षण, टूल उपयोग, कोड लिखने व चलाने, और संरचित आउटपुट बनाने में सक्षम बनाता है।

आप एक Managed Agent बनाएँगे, उसका वातावरण कॉन्फ़िगर करेंगे, एक CSV फ़ाइल अपलोड करेंगे, और एजेंट को टूल्स व एक XLSX स्किल तक पहुँच देंगे। 

एजेंट डेटा का विश्लेषण करेगा, Python, JSON, और Excel फ़ाइलें बनाएगा, परिणामों की पुष्टि करेगा, और पूर्ण आउटपुट को डाउनलोड के लिए उपलब्ध कराएगा।

यदि आप Claude में बिल्कुल नए हैं, तो पहले Claude Code 101 कोर्स देखने की सलाह देता हूँ।

Claude Managed Agents क्या हैं?

Claude Managed Agents, Anthropic का मैनेज्ड फ़्रेमवर्क है, जो Claude को एक स्वायत्त एजेंट के रूप में चलाने के लिए बनाया गया है। 

अपना खुद का लूप लिखकर प्रॉम्प्ट भेजने, टूल कॉल चलाने, परिणाम सहेजने, और रनटाइम मैनेज करने के बजाय, आप एजेंट परिभाषित करते हैं और Anthropic उस इन्फ्रास्ट्रक्चर को संभालता है। 

यह लंबे, बहु-चरणीय कार्यों के लिए बनाया गया है, जहाँ मॉडल को काम पूरा करने से पहले कई टूल्स का उपयोग करना पड़ सकता है।

Managed Agents चार प्रमुख हिस्सों के इर्द-गिर्द बने होते हैं:

• Agent: पुन: उपयोग योग्य कॉन्फ़िगरेशन जिसमें मॉडल, सिस्टम प्रॉम्प्ट, टूल्स, MCP सर्वर, और स्किल्स शामिल हैं।
• Environment: जहाँ एजेंट चलता है—या तो Anthropic के क्लाउड सैंडबॉक्स में या आपके स्वयं-होस्टेड सैंडबॉक्स में।
• Session: एजेंट का चल रहा इंस्टेंस जो कोई विशिष्ट कार्य करता है।
• Events: संदेश, टूल कॉल, परिणाम, और स्टेटस अपडेट जो सेशन के दौरान विनिमय होते हैं।

1. अपने Claude Agent वर्कस्पेस के लिए पूर्वापेक्षाएँ

इस ट्यूटोरियल का पालन करने के लिए अपने कंप्यूटर पर Python 3.12 या बाद का संस्करण और Jupyter Notebook इंस्टॉल करें। हम चरण-दर-चरण Managed Agent बनाने, चलाने और निरीक्षण करने के लिए Jupyter Notebook का उपयोग करेंगे।

आपको एक Anthropic Console अकाउंट भी चाहिए होगा। 

कंसोल में एक नया API की बनाएँ, कम से कम $5 के API क्रेडिट जोड़ें, और की को सुरक्षित रूप से सहेजें। 

Managed Agents एक ही सेशन में कई मॉडल और टूल कॉल कर सकते हैं, इसलिए उनकी लागत एक मानक API रिक्वेस्ट से अधिक हो सकती है।

की को ANTHROPIC_API_KEY एनवायरनमेंट वेरिएबल के रूप में स्टोर करें, इसे सीधे नोटबुक में जोड़ने या GitHub में कमिट करने के बजाय।

macOS, Linux, या WSL के लिए, अपने टर्मिनल में यह चलाएँ:

export ANTHROPIC_API_KEY="your-api-key-here"

Windows PowerShell के लिए, यह उपयोग करें:

$env:ANTHROPIC_API_KEY="your-api-key-here"

2. Anthropic Python SDK सेट अप करें

Managed Agent बनाने से पहले, आधिकारिक Anthropic Python SDK इंस्टॉल करें और इस नोटबुक के लिए आवश्यक मॉड्यूल इम्पोर्ट करें। 

SDK में Anthropic क्लाइंट उपलब्ध है, जिसका उपयोग आप एजेंट, वातावरण, फ़ाइलें, और सेशन बनाने के लिए करेंगे। 

%pip install -q --upgrade anthropic

अगला कदम, अपने Anthropic API की को एनवायरनमेंट वेरिएबल से लोड करें। 

की को नोटबुक से बाहर रखना, उसे सीधे कोड में रखने की तुलना में सुरक्षित है—खासकर यदि आप प्रोजेक्ट साझा करने या GitHub पर पुश करने की योजना बना रहे हैं।

import os
from anthropic import Anthropic

api_key = os.environ.get("ANTHROPIC_API_KEY")
assert api_key, "Set ANTHROPIC_API_KEY in your environment or in a local .env file."

Managed Agents फिलहाल Anthropic के बीटा API के माध्यम से एक्सेस होते हैं। managed-agents-2026-04-01 बीटा फ़्लैग इस फ़ीचर को सक्षम करता है, हालाँकि आधिकारिक SDK Managed Agents रिक्वेस्ट के लिए आवश्यक बीटा हैडर स्वत: भेजता है। 

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

BETA_FLAG = "managed-agents-2026-04-01"

client = Anthropic(api_key=api_key)

अंत में, एक डिक्शनरी बनाएँ जिसमें ट्यूटोरियल के दौरान बनाए गए हर संसाधन के ID स्टोर हों। 

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

created = {"agent": None, "environment": None, "file": None, "session": None}
print("✓ Anthropic client initialized.")

क्लाइंट अब तैयार है। 

3. Managed Agent बनाएँ

Managed Agent आपके वर्कफ़्लो के लिए पुन: उपयोग योग्य कॉन्फ़िगरेशन है। 

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

इसके बाद, आप हर बार कॉन्फ़िगरेशन दोबारा बनाने के बजाय उसी एजेंट को कई सेशनों में पुन: उपयोग कर सकते हैं। 

हम अपने एजेंट का नाम Sonnet 5 Data Analyst रखेंगे और claude-sonnet-5 का उपयोग करेंगे। 

सिस्टम प्रॉम्प्ट इसे एक सावधानीपूर्वक डेटा विश्लेषक की तरह व्यवहार करने को कहता है: /workspace में माउंट की गई फ़ाइलें पढ़ें, विश्लेषण के लिए कोड निष्पादन का उपयोग करें, अपने परिणाम संक्षिप्त रखें, और अंतिम फ़ाइलें /mnt/session/outputs में सहेजें।

agent = client.beta.agents.create(
    name="Sonnet 5 Data Analyst",
    model="claude-sonnet-5",
    system=(
        "You are a meticulous data analyst. When asked about data, always read the "
        "file mounted at /workspace, analyse it with the code execution tool, and "
        "report concise, numeric results. Use the XLSX skill for spreadsheet work. "
        "Save final artifacts to /mnt/session/outputs."
    ),
    tools=[
        {"type": "agent_toolset_20260401"},
    ],
    skills=[{"type": "anthropic", "skill_id": "xlsx"}],
)

agent_toolset_20260401 एजेंट को सेशन में Anthropic के बिल्ट-इन टूल्स तक पहुँच देता है, जबकि xlsx स्किल Excel वर्कबुक बनाने और विश्लेषण के लिए कार्य-विशिष्ट मार्गदर्शन प्रदान करती है। 

Anthropic PowerPoint, Word, और PDF वर्कफ़्लोज़ के लिए भी प्री-बिल्ट स्किल्स देता है।

अंत में, एजेंट ID सहेजें। 

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

created["agent"] = agent.id
print(f"✓ Created agent: {agent.id}")

आपको इस तरह का आउटपुट दिखना चाहिए:

✓ Created agent: agent_01EVcgvQsAkLxNnJFp6aynwm

4. Anthropic क्लाउड सैंडबॉक्स कॉन्फ़िगर करें

अब, हम वह वातावरण बनाएँगे जहाँ Managed Agent सेशन के दौरान चलता है। 

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

हम सीमित नेटवर्किंग के साथ Anthropic का क्लाउड वातावरण उपयोग करेंगे। एजेंट बाद में इसी सैंडबॉक्स का उपयोग अपलोड की गई CSV फ़ाइल का Python से विश्लेषण करने के लिए करेगा।

environment = client.beta.environments.create(
    name="code-exec-sandbox",
    config={"type": "cloud", "networking": {"type": "limited"}},
)

created["environment"] = environment.id
print(f"✓ Created environment: {environment.id}")

सेल चलाने के बाद, आपको इस तरह का एक environment ID दिखना चाहिए:

✓ Created environment: env_01FzWACEf9UJDL65ovBPA1zf

5. Anthropic Files API के साथ डेटा अपलोड करें

अब, हम वह डेटासेट अपलोड करेंगे जिसका एजेंट विश्लेषण करेगा। 

Managed Agents, स्थानीय फ़ाइलें अपलोड करने के लिए Anthropic की Files API का उपयोग करते हैं, जिन्हें बाद में सेशन वातावरण के अंदर माउंट किया जा सकता है।

इस गाइड के लिए, हम sales_data.csv नामक 12-पंक्ति वाले उदाहरण डेटासेट का उपयोग कर रहे हैं। 

इसे अपलोड करने से पहले, हम जाँचते हैं कि फ़ाइल मौजूद है और यह पुष्टि करते हैं कि इसमें अपेक्षित संख्या में डेटा पंक्तियाँ हैं।

from pathlib import Path

csv_path = Path("sales_data.csv")
assert csv_path.exists(), f"Missing input file: {csv_path.resolve()}"

row_count = sum(1 for _ in csv_path.open(encoding="utf-8")) - 1
assert row_count == 12, f"Expected 12 data rows, found {row_count}"

इसके बाद हम फ़ाइल अपलोड करते हैं और बाद में क्लीनअप के लिए उसकी ID स्टोर कर लेते हैं।

uploaded = client.beta.files.upload(file=csv_path)

created["file"] = uploaded.id
print(f"✓ Uploaded {csv_path}: {uploaded.id} ({row_count} rows)")

सेल चलाने के बाद, आपको इस तरह का आउटपुट दिखना चाहिए:

✓ Uploaded sales_data.csv: file_011Cch3EubJkswPdo3gMBvM2 (12 rows)

6. Agent Execution Session प्रारंभ करें

अब, हम एक सेशन बनाएँगे। 

एक सेशन एजेंट, वातावरण, और किसी विशिष्ट कार्य के लिए आवश्यक संसाधनों को जोड़ता है। यहाँ, हम अपलोड की गई CSV फ़ाइल को /workspace/sales_data.csv पर माउंट करते हैं, ताकि एजेंट सैंडबॉक्स के अंदर से इसे एक्सेस कर सके।

session = client.beta.sessions.create(
    agent=agent.id,
    environment_id=environment.id,
    resources=[
        {
            "type": "file",
            "file_id": uploaded.id,
            "mount_path": "/workspace/sales_data.csv",
        },
    ],
)

created["session"] = session.id
print(f"✓ Created session: {session.id}")

आपको इस तरह का एक सेशन ID दिखना चाहिए:

✓ Created session: sesn_015mNhrKhqqfe7u8VP6GuFdr

7. एजेंट की प्रतिक्रिया स्ट्रीम करें

अब, हम कार्य को सेशन में भेजेंगे और एजेंट की गतिविधि को उसके काम करते समय स्ट्रीम करेंगे। 

सेशन बनाना केवल एजेंट और सैंडबॉक्स तैयार करता है; एजेंट तब काम शुरू करता है जब उसे user.message इवेंट प्राप्त होता है। 

इवेंट स्ट्रीम हमें रीयल-टाइम में एजेंट के संदेश, टूल कॉल, और अंतिम सेशन स्टेटस देखने देती है। 

प्रॉम्प्ट एजेंट को माउंट की गई CSV फ़ाइल का विश्लेषण करने, एक Python स्क्रिप्ट लिखने व चलाने, JSON सारांश बनाने, और एक Excel रिपोर्ट तैयार करने को कहता है। 

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

agent_text_parts = []
tools_used = []
final_status = None

with client.beta.sessions.events.stream(session.id) as stream:
    # Send the user message once the stream is open.
    client.beta.sessions.events.send(
        session.id,
        events=[
            {
                "type": "user.message",
                "content": [
                    {
                        "type": "text",
                        "text": (
                            "Use the XLSX skill and analyze /workspace/sales_data.csv. "
                            "Write /mnt/session/outputs/analyze_sales.py, run that Python "
                            "script, and have it create /mnt/session/outputs/summary.json. "
                            "Also create /mnt/session/outputs/sales_report.xlsx with the "
                            "source data, monthly profit, and a summary sheet."
                        ),
                    }
                ],
            }
        ],
    )

    for event in stream:
        etype = getattr(event, "type", None)

        if etype == "agent.message":
            for block in event.content:
                txt = getattr(block, "text", None)
                if txt:
                    print(txt, end="")
                    agent_text_parts.append(txt)

        elif etype == "agent.tool_use":
            name = getattr(event, "name", "<tool>")
            print(f"\n[tool_use] {name}")
            tools_used.append(name)

        elif etype == "session.status_idle":
            final_status = "idle"
            print("\n\n✓ Agent finished; session is idle.")
            break

        elif etype == "session.status_error":
            final_status = "error"
            print("\n✗ Session reported an error.")
            break

print("Tools used:", tools_used)

रन के दौरान, आपको read, bash, write, और edit जैसे टूल इवेंट दिखाई देने चाहिए। 

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

जब एजेंट के पास करने के लिए और काम नहीं रहता, तो सेशन idle हो जाता है। इस उदाहरण में, session.status_idle इंगित करता है कि कार्य पूरा हो गया है, इसलिए हम स्ट्रीम सुनना बंद कर देते हैं। 

Anthropic अपने बिल्ट-इन टूल्स का सैंडबॉक्स के अंदर निष्पादन मैनेज करता है; आपको केवल कस्टम टूल्स का उपयोग करते समय टूल परिणामों को स्वयं संभालना पड़ता है। 

8. जेनरेटेड फ़ाइलें और इवेंट हिस्ट्री प्राप्त करें

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

इवेंट हिस्ट्री सेशन का पूरा रिकॉर्ड देती है, जिसमें मॉडल रिक्वेस्ट, टूल कॉल, टूल परिणाम, और स्टेटस परिवर्तन शामिल होते हैं।

history = client.beta.sessions.events.list(session.id, order="asc")

print("--- Session event history ---")
for event in history.data:
    print(event.type)

print(f"({len(history.data)} events total)")

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

import os

os.makedirs("outputs", exist_ok=True)

files = client.beta.files.list(scope_id=session.id, betas=[BETA_FLAG])
downloadable = [f for f in files.data if f.downloadable]

print(f"Found {len(downloadable)} downloadable file(s) for this session.")

downloaded_paths = []

for f in downloadable:
    try:
        content = client.beta.files.download(f.id, betas=[BETA_FLAG])
        local_path = os.path.join("outputs", f.filename)

        content.write_to_file(local_path)
        downloaded_paths.append(local_path)

        print(f"  downloaded {f.id} -> {local_path}")
    except Exception as exc:
        print(f"  skip {f.id}: {exc}")

अंत में, हम जाँचते हैं कि सभी अपेक्षित आउटपुट सफलतापूर्वक डाउनलोड हुए:

expected_outputs = {"analyze_sales.py", "summary.json", "sales_report.xlsx"}
downloaded_names = {os.path.basename(path) for path in downloaded_paths}

assert expected_outputs <= downloaded_names, (
    f"Missing expected outputs: {sorted(expected_outputs - downloaded_names)}"
)

अब जनरेट किया गया Python स्क्रिप्ट, JSON सारांश, और Excel रिपोर्ट स्थानीय outputs फ़ोल्डर में उपलब्ध हैं।

9. Python, JSON, और Excel आउटपुट का विश्लेषण करें

एजेंट द्वारा कार्य पूरा करने के बाद, जनरेट की गई फ़ाइलें स्थानीय outputs/ डायरेक्टरी में डाउनलोड हो जाती हैं। 

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

नीचे दिए गए स्क्रीनशॉट इन तीनों जेनरेटेड आर्टिफैक्ट्स को दिखाते हैं।

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

यह फ़ाइल परिणामों को एक संरचित फ़ॉर्मैट में स्टोर करती है, जिसका उपयोग डैशबोर्ड, API, या अन्य प्रोग्राम कर सकते हैं।

यह Excel फ़ाइल मासिक गणनाओं को दृश्य रूप में प्रस्तुत करती है—राजस्व, लागत, मुनाफ़ा, मार्जिन, कुल, और चार्ट के साथ।

sales_data.csv की 12 पंक्तियों के लिए, सत्यापित परिणाम इस प्रकार हैं:

• कुल राजस्व: $32,900
• कुल लागत: $14,750
• कुल मुनाफ़ा: $18,150
• औसत मासिक मुनाफ़ा: $1,512.50
• सबसे अच्छा महीना: दिसंबर ($2,550 मुनाफ़ा)
• सबसे खराब महीना: जनवरी ($400 मुनाफ़ा)

वर्कबुक हार्डकोडेड मानों पर निर्भर होने के बजाय फ़ॉर्मूलों द्वारा संचालित है। 

रन के दौरान, एजेंट ने संलग्न XLSX स्किल निर्देश पढ़े, वर्कबुक बनाई, उसे LibreOffice से पुनर्गणना किया, फ़ॉर्मूलों की जाँच की, और कार्य पूरा करने से पहले एक सर्कुलर-रेफरेंस समस्या को ठीक किया।

10. Managed Agent API संसाधनों की सफाई करें

Managed Agent संसाधन तब तक उपलब्ध रहते हैं जब तक आप उन्हें हटाते नहीं, इसलिए कार्य पूरा होने पर उन्हें साफ़ करना महत्वपूर्ण है। 

सक्रिय संसाधन—विशेषकर चल रहे सेशन और वातावरण—यदि चलती स्थिति में छोड़ दिए जाएँ तो लागत जारी रख सकते हैं।

किसी सेशन को डिलीट करने से पहले उसका idle होना ज़रूरी है। 

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

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

def safe(label, fn):
    try:
        fn()
        print(f"✓ deleted {label}")
    except Exception as exc:
        print(f"· could not delete {label}: {exc}")

if created["session"]:
    safe("session", lambda: client.beta.sessions.delete(created["session"]))

if created["file"]:
    safe("file", lambda: client.beta.files.delete(created["file"]))

if created["environment"]:
    safe("environment", lambda: client.beta.environments.delete(created["environment"]))

if created["agent"]:
    safe("agent (archived)", lambda: client.beta.agents.archive(created["agent"]))

print("\n🎉 Cleanup complete. The agent is archived; other resources were deleted.")

आपको इस तरह का आउटपुट दिखना चाहिए:

✓ deleted session
✓ deleted file
✓ deleted environment
✓ deleted agent (archived)

🎉 Cleanup complete. The agent is archived; other resources were deleted.

पूरा प्रोजेक्ट, जिसमें नोटबुक, सैंपल CSV फ़ाइल, और सेटअप निर्देश शामिल हैं, GitHub पर उपलब्ध है। 

आप रिपोज़िटरी को क्लोन कर सकते हैं और इस गाइड के परिणामों को दोबारा बनाने के लिए नोटबुक को पुन: चलाया जा सकता है।

अंतिम विचार

मुझे Claude Managed Agents सेट अप करने और उनके साथ काम करने में आसानी लगी। 

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

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

मैंने पहले Modal Sandbox इस्तेमाल करने की कोशिश की क्योंकि मैं एक अधिक लचीला बाहरी वातावरण चाहता था। 

हालाँकि, सेटअप इस गाइड के दायरे के लिए बहुत जटिल हो गया, इसलिए मैंने इस प्रोजेक्ट को Anthropic के मैनेज्ड क्लाउड सैंडबॉक्स पर केंद्रित रखने का निर्णय लिया।

मेरे लिए मुख्य नकारात्मक पक्ष लागत थी। मैंने इस उदाहरण को केवल 12 पंक्तियों वाली एक छोटी CSV फ़ाइल के साथ दो बार चलाया, और इसकी लागत लगभग $0.25 आई। 

डैशबोर्ड ने शुल्क को मॉडल के अंतर्गत दिखाया, लेकिन मुझे विस्तृत ब्रेकडाउन नहीं मिला। एक साधारण गणना और स्प्रेडशीट कार्य के लिए, यह कम-लागत वाले ओपन-सोर्स विकल्पों की तुलना में महंगा लगता है।

समग्र रूप से, यह प्रोजेक्ट पूरे Managed Agent वर्कफ़्लो को दिखाता है: एजेंट बनाना, CSV फ़ाइल अपलोड करना, मैनेज्ड सैंडबॉक्स के अंदर Python चलाना, JSON और Excel रिपोर्ट बनाना, आउटपुट की पुष्टि करना, फ़ाइलें डाउनलोड करना, और बाद में संसाधनों की सफ़ाई करना।