# Lagune vs. Deepsec: AI-संचालित सुरक्षा के दो तरीक़े, आमने-सामने

> Lagune और Vercel के Deepsec की तुलना करने वाला संदर्भ पेज: दोनों कैसे काम करते हैं, उनका जीवनचक्र, पहचान, लागत, निष्कर्ष और उन्हें बंद करना।

कैनोनिकल: https://lagune.ai/hi-IN/docs/references/deepsec
भाषा: hi-IN
मूल: https://lagune.ai/docs/references/deepsec
आख़िरी अपडेट: 2026-11-06

[Lagune](https://github.com/wellwelwel/lagune) और [Deepsec](https://github.com/vercel-labs/deepsec) (`v2.2.1`) एक ही समस्या के दो रक्षात्मक जवाब हैं: AI की मदद से डेवलपमेंट के दौर में सुरक्षा। दोनों का आधार, उनकी शुरुआत, बीच का हिस्सा और अंत, और उपयोगकर्ता के सामने वे ख़ुद को कैसे पेश करते हैं, ये सब सोच-समझकर अलग रखे गए हैं, भले ही उनका तंत्र कहीं-कहीं एक जैसा हो।

**टिप**

क्या Lagune, Deepsec से प्रेरित है? नहीं, Lagune पूरी तरह नए सिरे से लिखा गया है और Spec-Driven Development और Security Hardening से प्रेरित है। दोनों प्रोजेक्ट एक-दूसरे से स्वतंत्र रूप से बनाए गए हैं, और यह तुलना उपयोगकर्ताओं को उनके अंतर समझाने के लिए है।

## एक नज़र में

| पहलू               | Lagune                                                                                                     | Deepsec                                                                           |
| ------------------ | ---------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
| प्रकार             | एक पद्धति (SDH), रेफ़रेंस इम्प्लीमेंटेशन के साथ                                                            | एक प्रोडक्ट: एजेंट से चलने वाला कमज़ोरी स्कैनर                                    |
| मूल आधार           | सुरक्षा सिद्धांत और ज़रूरत पड़ने पर ही लोड होने वाला ज्ञान एजेंट को दिशा देते हैं, नियतात्मक हुक के सहारे  | regex का चौड़ा जाल एक अनिवार्य AI जाँच तक पहुँचाता है                             |
| यह क्या देता है    | सुरक्षा मज़बूत किया गया कोड, प्रमाण, और निष्कर्षों की ट्रैक की गई चेन                                      | गंभीरता के क्रम में लगी, ट्राइएज की गई निष्कर्षों की रिपोर्ट                      |
| आपके कोड में बदलाव | हाँ: `harden` चरण आपका कोड बदलता है                                                                        | नहीं: सिर्फ़ स्टैटिक एनालिसिस, निष्कर्ष और सुझाव का टेक्स्ट देता है               |
| रनटाइम             | आपके पहले से चल रहे एजेंट और मॉडल पर चलता है, किसी भी टियर का                                              | अपनी मॉडल पाइपलाइन चलाता है, डिफ़ॉल्ट रूप से फ़्रंटियर टियर                       |
| शुरुआत             | एक प्लगइन इंस्टॉल या `npx skills add`, फिर आसान भाषा में निर्देश दें, कोई नया टूल खड़ा करने की ज़रूरत नहीं | `.deepsec/` वर्कस्पेस खड़ा करें, डिपेंडेंसी इंस्टॉल करें, और मॉडल की कुंजी जोड़ें |

## यह कैसे काम करता है

Lagune एजेंट-फ़र्स्ट है: एजेंट काम चलाता है, कोड जैसा है उसके हिसाब से ज़रूरत पड़ने पर ही ज्ञान लाता है, और तय किया जा सकने वाला हिस्सा नियतात्मक हुक को सौंप देता है।

Deepsec नियतात्मकता-फ़र्स्ट है: एक चौड़ा स्कैन ऐसे उम्मीदवार पकड़ता है जो एक अनिवार्य मॉडल को बताते हैं कि किसकी जाँच करनी है और किस पर फ़ैसला देना है।

| पहलू                       | Lagune                                                                                                                 | Deepsec                                                              |
| -------------------------- | ---------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- |
| क्रम                       | सुरक्षा सिद्धांत और मेल खाता ज्ञान एजेंट को दिशा देते हैं, जो कुछ काम हुक को सौंपता है और बाक़ी पर ख़ुद फ़ैसला करता है | मैचर उम्मीदवार पकड़ते हैं, और मॉडल हर एक की जाँच करके फ़ैसला देता है |
| नियतात्मक हिस्से की भूमिका | कई भाषाओं वाले हुक जो फ़ैसला लौटाते हैं या एजेंट को सही जगह दिखाते हैं, श्रेणी के ज्ञान के साथ मिलकर                   | मैचर जो अनिवार्य मॉडल के फ़ैसले के लिए उम्मीदवार पकड़ते हैं          |
| डेवलपमेंट फ़्लो            | आपके कोड लिखते समय `/lagune` कमांड उसी जगह सुरक्षित ढंग से बनाती है                                                    | यह कोड रिव्यू करता है, लिखता नहीं                                    |
| ऑडिट फ़्लो                 | `charter` → `detect` → `plan` → `harden` → `verify`                                                                    | `scan` → `process` → `triage` → `revalidate` → `report`              |
| AI का काम                  | ज्ञान के आधार पर तर्क करना, सुधार लागू करना, और साबित करना कि वह कारगर है                                              | हर उम्मीदवार की जाँच करना और निष्कर्षों की रिपोर्ट देना              |

## जीवनचक्र

Lagune कोड लिखे जाने से पहले, उसके दौरान और उसके बाद काम करता है। Deepsec कोड मौजूद होने के बाद किसी रिपॉज़िटरी को रिव्यू करता है।

| मौक़ा            | Lagune                                                                                      | Deepsec                                                           |
| ---------------- | ------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- |
| कोड बनने से पहले | `charter` चरण बताए गए इरादे से सुरक्षा नीति तैयार करता है                                   | मौजूदा कोड से शुरू होता है: `init` कमांड को एक डायरेक्टरी चाहिए   |
| बनाते समय        | `/lagune` कमांड उसी जगह डिफ़ॉल्ट रूप से सुरक्षित बनाती है, पीछे कोई आर्टिफ़ैक्ट नहीं छोड़ती | बनने के बाद रिव्यू करता है, बनते समय नहीं                         |
| मौजूदा कोड पर    | `detect` → `plan` → `harden` → `verify`                                                     | `scan` → `process`, मुख्य फ़्लो                                   |
| लगातार रिव्यू    | हर दायरे के लिए चरण दोबारा चलाएँ, कोई तैयार CI गेट नहीं                                     | इंक्रीमेंटल री-स्कैन, CI में exit गेट के रूप में `process --diff` |

## पहचान की परत

दोनों की नियतात्मक परतें स्वभाव से उलटी हैं: एक फ़ैसला करती है, दूसरी बस पकड़ती है।

| पहलू            | Lagune                                                                | Deepsec                                                                     |
| --------------- | --------------------------------------------------------------------- | --------------------------------------------------------------------------- |
| समूह            | हुक और विशेषज्ञताएँ, श्रेणियों में बँटी                               | हर पैटर्न या फ़्रेमवर्क के लिए मैचर                                         |
| आउटपुट          | सीधा फ़ैसला (finding / review / advisory) और साथ में एक classify लेबल | बिना फ़ैसले वाला उम्मीदवार (slug, लाइनें, कोड का टुकड़ा, मेल खाया पैटर्न)   |
| ट्यूनिंग        | सटीकता: टिप्पणियों को समझने वाला, प्लेसहोल्डर और विंडो गार्ड के साथ   | रिकॉल: चौड़े जाल, फ़ॉल्स पॉज़िटिव बाद में AI छाँटता है                      |
| गहराई           | साझा वर्गों में ज़्यादा गहरा                                          | ज़्यादा व्यापक, साझा वर्गों में कम गहरा                                     |
| फ़ॉल्स पॉज़िटिव | स्रोत पर ही कम रखे जाते हैं, फिर संदर्भ में परखे जाते हैं             | जान-बूझकर ज़्यादा पैदा किए जाते हैं, फिर `revalidate` पास में घटाए जाते हैं |

## ज्ञान और फ़ैसला

दोनों में सुरक्षा का वह ज्ञान है जो regex में नहीं समा सकता। फ़र्क़ इसमें है कि वह ज्ञान कहाँ रहता है और उसे कौन ढाल सकता है।

| पहलू                | Lagune                                                                            | Deepsec                                                                          |
| ------------------- | --------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
| रूप                 | बदले जा सकने वाले Markdown मॉड्यूल, जिनमें से कई के पीछे एक नियतात्मक हुक है      | एक छोटा प्रॉम्प्ट और हर टेक के लिए ख़ास बिंदु, जो मॉडल के अपने ज्ञान पर टिके हैं |
| चुनाव               | कोड से मिलान होता है, और सिर्फ़ तब लोड होता है जब उसका संदर्भ मौजूद हो            | हर AI बैच में डाला जाता है, साथ में पहचानी गई टेक के ख़ास बिंदु                  |
| इसे कौन लिखता है    | उपयोगकर्ता मॉड्यूल बदलता है और `specialize` कमांड से नए जोड़ता है                 | प्रॉम्प्ट मेंटेनर के हाथ में है, उपयोगकर्ता एक `INFO.md` फ़ाइल भरता है           |
| फ़ैसला कहाँ होता है | हुक अपनी न्यूनतम सीमा तय करते हैं, बाक़ी पर एजेंट ज्ञान के आधार पर फ़ैसला करता है | केंद्रीकृत: एक AI प्रोसेसर हर उम्मीदवार पर फ़ैसला देता है                        |
| दोबारा इस्तेमाल     | एक मॉड्यूल `detect` और `verify`, दोनों चरणों को राह दिखाता है                     | एक प्रॉम्प्ट इकलौते `process` चरण को चलाता है                                    |

## निष्कर्ष और उन्हें बंद करना

सबसे बड़ा फ़र्क़ इसमें है कि सुलझ जाने के बाद किसी निष्कर्ष का क्या होता है।

| पहलू              | Lagune                                                                                      | Deepsec                                                                                            |
| ----------------- | ------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| गंभीरता           | CVSS v4.0 स्कोर, एक्सपोज़र और दाँव के हिसाब से समायोजित                                     | AI की दी हुई गंभीरता, साथ में एक्सप्लॉइट हो पाने की संभावना और असर के आधार पर P0 / P1 / P2 ट्राइएज |
| फ़ैसले            | Risk closed, Risk not closed, या Cannot tell from the code                                  | true-positive, false-positive, fixed, uncertain, accepted-risk, duplicate                          |
| सहेजना            | कामकाजी चेन मौजूदा स्थिति से मिलाकर अपडेट होती है, बंद निष्कर्षों का सार इतिहास में जाता है | हर फ़ाइल के लिए सिर्फ़ जुड़ते जाने वाले रिकॉर्ड, कुछ भी हटाया नहीं जाता                            |
| अंतिम स्थिति      | बंद हो सकने वाला: साबित हुआ निष्कर्ष बंद होता है, और चेन स्थिर हो सकती है                   | हर निष्कर्ष हमेशा के लिए रखा जाता है, सुलझने पर व्यू से छिपा दिया जाता है                          |
| इतिहास में ब्योरा | जोखिम क्या था, इसका छोटा सार                                                                | फ़ैसलों का पूरा सिलसिला, जिसमें यह भी कि उसे कैसे ठीक किया गया                                     |

## लागत

| पहलू                   | Lagune                                                                                                                                                       | Deepsec                                                                                                                                                                                                                     |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| नियतात्मक न्यूनतम आधार | मुफ़्त: हुक बिना AI और बिना कुंजी के चलते हैं, और तभी फ़ैसले दे देते हैं                                                                                     | मुफ़्त: `scan` कमांड बिना AI के चलती है, लेकिन अपने आप कोई फ़ैसला नहीं देती                                                                                                                                                 |
| आम ख़र्च               | आपके पहले से चल रहे एजेंट में ही शामिल: लोकल मॉडल पर $0 तक, आप जिस प्लान की क़ीमत पहले से चुका रहे हैं वही, या API आधारित इस्तेमाल में हर इटरेशन के हिसाब से | [100 से 2,000 फ़ाइलों के लिए हर रन पर लगभग $25 से $1,200, बड़े पैमाने पर और ज़्यादा](https://github.com/vercel-labs/deepsec/blob/f75a16803ec5250938bacfe41571d929e8564f45/docs/getting-started.md#run-the-ai-investigation) |
| सबसे सस्ता रास्ता      | कोई भी मॉडल, मुफ़्त लोकल मॉडल भी, चक्र पूरा कर देता है                                                                                                       | सस्ते पेड टियर मौजूद हैं, लेकिन निष्कर्षों के लिए पेड AI चरण ज़रूरी है                                                                                                                                                      |

## विस्तार और गवर्नेंस

हर एक वह परत खोलता है जिसे दूसरा बंद रखता है।

| पहलू               | Lagune                                                              | Deepsec                                   |
| ------------------ | ------------------------------------------------------------------- | ----------------------------------------- |
| आप क्या बढ़ाते हैं | मॉड्यूल बदलें, या `specialize` कमांड से नए जोड़ें                   | मैचर, एजेंट, नोटिफ़ायर और ओनरशिप जोड़ें   |
| नीति की परत        | सुरक्षा सिद्धांत हर चरण को दिशा देते हैं और उनका वर्ज़न रखा जाता है | कॉन्फ़िग कामकाजी है (मैचर, मॉडल, पाथ)     |
| नाम से ओवरराइड     | सुधारा गया मॉड्यूल बिल्ट-इन की जगह लेता है                          | मैचर का slug टकराए, तो आपका मैचर जीतता है |

## इंटरफ़ेस

Deepsec किसी सुरक्षा संगठन के लिए डिलीवरेबल तैयार करता है। Lagune उसे चलाने वाले व्यक्ति के लिए एक लाइव व्यू दिखाता है।

| पहलू                        | Lagune                                                                            | Deepsec                                                                         |
| --------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| लोगों के देखने का इंटरफ़ेस  | पूरी चेन का लोकल लाइव डैशबोर्ड, आसान भाषा में                                     | रिपोर्ट, एक्सपोर्ट, मेट्रिक्स और PR-कमेंट फ़ाइलें, साथ में एक डॉक्स साइट        |
| जवाबदेही                    | फ़ाइलें और लागू हुई विशेषज्ञताएँ सामने रखता है                                    | ज़िम्मेदारी के लिए किसी का सुझाव देता है: ऑन-कॉल, मैनेजर या कमिट करने वाला      |
| दोहराया जा सकने वाला प्रमाण | `prove` कमांड चलाए जा सकने वाले टेस्ट और खुलासे के लिए सुरक्षा एडवाइज़री लिखती है | डिज़ाइन से स्टैटिक रहता है, लक्ष्य को कभी चलाता नहीं                            |
| टूल की अपनी रक्षा           | डैशबोर्ड पर लोकल राइट API की सुरक्षा मज़बूत करता है                               | अविश्वसनीय लक्ष्य कोड के ख़िलाफ़ अपने AI एक्ज़ीक्यूशन की सुरक्षा मज़बूत करता है |

## पैमाना और डिप्लॉयमेंट

| पहलू           | Lagune                                                                          | Deepsec                                                      |
| -------------- | ------------------------------------------------------------------------------- | ------------------------------------------------------------ |
| इंस्टॉल        | आपके एजेंट के प्लगइन या **skills** CLI से नौ कमांड, कुछ भी स्कैफ़ोल्ड नहीं होता | अपने पैकेज और डिपेंडेंसी वाला एक `.deepsec/` वर्कस्पेस       |
| पैमाने की दिशा | किसी भी हिस्से तक सिमट सकता है, एक संदर्भ या एक फ़ाइल से लेकर पूरे प्रोजेक्ट तक | पूरी रिपॉज़िटरी स्कैन करता है, बड़े मोनोरेपो तक              |
| वितरण          | सिर्फ़ लोकल, इकलौता सर्वर लूपबैक से बँधा है                                     | ज़रूरत हो तो काम को Vercel Sandbox वर्कर VM में बाँट सकता है |

## उपयोगकर्ता अनुभव

हर टूल उसे चलाने वाले व्यक्ति से कैसे मिलता है: पहले रन के लिए क्या चाहिए, और चलाने वाला उसे किस ओर मोड़ता है।

### ऑनबोर्डिंग

Lagune पहले से खुले एजेंट के ज़रिए चलता है। Deepsec पहले अपना वर्कस्पेस और मॉडल एक्सेस तैयार करता है।

| पहलू                     | Lagune                                                                          | Deepsec                                                                           |
| ------------------------ | ------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
| पहली कमांड               | प्लगइन इंस्टॉल या `npx skills add wellwelwel/lagune`, फिर एजेंट में `/lagune-*` | `npx deepsec init`, फिर `cd .deepsec`, `pnpm install`, `scan`, `process`          |
| चलाने के लिए क्रेडेंशियल | अलग कुंजी नहीं, यह आपका मौजूदा एजेंट इस्तेमाल करता है                           | मॉडल की कुंजी (जैसे AI Gateway, 12 घंटे वाला Vercel OIDC टोकन, या Anthropic टोकन) |

### इसे दिशा देना

दोनों निर्देश लेते हैं। Lagune हर चरण में इनपुट का रूप पढ़ता है। Deepsec उन फ़ाइलों का दायरा छोटा करता है जिन पर वही जाँच चलती है।

| पहलू               | Lagune                                                                           | Deepsec                                                         |
| ------------------ | -------------------------------------------------------------------------------- | --------------------------------------------------------------- |
| पूरा प्रोजेक्ट     | बिना इनपुट वाला चरण पूरे दायरे को स्कैन करता है                                  | `scan` और `process` कमांड रिपॉज़िटरी को स्कैन करती हैं          |
| एक हिस्सा          | कोई भी चरण दी गई फ़ाइलों या डायरेक्टरी तक सिमट जाता है                           | `--files`, `--files-from` या `--diff` रन का दायरा छोटा करते हैं |
| एक चिंता           | चरण बताई गई चिंता तक सिमट जाता है                                                | जाँच का प्रॉम्प्ट तय है                                         |
| प्राथमिकता का स्तर | `harden` और `verify` चरण क्रिटिकल, उच्च, मध्यम या निम्न तक सिमट जाते हैं         | निष्कर्षों पर लेबल रन के बाद लगते हैं                           |
| एक अकेली वैल्यू    | हुक एक कोड के टुकड़े, पैटर्न या URL को सीधे स्कोर देता है (`--pattern`, `--url`) | काम की इकाई एक फ़ाइल है                                         |

## अक्सर पूछे जाने वाले सवाल

### Lagune और Deepsec में क्या फ़र्क़ है?

Lagune एजेंट-फ़र्स्ट है और कोड लिखे जाने से पहले, उसके दौरान और उसके बाद काम करता है: यह कोड से पहले नीति तय करता है, बनाते समय उसी जगह सुरक्षा मज़बूत करता है, और पहले से लिखे कोड का ऑडिट करता है, उसकी सुरक्षा मज़बूत करता है और पुष्टि करता है। Deepsec नियतात्मकता-फ़र्स्ट है: regex का चौड़ा स्कैन एक अनिवार्य फ़्रंटियर-मॉडल जाँच तक पहुँचाता है, जो मौजूदा कोड रिव्यू करती है और निष्कर्षों की रिपोर्ट देती है, कोड बदले बिना।

### क्या मैं इनमें से किसी को मुफ़्त में चला सकता हूँ?

Lagune का पूरा फ़्लो मुफ़्त लोकल मॉडल पर $0 में चल सकता है, और इसके नियतात्मक हुक बिना किसी AI के फ़ैसले देते हैं। Deepsec का स्कैन मुफ़्त है, लेकिन कोई फ़ैसला नहीं देता, इसलिए किसी भी निष्कर्ष के लिए उसका पेड AI चरण ज़रूरी है।

### क्या इनमें से कोई मेरा कोड बदलता है?

Lagune बदलता है: harden चरण आपके कोड में सुधार लागू करता है। Deepsec नहीं बदलता: यह सिर्फ़ स्टैटिक एनालिसिस करता है और निष्कर्ष व सुझाव का टेक्स्ट देता है, जिसे कोई व्यक्ति या एजेंट अलग से लागू करता है।