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

OpenClaw एक निजी AI assistant है जिसे आप अपने स्वयं के devices पर चलाते हैं। यह उन messaging surfaces पर जवाब देता है जिन्हें आप पहले से उपयोग करते हैं (WhatsApp, Telegram, Slack, Mattermost, Discord, Google Chat, Signal, iMessage, WebChat, और QQ Bot जैसे bundled channel plugins) और समर्थित platforms पर voice + live Canvas भी कर सकता है। Gateway हमेशा चालू रहने वाला control plane है; assistant ही product है।

OpenClaw "सिर्फ़ Claude wrapper" नहीं है। यह एक local-first control plane है जो आपको अपने स्वयं के hardware पर एक सक्षम assistant चलाने देता है, उन chat apps से पहुंच योग्य जिन्हें आप पहले से उपयोग करते हैं, stateful sessions, memory, और tools के साथ - अपने workflows का control किसी hosted SaaS को सौंपे बिना।

मुख्य बातें:

• आपके devices, आपका data: Gateway को जहां चाहें चलाएं (Mac, Linux, VPS) और workspace + session history को स्थानीय रखें।
• वास्तविक channels, web sandbox नहीं: WhatsApp/Telegram/Slack/Discord/Signal/iMessage/etc, साथ ही समर्थित platforms पर mobile voice और Canvas।
• Model-agnostic: Anthropic, OpenAI, MiniMax, OpenRouter, आदि का उपयोग करें, per-agent routing और failover के साथ।
• Local-only विकल्प: local models चलाएं ताकि चाहें तो सारा data आपके device पर रह सके।
• Multi-agent routing: channel, account, या task के अनुसार अलग agents, प्रत्येक का अपना workspace और defaults।
• Open source और hackable: vendor lock-in के बिना inspect, extend, और self-host करें।

Docs: Gateway, Channels, Multi-agent, Memory.

अच्छे first projects:

• एक website बनाएं (WordPress, Shopify, या simple static site)।
• mobile app का prototype बनाएं (outline, screens, API plan)।
• files और folders व्यवस्थित करें (cleanup, naming, tagging)।
• Gmail connect करें और summaries या follow ups automate करें।

यह बड़े tasks संभाल सकता है, लेकिन सबसे अच्छा तब काम करता है जब आप उन्हें phases में बांटते हैं और parallel work के लिए sub agents का उपयोग करते हैं।

रोज़मर्रा की जीत आमतौर पर ऐसी दिखती है:

• Personal briefings: inbox, calendar, और आपकी रुचि की news के summaries।
• Research और drafting: emails या docs के लिए quick research, summaries, और first drafts।
• Reminders और follow ups: Cron या Heartbeat driven nudges और checklists।
• Browser automation: forms भरना, data collect करना, और web tasks दोहराना।
• Cross device coordination: अपने phone से task भेजें, Gateway को server पर चलने दें, और result chat में वापस पाएं।

research, qualification, और drafting के लिए हाँ। यह sites scan कर सकता है, shortlists बना सकता है, prospects summarize कर सकता है, और outreach या ad copy drafts लिख सकता है।

outreach या ad runs के लिए, human को loop में रखें। spam से बचें, local laws और platform policies का पालन करें, और भेजने से पहले हर चीज़ review करें। सबसे सुरक्षित pattern है कि OpenClaw draft करे और आप approve करें।

Docs: Security.

OpenClaw एक personal assistant और coordination layer है, IDE replacement नहीं। repo के अंदर सबसे तेज़ direct coding loop के लिए Claude Code या Codex का उपयोग करें। OpenClaw तब उपयोग करें जब आपको durable memory, cross-device access, और tool orchestration चाहिए।

फायदे:

• sessions के पार Persistent memory + workspace
• Multi-platform access (WhatsApp, Telegram, TUI, WebChat)
• Tool orchestration (browser, files, scheduling, hooks)
• Always-on Gateway (VPS पर चलाएं, कहीं से भी interact करें)
• local browser/screen/camera/exec के लिए Nodes

Showcase: https://openclaw.ai/showcase

repo copy edit करने के बजाय managed overrides का उपयोग करें। अपने changes ~/.openclaw/skills/<name>/SKILL.md में रखें (या ~/.openclaw/openclaw.json में skills.load.extraDirs के जरिए folder जोड़ें)। precedence है <workspace>/skills → <workspace>/.agents/skills → ~/.agents/skills → ~/.openclaw/skills → bundled → skills.load.extraDirs, इसलिए managed overrides git को छुए बिना भी bundled skills पर जीतते हैं। अगर skill globally installed चाहिए लेकिन केवल कुछ agents को visible हो, तो shared copy ~/.openclaw/skills में रखें और visibility को agents.defaults.skills और agents.list[].skills से control करें। केवल upstream-worthy edits repo में रहने चाहिए और PRs के रूप में जाने चाहिए।

हाँ। ~/.openclaw/openclaw.json में skills.load.extraDirs के जरिए extra directories जोड़ें (सबसे कम precedence)। Default precedence है <workspace>/skills → <workspace>/.agents/skills → ~/.agents/skills → ~/.openclaw/skills → bundled → skills.load.extraDirs। clawhub default रूप से ./skills में install करता है, जिसे OpenClaw अगले session में <workspace>/skills मानता है। अगर skill केवल कुछ agents को visible होनी चाहिए, तो इसे agents.defaults.skills या agents.list[].skills के साथ जोड़ें।

आज supported patterns ये हैं:

• Cron jobs: isolated jobs per job एक model override set कर सकते हैं।
• Agents: अलग default models, thinking levels, और stream params वाले अलग agents को tasks route करें।
• On-demand switch: किसी भी समय current session model switch करने के लिए /model का उपयोग करें।

उदाहरण के लिए, अलग per-agent settings के साथ वही model उपयोग करें:

{  agents: {    list: [      {        id: "coder",        model: "xiaomi/mimo-v2.5-pro",        thinkingDefault: "high",        params: { temperature: 0.1 },      },      {        id: "chat",        model: "xiaomi/mimo-v2.5-pro",        thinkingDefault: "off",        params: { temperature: 0.8 },      },    ],  },}

shared per-model defaults को agents.defaults.models["provider/model"].params में रखें, फिर agent-specific overrides को flat agents.list[].params में रखें। उसी model के लिए अलग nested agents.list[].models["provider/model"].params entries define न करें; agents.list[].models per-agent model catalog और runtime overrides के लिए है।

Cron jobs, Multi-Agent Routing, Configuration, और Slash commands देखें।

लंबे या parallel tasks के लिए sub-agents का उपयोग करें। Sub-agents अपने session में चलते हैं, summary return करते हैं, और आपकी main chat responsive रखते हैं।

अपने bot से "spawn a sub-agent for this task" कहें या /subagents का उपयोग करें। Gateway अभी क्या कर रहा है (और क्या यह busy है) देखने के लिए chat में /status उपयोग करें।

Token tip: लंबे tasks और sub-agents दोनों tokens consume करते हैं। अगर cost concern है, तो agents.defaults.subagents.model के जरिए sub-agents के लिए cheaper model set करें।

Docs: Sub-agents, Background Tasks.

thread bindings का उपयोग करें। आप Discord thread को subagent या session target से bind कर सकते हैं ताकि उस thread में follow-up messages उसी bound session पर रहें।

Basic flow:

• sessions_spawn के साथ thread: true उपयोग करके spawn करें (और persistent follow-up के लिए वैकल्पिक रूप से mode: "session")।
• या /focus <target> से manually bind करें।
• binding state inspect करने के लिए /agents उपयोग करें।
• auto-unfocus control करने के लिए /session idle <duration|off> और /session max-age <duration|off> उपयोग करें।
• thread detach करने के लिए /unfocus उपयोग करें।

Required config:

• Global defaults: session.threadBindings.enabled, session.threadBindings.idleHours, session.threadBindings.maxAgeHours.
• Discord overrides: channels.discord.threadBindings.enabled, channels.discord.threadBindings.idleHours, channels.discord.threadBindings.maxAgeHours.
• Auto-bind on spawn: channels.discord.threadBindings.spawnSessions default रूप से true है; thread-bound session spawns disable करने के लिए इसे false set करें।

Docs: Sub-agents, Discord, Configuration Reference, Slash commands.

पहले resolved requester route check करें:

• Completion-mode subagent delivery किसी bound thread या conversation route को prefer करती है जब वह मौजूद हो।
• अगर completion origin केवल channel carry करता है, तो OpenClaw requester session के stored route (lastChannel / lastTo / lastAccountId) पर fallback करता है ताकि direct delivery फिर भी succeed कर सके।
• अगर न bound route मौजूद है और न usable stored route, तो direct delivery fail हो सकती है और result chat में तुरंत post होने के बजाय queued session delivery पर fallback करता है।
• invalid या stale targets अभी भी queue fallback या final delivery failure force कर सकते हैं।
• अगर child का last visible assistant reply exact silent token NO_REPLY / no_reply, या ठीक ANNOUNCE_SKIP है, तो OpenClaw stale earlier progress post करने के बजाय announce को intentionally suppress करता है।
• Tool/toolResult output child result text में promoted नहीं होता; result child का latest visible assistant reply होता है।

Debug:

openclaw tasks show <runId-or-sessionKey>

दस्तावेज़: Sub-agents, Background Tasks, Session Tools.

Cron Gateway प्रक्रिया के अंदर चलता है। यदि Gateway लगातार नहीं चल रहा है, तो शेड्यूल किए गए जॉब नहीं चलेंगे।

चेकलिस्ट:

• पुष्टि करें कि cron सक्षम है (cron.enabled) और OPENCLAW_SKIP_CRON सेट नहीं है।
• जांचें कि Gateway 24/7 चल रहा है (कोई स्लीप/रीस्टार्ट नहीं)।
• जॉब के लिए टाइमज़ोन सेटिंग्स सत्यापित करें (--tz बनाम होस्ट टाइमज़ोन)।

Debug:

openclaw cron run <jobId>openclaw cron runs --id <jobId> --limit 50

दस्तावेज़: Cron jobs, Automation.

पहले डिलीवरी मोड जांचें:

• --no-deliver / delivery.mode: "none" का मतलब है कि कोई रनर fallback send अपेक्षित नहीं है।
• अनुपस्थित या अमान्य announce target (channel / to) का मतलब है कि रनर ने आउटबाउंड डिलीवरी छोड़ दी।
• चैनल auth failures (unauthorized, Forbidden) का मतलब है कि रनर ने डिलीवर करने की कोशिश की लेकिन credentials ने उसे रोक दिया।
• एक silent isolated result (केवल NO_REPLY / no_reply) को जानबूझकर non-deliverable माना जाता है, इसलिए रनर queued fallback delivery को भी दबा देता है।

