AI सैंडबॉक्स: आइसोलेशन, कोड एक्ज़ीक्यूशन और लागत

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

अपने एजेंट के लिए रनटाइम चुनने से पहले जाँचें कि वह कोड को कैसे आइसोलेट करता है, आपके वर्कलोड को सपोर्ट करता है या नहीं, और चलते समय कितना चार्ज करता है। यह गाइड इन विकल्पों को समझाता है और Lizard SDK के साथ कोड चलाने का एक छोटा फ़्लो दिखाता है।

AI सैंडबॉक्स क्या है?

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

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

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

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

AI सैंडबॉक्स कैसे काम करता है

एक आम रिक्वेस्ट इस रास्ते से गुज़रती है:

1. आपके बैकएंड को एक टास्क मिलता है और वह मॉडल से कोड या टूल कॉल बनाने को कहता है।
2. आपका बैकएंड एक सैंडबॉक्स बनाता है और उसमें वे फ़ाइलें कॉपी करता है जिनकी टास्क को ज़रूरत है।
3. सैंडबॉक्स कोड चलाता है। आपका बैकएंड stdout, stderr, फ़ाइलें और एग्ज़िट कोड इकट्ठा करता है।
4. यूज़र को दिखाने या किसी दूसरी सर्विस को भेजने से पहले आपका बैकएंड नतीजे की जाँच करता है।
5. आपका बैकएंड ज़रूरी आउटपुट सेव करता है और सैंडबॉक्स को रोक देता है।

मॉडल प्रोवाइडर वाली API की और सैंडबॉक्स मैनेजमेंट वाली की, दोनों अपने बैकएंड में ही रखें। अगर जनरेट किए गए कोड को मैनेजमेंट की मिल गई, तो वह आपके अकाउंट से और रिसोर्स माँग सकता है।

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

Docker, gVisor और Firecracker: क्या बदलता है?

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

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

gVisor यूज़रस्पेस कर्नेल की एक और सीमा जोड़ता है, लेकिन कम्पैटिबिलिटी में कुछ समझौते करने पड़ते हैं। Firecracker एक छोटा वर्चुअल मशीन मॉनिटर और सीमित डिवाइस मॉडल इस्तेमाल करता है। इनमें से कोई भी सीक्रेट्स को सुरक्षित रखने या संवेदनशील सर्विसेज़ तक एक्सेस सीमित करने की ज़रूरत खत्म नहीं करता।

Lizard Sandboxes, Firecracker microVM के रूप में चलते हैं और हर एक का अपना कर्नेल होता है। Lizard Sandboxes डॉक्यूमेंटेशन देखें।

आइसोलेशन किससे बचाता है और किससे नहीं

सैंडबॉक्स कोड चलाने के असर को सीमित करता है। फिर भी यह आपके ऐप्लिकेशन को ही तय करना होगा कि यूज़र या एजेंट कौन-सी कार्रवाई कर सकता है।

क्रेडेंशियल और नेटवर्क एक्सेस

आप सैंडबॉक्स में जो कुछ भी कॉपी करते हैं, वह आपकी दी गई परमिशन के तहत वर्कलोड को उपलब्ध हो जाता है। अपनी पूरी .env, SSH डायरेक्टरी या क्लाउड क्रेडेंशियल कॉपी न करें। अगर किसी टास्क को बाहरी API चाहिए, तो उसे कम परमिशन वाला, थोड़ी देर का क्रेडेंशियल दें, या ऑपरेशन को ऐसे बैकएंड टूल से होकर भेजें जो हर रिक्वेस्ट की जाँच करे।

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

यूज़र और स्टोर की गई फ़ाइलें

हर सैंडबॉक्स को किसी ऑथेंटिकेटेड यूज़र या जॉब से जोड़ें। कोड चलाने, फ़ाइल डाउनलोड करने या सेशन दोबारा खोलने की हर रिक्वेस्ट पर ओनरशिप जाँचें। अंदाज़े से सही बैठ गई सैंडबॉक्स ID से एक्सेस नहीं मिलना चाहिए।

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

