---
read_when:
    - आप एजेंट के माध्यम से पृष्ठभूमि में या समानांतर रूप से काम करना चाहते हैं
    - आप sessions_spawn या उप-एजेंट टूल नीति बदल रहे हैं
    - आप थ्रेड-बाउंड सबएजेंट सत्रों को लागू कर रहे हैं या उनकी समस्या का निवारण कर रहे हैं
sidebarTitle: Sub-agents
summary: अलग-थलग पृष्ठभूमि एजेंट रन शुरू करें, जो अनुरोधकर्ता चैट में परिणामों की घोषणा करें
title: उप-एजेंट्स
x-i18n:
    generated_at: "2026-07-27T20:40:38Z"
    model: gpt-5.6
    postprocess_version: locale-links-v1
    prompt_version: 32
    provider: openai
    source_hash: e45b32fdb177c52ed785287712b9b6c2c30bbe392f0ce975970910ff91ed30ed
    source_path: tools/subagents.md
    workflow: 16
---

उप-एजेंट किसी मौजूदा एजेंट रन से शुरू किए गए पृष्ठभूमि एजेंट रन होते हैं।
हर एक अपने स्वयं के सेशन (`agent:<agentId>:subagent:<uuid>`) में चलता है और,
पूरा होने पर, अपना परिणाम अनुरोधकर्ता के चैट चैनल पर वापस **घोषित** करता है।
हर उप-एजेंट रन को एक [पृष्ठभूमि कार्य](/hi/automation/tasks) के रूप में ट्रैक किया जाता है।

लक्ष्य:

- मुख्य रन को अवरुद्ध किए बिना शोध, लंबे कार्यों और धीमे टूल कार्य को समानांतर रूप से चलाना।
- उप-एजेंट को डिफ़ॉल्ट रूप से पृथक रखना (सेशन पृथक्करण, वैकल्पिक सैंडबॉक्सिंग)।
- टूल सतह का दुरुपयोग कठिन बनाए रखना: उप-एजेंट को डिफ़ॉल्ट रूप से सेशन या संदेश टूल **नहीं** मिलते।
- ऑर्केस्ट्रेटर पैटर्न के लिए कॉन्फ़िगर करने योग्य नेस्टिंग गहराई का समर्थन करना।

<Note>
**लागत संबंधी नोट:** डिफ़ॉल्ट रूप से प्रत्येक उप-एजेंट का अपना कॉन्टेक्स्ट और टोकन उपयोग होता है।
भारी या दोहराए जाने वाले कार्यों के लिए, उप-एजेंट के लिए कम लागत वाला मॉडल सेट करें
और `agents.defaults.subagents.model` या प्रति-एजेंट ओवरराइड के माध्यम से अपने मुख्य एजेंट को
उच्च-गुणवत्ता वाले मॉडल पर रखें। जब किसी चाइल्ड को वास्तव में अनुरोधकर्ता की
वर्तमान ट्रांसक्रिप्ट की आवश्यकता हो, तो उसे `context: "fork"` के साथ शुरू करें।
थ्रेड-बाउंड उप-एजेंट सेशन डिफ़ॉल्ट रूप से `context: "fork"` होते हैं, क्योंकि वे
वर्तमान बातचीत को एक फ़ॉलो-अप थ्रेड में शाखित करते हैं।
</Note>

## स्लैश कमांड

`/subagents` **वर्तमान सेशन** के उप-एजेंट रन का निरीक्षण करता है:

```text
/subagents list
/subagents log <id|#> [limit] [tools]
/subagents info <id|#>
```

`/subagents info` रन मेटाडेटा (स्थिति, टाइमस्टैम्प, सेशन आईडी,
ट्रांसक्रिप्ट पथ, क्लीनअप) दिखाता है। `/subagents log` किसी रन के हाल के चैट टर्न
प्रिंट करता है; टूल-कॉल/परिणाम संदेश शामिल करने के लिए `tools` टोकन जोड़ें
(डिफ़ॉल्ट रूप से छोड़े जाते हैं)। किसी एजेंट टर्न के भीतर से सीमित, सुरक्षा-फ़िल्टर किया हुआ
रिकॉल दृश्य पाने के लिए `sessions_history` का उपयोग करें, या कच्ची पूर्ण ट्रांसक्रिप्ट के लिए
डिस्क पर ट्रांसक्रिप्ट पथ का निरीक्षण करें।

Control UI में, हाल के चाइल्ड रन वाले पैरेंट सेशन की साइडबार पंक्ति को विस्तृत किया जा सकता है।
नेस्टेड पंक्तियाँ चाइल्ड की स्थिति और रनटाइम दिखाती हैं, और किसी एक को चुनने पर
पैरेंट पदानुक्रम बनाए रखते हुए उस चाइल्ड की चैट खुलती है।

### थ्रेड बाइंडिंग नियंत्रण