isolated cron jobs के लिए, एजेंट अब भी message tool के साथ सीधे भेज सकता है जब chat route उपलब्ध हो। --announce केवल उस final text के लिए runner fallback path नियंत्रित करता है जिसे एजेंट ने पहले से नहीं भेजा है।

Debug:

openclaw cron runs --id <jobId> --limit 50openclaw tasks show <runId-or-sessionKey>

दस्तावेज़: Cron jobs, Background Tasks.

यह आमतौर पर live model-switch path होता है, duplicate scheduling नहीं।

Isolated cron एक runtime model handoff को persist कर सकता है और active run द्वारा LiveSessionModelSwitchError फेंकने पर retry कर सकता है। Retry switched provider/model को बनाए रखता है, और यदि switch में नया auth profile override था, तो cron retry करने से पहले उसे भी persist करता है।

संबंधित selection rules:

• लागू होने पर Gmail hook model override पहले जीतता है।
• फिर per-job model.
• फिर कोई stored cron-session model override.
• फिर सामान्य agent/default model selection.

Retry loop bounded है। प्रारंभिक प्रयास और 2 switch retries के बाद, cron हमेशा के लिए loop करने के बजाय abort कर देता है।

Debug:

openclaw cron runs --id <jobId> --limit 50openclaw tasks show <runId-or-sessionKey>

दस्तावेज़: Cron jobs, cron CLI.

native openclaw skills commands का उपयोग करें या skills को अपने workspace में डालें। macOS Skills UI Linux पर उपलब्ध नहीं है। skills ब्राउज़ करें https://clawhub.ai पर।

openclaw skills search "calendar"openclaw skills search --limit 20openclaw skills install @owner/<skill-slug>openclaw skills install @owner/<skill-slug> --version <version>openclaw skills install @owner/<skill-slug> --forceopenclaw skills install @owner/<skill-slug> --globalopenclaw skills update --allopenclaw skills update --all --globalopenclaw skills list --eligibleopenclaw skills check

Native openclaw skills install डिफ़ॉल्ट रूप से active workspace skills/ directory में लिखता है। सभी local agents के लिए shared managed skills directory में install करने के लिए --global जोड़ें। अलग clawhub CLI केवल तभी install करें जब आप अपनी skills publish या sync करना चाहते हों। यदि आप यह सीमित करना चाहते हैं कि कौन से agents shared skills देख सकते हैं, तो agents.defaults.skills या agents.list[].skills का उपयोग करें।

हां। Gateway scheduler का उपयोग करें:

• scheduled या recurring tasks के लिए Cron jobs (restarts के पार persist करते हैं)।
• "main session" periodic checks के लिए Heartbeat।
• summaries post करने या chats में deliver करने वाले autonomous agents के लिए Isolated jobs।

दस्तावेज़: Cron jobs, Automation, Heartbeat.

सीधे नहीं। macOS skills metadata.openclaw.os और required binaries से gated हैं, और skills system prompt में केवल तब दिखाई देती हैं जब वे Gateway host पर eligible हों। Linux पर, darwin-only skills (जैसे apple-notes, apple-reminders, things-mac) तब तक load नहीं होंगी जब तक आप gating override नहीं करते।

आपके पास तीन supported patterns हैं:

Option A - Gateway को Mac पर चलाएं (सबसे सरल)। Gateway को वहां चलाएं जहां macOS binaries मौजूद हैं, फिर Linux से remote mode में या Tailscale पर connect करें। skills सामान्य रूप से load होती हैं क्योंकि Gateway host macOS है।

Option B - macOS node का उपयोग करें (SSH नहीं)। Gateway को Linux पर चलाएं, macOS node (menubar app) pair करें, और Mac पर Node Run Commands को "Always Ask" या "Always Allow" पर set करें। OpenClaw macOS-only skills को eligible मान सकता है जब required binaries node पर मौजूद हों। एजेंट उन skills को nodes tool के जरिए चलाता है। यदि आप "Always Ask" चुनते हैं, तो prompt में "Always Allow" approve करने से वह command allowlist में जुड़ जाती है।

Option C - SSH पर macOS binaries proxy करें (advanced)। Gateway को Linux पर रखें, लेकिन required CLI binaries को ऐसे SSH wrappers में resolve कराएं जो Mac पर चलते हों। फिर skill को Linux allow करने के लिए override करें ताकि वह eligible बनी रहे।

1. binary के लिए SSH wrapper बनाएं (उदाहरण: Apple Notes के लिए memo):

   #!/usr/bin/env bashset -euo pipefailexec ssh -T user@mac-host /opt/homebrew/bin/memo "$@"

2. Linux host पर wrapper को PATH पर रखें (उदाहरण के लिए ~/bin/memo)।

3. Linux allow करने के लिए skill metadata (workspace या ~/.openclaw/skills) override करें:

   ---name: apple-notesdescription: Manage Apple Notes via the memo CLI on macOS.metadata: { "openclaw": { "os": ["darwin", "linux"], "requires": { "bins": ["memo"] } } }---

4. नया session शुरू करें ताकि skills snapshot refresh हो जाए।

आज built-in नहीं है।

विकल्प:

• Custom skill / Plugin: reliable API access के लिए सबसे अच्छा (Notion/HeyGen दोनों के पास APIs हैं)।
• Browser automation: code के बिना काम करता है लेकिन धीमा और अधिक fragile है।

यदि आप प्रति client context रखना चाहते हैं (agency workflows), तो एक simple pattern है:

• प्रति client एक Notion page (context + preferences + active work)।
• session की शुरुआत में agent से वह page fetch करने को कहें।

यदि आप native integration चाहते हैं, तो feature request खोलें या उन APIs को target करने वाली skill बनाएं।

Skills install करें:

openclaw skills install @owner/<skill-slug>openclaw skills update --all

Native installs active workspace skills/ directory में land होते हैं। सभी local agents में shared skills के लिए, openclaw skills install @owner/<skill-slug> --global का उपयोग करें (या उन्हें manually ~/.openclaw/skills/<name>/SKILL.md में रखें)। यदि केवल कुछ agents को shared install दिखना चाहिए, तो agents.defaults.skills या agents.list[].skills configure करें। कुछ skills Homebrew के जरिए installed binaries expect करती हैं; Linux पर इसका मतलब Linuxbrew है (ऊपर Homebrew Linux FAQ entry देखें)। Skills, Skills config, और ClawHub देखें।

built-in user browser profile का उपयोग करें, जो Chrome DevTools MCP के जरिए attach होता है:

openclaw browser --browser-profile user tabsopenclaw browser --browser-profile user snapshot

यदि आप custom name चाहते हैं, तो explicit MCP profile बनाएं:

openclaw browser create-profile --name chrome-live --driver existing-sessionopenclaw browser --browser-profile chrome-live tabs

यह path local host browser या connected browser node का उपयोग कर सकता है। यदि Gateway कहीं और चलता है, तो या तो browser machine पर node host चलाएं या remote CDP का उपयोग करें।

existing-session / user पर मौजूदा limits:

• actions ref-driven हैं, CSS-selector driven नहीं
• uploads को ref / inputRef चाहिए और फिलहाल एक बार में एक file support करते हैं
• responsebody, PDF export, download interception, और batch actions को अब भी managed browser या raw CDP profile चाहिए

हां। Sandboxing देखें। Docker-specific setup (Docker में full gateway या sandbox images) के लिए, Docker देखें।

default image security-first है और node user के रूप में चलती है, इसलिए इसमें system packages, Homebrew, या bundled browsers शामिल नहीं होते। अधिक fuller setup के लिए:

• /home/node को OPENCLAW_HOME_VOLUME के साथ persist करें ताकि caches बचे रहें।
• OPENCLAW_IMAGE_APT_PACKAGES के साथ system deps image में bake करें।
• bundled CLI के जरिए Playwright browsers install करें: node /app/node_modules/playwright-core/cli.js install chromium
• PLAYWRIGHT_BROWSERS_PATH set करें और सुनिश्चित करें कि path persisted है।

दस्तावेज़: Docker, Browser.

हां - यदि आपका private traffic DMs है और आपका public traffic groups है।

agents.defaults.sandbox.mode: "non-main" का उपयोग करें ताकि group/channel sessions (non-main keys) configured sandbox backend में चलें, जबकि main DM session on-host रहे। यदि आप कोई backend नहीं चुनते हैं तो Docker default backend है। फिर sandboxed sessions में उपलब्ध tools को tools.sandbox.tools के जरिए restrict करें।

Setup walkthrough + example config: Groups: personal DMs + public groups

मुख्य config reference: Gateway configuration

agents.defaults.sandbox.docker.binds को ["host:path:mode"] पर set करें (उदाहरण, "/home/user/src:/src:ro")। Global + per-agent binds merge होते हैं; scope: "shared" होने पर per-agent binds ignored होते हैं। किसी भी sensitive चीज़ के लिए :ro का उपयोग करें और याद रखें कि binds sandbox filesystem walls को bypass करते हैं।

OpenClaw bind sources को normalized path और deepest existing ancestor के जरिए resolved canonical path, दोनों के विरुद्ध validate करता है। इसका मतलब है कि symlink-parent escapes तब भी fail closed होते हैं जब last path segment अभी मौजूद नहीं है, और allowed-root checks symlink resolution के बाद भी apply होते हैं।

उदाहरणों और safety notes के लिए Sandboxing और Sandbox vs Tool Policy vs Elevated देखें।

OpenClaw memory agent workspace में केवल Markdown files है:

• Daily notes memory/YYYY-MM-DD.md में
• Curated long-term notes MEMORY.md में (केवल main/private sessions)

OpenClaw auto-compaction से पहले durable notes लिखने के लिए model को याद दिलाने हेतु silent pre-compaction memory flush भी चलाता है। यह केवल तब चलता है जब workspace writable हो (read-only sandboxes इसे skip करते हैं)। Memory देखें।

बॉट से तथ्य को मेमोरी में लिखने के लिए कहें। दीर्घकालिक नोट्स MEMORY.md में होने चाहिए, अल्पकालिक संदर्भ memory/YYYY-MM-DD.md में जाता है।

