diff --git a/README.md b/README.md index eb8364873ff..355bb53aff8 100644 --- a/README.md +++ b/README.md @@ -9,8 +9,8 @@ [![Security Policy](https://img.shields.io/badge/Security-Report%20a%20Vulnerability-red)](https://github.com/NVIDIA/NemoClaw/blob/main/SECURITY.md) [![Discord](https://img.shields.io/badge/Discord-Join-7289da)](https://discord.gg/XFpfPv9Uvx) -NVIDIA NemoClaw is an open source reference stack for running always-on AI agents more safely inside [NVIDIA OpenShell](https://github.com/NVIDIA/OpenShell) sandboxes. -It provides guided onboarding, a hardened blueprint, routed inference, network policy, and lifecycle management through a single CLI. +NVIDIA NemoClaw is an open source reference stack for running supported AI agents more safely inside [NVIDIA OpenShell](https://github.com/NVIDIA/OpenShell) sandboxes. +It provides guided onboarding, managed inference, network policy, managed integrations, snapshots, and lifecycle operations through the NemoClaw CLI and its agent-specific aliases. **Supported agents:** @@ -49,9 +49,9 @@ Refer to the following pages on the official documentation website for more info | Page | Description | |------|-------------| | [Overview](https://docs.nvidia.com/nemoclaw/latest/about/overview.html) | What NemoClaw does and how it fits together. | -| [Architecture Overview](https://docs.nvidia.com/nemoclaw/latest/about/how-it-works.html) | High-level overview of Plugin, blueprint, sandbox lifecycle, and protection layers. | +| [Architecture Overview](https://docs.nvidia.com/nemoclaw/latest/about/how-it-works.html) | High-level overview of the host CLI, agent integration layer, blueprint, sandbox lifecycle, and protection layers. | | [Ecosystem](https://docs.nvidia.com/nemoclaw/latest/about/ecosystem.html) | How OpenClaw, OpenShell, and NemoClaw form a stack and when to use NemoClaw versus OpenShell alone. | -| [Architecture Details](https://docs.nvidia.com/nemoclaw/latest/reference/architecture.html) | Detailed description of Plugin structure, blueprint lifecycle, sandbox environment, and host-side state. | +| [Architecture Details](https://docs.nvidia.com/nemoclaw/latest/reference/architecture.html) | Detailed description of agent integration structure, blueprint lifecycle, sandbox environment, and host-side state. | | [Prerequisites](https://docs.nvidia.com/nemoclaw/latest/get-started/prerequisites.html) | Hardware, software, and supported platforms, with any platform-specific pre-setup. | | [Choose an Inference Provider](https://docs.nvidia.com/nemoclaw/latest/user-guide/openclaw/inference/learn-and-choose/choose-inference-provider) | Supported providers, validation, and routed inference configuration. | | [Network Policies](https://docs.nvidia.com/nemoclaw/latest/reference/network-policies.html) | Baseline rules, operator approval flow, and egress control. | diff --git a/ci/platform-matrix.json b/ci/platform-matrix.json index 2e27ab585ab..599569dbdd7 100644 --- a/ci/platform-matrix.json +++ b/ci/platform-matrix.json @@ -1,7 +1,7 @@ { "$comment": "SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\nSPDX-License-Identifier: Apache-2.0\n\nSingle source of truth for NemoClaw launch claims and platform support. Covers platforms, inference providers, supported agents, messaging integrations, and deployment paths. Scripts read this to generate README and docs tables. QA/CI update platform/provider rows; the engineering owner reviews other rows. Docs are derived.", "version": "1.1", - "updated": "2026-07-21", + "updated": "2026-08-03", "project_status": { "stage": "alpha", @@ -18,7 +18,7 @@ "statuses": { "tested": "Validated by CI or QA. Safe to claim and to demo.", "caveated": "Works on the listed setup with documented caveats. Caveats must be cited whenever this row is claimed.", - "experimental": "Available behind `NEMOCLAW_EXPERIMENTAL=1` or an equivalent opt-in flag. Do not claim in launch-facing material without the opt-in mentioned.", + "experimental": "Available only after an explicit experimental opt-in, such as `NEMOCLAW_EXPERIMENTAL=1` or selecting an integration that the CLI labels experimental. Do not claim in launch-facing material without the opt-in mentioned.", "deferred": "Planned but not yet validated. Roadmap-only. Do not claim as supported.", "unsupported": "Explicitly out of scope. Not validated and not planned. Documented to set expectations and prevent drift.", "hermes only": "Available only when onboarding the Hermes agent." @@ -170,7 +170,7 @@ "name": "LangChain Deep Agents Code", "status": "tested", "default": false, - "notes": "Terminal-oriented coding harness (no in-sandbox gateway, no dashboard) built on the Deep Agents SDK; manifest at `agents/langchain-deepagents-code/manifest.yaml` with binary `dcode`. Onboard with `nemo-deepagents onboard` or `nemoclaw onboard --agent langchain-deepagents-code`, and follow [the quickstart](/user-guide/deepagents/get-started/quickstart). NemoClaw runs it as a managed harness: unmanaged sandbox/MCP/shell overrides are rejected and credential-bearing proxy URLs are dropped from persisted shell env. Inference routes through OpenShell's `inference.local` endpoint via Deep Agents Code's OpenAI-compatible provider. Live runtime acceptance, broader launch material, and terminal-agent diagnostics are tracked at open issue #4861." + "notes": "Terminal-oriented coding agent runtime with no in-sandbox gateway or dashboard, built on the Deep Agents SDK. Its manifest is `agents/langchain-deepagents-code/manifest.yaml`, and its binary is `dcode`. Onboard with `nemo-deepagents onboard` or `nemoclaw onboard --agent langchain-deepagents-code`, and follow [the quickstart](/user-guide/deepagents/get-started/quickstart). NemoClaw runs it as a managed agent runtime: unmanaged sandbox, Model Context Protocol (MCP) server, and shell overrides are rejected, and credential-bearing proxy URLs are dropped from persisted shell environment values. Inference routes through OpenShell's `inference.local` endpoint through the Deep Agents Code OpenAI-compatible provider. Live runtime acceptance, broader launch material, and terminal-agent diagnostics are tracked at open issue #4861." } ], @@ -178,7 +178,7 @@ { "name": "Guided onboarding", "status": "tested", - "notes": "Single-command interactive wizard (`$$nemoclaw onboard`) that walks the user through inference provider selection, credential setup, sandbox creation, and dashboard launch. Non-interactive mode is supported with `--non-interactive` + `NEMOCLAW_*` environment variables for CI and scripted installs." + "notes": "Single-command interactive wizard (`$$nemoclaw onboard`) that walks the user through inference provider selection, credential setup, and sandbox creation or update. It opens the agent dashboard when the selected runtime provides one. Non-interactive mode is supported with `--non-interactive` and `NEMOCLAW_*` environment variables for CI and scripted installs." }, { "name": "Sandboxed execution", @@ -205,6 +205,21 @@ "status": "tested", "notes": "Packaged agent skills are discoverable by Cursor, Claude Code, and other coding assistants under `.agents/skills/`. Skills also install into the sandbox with `$$nemoclaw skill install`." }, + { + "name": "Managed MCP servers", + "status": "tested", + "notes": "OpenClaw, Hermes, and LangChain Deep Agents Code support authenticated HTTPS Streamable HTTP MCP server lifecycle through `$$nemoclaw mcp`. NemoClaw stores only credential names and ownership metadata, while OpenShell keeps raw credential values outside the sandbox and replaces credential placeholders at approved egress boundaries." + }, + { + "name": "Host readiness reporting", + "status": "tested", + "notes": "`$$nemoclaw host probe` reports host observations, capabilities, qualifications, findings, evidence, and CLI provenance without changing host, gateway, provider, policy, credential, or sandbox state. The human-readable and JSON formats use the same schema-versioned report and deterministic exit codes." + }, + { + "name": "Deep Agents trace export", + "status": "caveated", + "notes": "LangChain Deep Agents Code can opt into bounded-content OpenTelemetry Protocol (OTLP) over HTTP trace export to an operator-managed host collector. The sandbox receives no remote-backend credential, the local receiver has no authentication, trace content can contain sensitive application data, and delivery failures do not stop agent work." + }, { "name": "State migration", "status": "tested", @@ -261,7 +276,7 @@ { "name": "Other LangChain, AutoGen, CrewAI, or non-listed agent harnesses", "status": "unsupported", - "notes": "LangChain Deep Agents Code is the only integrated LangChain-family harness (see the Agents section above; status `Experimental`). Other LangChain harnesses, AutoGen, CrewAI, and any agent runtime not listed in the Agents table are not integrated. Bringing more harnesses is tracked as a research epic (see open issue #4861) but is not on the current roadmap." + "notes": "LangChain Deep Agents Code is the only integrated LangChain-family agent runtime (refer to the Agents section above; status `Tested`). Other LangChain agent runtimes, AutoGen, CrewAI, and any agent runtime not listed in the Agents table are not integrated. Bringing more agent runtimes is tracked as a research epic (refer to open issue #4861) but is not on the current roadmap." }, { "name": "Multi-user host sharing", @@ -315,6 +330,11 @@ "name": "Microsoft Teams", "status": "experimental", "notes": "Supported by both OpenClaw and Hermes through the manifest-first messaging channel contract. Requires Bot Framework app credentials, a tenant ID, and a public HTTPS endpoint that reaches the sandbox webhook path `/api/messages`. Sandbox egress goes through the `teams` policy preset, and only one active Teams sandbox can use a given local `MSTEAMS_PORT` forward." + }, + { + "name": "Google Chat", + "status": "experimental", + "notes": "Available only for OpenClaw through the channel manifest contract. The onboarding picker labels Google Chat experimental, and NemoClaw enables it only after you explicitly select or add it. Requires a Google service-account credential and a public HTTPS endpoint that reaches only the `/googlechat` webhook path. OpenShell keeps the service-account private key outside the sandbox and supplies short-lived credentials at approved egress boundaries." } ], diff --git a/docs/about/ecosystem-deepagents.mdx b/docs/about/ecosystem-deepagents.mdx index f5c53418916..ad321c5259e 100644 --- a/docs/about/ecosystem-deepagents.mdx +++ b/docs/about/ecosystem-deepagents.mdx @@ -51,7 +51,7 @@ The following table shows the scope of each component in the stack. |---------|--------| | LangChain Deep Agents Code | The terminal coding agent runtime, interactive TUI, headless `dcode -n` mode, skills, memory, and tool approval UI inside the container. | | OpenShell | The execution environment: sandbox lifecycle, network, filesystem, process policy, inference routing, and the operator-facing `openshell` CLI for those primitives. | -| NemoClaw | The NVIDIA reference stack on the host: `nemo-deepagents` / `nemoclaw` CLI, versioned blueprint, managed Deep Agents runtime patches, credential-safe inference routing, policy presets, and state migration helpers. | +| NemoClaw | The NVIDIA reference stack on the host: `nemo-deepagents` and `nemoclaw` CLI paths, versioned blueprint, managed Deep Agents integration layer, managed inference and Model Context Protocol (MCP) servers, host readiness reporting, trace export, and lifecycle operations. | ## NemoClaw Path versus OpenShell Path @@ -73,14 +73,16 @@ The following table compares custom OpenShell integration with `nemo-deepagents | Capability | Custom OpenShell + Deep Agents | `nemo-deepagents onboard` | |---|---|---| -| Sandbox isolation | You define and apply OpenShell seccomp, Landlock, network namespace isolation, and no-new-privileges policy. | NemoClaw applies the managed Deep Agents policy through the blueprint and requires the runtime checks that the managed harness depends on. | -| Credential handling | You create OpenShell providers manually and decide how `dcode` receives endpoint credentials. | NemoClaw creates OpenShell providers during onboarding, points Deep Agents at `https://inference.local/v1`, and keeps provider credentials on the host. | -| Image hardening | Depends on your base image and install steps. | NemoClaw installs the pinned Deep Agents Code package in `/opt/venv`, uses managed launchers, and disables unsupported runtime escape paths such as unmanaged MCP autoloading, tracing exports, nested sandbox providers, and alternate model routes. | +| Sandbox isolation | You define and apply OpenShell seccomp, Landlock, network namespace isolation, and no-new-privileges policy. | NemoClaw applies the managed Deep Agents policy through the blueprint and requires the runtime checks that the managed agent runtime depends on. | +| Credential handling | You create OpenShell providers manually and decide how `dcode` receives endpoint credentials. | NemoClaw creates OpenShell providers during onboarding, points Deep Agents at `https://inference.local/v1`, and keeps provider credentials outside the sandbox. | +| Image hardening | Depends on your base image and install steps. | NemoClaw installs the pinned Deep Agents Code package in `/opt/venv`, uses managed launchers, and rejects unsupported runtime paths such as unmanaged MCP autoloading, nested sandbox providers, and alternate model routes. | | Filesystem policy | You define read-only and read-write paths in policy YAML. | NemoClaw defines a targeted layout: system paths are read-only, `/sandbox` and `/tmp` are writable, and Deep Agents state lives under `/sandbox/.deepagents`. | | Inference setup | You configure OpenShell inference routing and Deep Agents provider settings manually. | NemoClaw validates the selected provider from the host, configures the OpenShell route, and writes `/sandbox/.deepagents/config.toml` for the managed OpenAI-compatible path. | -| Optional integrations | You decide how web search, MCP, tracing, and other integrations enter the sandbox. | NemoClaw supports a maintained MCP projection and opt-in Tavily policy path, while keeping LangSmith and OpenTelemetry tracing disabled for the managed harness. | +| Managed MCP | You decide how MCP servers enter the sandbox and how they receive credentials. | NemoClaw manages authenticated HTTPS Streamable HTTP MCP server lifecycle, ownership records, policy, credential placeholders, and the Deep Agents MCP projection through host-side commands. | +| Optional integrations | You decide how web search, tracing, and other integrations enter the sandbox. | NemoClaw supports an explicit Tavily policy and credential path plus opt-in bounded trace export to an operator-managed host collector. Native LangSmith tracing and ambient OpenTelemetry exporter configuration remain disabled inside the sandbox. | | Blueprint versioning | No NemoClaw blueprint; your image tag is whatever you built locally. | NemoClaw downloads the blueprint artifact, checks version compatibility, and verifies its digest before applying. | -| State migration | Not included unless you build it. | NemoClaw preserves manifest-declared Deep Agents state and omits credential-bearing user files from snapshots and rebuilds. | +| Lifecycle state | Not included unless you build it. | NemoClaw preserves manifest-declared Deep Agents state and omits credential-bearing user files from snapshots and rebuilds. | +| Host readiness and operations | You inspect host prerequisites and operate OpenShell resources directly. | NemoClaw provides read-only host readiness reporting, sandbox status and logs, recovery guidance, rebuild, snapshot, restore, and uninstall workflows. | ## When to Use Which @@ -90,7 +92,7 @@ Use the following table to choose NemoClaw or custom OpenShell integration. |-----------|--------| | You want Deep Agents with NVIDIA defaults, managed inference routing, and the documented install and onboard flow. | NemoClaw (`nemo-deepagents`) | | You need maximum flexibility for custom images, a layout that does not match the NemoClaw Deep Agents blueprint, or an unsupported Deep Agents extension path. | OpenShell with your own integration | -| You are standardizing on a managed terminal coding agent with sandbox policy and host-owned credentials. | NemoClaw (`nemo-deepagents`) | +| You are standardizing on a managed terminal coding agent with sandbox policy and OpenShell-managed credentials. | NemoClaw (`nemo-deepagents`) | | You are building internal platform abstractions where the NemoClaw CLI or blueprint is not the right fit. | OpenShell and your orchestration | ## Related Topics @@ -98,6 +100,9 @@ Use the following table to choose NemoClaw or custom OpenShell integration. - [Overview](overview) defines NemoClaw's capabilities, benefits, and use cases. - [Architecture Overview](how-it-works) describes how NemoClaw runs, the blueprint, sandbox creation, routing, and protection layers for Deep Agents. - [Architecture Details](../reference/architecture) describes the Deep Agents blueprint, file layout, policy paths, and managed runtime internals. +- [Platform Support](../reference/platform-support) lists current support status and limitations. +- [About Managed MCP Servers](../manage-sandboxes/mcp-servers/about-managed-mcp-servers) explains the managed MCP security and lifecycle boundary. +- [Understand Deep Agents Trace Export](../monitoring/understand-deepagents-trace-export) explains the managed trace data and receiver trust boundaries. - [Quickstart with Deep Agents](../get-started/quickstart) installs NemoClaw and launches your first Deep Agents sandbox. - [Choose an Inference Provider](../inference/learn-and-choose/choose-inference-provider) explains provider choices and the `inference.local` route. - [Deep Agents Code overview](https://docs.langchain.com/oss/python/deepagents/code/overview) explains upstream `dcode` capabilities and commands. diff --git a/docs/about/ecosystem-hermes.mdx b/docs/about/ecosystem-hermes.mdx index b9118ae619f..83493dc437f 100644 --- a/docs/about/ecosystem-hermes.mdx +++ b/docs/about/ecosystem-hermes.mdx @@ -52,7 +52,7 @@ The following table shows the scope of each component in the stack. |---------|--------| | [Hermes](https://hermes-agent.nousresearch.com/docs/) | The agent: runtime, tools, messaging adapters, and an OpenAI-compatible API inside the container. It does not define the sandbox or the host gateway. | | [OpenShell](https://github.com/NVIDIA/OpenShell) | The execution environment: sandbox lifecycle, network, filesystem, and process policy, inference routing, and the operator-facing `openshell` CLI for those primitives. | -| NemoClaw | The NVIDIA reference stack on the host: `nemohermes` / `nemoclaw` CLI, versioned blueprint, channel messaging configured for OpenShell-managed delivery, and state migration helpers so Hermes runs inside OpenShell in a documented, repeatable way. | +| NemoClaw | The NVIDIA reference stack on the host: `nemohermes` and `nemoclaw` CLI paths, versioned blueprint, managed inference and Model Context Protocol (MCP) servers, messaging-channel setup, host readiness reporting, and lifecycle operations. | ## NemoClaw Path versus OpenShell Path @@ -78,11 +78,13 @@ The following table compares custom OpenShell integration with `nemohermes onboa | Credential handling | You create OpenShell providers manually with `openshell provider create` and configure placeholder resolution at egress. | NemoClaw creates OpenShell providers during onboarding and filters sensitive host environment variables from the sandbox creation command to reduce accidental leakage through build args. | | Image hardening | Depends on your base image and install steps. | NemoClaw removes build toolchains (`gcc`, `g++`, `make`) and network probes (`netcat`) from the runtime image to reduce attack surface. | | Filesystem policy | You define read-only and read-write paths in policy YAML. | NemoClaw defines a targeted layout: system paths (`/usr`, `/lib`, `/etc`) are read-only; `/sandbox` and `/sandbox/.hermes` are writable for agent state and configuration. | -| Inference setup | You configure OpenShell inference routing and Hermes `config.yaml` manually. | NemoClaw validates credentials from the host, configures the OpenShell route, and bakes model settings into `/sandbox/.hermes/config.yaml`. Hermes Provider onboarding is available through `nemohermes`. | -| Channel messaging | OpenShell delivers channel tokens through its provider system and L7 proxy; you configure Hermes platform adapters manually. | NemoClaw automates supported channel setup during onboarding and bakes Hermes env/config with placeholder tokens that OpenShell resolves at egress. | -| Blueprint versioning | No NemoClaw blueprint; your image tag is whatever you built locally. | NemoClaw downloads the blueprint artifact, checks version compatibility, and verifies its digest before applying. Running `nemohermes onboard` on different machines produces the same sandbox. | -| State migration | Not included unless you build it. | NemoClaw migrates agent state across machines with credential stripping and integrity verification. | -| Process count limits | You set process count limits manually with `--ulimit` or orchestrator config. | NemoClaw applies `ulimit -u 512` in the container entrypoint on top of OpenShell's seccomp and privilege dropping. | +| Inference setup | You configure OpenShell inference routing and Hermes `config.yaml` manually. | NemoClaw validates the selected provider and model from the host, configures the OpenShell route, and writes the managed model settings into `/sandbox/.hermes/config.yaml`. Hermes Provider onboarding is available through `nemohermes`. | +| Managed MCP | You register providers, network policy, and Hermes MCP configuration yourself. | NemoClaw manages authenticated HTTPS Streamable HTTP MCP server lifecycle, ownership records, policy, and credential placeholders through host-side commands. | +| Channel messaging | OpenShell delivers channel credentials through its provider system and L7 proxy. You configure Hermes platform adapters manually. | NemoClaw configures supported channels during onboarding or through lifecycle commands and writes the managed Hermes channel settings. | +| Blueprint versioning | No NemoClaw blueprint; your image tag is whatever you built locally. | NemoClaw downloads the blueprint artifact, checks version compatibility, and verifies its digest before applying. Repeated onboarding uses the selected blueprint and recorded configuration; host and platform differences can still affect the result. | +| Lifecycle state | Not included unless you build it. | NemoClaw records lifecycle progress, preserves manifest-declared Hermes state across rebuilds, and supports snapshot and restore without copying `auth.json`. | +| Host readiness and operations | You inspect host prerequisites and operate OpenShell resources directly. | NemoClaw provides read-only host readiness reporting, sandbox status and logs, recovery guidance, rebuild, snapshot, restore, and uninstall workflows. | +| Process count limits | You set process count limits manually with `--ulimit` or orchestrator configuration. | NemoClaw applies a best-effort `ulimit -u 512` in the container entrypoint. Refer to the platform and hardening guidance for hosts that cannot enforce the complete control set. | ## When to Use Which @@ -100,5 +102,7 @@ Use the following table to choose NemoHermes or OpenShell. - [Overview](overview) defines NemoClaw's capabilities, benefits, and use cases. - [How It Works](how-it-works) describes how NemoClaw runs, the blueprint, sandbox creation, routing, and protection layers for Hermes. - [Architecture](../reference/architecture) shows the repository structure and technical diagrams. +- [Platform Support](../reference/platform-support) lists current support status and limitations. +- [About Managed MCP Servers](../manage-sandboxes/mcp-servers/about-managed-mcp-servers) explains the managed MCP security and lifecycle boundary. - [Quickstart with Hermes](../get-started/quickstart) installs NemoClaw and launches your first Hermes sandbox. - [Community Solutions](../resources/community-contributions) explains how to contribute community-driven examples, showcases, and complete blueprint patterns. diff --git a/docs/about/ecosystem.mdx b/docs/about/ecosystem.mdx index e2258263ad1..2a834d01df4 100644 --- a/docs/about/ecosystem.mdx +++ b/docs/about/ecosystem.mdx @@ -51,7 +51,7 @@ The following table shows the scope of each component in the stack. |---------|--------| | [OpenClaw](https://openclaw.ai) | The assistant: runtime, tools, memory, and behavior inside the container. It does not define the sandbox or the host gateway. | | [OpenShell](https://github.com/NVIDIA/OpenShell) | The execution environment: sandbox lifecycle, network, filesystem, and process policy, inference routing, and the operator-facing `openshell` CLI for those primitives. | -| NemoClaw | The NVIDIA reference stack on the host: `nemoclaw` CLI and plugin, versioned blueprint, channel messaging configured for OpenShell-managed delivery, and state migration helpers so OpenClaw runs inside OpenShell in a documented, repeatable way. | +| NemoClaw | The NVIDIA reference stack on the host: `nemoclaw` CLI, OpenClaw plugin, versioned blueprint, managed inference and Model Context Protocol (MCP) servers, messaging-channel setup, host readiness reporting, and lifecycle operations. | ## NemoClaw Path versus OpenShell Path @@ -78,11 +78,13 @@ The following table compares the two paths. | Credential handling | OpenShell's provider system replaces real credentials with placeholder tokens in the sandbox environment. The L7 proxy resolves placeholders to real values at egress. You create providers manually with `openshell provider create`. | NemoClaw creates OpenShell providers automatically during onboarding. It also filters sensitive host environment variables (provider API keys, `DISCORD_BOT_TOKEN`, `SLACK_BOT_TOKEN`, `TELEGRAM_BOT_TOKEN`) from the sandbox creation command to prevent accidental leakage through build args. | | Image hardening | The community image includes standard system tools for general-purpose use. | NemoClaw removes build toolchains (`gcc`, `g++`, `make`) and network probes (`netcat`) from the runtime image to reduce attack surface. | | Filesystem policy | The community sandbox bundles a policy for OpenClaw. | NemoClaw defines a targeted read-only and read-write layout. System paths (`/usr`, `/lib`, `/etc`) are read-only. The agent's home directory (`/sandbox`) and config directory (`/sandbox/.openclaw`) are writable by default so the agent can manage config, install skills, and write to standard paths. | -| Inference setup | The community sandbox includes an `openclaw-start` script that runs OpenClaw's onboarding wizard inside the sandbox. You can also create providers and configure OpenShell inference routing manually from the host. | NemoClaw's onboarding wizard validates your credential from the host, lets you select a provider (NVIDIA Endpoints, OpenAI, Anthropic, Google Gemini, Ollama, and compatible endpoints), and configures OpenShell's inference routing automatically. Credentials stay on the host, and OpenShell's provider system delivers them. | -| Channel messaging | OpenShell provides the credential provider system and L7 proxy that delivers channel tokens securely (including path-based resolution for Telegram's `/bot/` URL pattern). You create providers and configure OpenClaw's channel settings manually. | NemoClaw automates channel setup during onboarding: it collects bot tokens, registers them as OpenShell providers, and bakes OpenClaw channel config with placeholder tokens that OpenShell's proxy resolves at egress. No separate bridge process runs on the host. | -| Blueprint versioning | No blueprint. The community sandbox uses the published image version. | NemoClaw downloads the blueprint artifact, checks version compatibility, and verifies its digest before applying. Running `nemoclaw onboard` on different machines produces the same sandbox. | -| State migration | Not included. | NemoClaw migrates agent state across machines with credential stripping and integrity verification. | -| Process count limits | OpenShell applies seccomp and privilege dropping. You set process count limits manually with `--ulimit` or orchestrator config. | NemoClaw applies `ulimit -u 512` in the container entrypoint to cap the process count and mitigate fork-bomb attacks, on top of OpenShell's seccomp and privilege dropping. | +| Inference setup | The community sandbox includes an `openclaw-start` script that runs OpenClaw's onboarding wizard inside the sandbox. You can also create providers and configure OpenShell inference routing manually from the host. | NemoClaw validates the selected provider and model from the host, configures the OpenShell inference route, and writes the managed OpenClaw model reference. Provider credentials stay outside the sandbox. | +| Managed MCP | You register providers, network policy, and OpenClaw MCP configuration yourself. | NemoClaw manages authenticated HTTPS Streamable HTTP MCP server lifecycle, ownership records, policy, and credential placeholders through host-side commands. | +| Channel messaging | OpenShell provides the credential provider system and L7 proxy for channel traffic. You create providers and configure OpenClaw channel settings manually. | NemoClaw configures supported channels during onboarding or through lifecycle commands. Some experimental webhook channels also require a route-restricted host-side public endpoint. | +| Blueprint versioning | No blueprint. The community sandbox uses the published image version. | NemoClaw downloads the blueprint artifact, checks version compatibility, and verifies its digest before applying. Repeated onboarding uses the selected blueprint and recorded configuration; host and platform differences can still affect the result. | +| Lifecycle state | Not included. | NemoClaw records lifecycle progress, preserves manifest-declared state across rebuilds, and supports snapshot and restore with credential stripping and integrity checks. | +| Host readiness and operations | You inspect host prerequisites and operate OpenShell resources directly. | NemoClaw provides read-only host readiness reporting, sandbox status and logs, recovery guidance, rebuild, snapshot, restore, and uninstall workflows. | +| Process count limits | OpenShell applies seccomp and privilege dropping. You set process count limits manually with `--ulimit` or orchestrator configuration. | NemoClaw applies a best-effort `ulimit -u 512` in the container entrypoint. Refer to the platform and hardening guidance for hosts that cannot enforce the complete control set. | ## When to Use Which @@ -100,4 +102,6 @@ Use the following table to choose NemoClaw or OpenShell. - [Overview](overview) defines NemoClaw's capabilities, benefits, and use cases. - [How It Works](how-it-works) describes how NemoClaw runs, including the plugin, blueprint, sandbox creation, routing, and protection layers. - [Architecture](../reference/architecture) shows the repository structure and technical diagrams. +- [Platform Support](../reference/platform-support) lists current support status and limitations. +- [About Managed MCP Servers](../manage-sandboxes/mcp-servers/about-managed-mcp-servers) explains the managed MCP security and lifecycle boundary. - [Community Solutions](../resources/community-contributions) explains how to contribute community-driven examples, showcases, and complete blueprint patterns. diff --git a/docs/about/how-it-works.mdx b/docs/about/how-it-works.mdx index 214cbb9e582..afcac70704b 100644 --- a/docs/about/how-it-works.mdx +++ b/docs/about/how-it-works.mdx @@ -3,78 +3,45 @@ # SPDX-License-Identifier: Apache-2.0 title: "NemoClaw Architecture Overview" sidebar-title: "Architecture Overview" -description: "Learn how NemoClaw combines a host CLI, sandbox plugin, and versioned blueprint to run supported agents in a controlled sandbox." -description-agent: "Describes how NemoClaw works internally: CLI, plugin, blueprint runner, OpenShell orchestration, inference routing, and protection layers. Use for sandbox lifecycle and architecture mechanics; not for product definition (Overview) or multi-project placement (Ecosystem)." -keywords: ["how nemoclaw works", "nemoclaw sandbox lifecycle blueprint"] +description: "Learn how NemoClaw combines a host CLI, agent integration layer, versioned blueprint, and OpenShell gateway to operate supported agents." +description-agent: "Describes how NemoClaw works internally: host CLI, agent integration layer, blueprint runner, OpenShell orchestration, lifecycle state, managed integrations, inference routing, and protection layers. Use for sandbox lifecycle and architecture mechanics; not for product definition (Overview) or multi-project placement (Ecosystem)." +keywords: ["how nemoclaw works", "nemoclaw sandbox lifecycle blueprint", "nemoclaw managed mcp architecture"] content: type: "concept" --- -This page explains how NemoClaw runs supported agents inside an OpenShell sandbox and how the gateway connects the agent to inference, integrations, and policy. +This page explains how NemoClaw runs supported agent runtimes inside OpenShell sandboxes. +It covers the host CLI, OpenShell gateway, agent integration layer, lifecycle state, managed Model Context Protocol (MCP) servers and other integrations, and protection layers. -NemoClaw does not replace OpenShell or your chosen agent runtime. -NemoClaw packages them as a repeatable setup with a host CLI, a versioned blueprint, default policies, inference setup, and state helpers. - -OpenClaw sandboxes also load the NemoClaw plugin for managed inference metadata and the `/nemoclaw` slash command. - - -Hermes sandboxes receive agent configuration under `/sandbox/.hermes` during onboarding instead of the OpenClaw plugin path. - - -Deep Agents sandboxes receive managed `dcode` configuration under `/sandbox/.deepagents` during onboarding instead of the OpenClaw plugin path. - -You can use that setup directly or adapt it for your own OpenShell integration. +NemoClaw does not replace OpenShell or the selected agent runtime. +It packages them as a repeatable setup with a versioned blueprint, agent-specific configuration, managed inference, network policy, and lifecycle operations. ## High-Level Flow -NemoClaw keeps the user workflow on the host while OpenShell enforces the sandbox boundary. -The gateway sits between NemoClaw control, the sandbox, inference providers, and external integrations. -That placement lets NemoClaw configure the environment without giving the agent direct access to host credentials or uncontrolled network egress. +NemoClaw keeps operator control on the host while OpenShell enforces the sandbox boundary. +The OpenShell gateway coordinates sandbox lifecycle, credentials, network policy, inference routes, and approved integration traffic. ```mermaid -flowchart TB - subgraph TOP_ROW[" "] - direction LR - TOP_USERS["Users + Operators
Developer, admin
end-user channels"]:::hidden - TOP_CONTROL["NemoClaw Control
CLI, installer, dashboard
onboard + configure"]:::hidden - INFERENCE["Inference
NVIDIA Endpoints, NIM
or compatible APIs"]:::inference - TOP_SANDBOX["NemoClaw Sandbox
Selected agent runtime
integration, blueprints, tools"]:::hidden - TOP_STATE["State + Artifacts
Config, credentials, logs
workspace, policy, transcripts"]:::hidden - - TOP_USERS ~~~ TOP_CONTROL ~~~ INFERENCE ~~~ TOP_SANDBOX ~~~ TOP_STATE - end - - subgraph MAIN_ROW[" "] - direction LR - USERS["Users + Operators
Developer, admin
end-user channels"]:::users - CONTROL["NemoClaw Control
CLI, installer, dashboard
onboard + configure"]:::control - GATEWAY["OpenShell Gateway
Sandbox lifecycle
networking + policy"]:::gateway - SANDBOX["NemoClaw Sandbox
Selected agent runtime
integration, blueprints, tools"]:::sandbox - STATE["State + Artifacts
Config, credentials, logs
workspace, policy, transcripts"]:::state - - USERS --> CONTROL - CONTROL --> GATEWAY - GATEWAY -->|"egress via gateway"| SANDBOX - SANDBOX -.-> STATE - end - - subgraph BOTTOM_ROW[" "] - direction LR - BOTTOM_USERS["Users + Operators
Developer, admin
end-user channels"]:::hidden - BOTTOM_CONTROL["NemoClaw Control
CLI, installer, dashboard
onboard + configure"]:::hidden - INTEGRATIONS["Integrations
Messaging, MCP
GitHub, npm, PyPI, HF"]:::integrations - BOTTOM_SANDBOX["NemoClaw Sandbox
Selected agent runtime
integration, blueprints, tools"]:::hidden - BOTTOM_STATE["State + Artifacts
Config, credentials, logs
workspace, policy, transcripts"]:::hidden - - BOTTOM_USERS ~~~ BOTTOM_CONTROL ~~~ INTEGRATIONS ~~~ BOTTOM_SANDBOX ~~~ BOTTOM_STATE - end - - GATEWAY -->|"inference via gateway"| INFERENCE - GATEWAY -->|"integrations via gateway"| INTEGRATIONS - - style TOP_ROW fill:transparent,stroke:transparent - style MAIN_ROW fill:transparent,stroke:transparent - style BOTTOM_ROW fill:transparent,stroke:transparent - classDef hidden fill:transparent,stroke:transparent,color:transparent,stroke-width:0px +flowchart LR + USERS["Users and operators"]:::users + CLI["NemoClaw host CLI
install, probe, onboard, operate"]:::control + GATEWAY["OpenShell gateway
lifecycle, credentials, policy, routing"]:::gateway + SANDBOX["OpenShell sandbox
agent runtime and integration layer"]:::sandbox + INTERFACE["Agent interface
runtime-specific interaction path"]:::users + STATE["Managed state and artifacts
registry, workspace, policy records, snapshots"]:::state + INFERENCE["Inference providers
supported hosted or local inference"]:::inference + INTEGRATIONS["Approved integrations
MCP servers and package services"]:::integrations + + USERS -->|"operate"| CLI + CLI -->|"configure resources"| GATEWAY + GATEWAY -->|"create and control"| SANDBOX + SANDBOX -->|"managed requests"| GATEWAY + GATEWAY -->|"routed inference"| INFERENCE + GATEWAY -->|"approved egress"| INTEGRATIONS + USERS -->|"interact"| INTERFACE + INTERFACE --> SANDBOX + CLI -->|"record lifecycle"| STATE + SANDBOX -.->|"persist declared state"| STATE + classDef users fill:#d9ecf7,stroke:#6aa6c8,color:#1a1a1a,stroke-width:2px classDef control fill:#d7f0dc,stroke:#5a9f70,color:#1a1a1a,stroke-width:2px classDef gateway fill:#fff1be,stroke:#c4992f,color:#1a1a1a,stroke-width:2px @@ -88,13 +55,14 @@ The diagram has the following components: | Component | Role in the flow | |-------|------------------| -| Users and operators | Start from the CLI, installer, dashboard, or an end-user channel. | -| NemoClaw control | Collects configuration, runs onboarding, prepares the blueprint, and asks OpenShell to create or update resources. | -| OpenShell gateway | Owns sandbox lifecycle, networking, policy enforcement, inference routing, and integration egress. | -| NemoClaw sandbox | Runs the onboarded agent with the selected blueprint contents and supporting tools. | -| Inference | Receives model requests through the gateway, using NVIDIA endpoints, NIM, or compatible APIs. | -| Integrations | Reach messaging services, MCP servers, GitHub, package indexes, or model hubs through gateway-managed egress. | -| State and artifacts | Store configuration, credentials, logs, workspace files, policies, and transcripts outside the running agent process. | +| Users and operators | Install and operate NemoClaw from the host, then interact through the selected agent interface. | +| NemoClaw host CLI | Collects configuration, runs readiness checks and onboarding, resolves the blueprint, and operates managed resources. | +| OpenShell gateway | Coordinates sandbox lifecycle, credentials, networking, policy enforcement, inference routing, and approved integration egress. | +| OpenShell sandbox | Runs the selected agent runtime with its NemoClaw integration layer, configuration, and supporting tools. | +| Agent interface | Provides the interaction path exposed by the selected agent runtime. | +| Inference providers | Receive managed inference requests through the OpenShell gateway. | +| Approved integrations | Receive policy-approved requests to MCP servers, package indexes, and other configured services. | +| Managed state and artifacts | Preserve registry records, workspace files, policy records, logs, and manifest-declared snapshot content across supported lifecycle operations. | For repository layout, file paths, and deeper diagrams, refer to [Architecture](../reference/architecture). @@ -103,70 +71,90 @@ For repository layout, file paths, and deeper diagrams, refer to [Architecture]( NemoClaw follows these architecture principles. Versioned blueprint -: Host-side orchestration uses a versioned blueprint and runner that can evolve on its own release cadence. +: The blueprint runner resolves a versioned blueprint and verifies its digest before it changes managed resources. - +Host credential custody +: OpenShell stores inference provider credentials and managed MCP bearer values outside the sandbox and replaces placeholders at approved request boundaries. -The OpenClaw sandbox plugin stays small and stable inside the container. +Agent-specific integration +: Each supported agent runtime receives the configuration, wrappers, plugin, or adapter required for its documented workflow. - +Resumable lifecycle +: NemoClaw records lifecycle progress and reconciles managed resources after supported interruptions or partial operations. -Respect CLI boundaries -: The `$$nemoclaw` CLI is the primary interface for sandbox management. +Manifest-declared state +: Rebuild, snapshot, and restore operations preserve only the state declared for the selected agent runtime. + Each agent manifest and operation defines which credential-bearing files to exclude. -Supply chain safety -: Blueprint artifacts are immutable, versioned, and digest-verified before execution. + -OpenShell-backed lifecycle -: NemoClaw orchestrates OpenShell resources under the hood, but `$$nemoclaw onboard` is the supported operator entry point for creating or recreating NemoClaw-managed sandboxes. +Host-configured messaging credentials also use OpenShell credential delivery. +Some messaging integrations, such as QR-paired WhatsApp, retain explicitly declared session credentials inside the sandbox so supported lifecycle operations can preserve them. -Reproducible setup -: Running setup again recreates the sandbox from the same blueprint and policy definitions. + -## CLI, Plugin, and Blueprint +## CLI, Integration Layer, and Blueprint -NemoClaw separates host orchestration from sandbox image contents. +NemoClaw separates host orchestration, agent-specific behavior, and sandbox definition. -- The _host CLI_ runs onboarding, validates provider choices, stores configuration, and calls OpenShell commands for gateway, provider, sandbox, and policy operations. +- The _host CLI_ runs readiness checks and onboarding, validates provider choices, records lifecycle state, and operates OpenShell resources. -- The _plugin_ is a TypeScript package that runs with OpenClaw inside the sandbox. +- The _OpenClaw integration layer_ includes a TypeScript plugin that runs inside the sandbox. It registers the managed inference provider metadata, the `/nemoclaw` slash command, and runtime context hooks. Runtime context is prepended as system guidance, so sandbox and policy instructions stay active without appearing in the visible chat transcript. -- NemoClaw writes Hermes runtime configuration into `/sandbox/.hermes` during onboarding, including `config.yaml`, environment files, and platform adapter settings for supported messaging channels. +- The _Hermes integration layer_ writes runtime configuration under `/sandbox/.hermes`, including `config.yaml`, environment files, and supported messaging-channel settings. -- NemoClaw writes Deep Agents runtime configuration into `/sandbox/.deepagents` during onboarding, including `config.toml`, managed MCP projection state, and the inference route used by `dcode`. +- The _Deep Agents integration layer_ writes managed runtime configuration under `/sandbox/.deepagents`. + It includes `config.toml`, managed MCP projection state, and the inference route used by `dcode`. -- The _blueprint_ is a versioned YAML package with the sandbox image, policy, inference profile, and supporting assets. +- The _blueprint_ is a versioned YAML package with the sandbox image, agent manifest, network policy, inference profile, and supporting assets. The runner resolves and verifies the blueprint before applying it through OpenShell. -This separation keeps agent-specific sandbox assets focused and lets host orchestration and blueprint contents evolve on separate release cadences. +This separation keeps host orchestration, agent-specific assets, and the sandbox definition at explicit lifecycle boundaries. + +## Readiness and Sandbox Creation -## Sandbox Creation +Run `$$nemoclaw host probe` when you need a read-only host readiness report before onboarding. +The report describes host observations, capabilities, qualifications, findings, evidence, and CLI provenance without changing host state. -When you run `$$nemoclaw onboard`, NemoClaw creates an OpenShell sandbox that runs your selected agent in an isolated container. -The host CLI and blueprint runner orchestrate this process through the OpenShell CLI: +When you run `$$nemoclaw onboard`, the host CLI and blueprint runner complete these operations: 1. NemoClaw resolves the blueprint, checks version compatibility, and verifies the digest. -2. The onboarding flow determines which OpenShell resources to create or update, such as the gateway, inference providers, sandbox, and network policy. -3. The runner calls OpenShell CLI commands to create the sandbox and configure each resource. +2. Onboarding validates the selected inference provider, credentials, agent settings, and platform requirements. +3. The runner determines which gateway, provider, policy, sandbox, and integration resources to create or update. +4. NemoClaw records progress so a supported interruption can resume or report a specific recovery action. + +After the sandbox starts, the selected agent uses its managed configuration and the controls supported by the host. + +## Lifecycle and State + +NemoClaw operates the sandbox and its manifest-declared state through host-side commands. -After the sandbox starts, the agent runs inside it with all network, filesystem, and inference controls in place. +| Operation | Result | +|---|---| +| Inspect | `host probe`, `status`, and `logs` report host, sandbox, agent-runtime, inference, and recovery information without replacing the sandbox. | +| Configure | Inference, policy, managed MCP, and supported agent-runtime integration commands update the applicable managed resources. | +| Rebuild | Recreates the sandbox from the recorded configuration and restores supported agent state through a recorded transaction. | +| Recover | Repairs a stopped or degraded agent runtime and its sandbox-scoped forwards when the recorded identities still match. | +| Snapshot and restore | Captures manifest-declared state with the agent- and operation-specific credential exclusions, then applies that state to an eligible sandbox. | +| Destroy and uninstall | Removes the selected sandbox or host installation according to the command scope and preservation choices. | + +Refer to [Recover and Rebuild Sandboxes](../manage-sandboxes/operate-sandboxes/recover-and-rebuild-sandboxes) and [Create and Restore Snapshots](../manage-sandboxes/state-and-backups/create-and-restore-snapshots) for lifecycle details. ## Inference Routing -Inference requests from the agent never leave the sandbox directly. -OpenShell intercepts every inference call and routes it to the configured provider. -During onboarding, NemoClaw validates the selected provider and model, configures the OpenShell route, and bakes the matching model reference into the sandbox image. -The sandbox then talks to `inference.local`, while the host owns the actual provider credential and upstream endpoint. +Managed agent runtimes send model requests to `inference.local` instead of an upstream endpoint. +During onboarding, NemoClaw validates the selected provider and model, configures the OpenShell inference route, and writes the matching model reference into the managed agent configuration. +OpenShell keeps the provider credential outside the sandbox and sends approved requests to the upstream endpoint. When you select the Model Router provider, `inference.local` routes to a host-side router that chooses from the configured NVIDIA model pool for each request. For Hermes, `$$nemoclaw inference set` updates `/sandbox/.hermes/config.yaml` at runtime without rebuilding the sandbox. @@ -175,9 +163,34 @@ For Hermes, `$$nemoclaw inference set` updates `/sandbox/.hermes/config.yaml` at For Deep Agents, the managed `dcode` runtime reads the OpenAI-compatible route that NemoClaw writes into `/sandbox/.deepagents/config.toml`. +## Managed Integrations + +NemoClaw connects supported external services through OpenShell providers, network policy, and agent-specific adapters. + +Managed MCP supports authenticated HTTPS Streamable HTTP MCP servers for OpenClaw, Hermes, and Deep Agents Code. +NemoClaw stores the credential name and ownership metadata, while OpenShell stores the raw value outside the sandbox. +The agent adapter receives a credential placeholder that OpenShell replaces only at the approved egress boundary. + + + +Messaging channels use agent-specific channel manifests, credential delivery, network policy, and lifecycle commands. +Some experimental webhook channels also require a route-restricted host-side public endpoint. +Refer to [Choose Messaging Channels](../manage-sandboxes/messaging-channels/choose-messaging-channels) for agent and channel status. + + + + +Deep Agents Code can also opt into bounded trace export to an operator-managed host collector. +Native LangSmith tracing and ambient OpenTelemetry exporter configuration remain disabled inside the sandbox. +Refer to [Understand Deep Agents Trace Export](../monitoring/understand-deepagents-trace-export) for the data and receiver trust boundaries. + + + +Refer to [About Managed MCP Servers](../manage-sandboxes/mcp-servers/about-managed-mcp-servers) for the managed MCP security and lifecycle design. + ## Protection Layers -The sandbox starts with a default policy that controls network egress, filesystem access, process privileges, and inference routing. +The sandbox starts with a baseline policy that controls network egress, filesystem access, process privileges, and inference routing. | Layer | What it protects | When it applies | |---|---|---| @@ -186,10 +199,13 @@ The sandbox starts with a default policy that controls network egress, filesyste | Process | Blocks privilege escalation and dangerous syscalls. | Locked at sandbox creation. | | Inference | Reroutes model API calls to controlled backends. | Hot-reloadable at runtime. | -When the agent tries to reach an unlisted host, OpenShell blocks the request and surfaces it in the TUI for operator approval. -Approved endpoints persist for the current session but are not saved to the baseline policy file. +When the agent tries to reach an unapproved host, OpenShell blocks the request and surfaces it in the terminal user interface (TUI) for operator approval. +Approved endpoints persist within the current sandbox instance but are not saved to the baseline policy file. NemoClaw's runtime context tells supported agents to try allowed network and filesystem actions first, then report whether policy denial, DNS, timeout, TLS, or filesystem access caused a failure. +Host and platform limitations can change how individual controls apply. +Refer to [Platform Support](../reference/platform-support) and [Security Best Practices](../security/best-practices) before you treat a control as an environment-wide guarantee. + ## Next Steps @@ -198,8 +214,8 @@ NemoClaw's runtime context tells supported agents to try allowed network and fil - Follow [Quickstart with OpenClaw](../get-started/quickstart) to launch your first sandbox. - Read [Architecture](../reference/architecture) for the full technical structure, including file layouts and the blueprint lifecycle. - Read [Choose an Inference Provider](../inference/learn-and-choose/choose-inference-provider) for detailed provider configuration. -- For details on the baseline rules, refer to [Network Policies](../reference/network-policies). -- For container-level hardening, refer to [Review Sandbox Hardening](../manage-sandboxes/configure-sandboxes/review-sandbox-hardening). +- Read [Network Policies](../reference/network-policies) for baseline rules and runtime changes. +- Read [Review Sandbox Hardening](../manage-sandboxes/configure-sandboxes/review-sandbox-hardening) for container-level controls and limitations. @@ -208,7 +224,7 @@ NemoClaw's runtime context tells supported agents to try allowed network and fil - Follow [Quickstart with Hermes](../get-started/quickstart) to launch your first sandbox. - Read [Architecture](../reference/architecture) for the full technical structure, including file layouts and the blueprint lifecycle. - Read [Choose an Inference Provider](../inference/learn-and-choose/choose-inference-provider) for detailed provider configuration. -- For details on the baseline rules, refer to [Network Policies](../reference/network-policies). +- Read [Network Policies](../reference/network-policies) for baseline rules and runtime changes. @@ -217,6 +233,6 @@ NemoClaw's runtime context tells supported agents to try allowed network and fil - Follow [Quickstart with Deep Agents](../get-started/quickstart) to launch your first sandbox. - Read [Architecture](../reference/architecture) for the full technical structure, including file layouts and the blueprint lifecycle. - Read [Choose an Inference Provider](../inference/learn-and-choose/choose-inference-provider) for detailed provider configuration. -- For details on the baseline rules, refer to [Network Policies](../reference/network-policies). +- Read [Network Policies](../reference/network-policies) for baseline rules and runtime changes. diff --git a/docs/about/overview.mdx b/docs/about/overview.mdx index d8af765c711..8ee356cda56 100644 --- a/docs/about/overview.mdx +++ b/docs/about/overview.mdx @@ -22,40 +22,33 @@ NVIDIA NemoClaw is an open-source reference stack for running AI coding agents m -NemoClaw provides onboarding, lifecycle management, and agent operations for supported runtimes in OpenShell sandboxes. -It adds policy-based privacy and security controls for agent behavior and data handling. -These controls help agents run in clouds, on-premises environments, RTX PCs, and DGX Spark. - -NemoClaw pairs hosted inference providers or local model endpoints with a hardened sandbox, routed inference, and declarative egress policy. -This keeps deployments repeatable and easier to constrain. -The sandbox runtime comes from [NVIDIA OpenShell](https://github.com/NVIDIA/OpenShell). -NemoClaw adds the blueprint, `$$nemoclaw` CLI, onboarding, and related tooling as the reference way to run supported agents there. - -| Capability | Description | -|-------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------| -| Sandbox supported agents | Creates an OpenShell sandbox pre-configured for your selected agent, with filesystem and network policies applied from the first boot. | -| Route inference | Configures OpenShell inference routing so agent traffic goes to the provider and model you chose during onboarding (NVIDIA Endpoints, OpenAI, Anthropic, Gemini, compatible endpoints, local Ollama, and others). The agent uses `inference.local` inside the sandbox; credentials stay on the host. | -| Manage the lifecycle | Handles blueprint versioning, digest verification, and sandbox setup. | - -## Key Features - -NemoClaw provides these product capabilities. - -| Feature | Description | -|---------|-------------| -| Guided onboarding | Validates credentials, selects providers, and creates a working sandbox in one command. | -| AI-agent docs | Publishes Markdown docs and a small routing skill so AI coding assistants can guide setup, inference configuration, policy management, monitoring, deployment, security review, and troubleshooting. | -| Hardened blueprint | A Dockerfile with capability drops, least-privilege network rules, and declarative policy. | -| State management | Safe migration of agent state across machines with credential stripping and integrity verification. | -| Routed inference | Provider-routed model calls through the OpenShell gateway, transparent to the agent. Supports NVIDIA Endpoints, OpenAI, Anthropic, Google Gemini, compatible endpoints, local Ollama, local vLLM, and the Model Router. | -| Layered protection | Network, filesystem, process, and inference controls that can be hot-reloaded or locked at creation. | - +NemoClaw provides onboarding, lifecycle management, and agent operations for supported agent runtimes in OpenShell sandboxes. +It combines a host CLI, a versioned blueprint, and an agent-specific integration layer. +The OpenShell gateway coordinates sandbox lifecycle, managed inference, credentials, and policy enforcement. + +The primary tested platforms are Linux and DGX Spark. +NemoClaw also documents platform limitations for macOS, Windows Subsystem for Linux (WSL), DGX Station, and headless Linux servers. +Refer to [Platform Support](../reference/platform-support) for current agent, platform, provider, integration, and deployment-path status. + +## What NemoClaw Provides + +NemoClaw groups its supported capabilities around running, connecting, controlling, and operating agents. + +| Area | Capability | +|---|---| +| Run supported agents | Onboards OpenClaw, Hermes, or LangChain Deep Agents Code into an agent-specific sandbox image and configuration. | +| Route inference | Connects supported hosted inference and local inference providers through `inference.local`. OpenShell keeps provider credentials outside the sandbox. | +| Control sandbox access | Applies network policy, filesystem policy, process controls, and managed inference through OpenShell. | +| Operate the lifecycle | Reports host readiness, creates or updates sandboxes, reports status and logs, rebuilds or recovers sandboxes, and creates or restores snapshots. | +| Connect Model Context Protocol (MCP) servers | Manages authenticated HTTPS Streamable HTTP MCP servers for all supported agent runtimes. OpenShell replaces credential placeholders at approved egress boundaries. | +| Extend agent workflows | Installs agent skills and publishes Markdown documentation that coding agents can use for setup, operation, security review, and troubleshooting. | - -| Feature | Description | -|---------|-------------| -| Messaging channels | OpenShell-managed processes connect Telegram, Discord, Slack, and similar platforms to supported messaging agents. NemoClaw configures channels during onboarding where the selected agent supports them; OpenShell supplies the native constructs, credential flow, and runtime supervision. | - +| Connect messaging channels | Configures supported messaging channels during onboarding or through lifecycle commands. Availability and maturity vary by agent and channel. | +| Configure web search | Configures a supported Brave Search or Tavily Search path and keeps the service credential outside the sandbox. Provider availability varies by agent. | + + +| Operate a terminal agent | Runs the managed `dcode` terminal agent interactively or through its headless JSON workflow. | +| Export traces | Optionally sends bounded Deep Agents Code traces to an operator-managed host collector. The receiver and exported content require the documented trust controls. | ## Benefits of Using NemoClaw @@ -63,58 +56,76 @@ NemoClaw provides these product capabilities. Autonomous AI agents can make arbitrary network requests, access the host filesystem, and call any inference endpoint. Without controls, this creates security, cost, and compliance risks that grow as agents run unattended. -NemoClaw provides these benefits to mitigate those risks. +NemoClaw provides these controls and lifecycle tools to reduce those risks. -| Benefit | Description | -|----------------------------|------------------------------------------------------------------------------------------------------------------------| -| Sandboxed execution | Every agent runs inside an OpenShell sandbox with Landlock, seccomp, and network namespace isolation. The sandbox grants no access by default. | -| Routed inference | The OpenShell gateway routes model traffic to your selected provider, transparent to the agent. You can switch providers or models. Refer to [Choose an Inference Provider](../inference/learn-and-choose/choose-inference-provider). | -| Declarative network policy | YAML defines egress rules. OpenShell blocks unknown hosts and surfaces them to the operator for approval. | -| Single CLI | The `$$nemoclaw` command orchestrates the full stack: gateway, sandbox, inference provider, and network policy. | -| Blueprint lifecycle | Versioned blueprints handle sandbox creation, digest verification, and reproducible setup. | +| Benefit | Description | +|---|---| +| Sandboxed execution | Runs each agent in an OpenShell sandbox with documented filesystem, process, and network controls. Enforcement limitations vary by host. | +| Credential custody | Keeps inference credentials and managed MCP bearer values outside the sandbox through OpenShell. | +| Operator-controlled egress | Uses YAML network policy and policy presets. OpenShell blocks unapproved destinations and surfaces requests for operator review. | +| Repeatable lifecycle | Uses versioned, digest-verified blueprints and manifest-declared state to support onboarding, rebuild, recovery, snapshot, and restore operations. | +| Agent-specific workflows | Provides dedicated CLI aliases, configuration, lifecycle adapters, documentation, and validation for each supported agent runtime. | + + + +Host-configured messaging credentials also use OpenShell credential delivery. +QR-paired sessions such as WhatsApp store mutable session credentials in the sandbox and preserve them according to the agent manifest. + + ## Use Cases -Use NemoClaw for these use cases. +Use NemoClaw when you need a supported agent runtime with managed inference, network policy, and lifecycle operations. -| Use Case | Description | -|---------------------------|----------------------------------------------------------------------------------------------| -| Always-on assistant | Run a sandboxed agent with controlled network access and operator-approved egress. | -| Terminal coding harness | Run `dcode` inside an OpenShell sandbox with host-owned inference credentials and a managed terminal workflow. | -| Sandboxed testing | Test agent behavior in a locked-down environment before granting broader permissions. | +| Use Case | Description | +|---|---| +| Controlled agent evaluation | Test agent behavior with explicit filesystem and network boundaries before you add more access. | +| Managed tool access | Connect authenticated MCP servers without storing raw service credentials in agent configuration. | | Headless server deployment | Run a sandboxed agent on a remote Linux server through SSH. Refer to [Deploy to a Headless Server](../deployment/deploy-to-headless-server). | + +| Always-on messaging agent | Connect a supported messaging channel to an agent with channel-specific credentials, policy, and lifecycle management. | + + +| Terminal coding agent | Run `dcode` inside an OpenShell sandbox with OpenShell-managed inference credentials and a managed terminal workflow. | + + +## Product Scope + +NemoClaw is an early-preview reference stack for a trusted operator on one host. +It is not a hosted NemoClaw service, a multi-tenant enterprise control plane, or an enterprise identity system. +Refer to [Enterprise Readiness](../reference/enterprise-readiness) for supported, manual, platform-owned, roadmap-only, and out-of-scope capabilities. ## Next Steps Use these topics to learn more about NemoClaw and how to install and use it. +- Read [Platform Support](../reference/platform-support) before you repeat an agent, platform, provider, integration, or deployment claim. +- Read [Architecture Overview](how-it-works) to understand the host CLI, integration layer, blueprint, OpenShell gateway, and sandbox lifecycle. +- Read [About Managed MCP Servers](../manage-sandboxes/mcp-servers/about-managed-mcp-servers) for the managed MCP security and lifecycle boundary. +- Read [System Readiness](../reference/system-readiness) to inspect a host before onboarding without changing host state. +- Read [Use NemoClaw Docs with Your Coding Agents](../resources/agent-skills) to give an AI coding agent the NemoClaw Markdown documentation entry points. + -- Read [Architecture Overview](how-it-works) to understand how NemoClaw works. - Read [Ecosystem](ecosystem) to understand how your agent, OpenShell, and NemoClaw relate in the wider stack, and when to use NemoClaw versus OpenShell. - Follow [Quickstart with OpenClaw](../get-started/quickstart) to install NemoClaw and run your first OpenClaw sandbox. -- Read [Use NemoClaw Docs with Your Coding Agents](../resources/agent-skills) to let your AI coding assistant fetch NemoClaw Markdown docs. -- Review [Community Solutions](../resources/community-contributions) for community-driven blueprint examples, showcases, and integrations. +- Read [Choose Messaging Channels](../manage-sandboxes/messaging-channels/choose-messaging-channels) before you enable a messaging channel. - Read [Choose an Inference Provider](../inference/learn-and-choose/choose-inference-provider) to check the inference providers that NemoClaw supports and how inference routing works. -- Read [Architecture Overview](how-it-works) to understand how NemoClaw works. - Read [Ecosystem](ecosystem) to understand how Hermes, OpenShell, and NemoClaw relate in the wider stack, and when to use NemoClaw versus OpenShell. - Follow [Quickstart with Hermes](../get-started/quickstart) to install NemoClaw and run your first Hermes sandbox with `$$nemoclaw`. -- Read [Use NemoClaw Docs with Your Coding Agents](../resources/agent-skills) to let your AI coding assistant fetch NemoClaw Markdown docs. -- Review [Community Solutions](../resources/community-contributions) for community-driven blueprint examples, showcases, and integrations. +- Read [Choose Messaging Channels](../manage-sandboxes/messaging-channels/choose-messaging-channels) before you enable a messaging channel. - Read [Choose an Inference Provider](../inference/learn-and-choose/choose-inference-provider) to check the inference providers that NemoClaw supports and how inference routing works. -- Read [Architecture Overview](how-it-works) to understand how NemoClaw works. - Read [Ecosystem](ecosystem) to understand how Deep Agents, OpenShell, and NemoClaw relate in the wider stack, and when to use NemoClaw versus OpenShell. - Follow [Quickstart with Deep Agents](../get-started/quickstart) to install NemoClaw and run your first Deep Agents sandbox with `$$nemoclaw`. -- Read [Use NemoClaw Docs with Your Coding Agents](../resources/agent-skills) to let your AI coding assistant fetch NemoClaw Markdown docs. -- Review [Community Solutions](../resources/community-contributions) for community-driven blueprint examples, showcases, and integrations. +- Read [Understand Deep Agents Trace Export](../monitoring/understand-deepagents-trace-export) before you enable managed trace export. - Read [Choose an Inference Provider](../inference/learn-and-choose/choose-inference-provider) to check the inference providers that NemoClaw supports and how inference routing works. diff --git a/docs/index.mdx b/docs/index.mdx index 31190e29f6a..2437c44a6ee 100644 --- a/docs/index.mdx +++ b/docs/index.mdx @@ -3,7 +3,7 @@ # SPDX-License-Identifier: Apache-2.0 title: "NVIDIA NemoClaw" sidebar-title: "Home" -description: "NemoClaw is an open-source reference stack for running sandboxed AI agents more safely, with a single command and Markdown docs for AI assistants." +description: "NemoClaw is an open source reference stack for running supported AI agents more safely with guided onboarding, managed inference, policy, and lifecycle operations." keywords: "NemoClaw, OpenClaw, Hermes, LangChain Deep Agents Code, dcode, OpenShell, AI agents, Markdown docs, sandboxing, inference routing" layout: overview position: 1 @@ -32,9 +32,10 @@ import { CommandTerminal } from "./_components/CommandTerminal"; ]} /> -NVIDIA NemoClaw is an open-source reference stack for running always-on AI agents more safely inside [NVIDIA OpenShell](https://github.com/NVIDIA/OpenShell) sandboxes. -NemoClaw provides onboarding, lifecycle management, and agent operations within OpenShell containers. -It installs the OpenShell runtime, part of NVIDIA Agent Toolkit, and sets up an environment designed for executing agents with additional security and inference routing capabilities. +NVIDIA NemoClaw is an open source reference stack for running supported AI agents more safely inside [NVIDIA OpenShell](https://github.com/NVIDIA/OpenShell) sandboxes. +NemoClaw provides guided onboarding, managed inference, network policy, managed integrations, and lifecycle operations for supported agent runtimes. +It installs OpenShell, part of NVIDIA Agent Toolkit, and applies the selected agent integration layer and versioned blueprint. +OpenShell provides credential custody for managed inference and host-configured integration credentials. ## Get Started diff --git a/docs/reference/platform-support.mdx b/docs/reference/platform-support.mdx index f63b51ed299..160d1f7909e 100644 --- a/docs/reference/platform-support.mdx +++ b/docs/reference/platform-support.mdx @@ -22,7 +22,7 @@ Update the JSON so the tables and partial views on other pages stay in sync with |--------|---------| | Tested | Validated by CI or QA. Safe to claim and to demo. | | Tested with limitations | Works on the listed setup with documented caveats. Caveats must be cited whenever this row is claimed. | -| Experimental | Available behind `NEMOCLAW_EXPERIMENTAL=1` or an equivalent opt-in flag. Do not claim in launch-facing material without the opt-in mentioned. | +| Experimental | Available only after an explicit experimental opt-in, such as `NEMOCLAW_EXPERIMENTAL=1` or selecting an integration that the CLI labels experimental. Do not claim in launch-facing material without the opt-in mentioned. | | Deferred | Planned but not yet validated. Roadmap-only. Do not claim as supported. | | Unsupported | Explicitly out of scope. Not validated and not planned. Documented to set expectations and prevent drift. | | Hermes only | Available only when onboarding the Hermes agent. | @@ -65,7 +65,7 @@ Pick the matching onboarding entry point for each agent. |-------|--------|---------|-------| | OpenClaw | Tested | Yes | Default agent runtime. Onboard with `nemoclaw onboard` (no `--agent` flag required). | | Hermes | Tested | No | First-class agent with dedicated CLI (`nemohermes`), Dockerfile, manifest, docs, and Hermes E2E coverage in `.github/workflows/e2e.yaml` (`hermes-e2e`, `hermes-*`, and Hermes rebuild/switch jobs). Onboard with `nemohermes onboard` or `nemoclaw onboard --agent hermes`. Unlocks the Hermes Provider inference route. Known structural gaps: model-provider compatibility registry is empty (backfilled after failures, see `nemoclaw-blueprint/model-specific-setup/hermes/README.md`); no Hermes-specific unit tests in `nemoclaw/src/`; macOS and WSL CI suites do not differentiate agents. Suitable for evaluation and the documented onboarding paths; production parity with OpenClaw is not yet asserted. | -| LangChain Deep Agents Code | Tested | No | Terminal-oriented coding harness (no in-sandbox gateway, no dashboard) built on the Deep Agents SDK; manifest at `agents/langchain-deepagents-code/manifest.yaml` with binary `dcode`. Onboard with `nemo-deepagents onboard` or `nemoclaw onboard --agent langchain-deepagents-code`, and follow [the quickstart](/user-guide/deepagents/get-started/quickstart). NemoClaw runs it as a managed harness: unmanaged sandbox/MCP/shell overrides are rejected and credential-bearing proxy URLs are dropped from persisted shell env. Inference routes through OpenShell's `inference.local` endpoint via Deep Agents Code's OpenAI-compatible provider. Live runtime acceptance, broader launch material, and terminal-agent diagnostics are tracked at open issue #4861. | +| LangChain Deep Agents Code | Tested | No | Terminal-oriented coding agent runtime with no in-sandbox gateway or dashboard, built on the Deep Agents SDK. Its manifest is `agents/langchain-deepagents-code/manifest.yaml`, and its binary is `dcode`. Onboard with `nemo-deepagents onboard` or `nemoclaw onboard --agent langchain-deepagents-code`, and follow [the quickstart](/user-guide/deepagents/get-started/quickstart). NemoClaw runs it as a managed agent runtime: unmanaged sandbox, Model Context Protocol (MCP) server, and shell overrides are rejected, and credential-bearing proxy URLs are dropped from persisted shell environment values. Inference routes through OpenShell's `inference.local` endpoint through the Deep Agents Code OpenAI-compatible provider. Live runtime acceptance, broader launch material, and terminal-agent diagnostics are tracked at open issue #4861. | {/* agent-status:end */} ## Platforms @@ -120,6 +120,7 @@ NemoClaw configures messaging channels during onboarding. The OpenShell gateway | WeChat | Tested with limitations | Channel hook available. Verify regional account access before relying on this path. | | WhatsApp | Tested with limitations | Supported by both OpenClaw and Hermes through the channel manifest `supportedAgents` declaration in `src/lib/messaging/channels/whatsapp/manifest.ts`. Pairing happens in the sandbox through WhatsApp Web by scanning a QR code at first run; the Hermes flow exposes this as `hermes whatsapp` and persists session credentials under `~/.hermes/platforms/whatsapp/session` (`agents/hermes/manifest.yaml:69-71`). Sandbox egress goes through the `whatsapp` policy preset, which carries the WebSocket / Noise / h1-ALPN caveats documented in `src/lib/messaging/channels/whatsapp/policy/openclaw.yaml` and `src/lib/messaging/channels/whatsapp/policy/hermes.yaml`. No Meta Business API integration today; that path is out of scope for this matrix. | | Microsoft Teams | Experimental | Supported by both OpenClaw and Hermes through the manifest-first messaging channel contract. Requires Bot Framework app credentials, a tenant ID, and a public HTTPS endpoint that reaches the sandbox webhook path `/api/messages`. Sandbox egress goes through the `teams` policy preset, and only one active Teams sandbox can use a given local `MSTEAMS_PORT` forward. | +| Google Chat | Experimental | Available only for OpenClaw through the channel manifest contract. The onboarding picker labels Google Chat experimental, and NemoClaw enables it only after you explicitly select or add it. Requires a Google service-account credential and a public HTTPS endpoint that reaches only the `/googlechat` webhook path. OpenShell keeps the service-account private key outside the sandbox and supplies short-lived credentials at approved egress boundaries. | {/* integration-status:end */} ## Capabilities @@ -129,12 +130,15 @@ Each row below is a launch-facing capability claim that NemoClaw makes in docs, {/* capability-status:begin */} | Capability | Status | Notes | |------------|--------|-------| -| Guided onboarding | Tested | Single-command interactive wizard (`$$nemoclaw onboard`) that walks the user through inference provider selection, credential setup, sandbox creation, and dashboard launch. Non-interactive mode is supported with `--non-interactive` + `NEMOCLAW_*` environment variables for CI and scripted installs. | +| Guided onboarding | Tested | Single-command interactive wizard (`$$nemoclaw onboard`) that walks the user through inference provider selection, credential setup, and sandbox creation or update. It opens the agent dashboard when the selected runtime provides one. Non-interactive mode is supported with `--non-interactive` and `NEMOCLAW_*` environment variables for CI and scripted installs. | | Sandboxed execution | Tested with limitations | Landlock, seccomp, network namespace isolation, no-new-privileges, privilege dropping, and process limits (ulimit -u 512 at `scripts/lib/sandbox-init.sh:237`) are tested and on by default. The `DANGEROUS_CAPS` list at `scripts/lib/sandbox-init.sh:288-299` drops cap_sys_admin, cap_sys_ptrace, cap_net_raw, cap_dac_override, cap_sys_chroot, cap_fsetid, cap_setfcap, cap_mknod, cap_audit_write, cap_net_bind_service with `capsh --drop` when CAP_SETPCAP is present. Limitation (active issue #3280): the fail-closed bounding-set gate is opt-in via `NEMOCLAW_REQUIRE_CAP_DROP=1`; the default is warn-and-continue so hosts without CAP_SETPCAP still boot, which means dangerous caps can remain in the bounding set on some hosts even though the effective set is empty. | | Routed inference | Tested | Provider-routed model calls through the OpenShell gateway, transparent to the agent. The agent uses `inference.local` inside the sandbox; provider credentials stay on the host. Supports every entry in the Providers table. | | Declarative network policy | Tested | YAML-defined egress with policy presets. Presets include `slack`, `discord`, `telegram`, `weather`, `openclaw-pricing`, `huggingface`, `npm`, `pypi`, `brew`, and others. Hot-reloadable at runtime with `$$nemoclaw policy add`. | | Snapshot and restore | Tested | Create, list, and restore named snapshots of sandbox state with the `$$nemoclaw snapshot` subcommands (`create`, `list`, `restore`). Credential stripping is enforced on capture. Unsafe symlinks are rejected on restore. | | Agent skills | Tested | Packaged agent skills are discoverable by Cursor, Claude Code, and other coding assistants under `.agents/skills/`. Skills also install into the sandbox with `$$nemoclaw skill install`. | +| Managed MCP servers | Tested | OpenClaw, Hermes, and LangChain Deep Agents Code support authenticated HTTPS Streamable HTTP MCP server lifecycle through `$$nemoclaw mcp`. NemoClaw stores only credential names and ownership metadata, while OpenShell keeps raw credential values outside the sandbox and replaces credential placeholders at approved egress boundaries. | +| Host readiness reporting | Tested | `$$nemoclaw host probe` reports host observations, capabilities, qualifications, findings, evidence, and CLI provenance without changing host, gateway, provider, policy, credential, or sandbox state. The human-readable and JSON formats use the same schema-versioned report and deterministic exit codes. | +| Deep Agents trace export | Tested with limitations | LangChain Deep Agents Code can opt into bounded-content OpenTelemetry Protocol (OTLP) over HTTP trace export to an operator-managed host collector. The sandbox receives no remote-backend credential, the local receiver has no authentication, trace content can contain sensitive application data, and delivery failures do not stop agent work. | | State migration | Tested | Sandbox state migrates across rebuilds with credentials intentionally excluded. Hermes excludes `auth.json` and restores its SQLite session DB through the backup API. OpenClaw config merge prevents stale state from overwriting fresh values. | | Blueprint versioning | Tested | Versioned, digest-verified, and reproducible blueprint lifecycle. Drives `$$nemoclaw rebuild` and the migration safeguards above. | | Web search backend | Tested with limitations | Onboarding supports Brave and Tavily for OpenClaw and Tavily for Hermes. Provider selection, agent configuration, and credential attachment are build-time inputs, so changing the provider recreates the sandbox. OpenShell replaces resolver placeholders at egress, including JSON request-body rewriting for Hermes Tavily. Users supply the backend credential; NemoClaw does not bundle a key. | @@ -167,7 +171,7 @@ They are listed here so launch material, sales conversations, and support triage | Air-gapped / offline installs | Unsupported | Onboard assumes network reachability for package fetches, container pulls, and provider validation. See open issues #4872 and #2218 (production-deployment epic covering air-gapped support, China network guidance, multi-host topology). | | Windows-on-ARM GPU passthrough | Unsupported | Windows-on-ARM CPU paths run under WSL2 'tested with limitations', but GPU passthrough on WOA is denylisted (`src/lib/onboard/wsl-docker-desktop-gpu.ts:188`, `src/lib/inference/gpu-trust.test.ts:70`). See closed issue #4565. | | Non-NVIDIA GPUs (AMD/ROCm, Intel Arc, Apple Metal) | Unsupported | Local vLLM and NIM paths assert NVIDIA CDI presence with `assertCdiNvidiaGpuSpecPresent` (`src/lib/onboard/fatal-runtime-preflight.ts`). NemoClaw does not install non-NVIDIA accelerator drivers. | -| Other LangChain, AutoGen, CrewAI, or non-listed agent harnesses | Unsupported | LangChain Deep Agents Code is the only integrated LangChain-family harness (see the Agents section above; status `Experimental`). Other LangChain harnesses, AutoGen, CrewAI, and any agent runtime not listed in the Agents table are not integrated. Bringing more harnesses is tracked as a research epic (see open issue #4861) but is not on the current roadmap. | +| Other LangChain, AutoGen, CrewAI, or non-listed agent harnesses | Unsupported | LangChain Deep Agents Code is the only integrated LangChain-family agent runtime (refer to the Agents section above; status `Tested`). Other LangChain agent runtimes, AutoGen, CrewAI, and any agent runtime not listed in the Agents table are not integrated. Bringing more agent runtimes is tracked as a research epic (refer to open issue #4861) but is not on the current roadmap. | | Multi-user host sharing | Unsupported | Sandboxes are scoped to a single host user. NemoClaw treats multi-user hosts as a risk and warns at onboard; see `docs/security/openclaw-controls.mdx` Multi-user detection. | | Hosted SaaS / managed NemoClaw | Unsupported | There is no managed offering. Supported deployment paths are local CLI onboarding and headless Linux server onboarding. | | Native provider integrations not in the Providers table | Unsupported | Vertex AI, Azure OpenAI, SageMaker, Together.ai, Replicate, and HuggingFace Inference Endpoints are not first-class onboarding entries. AWS Bedrock works through the `compatible-anthropic-endpoint` adapter (`src/lib/onboard/bedrock-runtime.ts`). |