# प्रोग्रेसिव डिस्क्लोज़र: एजेंट सिस्टम में झांकती CLI खिड़कियां

Canonical source: https://maguyva.ai/hi/blog/progressive-disclosure-cli-into-agents

License: text under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/); code samples under [MIT-0](https://opensource.org/license/mit-0); the Maguyva name, logos, brand assets and other code are not covered. Details: [maguyva.ai/license](https://maguyva.ai/license).

Date: 2026-01-20 · Author: Maguyva Team

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

> *इस पोस्ट में दिए गए आंकड़े प्रकाशन के समय (जनवरी 2026) की सिस्टम स्थिति दर्शाते हैं। मौजूदा आंकड़ों के लिए हमारा [टीम पेज](/hi/team) देखें।*

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

जवाब है प्रोग्रेसिव डिस्क्लोज़र: एक परतदार इंटरफ़ेस जो ठीक उतनी ही जटिलता दिखाता है जितनी आपको चाहिए, ठीक तभी जब आपको चाहिए।

## अपारदर्शिता की समस्या

एक आधुनिक एजेंट ऑर्केस्ट्रेशन सिस्टम में हो सकता है:

- 40+ स्पेशलिस्ट एजेंट, हर एक की अपनी अलग क्षमताएं
- आंतरिक ऑटोमेशन और वेंडर इंटीग्रेशन में फैली 700+ स्किल
- व्यवहार को आकार देते 470+ आर्किटेक्चरल डिसीज़न
- बाहरी क्षमताएं देने वाले दर्जनों MCP टूल सर्वर

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

आपको कैसे पता चलेगा कि कौन-सा एजेंट डेटाबेस माइग्रेशन संभालता है? किन डिसीज़न ने सर्च सिस्टम के रैंकिंग व्यवहार को आकार दिया? आर्किटेक्चर एडवाइज़र के पास किन टूल तक पहुंच है?

संरचित पहुंच के बिना, आप या तो सोर्स कोड पढ़ते रह जाते हैं या उम्मीद करते हैं कि डॉक्यूमेंटेशन अद्यतन है।

## आर्किटेक्चर के रूप में प्रोग्रेसिव डिस्क्लोज़र

प्रोग्रेसिव डिस्क्लोज़र सिर्फ़ एक UI पैटर्न नहीं है। यह एक आर्किटेक्चरल सिद्धांत है: जानकारी को परतों में व्यवस्थित करें, हर एक पिछली से गहरी, ताकि उपयोगकर्ता उस स्तर पर रुक सकें जो उनके सवाल का जवाब देता है।

एजेंट सिस्टम के लिए, यह बढ़ती गहराई पर CLI कमांड में तब्दील होता है:

| स्तर | कमांड | किस सवाल का जवाब मिलता है |
|-------|---------|-------------------|
| 1 | `orkestra system status` | क्या सब कुछ स्वस्थ है? |
| 2 | `orkestra agents list` | कौन-से एजेंट मौजूद हैं? |
| 3 | `orkestra agents info <name>` | यह एजेंट क्या करता है? |
| 4 | `orkestra decisions search` | यह इस तरह क्यों काम करता है? |
| 5 | Maguyva MCP टूल | मुझे कोड दिखाओ। |

हर स्तर एक स्वाभाविक फ़ॉलो-अप सवाल का जवाब देता है। आपको शायद ही कभी सीधे स्तर 5 तक कूदने की ज़रूरत पड़ती है।

## स्तर 1: सिस्टम हेल्थ

पहला सवाल हमेशा यही होता है: क्या सब कुछ काम कर रहा है?

```bash
$ orkestra system status
```
```json
{
  "agents": 40,
  "skills_internal": 466,
  "skills_vendor": 240,
  "skills_total": 706,
  "commands": 17
}
```

एक कमांड। चार आंकड़े। यह जानने के लिए काफ़ी कि सिस्टम कॉन्फ़िगर है और रजिस्ट्री भरी हुई हैं।

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

## स्तर 2: एजेंट इन्वेंटरी

एक बार जब आप जान लें कि सिस्टम स्वस्थ है, तो अगला सवाल है: क्या उपलब्ध है?

```bash
$ orkestra agents list
```

यह संरचित डेटा लौटाता है — एजेंट के नाम, विवरण, मॉडल प्राथमिकताएं, डोमेन कवरेज। आउटपुट डिफ़ॉल्ट रूप से JSON है, जिससे फ़िल्टरिंग के लिए इसे `jq` में पाइप करना आसान हो जाता है:

```bash
$ orkestra agents list | jq '.agents[] | select(.model == "opus") | .name'
```

डेटाबेस वर्क संभालने वाले एजेंट चाहिए? सर्च कमांड उसे सीमित कर देता है:

```bash
$ orkestra agents search "database"
```

यह नाम, विवरण, और क्षमताओं को स्कैन करता है। आप 40 एजेंट परिभाषाएं पढ़े बिना सही स्पेशलिस्ट खोज लेते हैं।

## स्तर 3: एजेंट डीप डाइव

कोई प्रासंगिक लगने वाला एजेंट मिल गया? `info` कमांड सब कुछ सामने ला देता है:

```bash
$ orkestra agents info architecture-advisor
```

आउटपुट में शामिल है:

- **मेटाडेटा**: नाम, श्रेणी, मॉडल प्राथमिकता, विवरण
- **डोमेन**: यह एजेंट किन नॉलेज क्षेत्रों को कवर करता है
- **Identity**: कैरेक्टर ट्रेट (architect, strategist, knowledge-architect)
- **टूल गाइड**: कॉन्टेक्स्ट में कौन-सा टूल डॉक्यूमेंटेशन इंजेक्ट किया गया है
- **टूल**: इस एजेंट के लिए उपलब्ध MCP टूल की पूरी सूची

जो आप देखते हैं उसका एक नमूना यह रहा:

```jsonc
{
  "metadata": {
    "name": "architecture-advisor",
    "model": "opus",
    "description": "Strategic decision-making and architectural guidance..."
  },
  "domains": [
    "product",
    "development/architecture",
    "meta/strategy"
  ],
  "tools": {
    "mcp_tools": [
      "mcp__maguyva__intelligent_search",
      "mcp__maguyva__analyze_dependencies",
      "mcp__supabase__execute_sql",
      ...
    ]
  }
}
```

यह आपको ठीक-ठीक बताता है कि एजेंट क्या कर सकता है। किसी सोर्स कोड की ज़रूरत नहीं।

## स्तर 4: डिसीज़न आर्कियोलॉजी

एजेंट दस्तावेज़ीकृत डिसीज़न के अनुसार व्यवहार करते हैं। जब आपको यह समझने की ज़रूरत हो कि कुछ किसी ख़ास तरीक़े से *क्यों* काम करता है, तो डिसीज़न रजिस्ट्री ही सच्चाई का स्रोत है।

```bash
$ orkestra decisions search "agent"
```

यह मिलते-जुलते आर्किटेक्चरल डिसीज़न लौटाता है:

```json
{
  "results": [
    {
      "id": "DEC-SR-049",
      "title": "AI-Agent-First Defaults with Graph Intelligence",
      "domain": "search",
      "status": "active"
    }
  ]
}
```

हर डिसीज़न के स्रोत और इतिहास का पूरा रिकॉर्ड होता है — यह कब लिया गया, क्यों, किन ट्रेड-ऑफ़ पर विचार किया गया, किन कमिट ने इसे इम्प्लीमेंट किया:

```bash
$ orkestra decisions info DEC-SR-049
```

```json
{
  "id": "DEC-SR-049",
  "title": "AI-Agent-First Defaults with Graph Intelligence",
  "summary": "Changes default values for search tools to AI-agent-optimal behavior...",
  "rationale": [
    "AI agents work better with pre-ranked, importance-weighted results",
    "Graph metrics already computed by pipeline - leverage them",
    "Community context helps agents understand feature scope in single query"
  ],
  "source_commits": [
    {
      "sha": "156a880d05eae295669ef7c194b039023f245511",
      "message": "feat(maguyva): enable boost_by_importance..."
    }
  ]
}
```

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

## स्तर 5: डायरेक्ट कोड इंटेलिजेंस

जब आपको असली इम्प्लीमेंटेशन देखने की ज़रूरत हो — उसके बारे में मेटाडेटा नहीं — तो Maguyva के MCP टूल डायरेक्ट एक्सेस देते हैं।

किसी एजेंट सेशन के भीतर से:

```
mcp__maguyva__intelligent_search
  query: "agent context loading"
```

यह प्रासंगिक कोड खोजने के लिए सिमेंटिक, टेक्स्ट, और AST सर्च में ख़ुद-ब-ख़ुद रूट करता है। विशिष्ट सिंबल के लिए:

```
mcp__maguyva__find_symbol
  symbol_name: "load_agent_context"
```

डिपेंडेंसी विश्लेषण के लिए:

```
mcp__maguyva__analyze_dependencies
  target: "packages/orchestration/core/agents.py"
```

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

## रजिस्ट्री में एकीकृत सर्च

कभी-कभी आपको नहीं पता होता कि किस रजिस्ट्री में जवाब है। एकीकृत सर्च सब कुछ कवर करता है:

```bash
$ orkestra search "database" --summary
```

```json
{
  "query": "database",
  "total": 254,
  "counts": {
    "agents": 40,
    "skills": 59,
    "decisions": 476,
    "truths": 2,
    "packages": 1
  }
}
```

पांच रजिस्ट्री में 254 मैच। सारांश आपको बताता है कि कहां गहराई से देखना है। विस्तृत नतीजों के लिए `--summary` हटाएं, या आउटपुट को प्रबंधनीय रखने के लिए `--limit 5` जोड़ें।

## यह क्यों मायने रखता है

प्रोग्रेसिव डिस्क्लोज़र सिर्फ़ सुविधा के बारे में नहीं है। यह बदल देता है कि आप जटिल सिस्टम के साथ कैसे बातचीत करते हैं।

**डीबगिंग आसान हो जाती है।** जब कोई एजेंट कोई अप्रत्याशित फ़ैसला लेता है, तो आप लॉग में grep नहीं करते। आप जांचते हैं कि उसके पास किन टूल तक पहुंच है (`agents info`), कौन-से डिसीज़न उसके व्यवहार को आकार देते हैं (`decisions search`), और ज़रूरत पड़ने पर इम्प्लीमेंटेशन ट्रेस करते हैं (`intelligent_search`)।

**ऑनबोर्डिंग तेज़ हो जाती है।** नए टीम मेंबर को पूरा कोडबेस पढ़ने की ज़रूरत नहीं। वे `system status` से शुरू करते हैं, `agents list` से एक्सप्लोर करते हैं, और तभी गहराई में जाते हैं जब उन्हें कुछ ऐसा मिले जो वे समझ न पाएं।

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

## इंटरफ़ेस के रूप में CLI

हम एक वेब डैशबोर्ड बना सकते थे। हम विस्तृत डॉक्यूमेंटेशन लिख सकते थे। इसके बजाय, हमने एक CLI बनाया जो सच्चाई के स्रोत से पढ़ता है।

CLI के फ़ायदे हैं:

- **कम्पोज़ेबल**: `jq` के ज़रिए आउटपुट पाइप करें, स्क्रिप्ट के साथ इंटीग्रेट करें
- **स्क्रिप्टेबल**: चेक ऑटोमेट करें, रिपोर्ट जनरेट करें
- **तेज़**: कोई पेज लोड नहीं, कोई ऑथेंटिकेशन फ़्लो नहीं
- **सटीक**: असली कॉन्फ़िगरेशन पढ़ता है, कोई कैश्ड प्रतिनिधित्व नहीं

ऐसे सिस्टम के लिए जहां सटीकता सौंदर्यशास्त्र से ज़्यादा मायने रखती है, CLI जीतता है।

## अपना ख़ुद का प्रोग्रेसिव डिस्क्लोज़र बनाना

अगर आप एजेंट सिस्टम बना रहे हैं, तो सोचें कि उपयोगकर्ता उन्हें कैसे जांचेंगे:

1. **हेल्थ चेक से शुरू करें।** एक कमांड जो आपको बताए कि चीज़ें काम कर रही हैं या नहीं।
2. **इन्वेंटरी व्यू दें।** यह समझाने से पहले कि कुछ क्या करता है, यह सूचीबद्ध करें कि क्या मौजूद है।
3. **टार्गेटेड क्वेरी सक्षम करें।** बड़े पैमाने पर सर्च, ब्राउज़िंग से बेहतर है।
4. **स्रोत और इतिहास दिखाएं।** उपयोगकर्ताओं को डिसीज़न को उनके मूल तक ट्रेस करने दें।
5. **कोड इंटेलिजेंस से जोड़ें।** आख़िरकार, उपयोगकर्ताओं को इम्प्लीमेंटेशन देखने की ज़रूरत होती है।

हर लेयर एक फ़ॉलो-अप सवाल का जवाब देती है। इन्हें आवृत्ति के क्रम में बनाएं — ज़्यादातर उपयोगकर्ता लेयर 2 या 3 पर रुक जाते हैं। सिर्फ़ पावर यूज़र लेयर 5 तक पहुंचते हैं।

लक्ष्य सब कुछ एक्सपोज़ करना नहीं है। यह ठीक वही एक्सपोज़ करना है जिसकी ज़रूरत है, ठीक तभी जब उसकी ज़रूरत है। यही है एजेंट आर्किटेक्चर पर लागू प्रोग्रेसिव डिस्क्लोज़र।