यह अभी भी ऐसा क्षेत्र है जिसे हम बेहतर बना रहे हैं। मॉडल को यादें संग्रहीत करने की याद दिलाने से मदद मिलती है; उसे पता होगा कि क्या करना है। यदि वह भूलता रहता है, तो सत्यापित करें कि Gateway हर रन में वही कार्यक्षेत्र उपयोग कर रहा है।

दस्तावेज़: मेमोरी, एजेंट कार्यक्षेत्र.

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

दस्तावेज़: मेमोरी, संदर्भ.

केवल तभी जब आप OpenAI embeddings उपयोग करते हैं। Codex OAuth चैट/कम्प्लीशंस को कवर करता है और embeddings access नहीं देता, इसलिए Codex से साइन इन करना (OAuth या Codex CLI login) semantic मेमोरी खोज में मदद नहीं करता। OpenAI embeddings को अब भी वास्तविक API key (OPENAI_API_KEY या models.providers.openai.apiKey) चाहिए।

यदि आप कोई provider स्पष्ट रूप से सेट नहीं करते, तो OpenClaw OpenAI embeddings उपयोग करता है। पुराने configs जिनमें अब भी memorySearch.provider = "auto" है, वे भी OpenAI पर resolve होते हैं। यदि कोई OpenAI API key उपलब्ध नहीं है, तो semantic मेमोरी खोज तब तक अनुपलब्ध रहती है जब तक आप key configure नहीं करते या कोई दूसरा provider स्पष्ट रूप से नहीं चुनते।

यदि आप local ही रहना चाहते हैं, तो memorySearch.provider = "local" सेट करें (और वैकल्पिक रूप से memorySearch.fallback = "none"). यदि आप Gemini embeddings चाहते हैं, तो memorySearch.provider = "gemini" सेट करें और GEMINI_API_KEY (या memorySearch.remote.apiKey) दें। हम OpenAI, OpenAI-compatible, Gemini, Voyage, Mistral, Bedrock, Ollama, LM Studio, GitHub Copilot, DeepInfra, या local embedding models का समर्थन करते हैं - setup details के लिए मेमोरी देखें।

नहीं - OpenClaw की state local है, लेकिन external services अब भी वह देखती हैं जो आप उन्हें भेजते हैं।

• Default रूप से local: sessions, memory files, config, और workspace Gateway host पर रहते हैं (~/.openclaw + आपकी workspace directory).
• आवश्यकता के कारण remote: model providers (Anthropic/OpenAI/etc.) को भेजे गए messages उनकी APIs पर जाते हैं, और chat platforms (WhatsApp/Telegram/Slack/etc.) message data अपने servers पर store करते हैं।
• Footprint आपके नियंत्रण में है: local models उपयोग करने से prompts आपकी machine पर रहते हैं, लेकिन channel traffic अब भी channel के servers से होकर जाता है।

संबंधित: एजेंट कार्यक्षेत्र, मेमोरी.

सब कुछ $OPENCLAW_STATE_DIR के अंतर्गत रहता है (default: ~/.openclaw):