टाइम लिमिट और लौटाया गया आउटपुट

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

लौटाई गई फ़ाइलों और टेक्स्ट को untrusted इनपुट मानें, यानी बिना जाँचे उन पर भरोसा न करें। JSON को उसी ढाँचे से वैलिडेट करें जिसकी आपका ऐप्लिकेशन उम्मीद करता है। रेंडर करते समय टेक्स्ट को एस्केप करें, और जनरेट किए गए HTML को अपने अकाउंट डैशबोर्ड वाले origin पर सर्व न करें।

जो एजेंट इंटरैक्टिव अप्रूवल छोड़ देते हैं, उनके लिए ये कंट्रोल पहली कमांड चलने से पहले ही ज़रूरी हैं। हमारी Claude Code परमिशन गाइड इस वर्कफ़्लो को कवर करती है।

Lizard Sandboxes में Python टास्क चलाएँ

यह उदाहरण बैकएंड कंट्रोलर के रूप में Node.js और सैंडबॉक्स के अंदर Python इस्तेमाल करता है। यह एक तय गणना चलाता है, ताकि मॉडल जोड़ने से पहले आप कोड चलने का रास्ता जाँच सकें। यह LLM को कॉल नहीं करता।

Node.js 22 या उसके बाद का वर्ज़न, एक Lizard प्रोजेक्ट और एक Lizard API की इस्तेमाल करें। अपने बैकएंड एनवायरनमेंट में LIZARD_API_KEY और LIZARD_PROJECT_ID सेट करें। दोनों को ब्राउज़र कोड से दूर रखें; API की आपके सीक्रेट स्टोर में होनी चाहिए।

JavaScript क्लाइंट इंस्टॉल करें:

npm install @lizard-build/sdk@0.1.69

इसे run-task.mjs नाम से सेव करें:

import { Lizard } from "@lizard-build/sdk";

const project = process.env.LIZARD_PROJECT_ID;
if (!project || !process.env.LIZARD_API_KEY) {
  throw new Error("Set LIZARD_PROJECT_ID and LIZARD_API_KEY");
}

const lizard = new Lizard({ project });
const sandbox = await lizard.create("base", {
  size: "small",
  timeoutMs: 120_000,
});

try {
  const script = [
    "import json",
    "values = [12, 8, 5]",
    "print(json.dumps({'total': sum(values)}))",
  ].join("\n");

  await sandbox.fs.write("/tmp/task.py", script);
  const result = await sandbox.process.exec(
    ["python3", "/tmp/task.py"],
    { user: "user", timeoutMs: 30_000 },
  );

  if (result.exitCode !== 0 || result.truncated) {
    throw new Error("Task failed or returned incomplete output");
  }
  if (Buffer.byteLength(result.stdout, "utf8") > 4096) {
    throw new Error("Task output exceeds the application limit");
  }

  const output = JSON.parse(result.stdout);
  if (
    output === null ||
    typeof output !== "object" ||
    Array.isArray(output) ||
    Object.keys(output).length !== 1 ||
    output.total !== 25
  ) {
    throw new Error("Unexpected task output");
  }

  console.log(output);
} finally {
  await sandbox.kill();
}

इसे अपनी बैकएंड मशीन से चलाएँ:

node run-task.mjs

21 अक्टूबर 2026 को हमने यही स्क्रिप्ट Node.js 26.0.0 और Lizard SDK 0.1.69 के साथ चलाई। इसने base टेम्प्लेट से एक Small Firecracker सैंडबॉक्स बनाया, Python को user के रूप में चलाया, { total: 25 } प्रिंट किया और एग्ज़िट कोड 0 के साथ क्लीनअप पूरा किया।