ये कमांड स्थायी थ्रेड बाइंडिंग वाले चैनलों पर काम करते हैं। नीचे
[थ्रेड का समर्थन करने वाले चैनल](#thread-supporting-channels) देखें।

```text
/focus <subagent-label|session-key|session-id|session-label>
/unfocus
/agents
/session idle <duration|off>
/session max-age <duration|off>
```

### शुरू करने का व्यवहार

एजेंट `sessions_spawn` टूल से पृष्ठभूमि उप-एजेंट शुरू करते हैं।
पूर्णताएँ आंतरिक पैरेंट-सेशन इवेंट के रूप में लौटती हैं; पैरेंट/अनुरोधकर्ता
एजेंट तय करता है कि उपयोगकर्ता को दिखाई देने वाला अपडेट आवश्यक है या नहीं।

<AccordionGroup>
  <Accordion title="गैर-अवरुद्ध, पुश-आधारित पूर्णता">
    - `sessions_spawn` गैर-अवरुद्ध है; यह तुरंत एक रन आईडी लौटाता है।
    - पूरा होने पर, उप-एजेंट पैरेंट/अनुरोधकर्ता सेशन को वापस रिपोर्ट करता है।
    - जिन एजेंट टर्न को चाइल्ड परिणामों की आवश्यकता हो, उन्हें आवश्यक कार्य शुरू करने के बाद `sessions_yield` कॉल करना चाहिए। इससे वर्तमान टर्न समाप्त हो जाता है और पूर्णता इवेंट अगले मॉडल-दृश्य संदेश के रूप में आ सकता है।
    - पूर्णता पुश-आधारित है। शुरू हो जाने के बाद, केवल इसके पूरा होने की प्रतीक्षा करने के लिए `/subagents list`, `sessions_list`, या `sessions_history` को लूप में पोल **न करें**; डीबगिंग करते समय ही आवश्यकता के अनुसार स्थिति जाँचें।
    - चाइल्ड आउटपुट अनुरोधकर्ता एजेंट द्वारा संश्लेषित किए जाने के लिए एक रिपोर्ट/साक्ष्य है। यह उपयोगकर्ता द्वारा लिखा गया निर्देश पाठ नहीं है और सिस्टम, डेवलपर या उपयोगकर्ता नीति को ओवरराइड नहीं कर सकता।
    - पूरा होने पर, घोषणा क्लीनअप प्रवाह जारी रहने से पहले OpenClaw उस उप-एजेंट सेशन द्वारा खोले गए ट्रैक किए गए ब्राउज़र टैब/प्रोसेस को यथासंभव बंद करता है।

  </Accordion>
  <Accordion title="पूर्णता डिलीवरी">
    - OpenClaw एक स्थिर आइडेम्पोटेंसी कुंजी वाले `agent` टर्न के माध्यम से पूर्णताएँ अनुरोधकर्ता सेशन को वापस सौंपता है।
    - यदि अनुरोधकर्ता रन अभी भी सक्रिय है, तो OpenClaw दूसरा दृश्यमान उत्तर पथ शुरू करने के बजाय पहले उस रन को जगाने/निर्देशित करने का प्रयास करता है।
    - यदि सक्रिय अनुरोधकर्ता को जगाया नहीं जा सकता, तो OpenClaw घोषणा को छोड़ने के बजाय उसी पूर्णता कॉन्टेक्स्ट के साथ अनुरोधकर्ता-एजेंट हैंडऑफ़ का सहारा लेता है।
    - सफल पैरेंट हैंडऑफ़ उप-एजेंट डिलीवरी पूरी कर देता है, भले ही पैरेंट यह तय करे कि उपयोगकर्ता को कोई दृश्यमान अपडेट आवश्यक नहीं है।
    - नेटिव उप-एजेंट को संदेश टूल नहीं मिलता। वे पैरेंट/अनुरोधकर्ता एजेंट को सादा सहायक पाठ लौटाते हैं; मनुष्यों को दिखाई देने वाले उत्तर पैरेंट/अनुरोधकर्ता एजेंट की सामान्य डिलीवरी नीति के अधीन रहते हैं।
    - यदि प्रत्यक्ष हैंडऑफ़ का उपयोग नहीं किया जा सकता, तो डिलीवरी पहले कतार रूटिंग और फिर अंतिम रूप से हार मानने से पहले घोषणा के छोटे एक्सपोनेंशियल-बैकऑफ़ पुनः प्रयास का सहारा लेती है।
    - डिलीवरी समाधान किए गए अनुरोधकर्ता रूट को बनाए रखती है: उपलब्ध होने पर थ्रेड-बाउंड या बातचीत-बाउंड पूर्णता रूट को प्राथमिकता मिलती है। यदि पूर्णता का मूल केवल एक चैनल प्रदान करता है, तो OpenClaw अनुरोधकर्ता सेशन के समाधान किए गए रूट (`lastChannel` / `lastTo` / `lastAccountId`) से अनुपलब्ध लक्ष्य/अकाउंट भरता है, ताकि प्रत्यक्ष डिलीवरी फिर भी काम करे।

  </Accordion>
  <Accordion title="पूर्णता हैंडऑफ़ मेटाडेटा">
    अनुरोधकर्ता सेशन को दिया जाने वाला पूर्णता हैंडऑफ़ रनटाइम द्वारा जनरेट किया गया
    आंतरिक कॉन्टेक्स्ट है (उपयोगकर्ता द्वारा लिखा गया पाठ नहीं) और इसमें शामिल हैं:

    - `Result` — चाइल्ड से नवीनतम दृश्यमान `assistant` उत्तर पाठ। टूल/toolResult आउटपुट को चाइल्ड परिणामों में पदोन्नत नहीं किया जाता। अंतिम रूप से विफल रन कैप्चर किए गए उत्तर पाठ का पुनः उपयोग नहीं करते।
    - `Status` — `completed; ready for parent review` / `failed` / `timed out` / `unknown`।
    - संक्षिप्त रनटाइम/टोकन आँकड़े।
    - एक समीक्षा निर्देश, जो मूल कार्य पूरा हुआ है या नहीं यह तय करने से पहले अनुरोधकर्ता एजेंट को परिणाम सत्यापित करने के लिए कहता है।
    - फ़ॉलो-अप मार्गदर्शन, जो चाइल्ड परिणाम में आगे की कार्रवाई शेष होने पर अनुरोधकर्ता एजेंट को कार्य जारी रखने या फ़ॉलो-अप दर्ज करने के लिए कहता है।
    - आगे कोई कार्रवाई न होने वाले पथ के लिए अंतिम-अपडेट निर्देश, जो कच्चा आंतरिक मेटाडेटा अग्रेषित किए बिना सामान्य सहायक शैली में लिखा जाता है।

  </Accordion>
  <Accordion title="मोड और ACP रनटाइम">
    - `--model` और `--thinking` उस विशिष्ट रन के डिफ़ॉल्ट को ओवरराइड करते हैं।
    - पूर्णता के बाद विवरण और आउटपुट का निरीक्षण करने के लिए `info`/`log` का उपयोग करें।
    - स्थायी थ्रेड-बाउंड सेशन के लिए, `thread: true` और `mode: "session"` के साथ `sessions_spawn` का उपयोग करें।
    - यदि अनुरोधकर्ता चैनल थ्रेड बाइंडिंग का समर्थन नहीं करता, तो असंभव थ्रेड-बाउंड संयोजन का पुनः प्रयास करने के बजाय `mode: "run"` का उपयोग करें।
    - ACP हार्नेस सेशन (Claude Code, Gemini CLI, OpenCode, या स्पष्ट Codex ACP/acpx) के लिए, जब टूल उस रनटाइम को विज्ञापित करे तब `runtime: "acp"` के साथ `sessions_spawn` का उपयोग करें। पूर्णताओं या एजेंट-से-एजेंट लूप की डीबगिंग करते समय [ACP डिलीवरी मॉडल](/hi/tools/acp-agents#delivery-model) देखें। जब `codex` Plugin सक्षम हो, तो Codex चैट/थ्रेड नियंत्रण को ACP के बजाय `/codex ...` को प्राथमिकता देनी चाहिए, जब तक कि उपयोगकर्ता स्पष्ट रूप से ACP/acpx न माँगे।
    - OpenClaw `runtime: "acp"` को तब तक छिपाता है जब तक ACP सक्षम न हो, अनुरोधकर्ता सैंडबॉक्स में न हो और `acpx` जैसा बैकएंड Plugin लोड न हो। `runtime: "acp"` को एक बाहरी ACP हार्नेस आईडी, या `runtime.type="acp"` वाली `agents.entries.*` प्रविष्टि चाहिए; `agents_list` से सामान्य OpenClaw कॉन्फ़िग एजेंट के लिए डिफ़ॉल्ट उप-एजेंट रनटाइम का उपयोग करें।

  </Accordion>
</AccordionGroup>

## कॉन्टेक्स्ट मोड

नेटिव उप-एजेंट पृथक रूप से शुरू होते हैं, जब तक कि कॉलर स्पष्ट रूप से
वर्तमान ट्रांसक्रिप्ट को फ़ोर्क करने के लिए न कहे।

| मोड       | इसका उपयोग कब करें                                                                                                                         | व्यवहार                                                                          |
| ---------- | -------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
| `isolated` | नया शोध, स्वतंत्र कार्यान्वयन, धीमा टूल कार्य, या ऐसा कोई भी कार्य जिसका विवरण कार्य पाठ में संक्षेप में दिया जा सकता है                           | एक साफ़ चाइल्ड ट्रांसक्रिप्ट बनाता है। यह डिफ़ॉल्ट है और टोकन उपयोग कम रखता है।  |
| `fork`     | ऐसा कार्य जो वर्तमान बातचीत, पिछले टूल परिणामों या अनुरोधकर्ता ट्रांसक्रिप्ट में पहले से मौजूद सूक्ष्म निर्देशों पर निर्भर करता है | चाइल्ड शुरू होने से पहले अनुरोधकर्ता ट्रांसक्रिप्ट को चाइल्ड सेशन में शाखित करता है। |

`fork` का उपयोग सीमित रूप से करें। यह कॉन्टेक्स्ट-संवेदनशील डेलिगेशन के लिए है,
स्पष्ट कार्य प्रॉम्प्ट लिखने का विकल्प नहीं।

## टूल: `sessions_spawn`

वैश्विक `subagent` लेन पर `deliver: false` के साथ एक उप-एजेंट रन शुरू करता है,
फिर घोषणा चरण चलाता है और घोषणा उत्तर अनुरोधकर्ता के
चैट चैनल पर पोस्ट करता है।

उपलब्धता कॉलर की प्रभावी टूल नीति पर निर्भर करती है। अंतर्निर्मित
`coding` और `messaging` प्रोफ़ाइल में `sessions_spawn`,
`sessions_yield`, और `subagents` शामिल हैं; `minimal` में नहीं। `full` हर
टूल की अनुमति देता है। ऐसे कस्टम संकरे प्रोफ़ाइल वाले एजेंट के लिए, जिसे फिर भी
कार्य डेलिगेट करना चाहिए, उन टूल को `tools.alsoAllow` से जोड़ें या ऊपर दिए गए
प्रोफ़ाइल में से किसी एक का उपयोग करें।
चैनल/समूह, प्रोवाइडर, सैंडबॉक्स और प्रति-एजेंट अनुमति/अस्वीकृति नीतियाँ
प्रोफ़ाइल चरण के बाद भी टूल को हटा सकती हैं। प्रभावी टूल सूची की पुष्टि करने के लिए उसी
सेशन से `/tools` का उपयोग करें।

**डिफ़ॉल्ट:**

- **मॉडल:** नेटिव उप-एजेंट कॉलर का मॉडल इनहेरिट करते हैं, जब तक कि आप `agents.defaults.subagents.model` (या प्रति-एजेंट `agents.entries.*.subagents.model`) सेट न करें। उपलब्ध होने पर ACP रनटाइम स्पॉन भी उसी कॉन्फ़िगर किए गए उप-एजेंट मॉडल का उपयोग करते हैं; अन्यथा ACP हार्नेस अपना डिफ़ॉल्ट बनाए रखता है। स्पष्ट `sessions_spawn.model` को फिर भी प्राथमिकता मिलती है।
- **सोच-विचार:** नेटिव उप-एजेंट कॉलर की सेटिंग इनहेरिट करते हैं, जब तक कि आप `agents.defaults.subagents.thinking` (या प्रति-एजेंट `agents.entries.*.subagents.thinking`) सेट न करें। ACP रनटाइम स्पॉन भी चुने गए मॉडल के लिए `agents.defaults.models["provider/model"].params.thinking` लागू करते हैं। स्पष्ट `sessions_spawn.thinking` को फिर भी प्राथमिकता मिलती है।
- **रन टाइमआउट:** सेट होने पर OpenClaw `agents.defaults.subagents.runTimeoutSeconds` का उपयोग करता है; अन्यथा यह `0` (कोई टाइमआउट नहीं) का सहारा लेता है। `sessions_spawn` प्रति-कॉल टाइमआउट ओवरराइड स्वीकार नहीं करता।
- **प्रोसेस जीवनकाल:** अलग किया गया OpenClaw उप-एजेंट अपना स्वयं का रन जीवनचक्र रखता है। किसी बाहरी CLI बैकएंड के भीतर बनाया गया पृष्ठभूमि कार्य अलग होता है: वह पैरेंट CLI सबप्रोसेस साझा करता है और यदि पैरेंट `agents.defaults.timeoutSeconds` पर पहुँचता है तो रुक जाता है।
- **कार्य डिलीवरी:** नेटिव उप-एजेंट को डेलिगेट किया गया कार्य उनके पहले दृश्यमान `[Subagent Task]` संदेश में मिलता है। उप-एजेंट सिस्टम प्रॉम्प्ट रनटाइम नियम और रूटिंग कॉन्टेक्स्ट रखता है, कार्य की कोई छिपी हुई प्रतिलिपि नहीं।

स्वीकृत नेटिव उप-एजेंट स्पॉन के टूल परिणाम में समाधान किया गया चाइल्ड मॉडल मेटाडेटा
शामिल होता है: `resolvedModel` में लागू मॉडल रेफ़ होता है और
जब रेफ़ में प्रोवाइडर प्रीफ़िक्स हो, तो `resolvedProvider` में वह प्रीफ़िक्स होता है।

### डेलिगेशन प्रॉम्प्ट मोड

`agents.defaults.subagents.delegationMode` केवल प्रॉम्प्ट मार्गदर्शन नियंत्रित करता है; यह टूल नीति नहीं बदलता या डेलिगेशन लागू नहीं करता।

- `suggest` (डिफ़ॉल्ट): बड़े या धीमे कार्यों के लिए उप-एजेंट का उपयोग करने का मानक प्रॉम्प्ट संकेत बनाए रखें।
- `prefer`: मुख्य एजेंट को प्रतिक्रियाशील बने रहने और प्रत्यक्ष उत्तर से अधिक जटिल किसी भी कार्य को `sessions_spawn` के माध्यम से डेलिगेट करने के लिए कहें।

प्रति-एजेंट ओवरराइड: `agents.entries.*.subagents.delegationMode`।

```json5
{
  agents: {
    defaults: {
      subagents: {
        delegationMode: "prefer",
        maxConcurrent: 4,
      },
    },
    list: [
      {
        id: "coordinator",
        subagents: { delegationMode: "prefer" },
      },
    ],
  },
}
```

### टूल पैरामीटर

<ParamField path="task" type="string" required>
  उप-एजेंट के लिए कार्य का विवरण।
</ParamField>
<ParamField path="taskName" type="string">
  बाद के स्थिति आउटपुट में किसी विशिष्ट चाइल्ड की पहचान करने के लिए वैकल्पिक स्थिर हैंडल। इसे `[a-z][a-z0-9_-]{0,63}` से मेल खाना चाहिए और यह `last` या `all` जैसा आरक्षित लक्ष्य नहीं हो सकता।
</ParamField>
<ParamField path="label" type="string">
  वैकल्पिक मानव-पठनीय लेबल।
</ParamField>
<ParamField path="agentId" type="string">
  `subagents.allowAgents` द्वारा अनुमति मिलने पर किसी अन्य कॉन्फ़िगर किए गए एजेंट आईडी के अंतर्गत स्पॉन करें।
</ParamField>
<ParamField path="cwd" type="string">
  चाइल्ड रन के लिए वैकल्पिक कार्य निर्देशिका। नेटिव उप-एजेंट फिर भी लक्ष्य एजेंट वर्कस्पेस से बूटस्ट्रैप फ़ाइलें लोड करते हैं; `cwd` केवल वह स्थान बदलता है जहाँ रनटाइम टूल और CLI हार्नेस प्रत्यायोजित कार्य करते हैं।
</ParamField>
<ParamField path="runtime" type='"subagent" | "acp"' default="subagent">
  `acp` केवल बाहरी ACP हार्नेस (`claude`, `droid`, `gemini`, `opencode`, या स्पष्ट रूप से अनुरोधित Codex ACP/acpx) और उन `agents.entries.*` प्रविष्टियों के लिए है जिनका `runtime.type`, `acp` है।
</ParamField>
<ParamField path="resumeSessionId" type="string">
  केवल ACP। `runtime: "acp"` होने पर मौजूदा ACP हार्नेस सत्र फिर से शुरू करता है; नेटिव उप-एजेंट स्पॉन के लिए इसे अनदेखा किया जाता है।
</ParamField>
<ParamField path="streamTo" type='"parent"'>
  केवल ACP। `runtime: "acp"` होने पर ACP रन आउटपुट को पैरेंट सत्र में स्ट्रीम करता है; नेटिव उप-एजेंट स्पॉन के लिए इसे छोड़ दें।
</ParamField>
<ParamField path="model" type="string">
  उप-एजेंट मॉडल को ओवरराइड करें। अमान्य मान छोड़ दिए जाते हैं और उप-एजेंट डिफ़ॉल्ट मॉडल पर चलता है, साथ ही टूल परिणाम में चेतावनी दी जाती है।
</ParamField>
<ParamField path="thinking" type="string">
  उप-एजेंट रन के लिए चिंतन स्तर को ओवरराइड करें। `visible: true` के साथ उपलब्ध नहीं है।
</ParamField>
<ParamField path="thread" type="boolean" default="false">
  `true` होने पर इस उप-एजेंट सत्र के लिए चैनल थ्रेड बाइंडिंग का अनुरोध करता है।
</ParamField>
<ParamField path="mode" type='"run" | "session"' default="run">
  यदि `thread: true` है और `mode` छोड़ा गया है, तो डिफ़ॉल्ट `session` हो जाता है। `mode: "session"` के लिए `thread: true` आवश्यक है।
  यदि अनुरोधकर्ता चैनल के लिए थ्रेड बाइंडिंग उपलब्ध नहीं है, तो इसके बजाय `mode: "run"` का उपयोग करें।
  `visible: true` के साथ, `mode` छोड़ दें; दृश्यमान सत्र स्थायी होते हैं और `mode: "run"` का समर्थन नहीं करते।
</ParamField>
<ParamField path="cleanup" type='"delete" | "keep"' default="keep">
  `"delete"` घोषणा के तुरंत बाद सत्र को संग्रहित करता है (फिर भी नाम बदलकर ट्रांसक्रिप्ट रखता है)।
</ParamField>
<ParamField path="sandbox" type='"inherit" | "require"' default="inherit">
  यदि लक्ष्य चाइल्ड रनटाइम सैंडबॉक्स में नहीं है, तो `require` स्पॉन को अस्वीकार करता है।
</ParamField>
<ParamField path="context" type='"isolated" | "fork"' default="isolated">
  `fork` अनुरोधकर्ता के वर्तमान ट्रांसक्रिप्ट की शाखा चाइल्ड सत्र में बनाता है। केवल नेटिव उप-एजेंट। थ्रेड-बाउंड स्पॉन का डिफ़ॉल्ट `fork` है; गैर-थ्रेड स्पॉन का डिफ़ॉल्ट `isolated` है। दृश्यमान फ़ोर्क का लक्ष्य अनुरोधकर्ता वाला ही एजेंट होना चाहिए।
</ParamField>
<ParamField path="visible" type="boolean" default="false">
  एक स्थायी डैशबोर्ड सत्र बनाएँ जिसे उपयोगकर्ता Control UI में खोल सकता है। दृश्यमान स्पॉन केवल `runtime: "subagent"` का समर्थन करते हैं और बनाए गए सत्र को हमेशा रखते हैं।
</ParamField>
<ParamField path="worktree" type="boolean" default="false">
  नए डैशबोर्ड सत्र के लिए प्रबंधित git वर्कट्री का प्रावधान करें। `visible: true` आवश्यक है।
</ParamField>
<ParamField path="worktreeName" type="string">
  वैकल्पिक प्रबंधित-वर्कट्री नाम। `visible: true` और `worktree: true` आवश्यक हैं।
</ParamField>
<ParamField path="worktreeBaseRef" type="string">
  प्रबंधित वर्कट्री के लिए वैकल्पिक git बेस रेफ़। `visible: true` और `worktree: true` आवश्यक हैं।
</ParamField>

<Warning>
`sessions_spawn` चैनल-वितरण पैरामीटर (`target`,
`channel`, `to`, `threadId`, `replyTo`, `transport`) स्वीकार **नहीं** करता। नेटिव उप-एजेंट
अपना नवीनतम सहायक टर्न अनुरोधकर्ता को वापस रिपोर्ट करते हैं; बाहरी वितरण
पैरेंट/अनुरोधकर्ता एजेंट के पास रहता है।
</Warning>

`visible: true` के साथ, `model`, `cwd`, और समान-एजेंट `context: "fork"` समर्थित हैं। सैंडबॉक्स किया गया लक्ष्य `cwd` को उस एजेंट के वर्कस्पेस तक सीमित करता है। थ्रेड बाइंडिंग, `mode`, चिंतन ओवरराइड, `lightContext`, `attachments`, और `attachAs` इस पथ पर उपलब्ध नहीं हैं क्योंकि दृश्यमान सत्र `sessions.create` के माध्यम से बनाए गए स्थायी डैशबोर्ड सत्र होते हैं। यदि अनुरोधकर्ता को स्वयं विरासत में मिली टूल अनुमत-सूची या निषेध-सूची के साथ स्पॉन किया गया था, तो दृश्यमान स्पॉन अस्वीकार कर दिया जाता है; यह प्रतिबंध स्पॉन के समय निर्धारित होता है और इसका कोई कॉन्फ़िग ओवरराइड नहीं है। सत्र सूचीकरण और संबोधन `tools.sessions.visibility` का पालन करते हैं; डिफ़ॉल्ट `tree` स्कोप वर्तमान सत्र और उसके अपने स्पॉन उप-वृक्ष को कवर करता है। चेकआउट नामकरण, सेटअप, क्लीनअप और पुनर्स्थापना व्यवहार के लिए [प्रबंधित वर्कट्री](/hi/concepts/managed-worktrees) देखें।

### कार्य नाम और लक्ष्य निर्धारण

`taskName` ऑर्केस्ट्रेशन के लिए मॉडल-सामना करने वाला हैंडल है, सत्र कुंजी नहीं।
जब किसी समन्वयक को बाद में उस चाइल्ड का निरीक्षण करना पड़ सकता है, तो `review_subagents`,
`linux_validation`, या `docs_update` जैसे स्थिर चाइल्ड नामों के लिए इसका उपयोग करें।

लक्ष्य समाधान सटीक `taskName` मिलान और असंदिग्ध
उपसर्ग स्वीकार करता है। मिलान उसी सक्रिय/हालिया लक्ष्य विंडो तक सीमित है जिसका उपयोग
क्रमांकित `/subagents` लक्ष्य करते हैं, इसलिए कोई पुराना पूर्ण हुआ चाइल्ड
पुनः उपयोग किए गए हैंडल को संदिग्ध नहीं बनाता। यदि दो सक्रिय या हालिया चाइल्ड समान
`taskName` साझा करते हैं, तो लक्ष्य संदिग्ध है; इसके बजाय सूची अनुक्रमणिका, सत्र कुंजी, या
रन आईडी का उपयोग करें।

आरक्षित लक्ष्य `last` और `all`, `taskName` के मान्य मान नहीं हैं
क्योंकि उनके नियंत्रण संबंधी अर्थ पहले से हैं।

## टूल: `sessions_yield`

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

`sessions_yield` प्रतीक्षा की मूल क्रिया है। केवल चाइल्ड पूर्णता का पता लगाने के लिए इसे
`subagents`, `sessions_list`, `sessions_history`, शेल
`sleep`, या प्रक्रिया पोलिंग के पोलिंग लूप से न बदलें।

`sessions_yield` का उपयोग केवल तभी करें जब सत्र की प्रभावी टूल सूची में
यह शामिल हो। कुछ न्यूनतम या कस्टम टूल प्रोफ़ाइल `sessions_spawn` और
`subagents` को `sessions_yield` के बिना उपलब्ध करा सकती हैं; उस स्थिति में, पूर्णता की
प्रतीक्षा के लिए कोई पोलिंग लूप न गढ़ें।

जब सक्रिय चाइल्ड मौजूद होते हैं, तो OpenClaw सामान्य टर्न में रनटाइम द्वारा जनरेट किया गया एक संक्षिप्त
`Active Subagents` प्रॉम्प्ट ब्लॉक इंजेक्ट करता है, ताकि अनुरोधकर्ता
वर्तमान चाइल्ड सत्र, रन आईडी, स्थितियाँ, लेबल, कार्य और
`taskName` उपनाम बिना पोलिंग के देख सके। उस ब्लॉक में कार्य और लेबल फ़ील्ड
निर्देशों के रूप में नहीं, बल्कि डेटा के रूप में उद्धृत होते हैं, क्योंकि वे
उपयोगकर्ता/मॉडल द्वारा दिए गए स्पॉन आर्ग्युमेंट से उत्पन्न हो सकते हैं।

## टूल: `subagents`

अनुरोधकर्ता सत्र वृक्ष के स्वामित्व वाले स्पॉन किए गए उप-एजेंट रन और पृष्ठभूमि-कार्य रिकॉर्ड
सूचीबद्ध करता है। कार्य पंक्तियाँ नेटिव उप-एजेंट, ACP रन,
Gateway CLI/मीडिया कार्य और Cron निष्पादन कवर करती हैं। इसका स्कोप वर्तमान
अनुरोधकर्ता तक सीमित है; कोई चाइल्ड केवल अपने नियंत्रित चाइल्ड देख सकता है।

माँग पर स्थिति और डीबगिंग के लिए `subagents` का उपयोग करें। पूर्णता घटनाओं की
प्रतीक्षा के लिए `sessions_yield` का उपयोग करें।

किसी कार्य को रोकने के लिए `action: "list"` द्वारा लौटाए गए `taskId` के साथ `action: "cancel"`
का उपयोग करें। रद्दीकरण नियंत्रित सत्र वृक्ष तक सीमित है; कोई लीफ़
उप-एजेंट किसी अन्य सत्र के स्वामित्व वाला कार्य रद्द नहीं कर सकता।

## थ्रेड-बाउंड सत्र

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

### थ्रेड का समर्थन करने वाले चैनल

जब कोई चैनल वार्तालाप
बाइंडिंग अडैप्टर पंजीकृत करता है, तो वह स्थायी थ्रेड-बाउंड उप-एजेंट सत्रों
(`sessions_spawn` के साथ `thread: true`) का समर्थन करता है। इस समर्थन वाले बंडल चैनल: **Discord**,
**iMessage**, **Matrix**, और **Telegram**। Discord और Matrix में डिफ़ॉल्ट रूप से
चाइल्ड थ्रेड बनाया जाता है; Telegram और iMessage में डिफ़ॉल्ट रूप से
वर्तमान वार्तालाप को बाइंड किया जाता है। सक्षमता, टाइमआउट और `spawnSessions` के लिए
प्रति-चैनल `threadBindings` कॉन्फ़िग कुंजियों का उपयोग करें।

### त्वरित प्रवाह

<Steps>
  <Step title="स्पॉन करें">
    `sessions_spawn` को `thread: true` (और वैकल्पिक रूप से `mode: "session"`) के साथ।
  </Step>
  <Step title="बाइंड करें">
    OpenClaw सक्रिय चैनल में उस सत्र लक्ष्य के लिए थ्रेड बनाता है या उसे बाइंड करता है।
  </Step>
  <Step title="अनुवर्ती संदेश रूट करें">
    उस थ्रेड के उत्तर और अनुवर्ती संदेश बाउंड सत्र को रूट होते हैं।
  </Step>
  <Step title="टाइमआउट जाँचें">
    निष्क्रियता के बाद स्वचालित अनफ़ोकस का निरीक्षण/अपडेट करने के लिए `/session idle` और
    अधिकतम सीमा नियंत्रित करने के लिए `/session max-age` का उपयोग करें।
  </Step>
  <Step title="अलग करें">
    मैन्युअल रूप से अलग करने के लिए `/unfocus` का उपयोग करें।
  </Step>
</Steps>

### मैन्युअल नियंत्रण

| कमांड            | प्रभाव                                                                                    |
| ------------------ | ----------------------------------------------------------------------------------------- |
| `/focus <target>`  | वर्तमान थ्रेड को किसी उप-एजेंट/सत्र लक्ष्य से बाइंड करें (या एक बनाएँ)                     |
| `/unfocus`         | वर्तमान बाउंड थ्रेड की बाइंडिंग हटाएँ                                           |
| `/agents`          | सक्रिय रन और बाइंडिंग स्थिति सूचीबद्ध करें (`binding:<id>`, `unbound`, या `bindings unavailable`) |
| `/session idle`    | निष्क्रियता के बाद स्वचालित अनफ़ोकस का निरीक्षण/अपडेट करें (केवल फ़ोकस किए गए बाउंड थ्रेड)                             |
| `/session max-age` | अधिकतम सीमा का निरीक्षण/अपडेट करें (केवल फ़ोकस किए गए बाउंड थ्रेड)                                      |

### कॉन्फ़िग स्विच

- **वैश्विक डिफ़ॉल्ट:** `session.threadBindings.enabled`, `session.threadBindings.idleHours`, `session.threadBindings.maxAgeHours`।
- **चैनल ओवरराइड और स्पॉन ऑटो-बाइंड कुंजियाँ** अडैप्टर-विशिष्ट हैं। ऊपर [थ्रेड का समर्थन करने वाले चैनल](#thread-supporting-channels) देखें।

वर्तमान अडैप्टर विवरण के लिए [कॉन्फ़िगरेशन संदर्भ](/hi/gateway/configuration-reference) और
[स्लैश कमांड](/hi/tools/slash-commands) देखें।

### अनुमत-सूची

<ParamField path="agents.entries.*.subagents.allowAgents" type="string[]">
  कॉन्फ़िगर किए गए एजेंट आईडी की सूची जिन्हें स्पष्ट `agentId` के माध्यम से लक्ष्य बनाया जा सकता है (`["*"]` किसी भी कॉन्फ़िगर किए गए लक्ष्य की अनुमति देता है)। डिफ़ॉल्ट: केवल अनुरोधकर्ता एजेंट। यदि आप कोई सूची सेट करते हैं और फिर भी चाहते हैं कि अनुरोधकर्ता `agentId` के साथ स्वयं को स्पॉन करे, तो सूची में अनुरोधकर्ता आईडी शामिल करें।
</ParamField>
<ParamField path="agents.defaults.subagents.allowAgents" type="string[]">
  जब अनुरोधकर्ता एजेंट अपना `subagents.allowAgents` सेट नहीं करता, तब उपयोग की जाने वाली डिफ़ॉल्ट कॉन्फ़िगर लक्ष्य-एजेंट अनुमत-सूची।
</ParamField>
<ParamField path="agents.defaults.subagents.requireAgentId" type="boolean" default="false">
  `agentId` छोड़ने वाली `sessions_spawn` कॉल को ब्लॉक करें (स्पष्ट प्रोफ़ाइल चयन अनिवार्य करता है)। प्रति-एजेंट ओवरराइड: `agents.entries.*.subagents.requireAgentId`।
</ParamField>
<ParamField path="agents.defaults.subagents.announceTimeoutMs" type="number" default="120000">
  Gateway `agent` घोषणा वितरण प्रयासों के लिए प्रति-कॉल टाइमआउट। मान धनात्मक पूर्णांक मिलीसेकंड होते हैं और प्लेटफ़ॉर्म-सुरक्षित टाइमर अधिकतम तक सीमित किए जाते हैं। अस्थायी पुनः प्रयास कुल घोषणा प्रतीक्षा को कॉन्फ़िगर किए गए एक टाइमआउट से अधिक लंबा बना सकते हैं।
</ParamField>

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

### खोज

वर्तमान में किन agent ids को
`sessions_spawn` के लिए अनुमति है, यह देखने के लिए `agents_list` का उपयोग करें। प्रतिक्रिया में सूचीबद्ध प्रत्येक agent का प्रभावी
model और अंतर्निहित runtime metadata शामिल होता है, ताकि कॉलर OpenClaw, Codex
app-server और अन्य कॉन्फ़िगर किए गए native runtimes के बीच अंतर कर सकें।

`allowAgents` प्रविष्टियों को `agents.entries.*` में कॉन्फ़िगर किए गए agent ids की ओर संकेत करना चाहिए।
`["*"]` का अर्थ है कोई भी कॉन्फ़िगर किया गया लक्ष्य agent और अनुरोधकर्ता। यदि किसी agent का config
हटा दिया जाता है, लेकिन उसका id `allowAgents` में बना रहता है, तो `sessions_spawn` उस id को अस्वीकार करता है
और `agents_list` उसे छोड़ देता है। पुराने हो चुके allowlist
प्रविष्टियों को साफ़ करने के लिए `openclaw doctor --fix` चलाएँ, या जब लक्ष्य को
डिफ़ॉल्ट्स इनहेरिट करते हुए spawn करने योग्य रखना हो, तब एक न्यूनतम `agents.entries.*` प्रविष्टि जोड़ें।

### स्वचालित आर्काइव

- Sub-agent सत्र `agents.defaults.subagents.archiveAfterMinutes` (डिफ़ॉल्ट `60`) के बाद स्वचालित रूप से आर्काइव किए जाते हैं।
- आर्काइव `sessions.delete` का उपयोग करता है और ट्रांसक्रिप्ट का नाम बदलकर `*.deleted.<timestamp>` करता है (उसी फ़ोल्डर में)।
- `cleanup: "delete"` घोषणा के तुरंत बाद आर्काइव करता है (नाम बदलकर ट्रांसक्रिप्ट को फिर भी बनाए रखता है)।
- स्वचालित आर्काइव सर्वोत्तम-प्रयास पर आधारित है; Gateway के पुनः आरंभ होने पर लंबित टाइमर खो जाते हैं।
- कॉन्फ़िगर किए गए रन टाइमआउट स्वचालित रूप से आर्काइव **नहीं** करते; वे केवल रन रोकते हैं। सत्र स्वचालित आर्काइव होने तक बना रहता है।
- स्वचालित आर्काइव depth-1 और depth-2 सत्रों पर समान रूप से लागू होता है।
- ब्राउज़र क्लीनअप, आर्काइव क्लीनअप से अलग है: रन समाप्त होने पर ट्रैक किए गए ब्राउज़र टैब/प्रोसेस सर्वोत्तम-प्रयास के आधार पर बंद किए जाते हैं, भले ही ट्रांसक्रिप्ट/सत्र रिकॉर्ड रखा गया हो।

## नेस्टेड sub-agents

डिफ़ॉल्ट रूप से, sub-agents अपने स्वयं के sub-agents को spawn नहीं कर सकते
(`maxSpawnDepth: 1`)। नेस्टिंग का एक स्तर सक्षम करने के लिए `maxSpawnDepth: 2` सेट करें
— **orchestrator पैटर्न**: मुख्य → orchestrator sub-agent →
worker sub-sub-agents।

```json5
{
  agents: {
    defaults: {
      subagents: {
        maxSpawnDepth: 2, // sub-agents को children spawn करने दें (डिफ़ॉल्ट: 1, सीमा 1-5)
        maxChildrenPerAgent: 5, // प्रति agent सत्र अधिकतम सक्रिय children (डिफ़ॉल्ट: 5, सीमा 1-20)
        maxConcurrent: 8, // वैश्विक concurrency lane सीमा (डिफ़ॉल्ट: 8)
        runTimeoutSeconds: 900, // sessions_spawn के लिए डिफ़ॉल्ट टाइमआउट (0 = कोई टाइमआउट नहीं)
        announceTimeoutMs: 120000, // प्रति-कॉल Gateway घोषणा टाइमआउट
      },
    },
  },
}
```

### गहराई के स्तर

| गहराई | सत्र कुंजी का स्वरूप                            | भूमिका                                          | spawn कर सकता है?                   |
| ----- | -------------------------------------------- | --------------------------------------------- | ---------------------------- |
| 0     | `agent:<id>:main`                            | मुख्य agent                                    | हमेशा                       |
| 1     | `agent:<id>:subagent:<uuid>`                 | Sub-agent (depth 2 की अनुमति होने पर orchestrator) | केवल यदि `maxSpawnDepth >= 2` |
| 2     | `agent:<id>:subagent:<uuid>:subagent:<uuid>` | Sub-sub-agent (लीफ़ worker)                   | कभी नहीं                        |

### घोषणा शृंखला

परिणाम शृंखला में ऊपर की ओर प्रवाहित होते हैं:

1. Depth-2 worker समाप्त होता है → अपने parent (depth-1 orchestrator) को घोषणा करता है।
2. Depth-1 orchestrator घोषणा प्राप्त करता है, परिणामों का संश्लेषण करता है, समाप्त होता है → मुख्य को घोषणा करता है।
3. मुख्य agent घोषणा प्राप्त करता है और उपयोगकर्ता तक पहुँचाता है।

प्रत्येक स्तर केवल अपने प्रत्यक्ष children की घोषणाएँ देखता है।

<Note>
**परिचालन मार्गदर्शन:** `sessions_list`,
`sessions_history`, `/subagents list` या `exec` sleep कमांड के आसपास
poll loops बनाने के बजाय child कार्य को एक बार शुरू करें और पूर्णता
इवेंट्स की प्रतीक्षा करें।
`sessions_list` और `/subagents list` child-session संबंधों को
सक्रिय कार्य पर केंद्रित रखते हैं — सक्रिय children संलग्न रहते हैं, समाप्त children हाल की एक छोटी
अवधि तक दृश्यमान रहते हैं और केवल स्टोर में मौजूद पुराने child लिंक उनकी
ताज़गी अवधि के बाद अनदेखे कर दिए जाते हैं। यह पुनः आरंभ के बाद पुराने `spawnedBy` /
`parentSessionKey` metadata को काल्पनिक children फिर से सक्रिय करने से रोकता है।
यदि अंतिम उत्तर पहले ही भेजने के बाद child पूर्णता इवेंट आता है,
तो सही अनुवर्ती कार्रवाई सटीक silent token
`NO_REPLY` / `no_reply` है।
</Note>

### गहराई के अनुसार टूल नीति

- spawn किए जाने पर child अनुरोधकर्ता की प्रभावी sender policy को कैप्चर करता है। Senderless child runs और प्रमाणित operator resumes उस snapshot को बनाए रखते हैं, भले ही `toolsBySender` बाद में बदल जाए; वर्तमान वैश्विक, agent, provider, sandbox और sub-agent प्रतिबंध फिर भी लागू होते हैं। इसके बजाय child को लक्षित करने वाला नया external channel turn वर्तमान sender policy को फिर से resolve करता है।
- spawn के समय भूमिका और नियंत्रण का दायरा सत्र metadata में लिखा जाता है। यह flat या restore की गई session keys को गलती से orchestrator विशेषाधिकार दोबारा प्राप्त करने से रोकता है।
- **Depth 1 (orchestrator, जब `maxSpawnDepth >= 2`):** इसे `sessions_spawn`, `subagents`, `sessions_list`, `sessions_history` मिलते हैं, ताकि यह children spawn कर सके और उनकी स्थिति जाँच सके। अन्य session/system tools अस्वीकृत रहते हैं।
- **Depth 1 (लीफ़, जब `maxSpawnDepth == 1`):** कोई session tools नहीं (वर्तमान डिफ़ॉल्ट व्यवहार)।
- **Depth 2 (लीफ़ worker):** कोई session tools नहीं — depth 2 पर `sessions_spawn` हमेशा अस्वीकृत रहता है। आगे children spawn नहीं कर सकता।

### प्रति-agent spawn सीमा

प्रत्येक agent सत्र (किसी भी गहराई पर) में एक समय में अधिकतम `maxChildrenPerAgent`
(डिफ़ॉल्ट `5`) सक्रिय children हो सकते हैं। यह किसी एक orchestrator से
अनियंत्रित fan-out को रोकता है।

### कैस्केड स्टॉप

depth-1 orchestrator को रोकने पर उसके सभी depth-2
children स्वतः रुक जाते हैं:

- मुख्य चैट में `/stop` सभी depth-1 agents को रोकता है और यह रोक उनके depth-2 children तक कैस्केड होती है।

## प्रमाणीकरण

Sub-agent प्रमाणीकरण **agent id** के आधार पर resolve होता है, सत्र प्रकार के आधार पर नहीं:

- Sub-agent सत्र कुंजी `agent:<agentId>:subagent:<uuid>` है।
- प्रमाणीकरण स्टोर उस agent के `agentDir` से लोड किया जाता है।
- मुख्य agent की प्रमाणीकरण प्रोफ़ाइलें **fallback** के रूप में मर्ज की जाती हैं; टकराव होने पर agent प्रोफ़ाइलें मुख्य प्रोफ़ाइलों को ओवरराइड करती हैं।

मर्ज योगात्मक है, इसलिए मुख्य प्रोफ़ाइलें हमेशा
fallback के रूप में उपलब्ध रहती हैं। प्रति-agent पूरी तरह पृथक प्रमाणीकरण अभी समर्थित नहीं है।

## घोषणा

Sub-agents एक घोषणा चरण के माध्यम से रिपोर्ट करते हैं:

- घोषणा चरण sub-agent सत्र के भीतर चलता है (अनुरोधकर्ता सत्र में नहीं)।
- यदि sub-agent ठीक `ANNOUNCE_SKIP` उत्तर देता है, तो कुछ भी पोस्ट नहीं किया जाता।
- यदि नवीनतम assistant टेक्स्ट सटीक silent token `NO_REPLY` / `no_reply` है, तो घोषणा आउटपुट दबा दिया जाता है, भले ही पहले दृश्यमान प्रगति मौजूद रही हो।

डिलीवरी अनुरोधकर्ता की गहराई पर निर्भर करती है:

- शीर्ष-स्तरीय अनुरोधकर्ता सत्र बाहरी डिलीवरी (`deliver=true`) के साथ एक अनुवर्ती `agent` कॉल का उपयोग करते हैं।
- नेस्टेड अनुरोधकर्ता subagent सत्र एक आंतरिक अनुवर्ती इंजेक्शन (`deliver=false`) प्राप्त करते हैं, ताकि orchestrator सत्र के भीतर child परिणामों का संश्लेषण कर सके।
- यदि नेस्टेड अनुरोधकर्ता subagent सत्र समाप्त हो चुका हो, तो उपलब्ध होने पर OpenClaw उस सत्र के अनुरोधकर्ता पर fallback करता है।

शीर्ष-स्तरीय अनुरोधकर्ता सत्रों के लिए, completion-mode प्रत्यक्ष डिलीवरी पहले
किसी भी बाउंड conversation/thread route और hook override को resolve करती है, फिर
अनुरोधकर्ता सत्र के संग्रहीत route से अनुपस्थित channel-target फ़ील्ड भरती है।
इससे completions सही chat/topic पर बनी रहती हैं, भले ही completion
origin केवल channel की पहचान करता हो।

नेस्टेड completion findings बनाते समय child completion aggregation
वर्तमान अनुरोधकर्ता रन तक सीमित रहती है, जिससे पहले के पुराने रन के child
outputs वर्तमान घोषणा में लीक नहीं होते। Channel adapters पर उपलब्ध होने पर
घोषणा उत्तर thread/topic routing को बनाए रखते हैं।

### घोषणा संदर्भ

घोषणा संदर्भ को एक स्थिर आंतरिक इवेंट ब्लॉक में सामान्यीकृत किया जाता है:

| फ़ील्ड          | स्रोत                                                                                                   |
| -------------- | -------------------------------------------------------------------------------------------------------- |
| स्रोत         | `subagent` या `cron`                                                                                     |
| सत्र ids    | Child सत्र कुंजी/id                                                                                     |
| प्रकार           | घोषणा प्रकार + कार्य लेबल                                                                               |
| स्थिति         | runtime परिणाम (`ok`, `error`, `timeout` या `unknown`) से व्युत्पन्न — model टेक्स्ट से अनुमानित **नहीं** |
| परिणाम सामग्री | child का नवीनतम दृश्यमान assistant टेक्स्ट                                                             |
| अनुवर्ती      | कब उत्तर देना है और कब मौन रहना है, इसका वर्णन करने वाला निर्देश                                                      |

अंतिम विफल रन कैप्चर किए गए
उत्तर टेक्स्ट को दोबारा चलाए बिना विफलता स्थिति रिपोर्ट करते हैं। Tool/toolResult आउटपुट को child परिणाम टेक्स्ट में प्रोत्साहित नहीं किया जाता।

### आँकड़े पंक्ति

घोषणा payloads के अंत में एक आँकड़े पंक्ति शामिल होती है (wrap होने पर भी):

- Runtime (उदा. `runtime 5m12s`)।
- Token उपयोग (इनपुट/आउटपुट/कुल)।
- model pricing कॉन्फ़िगर होने पर अनुमानित लागत (`models.providers.*.models[].cost`)।
- `sessionKey`, `sessionId` और ट्रांसक्रिप्ट पथ, ताकि मुख्य agent `sessions_history` के माध्यम से इतिहास प्राप्त कर सके या डिस्क पर फ़ाइल जाँच सके।

आंतरिक metadata केवल orchestration के लिए है; उपयोगकर्ता को दिखाए जाने वाले उत्तरों को
सामान्य assistant शैली में दोबारा लिखा जाना चाहिए।

### `sessions_history` को प्राथमिकता क्यों दें

`sessions_history` किसी agent turn के भीतर से child का
ट्रांसक्रिप्ट पढ़ने के लिए अधिक सुरक्षित orchestration पथ है:

- सामान्य-उद्देश्य लॉग redaction अक्षम होने पर भी credential/token जैसे टेक्स्ट को छिपाता है।
- लंबे टेक्स्ट ब्लॉक को छोटा करता है (प्रति ब्लॉक 4000 वर्ण) और thinking signatures, reasoning replay payloads तथा inline image data हटा देता है।
- 80 KB प्रतिक्रिया सीमा लागू करता है; बहुत बड़ी पंक्तियों को `[sessions_history omitted: message too large]` से बदल दिया जाता है।
- मौजूद होने पर पुराने ट्रांसक्रिप्ट विंडो में पीछे की ओर पेज करने के लिए `nextOffset` का उपयोग करें।
- `sessions_history` message text से reasoning tags, `<relevant-memories>` scaffolding या tool-call XML को **नहीं** हटाता — यह केवल redacted और आकार-सीमित रूप में, कच्चे ट्रांसक्रिप्ट स्वरूप के निकट structured content blocks लौटाता है। `/subagents log` अधिक व्यापक prose sanitizer लागू करता है (reasoning tags, memory scaffolding और tool-call XML हटाता है), क्योंकि यह structured blocks के बजाय साधारण chat lines render करता है।
- जब पूर्ण byte-for-byte ट्रांसक्रिप्ट की आवश्यकता हो, तब डिस्क पर मौजूद कच्चे ट्रांसक्रिप्ट का निरीक्षण fallback है।

## टूल नीति

Sub-agents पहले parent या लक्ष्य agent वाली समान प्रोफ़ाइल और tool-policy
पाइपलाइन का उपयोग करते हैं। उसके बाद OpenClaw sub-agent प्रतिबंध
परत लागू करता है।

Sub-agents गहराई या भूमिका की परवाह किए बिना हमेशा `gateway`, `agents_list`, `session_status` और
`cron` खो देते हैं (सिस्टम-स्तरीय/इंटरैक्टिव tools या
ऐसे tools जिनका समन्वय मुख्य agent को करना चाहिए)। लीफ़ sub-agents (डिफ़ॉल्ट depth-1
व्यवहार और हमेशा depth 2 पर) इसके अतिरिक्त `subagents`,
`sessions_list`, `sessions_history` और `sessions_spawn` खो देते हैं। Sub-agents को कभी
`message` tool नहीं मिलता — इसे spawn के समय अक्षम किया जाता है, इस deny list द्वारा
फ़िल्टर नहीं किया जाता — और `sessions_send` अस्वीकृत ही रहता है, ताकि sub-agents
केवल घोषणा शृंखला के माध्यम से संचार करें।

`sessions_history` यहाँ भी सीमित, sanitized recall दृश्य बना रहता है —
यह कच्चा ट्रांसक्रिप्ट डंप नहीं है।

जब `maxSpawnDepth >= 2`, तब depth-1 orchestrator sub-agents को अतिरिक्त रूप से
`sessions_spawn`, `subagents`, `sessions_list` और
`sessions_history` मिलते हैं, ताकि वे अपने children प्रबंधित कर सकें।

### config के माध्यम से ओवरराइड

```json5
{
  agents: {
    defaults: {
      subagents: {
        maxConcurrent: 1,
      },
    },
  },
  tools: {
    subagents: {
      tools: {
        // निषेध को प्राथमिकता मिलती है
        deny: ["gateway", "cron"],
        // यदि अनुमति सेट है, तो केवल अनुमत टूल उपलब्ध होते हैं (निषेध को फिर भी प्राथमिकता मिलती है)
        // allow: ["read", "exec", "process"]
      },
    },
  },
}
```

`tools.subagents.tools.allow` अंतिम केवल-अनुमति फ़िल्टर है। यह पहले से निर्धारित
टूल सेट को सीमित कर सकता है, लेकिन `tools.profile` द्वारा हटाए गए टूल को
**वापस नहीं जोड़** सकता। उदाहरण के लिए, `tools.profile: "coding"` में
`web_search`/`web_fetch` शामिल हैं, लेकिन `browser` टूल नहीं। कोडिंग-प्रोफ़ाइल
उप-एजेंटों को ब्राउज़र स्वचालन का उपयोग करने देने के लिए, प्रोफ़ाइल
चरण में ब्राउज़र जोड़ें:

```json5
{
  tools: {
    profile: "coding",
    alsoAllow: ["browser"],
  },
}
```

जब केवल एक एजेंट को ब्राउज़र स्वचालन मिलना चाहिए, तब प्रति-एजेंट
`agents.entries.*.tools.alsoAllow: ["browser"]` का उपयोग करें।

## समवर्ती निष्पादन

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

- **लेन का नाम:** `subagent`
- **समवर्ती निष्पादन:** `agents.defaults.subagents.maxConcurrent` (डिफ़ॉल्ट `8`)

## सक्रियता और पुनर्प्राप्ति

OpenClaw, `endedAt` की अनुपस्थिति को इस बात का स्थायी प्रमाण नहीं मानता कि कोई
उप-एजेंट अभी भी सक्रिय है। बासी रन विंडो से पुराने समाप्त न हुए रन
(2 घंटे, या कॉन्फ़िगर किया गया रन टाइमआउट और एक छोटी अतिरिक्त अवधि,
इनमें से जो भी अधिक हो) `/subagents list`,
स्थिति सारांशों, वंशज पूर्णता गेटिंग और प्रति-सत्र
समवर्ती निष्पादन जाँचों में सक्रिय/लंबित के रूप में गिने जाना बंद कर देते हैं।

Gateway पुनः आरंभ होने के बाद, पुनर्स्थापित किए गए बासी और समाप्त न हुए रन हटा दिए जाते हैं, जब तक कि
उनका चाइल्ड सत्र `abortedLastRun: true` के रूप में चिह्नित न हो। पुनः आरंभ के कारण निरस्त हुए
रन उप-एजेंट अनाथ पुनर्प्राप्ति प्रवाह के लिए पंजीकृत रहते हैं: बासी
रन बिना पुनः शुरू किए अंतिम रूप दिए जाते हैं, जबकि नए चाइल्ड सत्रों को
निरस्त मार्कर हटाए जाने से पहले एक कृत्रिम पुनः आरंभ संदेश मिलता है।

स्वचालित पुनः आरंभ पुनर्प्राप्ति प्रत्येक चाइल्ड सत्र के लिए सीमित है। यदि उसी
उप-एजेंट चाइल्ड को तीव्र पुनः-अटकाव विंडो के भीतर बार-बार अनाथ पुनर्प्राप्ति के लिए
स्वीकार किया जाता है, तो OpenClaw उस सत्र पर एक पुनर्प्राप्ति टूम्बस्टोन सहेजता है और
बाद के पुनः आरंभों पर उसे स्वचालित रूप से फिर शुरू करना बंद कर देता है। कार्य रिकॉर्ड का
मिलान करने के लिए `openclaw tasks maintenance --apply` चलाएँ, या टूम्बस्टोन वाले
सत्रों पर बासी निरस्त पुनर्प्राप्ति फ़्लैग साफ़ करने के लिए
`openclaw doctor --fix` चलाएँ।

<Note>
यदि किसी उप-एजेंट का स्पॉन Gateway `PAIRING_REQUIRED` /
`scope-upgrade` के साथ विफल होता है, तो पेयरिंग स्थिति संपादित करने से पहले RPC कॉलर की जाँच करें।
जब कॉलर पहले से ही Gateway अनुरोध संदर्भ के भीतर चल रहा हो, तो आंतरिक
`sessions_spawn` समन्वय इन-प्रोसेस डिस्पैच होता है, इसलिए यह
लूपबैक WebSocket नहीं खोलता और न ही CLI के पेयर्ड-डिवाइस स्कोप
बेसलाइन पर निर्भर करता है। Gateway प्रोसेस के बाहर के कॉलर अब भी सीधे लूपबैक
साझा-टोकन/पासवर्ड प्रमाणीकरण के बजाय `client.id: "gateway-client"` के रूप में
`client.mode: "backend"` के साथ WebSocket फ़ॉलबैक का उपयोग करते हैं।
दूरस्थ कॉलर, स्पष्ट `deviceIdentity`, स्पष्ट डिवाइस-टोकन पथ और ब्राउज़र/Node क्लाइंट
को स्कोप अपग्रेड के लिए अब भी सामान्य डिवाइस अनुमोदन की आवश्यकता होती है।
</Note>

## रोकना

- अनुरोधकर्ता चैट में `/stop` भेजने से अनुरोधकर्ता सत्र निरस्त हो जाता है और उससे स्पॉन हुए सभी सक्रिय उप-एजेंट रन रुक जाते हैं; यह प्रक्रिया नेस्टेड चिल्ड्रन तक क्रमिक रूप से लागू होती है।

## सीमाएँ

- उप-एजेंट घोषणा **सर्वोत्तम-प्रयास** के आधार पर होती है। यदि Gateway पुनः आरंभ होता है, तो लंबित "वापस घोषणा" कार्य खो जाता है।
- उप-एजेंट अब भी उसी Gateway प्रोसेस के संसाधन साझा करते हैं; `maxConcurrent` को सुरक्षा वाल्व मानें।
- `sessions_spawn` हमेशा नॉन-ब्लॉकिंग होता है: यह तुरंत `{ status: "accepted", runId, childSessionKey }` लौटाता है।
- उप-एजेंट संदर्भ केवल `AGENTS.md` और `TOOLS.md` इंजेक्ट करता है (`SOUL.md`, `IDENTITY.md`, `USER.md`, `MEMORY.md`, `HEARTBEAT.md`, या `BOOTSTRAP.md` नहीं)। Codex-नेटिव उप-एजेंट भी इसी सीमा का पालन करते हैं: `TOOLS.md` इनहेरिट किए गए Codex थ्रेड निर्देशों में बना रहता है, जबकि केवल-पैरेंट पर्सोना, पहचान और उपयोगकर्ता फ़ाइलें टर्न-स्कोप्ड सहयोग निर्देशों के रूप में इंजेक्ट की जाती हैं, ताकि चिल्ड्रन उन्हें क्लोन न करें।
- अधिकतम नेस्टिंग गहराई 5 है (`maxSpawnDepth` सीमा: 1-5)। अधिकांश उपयोग स्थितियों के लिए गहराई 2 अनुशंसित है।
- `maxChildrenPerAgent` प्रति सत्र सक्रिय चिल्ड्रन की सीमा निर्धारित करता है (डिफ़ॉल्ट `5`, सीमा `1-20`)।

## संबंधित

- [सत्र टूल और स्थिति परिवर्तन](/hi/concepts/session-tool)
- [ACP एजेंट](/hi/tools/acp-agents)
- [एजेंट प्रेषण](/hi/tools/agent-send)
- [पृष्ठभूमि कार्य](/hi/automation/tasks)
- [बहु-एजेंट सैंडबॉक्स टूल](/hi/tools/multi-agent-sandbox-tools)