Legacy single-agent path: ~/.openclaw/agent/* (openclaw doctor द्वारा migrate किया गया).

आपका workspace (AGENTS.md, memory files, skills, आदि) अलग है और agents.defaults.workspace के ज़रिए configure होता है (default: ~/.openclaw/workspace).

ये files agent workspace में रहती हैं, ~/.openclaw में नहीं।

• Workspace (प्रति एजेंट): AGENTS.md, SOUL.md, IDENTITY.md, USER.md, MEMORY.md, memory/YYYY-MM-DD.md, वैकल्पिक HEARTBEAT.md. Lowercase root memory.md केवल legacy repair input है; openclaw doctor --fix दोनों files मौजूद होने पर इसे MEMORY.md में merge कर सकता है।
• State dir (~/.openclaw): config, channel/provider state, auth profiles, sessions, logs, और shared skills (~/.openclaw/skills).

Default workspace ~/.openclaw/workspace है, जिसे इसके ज़रिए configure किया जा सकता है:

{  agents: { defaults: { workspace: "~/.openclaw/workspace" } },}

यदि restart के बाद बॉट "भूल" जाता है, तो पुष्टि करें कि Gateway हर launch पर वही workspace उपयोग कर रहा है (और याद रखें: remote mode gateway host का workspace उपयोग करता है, आपके local laptop का नहीं).

सुझाव: यदि आप कोई टिकाऊ behavior या preference चाहते हैं, तो chat history पर निर्भर रहने के बजाय बॉट से उसे AGENTS.md या MEMORY.md में लिखने के लिए कहें।

एजेंट कार्यक्षेत्र और मेमोरी देखें।

हां। SOUL.md उन workspace bootstrap files में से एक है जिन्हें agent context में inject किया जाता है। Default प्रति-file injection limit 20000 characters है, और files में कुल bootstrap budget 60000 characters है।

अपने OpenClaw config में shared defaults बदलें:

{  agents: {    defaults: {      bootstrapMaxChars: 50000,      bootstrapTotalMaxChars: 300000,    },  },}

या एक agent को override करें:

{  agents: {    list: [      {        id: "main",        bootstrapMaxChars: 50000,        bootstrapTotalMaxChars: 300000,      },    ],  },}

Raw बनाम injected sizes और truncation हुआ या नहीं जांचने के लिए /context उपयोग करें। SOUL.md को voice, stance, और personality पर focused रखें; operating rules AGENTS.md में और टिकाऊ facts memory में रखें।

संदर्भ और एजेंट config देखें।

अपने agent workspace को private git repo में रखें और उसे किसी private जगह backup करें (उदाहरण के लिए GitHub private). इससे memory + AGENTS/SOUL/USER files capture होती हैं, और बाद में assistant का "mind" restore किया जा सकता है।

~/.openclaw के अंतर्गत कुछ भी commit न करें (credentials, sessions, tokens, या encrypted secrets payloads). यदि आपको full restore चाहिए, तो workspace और state directory दोनों को अलग-अलग backup करें (ऊपर migration question देखें).

दस्तावेज़: एजेंट कार्यक्षेत्र.

समर्पित guide देखें: Uninstall.

हां। Workspace default cwd और memory anchor है, कोई hard sandbox नहीं। Relative paths workspace के अंदर resolve होते हैं, लेकिन absolute paths अन्य host locations तक पहुंच सकते हैं, जब तक sandboxing enabled न हो। यदि आपको isolation चाहिए, तो agents.defaults.sandbox या प्रति-agent sandbox settings उपयोग करें। यदि आप किसी repo को default working directory बनाना चाहते हैं, तो उस agent के workspace को repo root पर point करें। OpenClaw repo केवल source code है; workspace को अलग रखें, जब तक आप जानबूझकर agent को उसके अंदर काम कराना नहीं चाहते।

उदाहरण (repo को default cwd के रूप में):

{  agents: {    defaults: {      workspace: "~/Projects/my-repo",    },  },}

Session state gateway host के स्वामित्व में है। यदि आप remote mode में हैं, तो जिस session store की आपको परवाह है वह remote machine पर है, आपके local laptop पर नहीं। Session management देखें।

OpenClaw $OPENCLAW_CONFIG_PATH से वैकल्पिक JSON5 config पढ़ता है (default: ~/.openclaw/openclaw.json):

$OPENCLAW_CONFIG_PATH

यदि file मौजूद नहीं है, तो यह safe-ish defaults उपयोग करता है (जिसमें ~/.openclaw/workspace का default workspace शामिल है).

Non-loopback binds के लिए valid gateway auth path आवश्यक है। व्यवहार में इसका अर्थ है:

• shared-secret auth: token या password
• सही तरह configured identity-aware reverse proxy के पीछे gateway.auth.mode: "trusted-proxy"

{  gateway: {    bind: "lan",    auth: {      mode: "token",      token: "replace-me",    },  },}

नोट्स:

• gateway.remote.token / .password अपने आप local gateway auth enable नहीं करते।
• Local call paths gateway.auth.* unset होने पर ही fallback के रूप में gateway.remote.* उपयोग कर सकते हैं।
• Password auth के लिए, इसके बजाय gateway.auth.mode: "password" के साथ gateway.auth.password (या OPENCLAW_GATEWAY_PASSWORD) सेट करें।
• यदि gateway.auth.token / gateway.auth.password SecretRef के ज़रिए स्पष्ट रूप से configure है और unresolved है, तो resolution fails closed होता है (कोई remote fallback masking नहीं).
• Shared-secret Control UI setups connect.params.auth.token या connect.params.auth.password (app/UI settings में stored) के ज़रिए authenticate करते हैं। Tailscale Serve या trusted-proxy जैसे identity-bearing modes इसके बजाय request headers उपयोग करते हैं। Shared secrets को URLs में डालने से बचें।
• gateway.auth.mode: "trusted-proxy" के साथ, same-host loopback reverse proxies को explicit gateway.auth.trustedProxy.allowLoopback = true और gateway.trustedProxies में loopback entry चाहिए।

OpenClaw default रूप से gateway auth enforce करता है, जिसमें loopback भी शामिल है। सामान्य default path में इसका अर्थ token auth है: यदि कोई explicit auth path configured नहीं है, तो gateway startup token mode पर resolve होता है और उस startup के लिए runtime-only token generate करता है, इसलिए local WS clients को authenticate करना होगा। जब clients को restarts के बीच stable secret चाहिए, तो gateway.auth.token, gateway.auth.password, OPENCLAW_GATEWAY_TOKEN, या OPENCLAW_GATEWAY_PASSWORD स्पष्ट रूप से configure करें। यह अन्य local processes को Gateway call करने से रोकता है।

यदि आप कोई अलग auth पथ पसंद करते हैं, तो आप स्पष्ट रूप से password mode (या, identity-aware reverse proxies के लिए, trusted-proxy) चुन सकते हैं। यदि आप वास्तव में खुला loopback चाहते हैं, तो अपनी config में gateway.auth.mode: "none" स्पष्ट रूप से सेट करें। Doctor आपके लिए किसी भी समय token जनरेट कर सकता है: openclaw doctor --generate-gateway-token.

Gateway config को watch करता है और hot-reload का समर्थन करता है:

• gateway.reload.mode: "hybrid" (default): सुरक्षित बदलावों को hot-apply करें, critical बदलावों के लिए restart करें
• hot, restart, off भी समर्थित हैं

config में cli.banner.taglineMode सेट करें:

{  cli: {    banner: {      taglineMode: "off", // random | default | off    },  },}

• off: tagline text छिपाता है लेकिन banner title/version line रखता है।
• default: हर बार All your chats, one OpenClaw. का उपयोग करता है।
• random: बदलती हुई मज़ेदार/seasonal taglines (default behavior)।
• यदि आप कोई banner बिल्कुल नहीं चाहते, तो env OPENCLAW_HIDE_BANNER=1 सेट करें।

web_fetch API key के बिना काम करता है। web_search आपके चुने हुए provider पर निर्भर करता है:

• Brave, Exa, Firecrawl, Gemini, Kimi, MiniMax Search, Perplexity, और Tavily जैसे API-backed providers को उनके सामान्य API key setup की आवश्यकता होती है।
• Grok model auth से xAI OAuth का पुनः उपयोग कर सकता है, या XAI_API_KEY / plugin web-search config पर वापस जा सकता है।
• Ollama Web Search key-free है, लेकिन यह आपके configured Ollama host का उपयोग करता है और ollama signin की आवश्यकता होती है।
• DuckDuckGo key-free है, लेकिन यह एक अनौपचारिक HTML-based integration है।
• SearXNG key-free/self-hosted है; SEARXNG_BASE_URL या plugins.entries.searxng.config.webSearch.baseUrl configure करें।

अनुशंसित: openclaw configure --section web चलाएँ और एक provider चुनें। Environment alternatives:

• Brave: BRAVE_API_KEY
• Exa: EXA_API_KEY
• Firecrawl: FIRECRAWL_API_KEY
• Gemini: GEMINI_API_KEY
• Grok: xAI OAuth, XAI_API_KEY
• Kimi: KIMI_API_KEY या MOONSHOT_API_KEY
• MiniMax Search: MINIMAX_CODE_PLAN_KEY, MINIMAX_CODING_API_KEY, या MINIMAX_API_KEY
• Perplexity: PERPLEXITY_API_KEY या OPENROUTER_API_KEY
• SearXNG: SEARXNG_BASE_URL
• Tavily: TAVILY_API_KEY

{  plugins: {    entries: {      brave: {        config: {          webSearch: {            apiKey: "BRAVE_API_KEY_HERE",          },        },      },    },    },    tools: {      web: {        search: {          enabled: true,          provider: "brave",          maxResults: 5,        },        fetch: {          enabled: true,          provider: "firecrawl", // optional; omit for auto-detect        },      },    },}

Provider-specific web-search config अब plugins.entries.<plugin>.config.webSearch.* के अंतर्गत रहता है। Legacy tools.web.search.* provider paths compatibility के लिए अभी भी अस्थायी रूप से load होते हैं, लेकिन नई configs के लिए उनका उपयोग नहीं किया जाना चाहिए। Firecrawl web-fetch fallback config plugins.entries.firecrawl.config.webFetch.* के अंतर्गत रहता है।

नोट्स:

• यदि आप allowlists का उपयोग करते हैं, तो web_search/web_fetch/x_search या group:web जोड़ें।
• web_fetch default रूप से enabled है (जब तक स्पष्ट रूप से disabled न हो)।
• यदि tools.web.fetch.provider छोड़ा गया है, तो OpenClaw उपलब्ध credentials से पहले ready fetch fallback provider को auto-detect करता है। आधिकारिक Firecrawl plugin वह fallback देता है।
• Daemons env vars को ~/.openclaw/.env (या service environment) से पढ़ते हैं।

दस्तावेज़: Web tools.

config.apply पूरी config को replace करता है। यदि आप partial object भेजते हैं, तो बाकी सब कुछ हटा दिया जाता है।

वर्तमान OpenClaw कई accidental clobbers से बचाता है:

• OpenClaw-owned config writes लिखने से पहले पूरी post-change config को validate करते हैं।
• Invalid या destructive OpenClaw-owned writes reject कर दिए जाते हैं और openclaw.json.rejected.* के रूप में save किए जाते हैं।
• यदि कोई direct edit startup या hot reload तोड़ देता है, तो Gateway fail closed करता है या reload skip करता है; यह openclaw.json को rewrite नहीं करता।
• openclaw doctor --fix repair का owner है और rejected file को openclaw.json.clobbered.* के रूप में save करते हुए last-known-good restore कर सकता है।

Recover करें:

• Invalid config at, Config write rejected:, या config reload skipped (invalid config) के लिए openclaw logs --follow देखें।
• active config के पास नवीनतम openclaw.json.clobbered.* या openclaw.json.rejected.* inspect करें।
• openclaw config validate और openclaw doctor --fix चलाएँ।
• केवल intended keys को openclaw config set या config.patch के साथ वापस copy करें।
• यदि आपके पास कोई last-known-good या rejected payload नहीं है, तो backup से restore करें, या openclaw doctor फिर से चलाएँ और channels/models फिर से configure करें।
• यदि यह unexpected था, तो bug file करें और अपनी last known config या कोई backup शामिल करें।
• एक local coding agent अक्सर logs या history से working config reconstruct कर सकता है।

इससे बचें:

• छोटे बदलावों के लिए openclaw config set का उपयोग करें।
• interactive edits के लिए openclaw configure का उपयोग करें।
• जब आप exact path या field shape के बारे में निश्चित न हों, तो पहले config.schema.lookup का उपयोग करें; यह drill-down के लिए shallow schema node और immediate child summaries लौटाता है।
• partial RPC edits के लिए config.patch का उपयोग करें; config.apply को केवल full-config replacement के लिए रखें।
• यदि आप agent run से agent-facing gateway tool का उपयोग कर रहे हैं, तो यह अभी भी tools.exec.ask / tools.exec.security (legacy tools.bash.* aliases सहित, जो उसी protected exec paths में normalize होते हैं) पर writes reject करेगा।

दस्तावेज़: Config, Configure, Gateway troubleshooting, Doctor.

सामान्य pattern एक Gateway (जैसे Raspberry Pi) और nodes तथा agents है:

• Gateway (central): channels (Signal/WhatsApp), routing, और sessions का owner होता है।
• Nodes (devices): Macs/iOS/Android peripherals के रूप में connect होते हैं और local tools (system.run, canvas, camera) expose करते हैं।
• Agents (workers): special roles (जैसे "Hetzner ops", "Personal data") के लिए अलग brains/workspaces।
• Sub-agents: जब आप parallelism चाहते हैं, तो main agent से background work spawn करें।
• TUI: Gateway से connect करें और agents/sessions switch करें।

दस्तावेज़: Nodes, Remote access, Multi-Agent Routing, Sub-agents, TUI.

हाँ। यह एक config option है:

{  browser: { headless: true },  agents: {    defaults: {      sandbox: { browser: { headless: true } },    },  },}

Default false (headful) है। Headless कुछ sites पर anti-bot checks trigger करने की अधिक संभावना रखता है। Browser देखें।

Headless उसी Chromium engine का उपयोग करता है और अधिकांश automation (forms, clicks, scraping, logins) के लिए काम करता है। मुख्य अंतर:

• कोई visible browser window नहीं (यदि आपको visuals चाहिए, तो screenshots का उपयोग करें)।
• कुछ sites headless mode में automation के बारे में अधिक strict होती हैं (CAPTCHAs, anti-bot)। उदाहरण के लिए, X/Twitter अक्सर headless sessions block करता है।

browser.executablePath को अपने Brave binary (या किसी भी Chromium-based browser) पर सेट करें और Gateway restart करें। पूरे config examples Browser में देखें।

Telegram messages को gateway handle करता है। gateway agent चलाता है और केवल तब Gateway WebSocket पर nodes को call करता है जब node tool की आवश्यकता होती है:

Telegram → Gateway → Agent → node.* → Node → Gateway → Telegram

Nodes inbound provider traffic नहीं देखते; उन्हें केवल node RPC calls मिलते हैं।

संक्षिप्त उत्तर: अपने computer को node के रूप में pair करें। Gateway कहीं और चलता है, लेकिन यह Gateway WebSocket पर आपकी local machine पर node.* tools (screen, camera, system) call कर सकता है।

सामान्य setup:

1. Gateway को always-on host (VPS/home server) पर चलाएँ।

2. Gateway host + अपने computer को उसी tailnet पर रखें।

3. सुनिश्चित करें कि Gateway WS reachable है (tailnet bind या SSH tunnel)।

4. macOS app को locally खोलें और Remote over SSH mode (या direct tailnet) में connect करें ताकि यह node के रूप में register हो सके।

5. Gateway पर node approve करें:

   openclaw devices listopenclaw devices approve <requestId>

अलग TCP bridge की आवश्यकता नहीं है; nodes Gateway WebSocket पर connect होते हैं।

Security reminder: macOS node pair करने से उस machine पर system.run की अनुमति मिलती है। केवल trusted devices pair करें, और Security review करें।

दस्तावेज़: Nodes, Gateway protocol, macOS remote mode, Security.

basics जांचें:

• Gateway चल रहा है: openclaw gateway status
• Gateway health: openclaw status
• Channel health: openclaw channels status

फिर auth और routing verify करें:

• यदि आप Tailscale Serve का उपयोग करते हैं, तो सुनिश्चित करें कि gateway.auth.allowTailscale सही ढंग से set है।
• यदि आप SSH tunnel के माध्यम से connect करते हैं, तो confirm करें कि local tunnel up है और सही port की ओर point करता है।
• Confirm करें कि आपकी allowlists (DM या group) में आपका account शामिल है।

दस्तावेज़: Tailscale, Remote access, Channels.

हाँ। कोई built-in "bot-to-bot" bridge नहीं है, लेकिन आप इसे कुछ reliable तरीकों से wire up कर सकते हैं:

सबसे सरल: एक normal chat channel का उपयोग करें जिसे दोनों bots access कर सकते हैं (Telegram/Slack/WhatsApp)। Bot A से Bot B को message भेजें, फिर Bot B को सामान्य रूप से reply करने दें।

CLI bridge (generic): एक script चलाएँ जो दूसरे Gateway को openclaw agent --message ... --deliver के साथ call करे, ऐसे chat को target करते हुए जहाँ दूसरा bot सुनता है। यदि एक bot remote VPS पर है, तो अपनी CLI को SSH/Tailscale के माध्यम से उस remote Gateway की ओर point करें (Remote access देखें)।

Example pattern (ऐसी machine से चलाएँ जो target Gateway तक पहुँच सकती हो):

openclaw agent --message "Hello from local bot" --deliver --channel telegram --reply-to <chat-id>

Tip: guardrail जोड़ें ताकि दोनों bots endless loop न करें (mention-only, channel allowlists, या "bot messages का reply न करें" rule)।

दस्तावेज़: Remote access, Agent CLI, Agent send.

नहीं। एक Gateway multiple agents host कर सकता है, प्रत्येक अपने workspace, model defaults, और routing के साथ। यह normal setup है और प्रति agent एक VPS चलाने की तुलना में बहुत सस्ता और सरल है।

अलग VPSes केवल तब उपयोग करें जब आपको hard isolation (security boundaries) या बहुत अलग configs चाहिए जिन्हें आप share नहीं करना चाहते। अन्यथा, एक Gateway रखें और multiple agents या sub-agents का उपयोग करें।

हाँ - दूरस्थ Gateway से आपके लैपटॉप तक पहुँचने का प्रथम-श्रेणी तरीका Nodes हैं, और वे shell पहुँच से अधिक सुविधाएँ खोलते हैं। Gateway macOS/Linux पर चलता है (Windows via WSL2) और हल्का है (एक छोटा VPS या Raspberry Pi-स्तर का बॉक्स ठीक है; 4 GB RAM पर्याप्त है), इसलिए एक सामान्य सेटअप हमेशा चालू रहने वाला host और आपका लैपटॉप Node के रूप में होता है।

• इनबाउंड SSH आवश्यक नहीं। Nodes Gateway WebSocket से बाहर की ओर कनेक्ट होते हैं और device pairing का उपयोग करते हैं।
• अधिक सुरक्षित execution controls। system.run उस लैपटॉप पर Node allowlists/approvals द्वारा gate किया जाता है।
• अधिक device tools। Nodes system.run के अलावा canvas, camera, और screen expose करते हैं।
• स्थानीय browser automation। Gateway को VPS पर रखें, लेकिन लैपटॉप पर Node host के जरिए Chrome locally चलाएँ, या Chrome MCP के जरिए host पर local Chrome से attach करें।

ad-hoc shell access के लिए SSH ठीक है, लेकिन लगातार agent workflows और device automation के लिए Nodes सरल हैं।

दस्तावेज़: Nodes, Nodes CLI, ब्राउज़र.

नहीं। जब तक आप जानबूझकर isolated profiles नहीं चलाते (देखें कई gateways), प्रति host केवल एक gateway चलना चाहिए। Nodes peripherals हैं जो gateway से connect होते हैं (iOS/Android Nodes, या menubar app में macOS "node mode")। headless Node hosts और CLI control के लिए, देखें Node host CLI.

gateway, discovery, और hosted Plugin surface बदलावों के लिए full restart आवश्यक है।

हाँ।

• config.schema.lookup: लिखने से पहले एक config subtree को उसके shallow schema node, matched UI hint, और immediate child summaries के साथ inspect करें
• config.get: current snapshot + hash fetch करें
• config.patch: सुरक्षित partial update (अधिकांश RPC edits के लिए preferred); संभव होने पर hot-reload करता है और आवश्यक होने पर restart करता है
• config.apply: full config validate + replace करें; संभव होने पर hot-reload करता है और आवश्यक होने पर restart करता है
• agent-facing gateway runtime tool अभी भी tools.exec.ask / tools.exec.security को rewrite करने से इनकार करता है; legacy tools.bash.* aliases उसी protected exec paths में normalize होते हैं

{  agents: { defaults: { workspace: "~/.openclaw/workspace" } },  channels: { whatsapp: { allowFrom: ["+15555550123"] } },}

यह आपका workspace set करता है और restrict करता है कि bot को कौन trigger कर सकता है।

न्यूनतम चरण:

1. VPS पर install + login करें

   curl -fsSL https://tailscale.com/install.sh | shsudo tailscale up

2. अपने Mac पर install + login करें

   • Tailscale app का उपयोग करें और उसी tailnet में sign in करें।

3. MagicDNS enable करें (recommended)

   • Tailscale admin console में MagicDNS enable करें ताकि VPS का stable name हो।

4. tailnet hostname का उपयोग करें

   • SSH: ssh user@your-vps.tailnet-xxxx.ts.net
   • Gateway WS: ws://your-vps.tailnet-xxxx.ts.net:18789

यदि आप SSH के बिना Control UI चाहते हैं, तो VPS पर Tailscale Serve का उपयोग करें:

openclaw gateway --tailscale serve

यह gateway को loopback से bound रखता है और Tailscale के जरिए HTTPS expose करता है। देखें Tailscale.

Serve Gateway Control UI + WS expose करता है। Nodes उसी Gateway WS endpoint पर connect होते हैं।

recommended setup:

1. सुनिश्चित करें कि VPS + Mac एक ही tailnet पर हैं।

2. macOS app को Remote mode में उपयोग करें (SSH target tailnet hostname हो सकता है)। app Gateway port को tunnel करेगा और Node के रूप में connect होगा।

3. gateway पर Node approve करें:

   openclaw devices listopenclaw devices approve <requestId>

दस्तावेज़: Gateway protocol, Discovery, macOS remote mode.

यदि आपको दूसरे लैपटॉप पर केवल local tools (screen/camera/exec) चाहिए, तो उसे Node के रूप में जोड़ें। इससे एक ही Gateway रहता है और duplicated config से बचता है। Local Node tools currently केवल macOS के लिए हैं, लेकिन हम इन्हें अन्य OSes तक extend करने की योजना रखते हैं।

दूसरा Gateway केवल तब install करें जब आपको hard isolation या दो पूरी तरह अलग bots चाहिए हों।

दस्तावेज़: Nodes, Nodes CLI, कई gateways.

OpenClaw parent process (shell, launchd/systemd, CI, आदि) से env vars पढ़ता है और अतिरिक्त रूप से load करता है:

• current working directory से .env
• ~/.openclaw/.env से global fallback .env (अर्थात $OPENCLAW_STATE_DIR/.env)

कोई भी .env file existing env vars override नहीं करती। Provider credential variables workspace .env के लिए exception हैं: जैसे keys GEMINI_API_KEY, XAI_API_KEY, या MISTRAL_API_KEY workspace .env से ignore की जाती हैं और process environment, ~/.openclaw/.env, या config env में रहनी चाहिए।

आप config में inline env vars भी define कर सकते हैं (केवल process env में missing होने पर applied):

{  env: {    OPENROUTER_API_KEY: "sk-or-...",    vars: { GROQ_API_KEY: "gsk-..." },  },}

full precedence और sources के लिए देखें /environment.

दो common fixes:

1. missing keys को ~/.openclaw/.env में रखें ताकि service द्वारा आपका shell env inherit न करने पर भी वे picked up हों।
2. shell import enable करें (opt-in convenience):

{  env: {    shellEnv: {      enabled: true,      timeoutMs: 15000,    },  },}

यह आपका login shell चलाता है और केवल missing expected keys import करता है (कभी override नहीं करता)। Env var equivalents: OPENCLAW_LOAD_SHELL_ENV=1, OPENCLAW_SHELL_ENV_TIMEOUT_MS=15000.

openclaw models status report करता है कि shell env import enabled है या नहीं। "Shell env: off" का अर्थ यह नहीं है कि आपके env vars missing हैं - इसका बस अर्थ है कि OpenClaw आपका login shell automatically load नहीं करेगा।

यदि Gateway service (launchd/systemd) के रूप में चलता है, तो यह आपका shell environment inherit नहीं करेगा। इनमें से एक करके fix करें:

1. token को ~/.openclaw/.env में रखें:

   COPILOT_GITHUB_TOKEN=...

2. या shell import enable करें (env.shellEnv.enabled: true)।

3. या इसे अपने config env block में जोड़ें (केवल missing होने पर apply होता है)।

फिर gateway restart करें और दोबारा check करें:

openclaw models status

Copilot tokens COPILOT_GITHUB_TOKEN (साथ ही GH_TOKEN / GITHUB_TOKEN) से read किए जाते हैं। देखें /concepts/model-providers और /environment.

standalone message के रूप में /new या /reset भेजें। देखें Session management.

Sessions session.idleMinutes के बाद expire हो सकते हैं, लेकिन यह default रूप से disabled है (default 0)। idle expiry enable करने के लिए इसे positive value पर set करें। Enabled होने पर, idle period के बाद अगला message उस chat key के लिए fresh session id start करता है। यह transcripts delete नहीं करता - यह बस नया session start करता है।

{  session: {    idleMinutes: 240,  },}

हाँ, multi-agent routing और sub-agents के जरिए। आप एक coordinator agent और कई worker agents उनके अपने workspaces और models के साथ बना सकते हैं।

फिर भी, इसे मज़ेदार experiment के रूप में देखना सबसे बेहतर है। यह token heavy है और अक्सर अलग sessions वाले एक bot का उपयोग करने से कम efficient होता है। typical model जिसे हम envision करते हैं वह एक bot है जिससे आप बात करते हैं, parallel work के लिए अलग sessions के साथ। वह bot जरूरत पड़ने पर sub-agents भी spawn कर सकता है।

दस्तावेज़: Multi-agent routing, Sub-agents, Agents CLI.

Session context model window द्वारा limited होता है। Long chats, large tool outputs, या कई files compaction या truncation trigger कर सकते हैं।

क्या मदद करता है:

• bot से current state summarize करने और इसे file में लिखने को कहें।
• long tasks से पहले /compact का उपयोग करें, और topics switch करते समय /new का उपयोग करें।
• important context workspace में रखें और bot से उसे वापस read करने को कहें।
• long या parallel work के लिए sub-agents का उपयोग करें ताकि main chat छोटा रहे।
• यदि यह अक्सर होता है तो larger context window वाला model चुनें।

reset command का उपयोग करें:

openclaw reset

Non-interactive full reset:

openclaw reset --scope full --yes --non-interactive

फिर setup दोबारा चलाएँ:

openclaw onboard --install-daemon

Notes:

• यदि onboarding existing config देखता है, तो वह Reset भी offer करता है। देखें Onboarding (CLI).
• यदि आपने profiles (--profile / OPENCLAW_PROFILE) उपयोग किए हैं, तो प्रत्येक state dir reset करें (defaults ~/.openclaw-<profile> हैं)।
• Dev reset: openclaw gateway --dev --reset (केवल dev; dev config + credentials + sessions + workspace wipe करता है)।

इनमें से एक का उपयोग करें:

• Compact (conversation रखता है लेकिन पुराने turns summarize करता है):

  /compact

  या summary guide करने के लिए /compact <instructions>।

• Reset (same chat key के लिए fresh session ID):

  /new/reset

यदि यह होता रहता है:

• पुराने tool output trim करने के लिए session pruning (agents.defaults.contextPruning) enable या tune करें।
• larger context window वाले model का उपयोग करें।

दस्तावेज़: Compaction, Session pruning, Session management.

यह provider validation error है: model ने required input के बिना tool_use block emit किया। इसका आम तौर पर अर्थ है कि session history stale या corrupted है (अक्सर long threads या tool/schema change के बाद)।

Fix: /new (standalone message) के साथ fresh session start करें।

Heartbeats default रूप से हर 30m चलते हैं (OAuth auth उपयोग करते समय 1h)। इन्हें tune या disable करें:

{  agents: {    defaults: {      heartbeat: {        every: "2h", // or "0m" to disable      },    },  },}

यदि HEARTBEAT.md मौजूद है लेकिन प्रभावी रूप से खाली है (केवल खाली पंक्तियां, Markdown/HTML टिप्पणियां, # Heading जैसी Markdown हेडिंग, fence markers, या खाली checklist stubs), तो OpenClaw API कॉल बचाने के लिए Heartbeat रन छोड़ देता है. अगर फ़ाइल मौजूद नहीं है, तो Heartbeat फिर भी चलता है और मॉडल तय करता है कि क्या करना है.

प्रति-agent overrides agents.list[].heartbeat का उपयोग करते हैं. दस्तावेज़: Heartbeat.

नहीं. OpenClaw आपके अपने account पर चलता है, इसलिए अगर आप समूह में हैं, तो OpenClaw उसे देख सकता है. डिफ़ॉल्ट रूप से, समूह replies तब तक blocked रहती हैं जब तक आप senders को अनुमति नहीं देते (groupPolicy: "allowlist").

अगर आप चाहते हैं कि केवल आप समूह replies trigger कर सकें:

{  channels: {    whatsapp: {      groupPolicy: "allowlist",      groupAllowFrom: ["+15551234567"],    },  },}

विकल्प 1 (सबसे तेज): logs tail करें और समूह में एक test message भेजें:

openclaw logs --follow --json

@g.us पर समाप्त होने वाला chatId (या from) ढूंढें, जैसे: 1234567890-1234567890@g.us.

विकल्प 2 (अगर पहले से configured/allowlisted है): config से समूह list करें:

openclaw directory groups list --channel whatsapp

दस्तावेज़: WhatsApp, Directory, Logs.

दो सामान्य कारण:

• Mention gating चालू है (डिफ़ॉल्ट). आपको bot को @mention करना होगा (या mentionPatterns से match करना होगा).
• आपने channels.whatsapp.groups को "*" के बिना configured किया है और समूह allowlisted नहीं है.

Groups और Group messages देखें.

Direct chats डिफ़ॉल्ट रूप से मुख्य session में collapse हो जाते हैं. Groups/channels की अपनी session keys होती हैं, और Telegram topics / Discord threads अलग sessions होते हैं. Groups और Group messages देखें.

कोई hard limits नहीं. दर्जनों (यहां तक कि सैकड़ों) ठीक हैं, लेकिन इन पर ध्यान दें:

• Disk growth: sessions + transcripts ~/.openclaw/agents/<agentId>/sessions/ के अंतर्गत रहते हैं.
• Token cost: अधिक agents का मतलब अधिक concurrent model usage है.
• Ops overhead: प्रति-agent auth profiles, workspaces, और channel routing.

सुझाव:

• प्रति agent एक active workspace रखें (agents.defaults.workspace).
• अगर disk बढ़ती है तो पुराने sessions prune करें (JSONL या store entries हटाएं).
• stray workspaces और profile mismatches पहचानने के लिए openclaw doctor का उपयोग करें.

हां. कई isolated agents चलाने और inbound messages को channel/account/peer के आधार पर route करने के लिए Multi-Agent Routing का उपयोग करें. Slack एक channel के रूप में समर्थित है और विशिष्ट agents से bind किया जा सकता है.

Browser access शक्तिशाली है, लेकिन यह "इंसान जो कुछ कर सकता है वह सब करें" नहीं है - anti-bot, CAPTCHAs, और MFA अभी भी automation को block कर सकते हैं. सबसे विश्वसनीय browser control के लिए, host पर local Chrome MCP का उपयोग करें, या उस machine पर CDP का उपयोग करें जो वास्तव में browser चलाती है.

Best-practice setup:

• Always-on Gateway host (VPS/Mac mini).
• प्रति role एक agent (bindings).
• उन agents से bound Slack channel(s).
• जरूरत पड़ने पर Chrome MCP या किसी Node के जरिए local browser.

दस्तावेज़: Multi-Agent Routing, Slack, Browser, Nodes.

gateway.port WebSocket + HTTP (Control UI, hooks, आदि) के लिए एकल multiplexed port नियंत्रित करता है.

प्राथमिकता:

--port > OPENCLAW_GATEWAY_PORT > gateway.port > default 18789

क्योंकि "running" supervisor का view है (launchd/systemd/schtasks). connectivity probe CLI का वास्तव में gateway WebSocket से connect करना है.

openclaw gateway status का उपयोग करें और इन पंक्तियों पर भरोसा करें:

• Probe target: (probe ने वास्तव में जो URL उपयोग किया)
• Listening: (port पर वास्तव में क्या bound है)
• Last gateway error: (जब process alive है लेकिन port listening नहीं है, तब common root cause)

आप एक config file edit कर रहे हैं जबकि service दूसरी चला रही है (अक्सर --profile / OPENCLAW_STATE_DIR mismatch).

समाधान:

openclaw gateway install --force

इसे उसी --profile / environment से चलाएं जिसका उपयोग आप service से करवाना चाहते हैं.

OpenClaw startup पर तुरंत WebSocket listener bind करके runtime lock लागू करता है (डिफ़ॉल्ट ws://127.0.0.1:18789). अगर bind EADDRINUSE के साथ fail होता है, तो यह GatewayLockError throw करता है, जो बताता है कि दूसरा instance पहले से listening है.

समाधान: दूसरा instance stop करें, port free करें, या openclaw gateway --port <port> के साथ चलाएं.

gateway.mode: "remote" set करें और remote WebSocket URL की ओर point करें, वैकल्पिक shared-secret remote credentials के साथ:

{  gateway: {    mode: "remote",    remote: {      url: "ws://gateway.tailnet:18789",      token: "your-token",      password: "your-password",    },  },}

Notes:

• openclaw gateway केवल तब start होता है जब gateway.mode local हो (या आप override flag pass करें).
• macOS app config file watch करता है और ये values बदलने पर live modes switch करता है.
• gateway.remote.token / .password केवल client-side remote credentials हैं; वे अपने आप local gateway auth enable नहीं करते.

आपका gateway auth path और UI की auth method match नहीं करते.

तथ्य (कोड से):

• Control UI token को current browser tab session और selected gateway URL के लिए sessionStorage में रखता है, इसलिए same-tab refreshes long-lived localStorage token persistence restore किए बिना काम करते रहते हैं.
• AUTH_TOKEN_MISMATCH पर, trusted clients cached device token के साथ एक bounded retry attempt कर सकते हैं जब gateway retry hints return करता है (canRetryWithDeviceToken=true, recommendedNextStep=retry_with_device_token).
• वह cached-token retry अब device token के साथ stored cached approved scopes को reuse करता है. explicit deviceToken / explicit scopes callers अभी भी cached scopes inherit करने के बजाय अपना requested scope set रखते हैं.
• उस retry path के बाहर, connect auth precedence है: पहले explicit shared token/password, फिर explicit deviceToken, फिर stored device token, फिर bootstrap token.
• Built-in setup-code bootstrap केवल node-only है. approval के बाद, यह scopes: [] के साथ एक node device token return करता है और handed-off operator token return नहीं करता.

समाधान:

• सबसे तेज: openclaw dashboard (dashboard URL print + copy करता है, open करने की कोशिश करता है; headless होने पर SSH hint दिखाता है).
• अगर आपके पास अभी token नहीं है: openclaw doctor --generate-gateway-token.
• अगर remote है, पहले tunnel करें: ssh -N -L 18789:127.0.0.1:18789 user@host फिर http://127.0.0.1:18789/ खोलें.
• Shared-secret mode: gateway.auth.token / OPENCLAW_GATEWAY_TOKEN या gateway.auth.password / OPENCLAW_GATEWAY_PASSWORD set करें, फिर matching secret को Control UI settings में paste करें.
• Tailscale Serve mode: सुनिश्चित करें कि gateway.auth.allowTailscale enabled है और आप Serve URL खोल रहे हैं, raw loopback/tailnet URL नहीं जो Tailscale identity headers bypass करता है.
• Trusted-proxy mode: सुनिश्चित करें कि आप configured identity-aware proxy के जरिए आ रहे हैं, raw gateway URL से नहीं. Same-host loopback proxies को भी gateway.auth.trustedProxy.allowLoopback = true चाहिए.
• अगर एक retry के बाद भी mismatch बना रहता है, paired device token rotate/re-approve करें:
  • openclaw devices list
  • openclaw devices rotate --device <id> --role operator
• अगर वह rotate call कहता है कि इसे deny किया गया, तो दो चीजें check करें:
  • paired-device sessions केवल अपने own device को rotate कर सकते हैं, जब तक उनके पास operator.admin भी न हो
  • explicit --scope values caller के current operator scopes से अधिक नहीं हो सकतीं
• अभी भी अटके हैं? openclaw status --all चलाएं और Troubleshooting follow करें. auth details के लिए Dashboard देखें.

tailnet bind आपके network interfaces (100.64.0.0/10) से Tailscale IP चुनता है. अगर machine Tailscale पर नहीं है (या interface down है), तो bind करने के लिए कुछ नहीं है.

समाधान:

• उस host पर Tailscale start करें (ताकि उसके पास 100.x address हो), या
• gateway.bind: "loopback" / "lan" पर switch करें.

Note: tailnet explicit है. auto loopback को prefer करता है; जब आप tailnet-only bind चाहते हैं तो gateway.bind: "tailnet" उपयोग करें.

आम तौर पर नहीं - एक Gateway कई messaging channels और agents चला सकता है. कई Gateways केवल तब उपयोग करें जब आपको redundancy (उदाहरण: rescue bot) या hard isolation चाहिए.

हां, लेकिन आपको isolate करना होगा:

• OPENCLAW_CONFIG_PATH (per-instance config)
• OPENCLAW_STATE_DIR (per-instance state)
• agents.defaults.workspace (workspace isolation)
• gateway.port (unique ports)

त्वरित setup (अनुशंसित):

• प्रति instance openclaw --profile <name> ... उपयोग करें (auto-creates ~/.openclaw-<name>).
• हर profile config में unique gateway.port set करें (या manual runs के लिए --port pass करें).
• per-profile service install करें: openclaw --profile <name> gateway install.

Profiles service names में suffix भी जोड़ते हैं (ai.openclaw.<profile>; legacy com.openclaw.*, openclaw-gateway-<profile>.service, OpenClaw Gateway (<profile>)). पूरी guide: Multiple gateways.

Gateway एक WebSocket server है, और यह अपेक्षा करता है कि सबसे पहला message एक connect frame हो. अगर इसे कुछ और मिलता है, तो यह connection को code 1008 (policy violation) के साथ close कर देता है.

सामान्य कारण:

• आपने WS client के बजाय browser में HTTP URL खोला (http://...).
• आपने गलत port या path उपयोग किया.
• किसी proxy या tunnel ने auth headers strip कर दिए या non-Gateway request भेजी.

त्वरित समाधान:

1. WS URL उपयोग करें: ws://<host>:18789 (या HTTPS होने पर wss://...).
2. WS port को सामान्य browser tab में न खोलें.
3. अगर auth on है, तो connect frame में token/password शामिल करें.

अगर आप CLI या TUI उपयोग कर रहे हैं, तो URL ऐसा दिखना चाहिए:

openclaw tui --url ws://<host>:18789 --token <token>

Protocol details: Gateway protocol.

File logs (structured):

/tmp/openclaw/openclaw-YYYY-MM-DD.log

आप logging.file के माध्यम से एक स्थिर पाथ सेट कर सकते हैं। फ़ाइल लॉग स्तर logging.level से नियंत्रित होता है। कंसोल वर्बोसिटी --verbose और logging.consoleLevel से नियंत्रित होती है।

सबसे तेज़ लॉग टेल:

openclaw logs --follow

सेवा/सुपरवाइज़र लॉग (जब Gateway launchd/systemd के माध्यम से चलता है):

• macOS launchd stdout: ~/Library/Logs/openclaw/gateway.log (प्रोफ़ाइल gateway-<profile>.log का उपयोग करती हैं; stderr दबा दिया जाता है)
• Linux: journalctl --user -u openclaw-gateway[-<profile>].service -n 200 --no-pager
• Windows: schtasks /Query /TN "OpenClaw Gateway (<profile>)" /V /FO LIST

अधिक जानकारी के लिए समस्या निवारण देखें।

Gateway हेल्पर का उपयोग करें:

openclaw gateway statusopenclaw gateway restart

यदि आप Gateway को मैन्युअल रूप से चलाते हैं, तो openclaw gateway --force पोर्ट वापस ले सकता है। Gateway देखें।

तीन Windows इंस्टॉल मोड हैं:

1) Windows Hub स्थानीय सेटअप: नेटिव ऐप स्थानीय ऐप-स्वामित्व वाला WSL Gateway प्रबंधित करता है।

Start मेनू या ट्रे से OpenClaw Companion खोलें, फिर Gateway Setup या Connections टैब का उपयोग करें।

2) मैन्युअल WSL2 Gateway: Gateway Linux के अंदर चलता है।

PowerShell खोलें, WSL में प्रवेश करें, फिर रीस्टार्ट करें:

wslopenclaw gateway statusopenclaw gateway restart

यदि आपने सेवा कभी इंस्टॉल नहीं की है, तो इसे फ़ोरग्राउंड में शुरू करें:

openclaw gateway run

3) नेटिव Windows CLI/Gateway: Gateway सीधे Windows में चलता है।

PowerShell खोलें और चलाएं:

openclaw gateway statusopenclaw gateway restart

यदि आप इसे मैन्युअल रूप से चलाते हैं (कोई सेवा नहीं), तो उपयोग करें:

openclaw gateway run

दस्तावेज़: Windows, Gateway सेवा रनबुक.

त्वरित हेल्थ स्वीप से शुरू करें:

openclaw statusopenclaw models statusopenclaw channels statusopenclaw logs --follow

सामान्य कारण:

• मॉडल ऑथ Gateway होस्ट पर लोड नहीं है (models status जांचें)।
• चैनल पेयरिंग/अलाउलिस्ट जवाबों को रोक रही है (चैनल कॉन्फ़िग + लॉग जांचें)।
• WebChat/Dashboard सही टोकन के बिना खुला है।

यदि आप रिमोट हैं, तो पुष्टि करें कि टनल/Tailscale कनेक्शन चालू है और Gateway WebSocket पहुंच योग्य है।

दस्तावेज़: चैनल, समस्या निवारण, रिमोट एक्सेस.

इसका आमतौर पर मतलब है कि UI ने WebSocket कनेक्शन खो दिया। जांचें:

1. क्या Gateway चल रहा है? openclaw gateway status
2. क्या Gateway स्वस्थ है? openclaw status
3. क्या UI के पास सही टोकन है? openclaw dashboard
4. यदि रिमोट है, तो क्या टनल/Tailscale लिंक चालू है?

फिर लॉग टेल करें:

openclaw logs --follow

दस्तावेज़: Dashboard, रिमोट एक्सेस, समस्या निवारण.

लॉग और चैनल स्थिति से शुरू करें:

openclaw channels statusopenclaw channels logs --channel telegram

फिर त्रुटि से मिलान करें:

• BOT_COMMANDS_TOO_MUCH: Telegram मेनू में बहुत अधिक प्रविष्टियां हैं। OpenClaw पहले से ही Telegram सीमा तक काटता है और कम कमांड के साथ दोबारा कोशिश करता है, लेकिन कुछ मेनू प्रविष्टियां फिर भी हटानी होंगी। Plugin/Skill/कस्टम कमांड घटाएं, या यदि आपको मेनू की जरूरत नहीं है तो channels.telegram.commands.native अक्षम करें।
• TypeError: fetch failed, Network request for 'setMyCommands' failed!, या समान नेटवर्क त्रुटियां: यदि आप VPS पर हैं या प्रॉक्सी के पीछे हैं, तो पुष्टि करें कि आउटबाउंड HTTPS अनुमत है और DNS api.telegram.org के लिए काम करता है।

यदि Gateway रिमोट है, तो सुनिश्चित करें कि आप Gateway होस्ट पर लॉग देख रहे हैं।

दस्तावेज़: Telegram, चैनल समस्या निवारण.

पहले पुष्टि करें कि Gateway पहुंच योग्य है और एजेंट चल सकता है:

openclaw statusopenclaw models statusopenclaw logs --follow

TUI में, मौजूदा स्थिति देखने के लिए /status का उपयोग करें। यदि आप चैट चैनल में जवाबों की अपेक्षा करते हैं, तो सुनिश्चित करें कि डिलीवरी सक्षम है (/deliver on)।

दस्तावेज़: TUI, स्लैश कमांड.

यदि आपने सेवा इंस्टॉल की है:

openclaw gateway stopopenclaw gateway start

यह निगरानी वाली सेवा को रोकता/शुरू करता है (macOS पर launchd, Linux पर systemd)। जब Gateway बैकग्राउंड में डेमन के रूप में चलता है, तब इसका उपयोग करें।

यदि आप फ़ोरग्राउंड में चला रहे हैं, तो Ctrl-C से रोकें, फिर:

openclaw gateway run

दस्तावेज़: Gateway सेवा रनबुक.

• openclaw gateway restart: बैकग्राउंड सेवा को रीस्टार्ट करता है (launchd/systemd)।
• openclaw gateway: इस टर्मिनल सत्र के लिए Gateway को फ़ोरग्राउंड में चलाता है।

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

अधिक कंसोल विवरण पाने के लिए Gateway को --verbose के साथ शुरू करें। फिर चैनल ऑथ, मॉडल रूटिंग, और RPC त्रुटियों के लिए लॉग फ़ाइल देखें।

एजेंट से आउटबाउंड अटैचमेंट को media, mediaUrl, path, या filePath जैसे संरचित मीडिया फ़ील्ड का उपयोग करना चाहिए। OpenClaw असिस्टेंट सेटअप और एजेंट भेजना देखें।

CLI से भेजना:

openclaw message send --target +15555550123 --message "Here you go" --media /path/to/file.png

यह भी जांचें:

• लक्षित चैनल आउटबाउंड मीडिया का समर्थन करता है और अलाउलिस्ट से ब्लॉक नहीं है।
• फ़ाइल प्रदाता की आकार सीमाओं के भीतर है (इमेज अधिकतम 2048px तक रिसाइज़ की जाती हैं)।
• tools.fs.workspaceOnly=true स्थानीय-पाथ भेजने को workspace, temp/media-store, और sandbox-validated फ़ाइलों तक सीमित रखता है।
• tools.fs.workspaceOnly=false संरचित स्थानीय मीडिया भेजने को होस्ट-स्थानीय फ़ाइलों का उपयोग करने देता है जिन्हें एजेंट पहले से पढ़ सकता है, लेकिन केवल मीडिया और सुरक्षित दस्तावेज़ प्रकारों के लिए (इमेज, ऑडियो, वीडियो, PDF, Office दस्तावेज़, और Markdown/MD, TXT, JSON, YAML, और YML जैसे सत्यापित टेक्स्ट दस्तावेज़)। यह कोई सीक्रेट स्कैनर नहीं है: यदि एक्सटेंशन और सामग्री सत्यापन मेल खाते हैं, तो एजेंट-पठनीय secret.txt या config.json अटैच किया जा सकता है। संवेदनशील फ़ाइलों को एजेंट-पठनीय पाथ से बाहर रखें, या कठोर स्थानीय-पाथ भेजने के लिए tools.fs.workspaceOnly=true रखें।

इमेज देखें।

इनबाउंड DM को अविश्वसनीय इनपुट मानें। डिफ़ॉल्ट जोखिम घटाने के लिए डिज़ाइन किए गए हैं:

• DM-सक्षम चैनलों पर डिफ़ॉल्ट व्यवहार पेयरिंग है:
  • अज्ञात भेजने वालों को पेयरिंग कोड मिलता है; बॉट उनका संदेश प्रोसेस नहीं करता।
  • इससे स्वीकृत करें: openclaw pairing approve --channel <channel> [--account <id>] <code>
  • लंबित अनुरोध प्रति चैनल 3 तक सीमित हैं; यदि कोड नहीं आया तो openclaw pairing list --channel <channel> [--account <id>] जांचें।
• DM को सार्वजनिक रूप से खोलने के लिए स्पष्ट ऑप्ट-इन चाहिए (dmPolicy: "open" और अलाउलिस्ट "*").

जोखिमपूर्ण DM नीतियां सामने लाने के लिए openclaw doctor चलाएं।

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

सबसे बड़ा जोखिम तब होता है जब टूल सक्षम होते हैं: मॉडल को संदर्भ बाहर भेजने या आपकी ओर से टूल कॉल करने के लिए भ्रमित किया जा सकता है। प्रभाव क्षेत्र घटाने के लिए:

• अविश्वसनीय सामग्री का सारांश बनाने के लिए रीड-ओनली या टूल-अक्षम "रीडर" एजेंट का उपयोग करें
• टूल-सक्षम एजेंटों के लिए web_search / web_fetch / browser बंद रखें
• डीकोड किए गए फ़ाइल/दस्तावेज़ टेक्स्ट को भी अविश्वसनीय मानें: OpenResponses input_file और मीडिया-अटैचमेंट एक्सट्रैक्शन दोनों निकाले गए टेक्स्ट को कच्चा फ़ाइल टेक्स्ट पास करने के बजाय स्पष्ट बाहरी-सामग्री सीमा मार्कर में लपेटते हैं
• सैंडबॉक्सिंग और सख्त टूल अलाउलिस्ट

विवरण: सुरक्षा.

भाषा और रनटाइम मायने रखते हैं, लेकिन वे व्यक्तिगत एजेंट के लिए मुख्य जोखिम नहीं हैं। व्यावहारिक OpenClaw जोखिम हैं Gateway एक्सपोज़र, बॉट को कौन संदेश भेज सकता है, प्रॉम्प्ट इंजेक्शन, टूल दायरा, क्रेडेंशियल हैंडलिंग, ब्राउज़र एक्सेस, exec एक्सेस, और तृतीय-पक्ष Skill या Plugin भरोसा।

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

• Gateway को निजी या प्रमाणित रखें
• DM और समूहों के लिए पेयरिंग और अलाउलिस्ट का उपयोग करें
• अविश्वसनीय इनपुट के लिए जोखिमपूर्ण टूल अस्वीकार करें या सैंडबॉक्स करें
• केवल विश्वसनीय Plugin और Skills इंस्टॉल करें
• कॉन्फ़िग बदलावों के बाद openclaw security audit --deep चलाएं

विवरण: सुरक्षा, सैंडबॉक्सिंग.

पहले अपनी वास्तविक डिप्लॉयमेंट जांचें:

openclaw security audit --deepopenclaw gateway status

अधिक सुरक्षित बेसलाइन है:

• Gateway loopback से बंधा हो, या केवल प्रमाणित निजी एक्सेस जैसे tailnet, SSH टनल, टोकन/पासवर्ड ऑथ, या सही ढंग से कॉन्फ़िगर किए गए विश्वसनीय प्रॉक्सी के माध्यम से एक्सपोज़ हो
• DM pairing या allowlist मोड में हों
• समूह अलाउलिस्टेड और मेंशन-गेटेड हों, जब तक हर सदस्य विश्वसनीय न हो
• उच्च-जोखिम टूल (exec, browser, gateway, cron) उन एजेंटों के लिए अस्वीकार या कड़ाई से सीमित हों जो अविश्वसनीय सामग्री पढ़ते हैं
• जहां टूल निष्पादन को छोटा प्रभाव क्षेत्र चाहिए, वहां सैंडबॉक्सिंग सक्षम हो

ऑथ के बिना सार्वजनिक बाइंड, टूल के साथ खुले DM/समूह, और एक्सपोज़ ब्राउज़र नियंत्रण वे निष्कर्ष हैं जिन्हें पहले ठीक करना चाहिए। विवरण: सुरक्षा ऑडिट चेकलिस्ट.

तृतीय-पक्ष Skills और Plugin को ऐसे कोड के रूप में मानें जिस पर आप भरोसा करना चुन रहे हैं। ClawHub Skill पेज इंस्टॉल से पहले स्कैन स्थिति दिखाते हैं, लेकिन स्कैन कोई पूर्ण सुरक्षा सीमा नहीं हैं। OpenClaw Plugin या Skill इंस्टॉल/अपडेट फ़्लो के दौरान बिल्ट-इन स्थानीय खतरनाक-कोड ब्लॉकिंग नहीं चलाता; स्थानीय अनुमति/ब्लॉक निर्णयों के लिए ऑपरेटर-स्वामित्व वाली security.installPolicy का उपयोग करें।

अधिक सुरक्षित पैटर्न:

• विश्वसनीय लेखकों और पिन किए गए संस्करणों को प्राथमिकता दें
• सक्षम करने से पहले Skill या Plugin पढ़ें
• Plugin और Skill अलाउलिस्ट संकीर्ण रखें
• अविश्वसनीय-इनपुट वर्कफ़्लो न्यूनतम टूल वाले सैंडबॉक्स में चलाएं
• तृतीय-पक्ष कोड को व्यापक फ़ाइलसिस्टम, exec, ब्राउज़र, या सीक्रेट एक्सेस देने से बचें

विवरण: Skills, Plugins, सुरक्षा.

हाँ, अधिकतर setup के लिए। bot को अलग accounts और phone numbers के साथ अलग-थलग रखने से कुछ गलत होने पर प्रभाव-क्षेत्र कम हो जाता है। इससे credentials घुमाना या access revoke करना भी आसान हो जाता है, बिना आपके personal accounts को प्रभावित किए।

छोटी शुरुआत करें। केवल उन tools और accounts को access दें जिनकी आपको सच में जरूरत है, और जरूरत पड़ने पर बाद में विस्तार करें।

Docs: सुरक्षा, पेयरिंग.

हम आपके personal messages पर पूरी autonomy की अनुशंसा नहीं करते। सबसे सुरक्षित pattern है:

• DMs को pairing mode या सख्त allowlist में रखें।
• अगर आप चाहते हैं कि यह आपकी ओर से message भेजे, तो अलग number या account का उपयोग करें।
• इसे draft करने दें, फिर भेजने से पहले approve करें।

अगर आप प्रयोग करना चाहते हैं, तो इसे dedicated account पर करें और अलग-थलग रखें। देखें सुरक्षा.

हाँ, अगर agent केवल chat-only है और input trusted है। छोटे tiers instruction hijacking के प्रति अधिक संवेदनशील होते हैं, इसलिए tool-enabled agents या untrusted content पढ़ते समय उनसे बचें। अगर आपको छोटा model उपयोग करना ही है, तो tools को lock down करें और sandbox के अंदर चलाएँ। देखें सुरक्षा.

Pairing codes केवल तब भेजे जाते हैं जब कोई unknown sender bot को message करता है और dmPolicy: "pairing" enabled होता है। /start अपने आप code generate नहीं करता।

pending requests जाँचें:

openclaw pairing list telegram

अगर आप तुरंत access चाहते हैं, तो अपने sender id को allowlist करें या उस account के लिए dmPolicy: "open" set करें।

नहीं। default WhatsApp DM policy pairing है। Unknown senders को केवल pairing code मिलता है और उनका message process नहीं होता। OpenClaw केवल उन chats का reply करता है जिन्हें वह receive करता है या उन explicit sends का जिन्हें आप trigger करते हैं।

Pairing approve करें:

openclaw pairing approve whatsapp <code>

pending requests list करें:

openclaw pairing list whatsapp

Wizard phone number prompt: इसका उपयोग आपकी allowlist/owner set करने के लिए होता है ताकि आपकी अपनी DMs permitted हों। इसका उपयोग auto-sending के लिए नहीं होता। अगर आप अपने personal WhatsApp number पर चलाते हैं, तो वही number उपयोग करें और channels.whatsapp.selfChatMode enable करें।

अधिकतर internal या tool messages केवल तब दिखाई देते हैं जब उस session के लिए verbose, trace, या reasoning enabled हो।

जिस chat में आप इसे देख रहे हैं, वहाँ fix करें:

/verbose off/trace off/reasoning off

अगर यह अब भी noisy है, तो Control UI में session settings जाँचें और verbose को inherit पर set करें। यह भी confirm करें कि आप ऐसा bot profile उपयोग नहीं कर रहे हैं जिसमें config में verboseDefault on पर set हो।

Docs: Thinking और verbose, सुरक्षा.

इनमें से कोई भी standalone message के रूप में भेजें (slash नहीं):

stopstop actionstop current actionstop runstop current runstop agentstop the agentstop openclawopenclaw stopstop don't do anythingstop do not do anythingstop doing anythingplease stopstop pleaseabortescwaitexitinterrupt

ये abort triggers हैं (slash commands नहीं)।

background processes के लिए (exec tool से), आप agent से चलाने को कह सकते हैं:

process action:kill sessionId:XXX

Slash commands overview: देखें Slash commands.

अधिकांश commands को standalone message के रूप में भेजना होता है जो / से शुरू होता है, लेकिन कुछ shortcuts (जैसे /status) allowlisted senders के लिए inline भी काम करते हैं।

OpenClaw default रूप से cross-provider messaging block करता है। अगर tool call Telegram से bound है, तो वह Discord को नहीं भेजेगा जब तक आप इसे explicit रूप से allow न करें।

agent के लिए cross-provider messaging enable करें:

{  tools: {    message: {      crossContext: {        allowAcrossProviders: true,        marker: { enabled: true, prefix: "[from {channel}] " },      },    },  },}

config edit करने के बाद gateway restart करें।

Mid-run prompts default रूप से active run में steer किए जाते हैं। active-run behavior चुनने के लिए /queue उपयोग करें:

• steer - अगले model boundary पर active run को guide करें
• followup - messages queue करें और current run समाप्त होने के बाद उन्हें एक-एक करके चलाएँ
• collect - compatible messages queue करें और current run समाप्त होने के बाद एक बार reply करें
• interrupt - current run abort करें और fresh start करें

Default mode steer है। queued modes के लिए आप debounce:0.5s cap:25 drop:summarize जैसे options जोड़ सकते हैं। देखें Command queue और Steering queue.

OpenClaw में credentials और model selection अलग-अलग हैं। ANTHROPIC_API_KEY set करना (या auth profiles में Anthropic API key store करना) authentication enable करता है, लेकिन actual default model वही होता है जिसे आप agents.defaults.model.primary में configure करते हैं (उदाहरण के लिए, anthropic/claude-sonnet-4-6 या anthropic/claude-opus-4-6)। अगर आपको No credentials found for profile "anthropic:default" दिखता है, तो इसका मतलब है कि Gateway running agent के लिए expected auth-profiles.json में Anthropic credentials नहीं ढूँढ सका।