SDK कंट्रोलर के एनवायरनमेंट से LIZARD_API_KEY पढ़ता है। यह कोड उसे Python चलाने वाले सैंडबॉक्स में पास नहीं करता।

आर्गुमेंट ऐरे Python को शेल इंटरपोलेशन के बिना चलाता है। फिर भी Python वे सारे ऑपरेशन कर सकता है जिनकी सैंडबॉक्स अनुमति देता है। 30 सेकंड का कमांड टाइमआउट तय करता है कि क्लाइंट कितनी देर इंतज़ार करेगा; दो मिनट की सैंडबॉक्स लाइफ़टाइम एक अलग एक्सपायरी सेट करती है। आउटपुट वैलिडेशन फ़ेल होने पर भी finally ब्लॉक क्लीनअप की रिक्वेस्ट भेजता है। Lizard SDK रेफ़रेंस देखें।

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

AI सैंडबॉक्स से आप क्या बना सकते हैं?

डेटा एनालिसिस: यूज़र का अपलोड प्रोसेस करें, Python चलाएँ और एक चार्ट या छोटा JSON रिज़ल्ट लौटाएँ। फ़ाइल साइज़ और एक्ज़ीक्यूशन टाइम पर लिमिट लगाएँ, फिर सिर्फ़ वही आउटपुट रखें जिसकी यूज़र को ज़रूरत है।

कोडिंग एजेंट्स: रिपॉज़िटरी की टास्क के हिसाब से अलग कॉपी चेक आउट करें, फ़ाइलें एडिट करें और टेस्ट चलाएँ। कोई अलग वर्कफ़्लो बदलावों को मर्ज या डिप्लॉय करे, उससे पहले डिफ़ और टेस्ट रिज़ल्ट का रिव्यू करें।

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

ब्राउज़र एजेंट्स: जब टास्क में UI इंटरैक्शन चाहिए, तो ब्राउज़र और डेस्कटॉप वाला रनटाइम इस्तेमाल करें। किसी भी लॉग-इन सेशन को उस अकाउंट के एक्सेस वाला क्रेडेंशियल मानें।

Lizard Sandboxes शेल कमांड, फ़ाइल एक्सेस और प्राइवेट HTTPS प्रीव्यू देते हैं। ब्राउज़र और डेस्कटॉप वाले काम के लिए desktop टेम्प्लेट इस्तेमाल होता है। डेवलपमेंट प्रीव्यू और डिप्लॉय किए गए ऐप्लिकेशन की लाइफ़टाइम अलग होती है; चुनें कि आपके यूज़र को कौन-सा चाहिए। Lizard Sandboxes देखें।

AI सैंडबॉक्स की लागत कितनी है?

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

17 अक्टूबर 2026 तक Lizard की सूचीबद्ध कंप्यूट दरें ये हैं:

सैंडबॉक्स चलने के दौरान Lizard कंप्यूट को प्रति सेकंड मीटर करता है, आइडल टाइम समेत। Lizard Pro की कीमत $19 प्रति माह है और इसमें $19 का उपयोग शामिल है; इससे ज़्यादा उपयोग pay as you go है। Persistent Volumes की कीमत $0.14 प्रति GB प्रति माह है। बजट बनाने से पहले मौजूदा कीमतें जाँचें।

1,000 Small जॉब्स के लिए, जिनमें से हर एक सैंडबॉक्स को पाँच मिनट चलाए रखता है:

1,000 × (5 / 60 hours) × $0.0162 = $1.35 in compute usage

यह वर्कलोड का कंप्यूट हिस्सा है। आपके कुल बिल में फिर भी Pro सब्सक्रिप्शन और उसमें शामिल उपयोग से ऊपर का कोई भी उपयोग जुड़ेगा। मॉडल टोकन की लागत अलग है।

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

AI सैंडबॉक्स कैसे चुनें

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

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

रनटाइम अपनाने से पहले इन सवालों के जवाब दें:

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

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