Quickstart with LangChain Deep Agents Code
Create a sandboxed LangChain Deep Agents Code agent, then run your first prompt. The nemo-deepagents command is an alias for nemoclaw with the langchain-deepagents-code agent pre-selected.
Set Up with the Starter Prompt on Your Coding Agent
Copy this starter prompt into Cursor, Claude Code, Codex, Copilot, or another local coding agent when you want it to guide the installation. The prompt points the agent to Use NemoClaw Docs with Your Coding Agents, this quickstart, the Markdown docs, and the optional nemoclaw-user-guide skill. It asks the agent to confirm LangChain Deep Agents Code before it runs commands that create a sandbox or receive credentials and to use the checked-in local credential helper and form only after you approve the command that receives credentials.
Install NemoClaw with your coding agent
# NemoClaw Instructions for a Non-Technical User
Help me install and run NVIDIA NemoClaw from this coding-agent UI.
I may use Cursor, Claude Code, Codex, Copilot, or another local coding agent.
I do not know how to use a terminal.
## Interaction Rules
* Ask exactly one question at a time.
* Use clickable choices when supported; otherwise show one short numbered list and wait.
* Detect the operating system and whether it is WSL using read-only checks.
* Ask which computer I am using only if the environment cannot be determined reliably.
* Next ask which agent I want: OpenClaw, Hermes, or LangChain Deep Agents Code.
* Never ask me to run commands myself, except the one workstation-side `ssh -N -L` command needed to open a remote credential form securely.
* Explain each command in plain language, ask permission, then run it for me.
* Pause before installs, system changes, administrator access, large downloads, credentials, sandbox creation, and long-running processes.
* Summarize command output instead of asking me to copy it into chat.
* Explain errors and unfamiliar terms such as Docker, container, model, API key, port, and SSH.
* Never ask me to paste passwords, API keys, tokens, or private credentials into chat.
* Use redacted placeholders such as `<PASTE_YOUR_API_KEY_HERE>` in examples.
* During long operations, give a short update at least once per minute.
* Do not start duplicate installers, downloads, or model servers.
* Verify results after important commands; do not rely only on exit codes.
## Goal
Install NemoClaw, collect onboarding choices before execution, include messaging in the first sandbox build when the selected agent supports it, launch the selected agent, and verify that it responds.
## Agent Selection
Ask: “Which NemoClaw agent would you like?”
Choices:
1. OpenClaw, the default.
2. Hermes.
3. LangChain Deep Agents Code.
Set `NEMOCLAW_AGENT=openclaw` for OpenClaw.
Set `NEMOCLAW_AGENT=hermes` for Hermes, or use `nemohermes onboard`.
Set `NEMOCLAW_AGENT=langchain-deepagents-code` for Deep Agents, or use `nemo-deepagents onboard`.
## Hardware and Readiness
* On Linux, ask permission to run a read-only readiness check before provider selection.
* Check distribution, architecture, product and firmware identity, GPU and memory, NVIDIA driver, Container Toolkit, Docker, Node.js, disk space, existing NemoClaw, Ollama, vLLM, relevant ports, and administrator access.
* Classify the computer as DGX Spark, DGX Station, NVIDIA GB300, another NVIDIA computer, ordinary macOS/Linux, or unknown.
* Do not identify DGX Spark from the GPU name alone; combine product, firmware, architecture, and GPU evidence.
* Treat DGX Station GB300 hardware as confirmed only when the Station hardware qualification passes. Do not load Station instructions for unsupported or inconclusive hardware.
* If Station hardware is confirmed but its software profile is unqualified, load Station instructions only for the documented explicit validation-only recovery. This does not authorize Station Express onboarding.
* Treat the host as qualified for Station Express only when the combined Station qualification passes.
* A confirmed NVIDIA GB300 can independently qualify for expanded local-runtime choices.
* If uncertain, explain that and let NemoClaw’s official preflight make the final platform decision.
## Administrator Access
* Check administrator availability without waiting for input, such as with a non-interactive sudo check.
* If passwordless sudo works, continue without prompt mode.
* If passwordless sudo is unavailable but the coding-agent UI provides a secure visible password prompt, explain why access is needed, ask permission, and set `NEMOCLAW_NON_INTERACTIVE_SUDO_MODE=prompt`.
* Let the real `sudo` program collect the password; never use chat or the API-key form for the computer password.
* If neither passwordless sudo nor a secure password prompt is available, stop before the affected install or system change.
* Never pipe a password, store it in a file, generate a password helper, or put it in command arguments.
* Offer a user-local alternative only when official documentation supports it for that operation.
* Do not silently use user-local Ollama for a system Ollama upgrade when the old system service would remain active.
## Execution Sandbox
* If the coding agent’s execution sandbox blocks a Docker command, use its command-scoped approval flow, if available.
* Request permission to rerun only that command outside the sandbox.
* Before requesting approval, explain that Docker daemon access can modify containers, images, and host files.
* Do not change Docker socket permissions or request broad host access only to bypass the execution sandbox.
* If the user or managed policy denies approval, stop before the command.
* Explain that `NEMOCLAW_NON_INTERACTIVE=1` removes NemoClaw prompts.
* Explain that `NEMOCLAW_NON_INTERACTIVE=1` does not bypass execution-sandbox permissions.
## Platform-Specific Instructions
After the readiness check, load exactly one matching instruction asset before provider selection:
* Confirmed DGX Spark: [DGX Spark Express instructions](https://raw.githubusercontent.com/NVIDIA/NemoClaw/6b8e9d3ccc8564636f615f4e0652eca68214520f/docs/resources/prompt-assets/dgx-spark.md).
* Confirmed DGX Station: [DGX Station installation instructions](https://raw.githubusercontent.com/NVIDIA/NemoClaw/6b8e9d3ccc8564636f615f4e0652eca68214520f/docs/resources/prompt-assets/dgx-station.md).
* Officially detected Windows WSL: [Windows WSL Express instructions](https://raw.githubusercontent.com/NVIDIA/NemoClaw/6b8e9d3ccc8564636f615f4e0652eca68214520f/docs/resources/prompt-assets/windows-wsl.md).
Read the matching raw Markdown file completely and follow it before continuing.
Do not load a platform asset for any other computer.
## Runtime and Provider Selection
If the Windows WSL platform asset applies, follow that asset’s provider selection and skip the native-N1x branch below.
If the readiness check confirms native N1x (not Windows WSL), offer the Deferred managed-vLLM preview before the generic provider menu.
If the user accepts, set `NEMOCLAW_PROVIDER=install-vllm`.
Explain that N1x remains outside the supported-platform set pending complete physical NemoClaw Express E2E validation, accepting this path is explicit preview intent, and the preview uses one-host managed vLLM with `nvidia/Qwen3.6-35B-A3B-NVFP4`.
If the user declines, continue to the provider question below and explain that each provider retains its existing requirements.
Do not offer local NVIDIA NIM on native N1x.
If the user selects managed vLLM and the configured port, `${NEMOCLAW_VLLM_PORT:-8000}`, is occupied, stop and ask the user to stop that server before trying the Deferred preview again.
If no platform asset applies or its offered install path is declined, ask: “Which inference runtime or provider would you like?”
Choices:
1. Existing vLLM, when a ready server is detected on `localhost:${NEMOCLAW_VLLM_PORT:-8000}`; native N1x requires explicit standard-onboarding intent.
2. Managed vLLM, optimized local inference with a large download.
3. Local Ollama, only when the selected agent and platform support it.
4. NVIDIA Endpoints, which requires an NVIDIA API key.
5. OpenRouter, which requires an OpenRouter API key.
6. OpenAI, which requires an OpenAI API key.
7. Anthropic, which requires an Anthropic API key.
8. Google Gemini, which requires a Gemini API key.
9. Model Router, which requires an NVIDIA API key.
10. Other OpenAI-compatible endpoint, which requires an endpoint, model, and usually a key.
11. Other Anthropic-compatible endpoint, which requires an endpoint, model, and usually a key.
12. Hermes Provider, only when Hermes is selected.
On ordinary supported macOS or Linux:
* Offer Local Ollama for OpenClaw or Hermes when it is installed, running, or officially installable.
* Do not offer Local Ollama for Deep Agents unless current official documentation adds support.
* Offer an existing ready vLLM server when detected.
* Also show all applicable hosted and compatible providers.
* Do not hide Ollama merely because the computer is not DGX or GB300.
* Omit managed vLLM unless current official support permits it for the detected hardware.
When a platform asset applies, follow its local-runtime eligibility and model instructions.
On other platforms, show every provider supported by the selected agent and platform.
Renumber choices after filtering and do not hide hosted providers behind another menu.
Ask required model, endpoint, credential, and download questions one at a time.
## Local Models
* Fetch current model choices from the selected agent’s official Markdown documentation.
* The selected maintained NemoClaw release is authoritative for supported slugs and arguments.
* For Ollama, ask permission to inspect installed models and offer NemoClaw’s memory-aware recommendation first.
* Current Ollama starter examples include `qwen3.6:35b`, `nemotron-3-nano:30b`, and `qwen3.5:9b`.
* Explain download size and storage requirements, then ask separately for permission.
* Do not request an NGC or Hugging Face credential unless the selected operation actually requires it.
## Avoid Interactive Menus
* Collect every choice before running the installer.
* Ask one question at a time for model, endpoint, sandbox name, web search, messaging when the selected agent supports it, policy when no platform-asset install path is selected, credentials, administrator access, and downloads.
* Use non-interactive environment variables whenever supported.
* For installation outside an accepted platform-asset path, set `NEMOCLAW_AGENT` and `NEMOCLAW_PROVIDER` from my selections.
* Use the maintained release unless I request a specific version.
* For a specific version, clear any inherited `NEMOCLAW_INSTALL_REF`, then set `NEMOCLAW_INSTALL_TAG=vX.Y.Z` to its versioned release tag.
* Never leave a command waiting at `Choose [1]:`.
* If a choice cannot be supplied non-interactively, stop before starting and explain the supported alternative.
* The DGX Station asset is the exception for the official third-party-software notice and Express confirmation. Keep those installer prompts visible, wait for the user’s response, and do not pre-answer them.
## Handle Tokens Securely and Visually
Before collecting secrets, determine every environment-variable name and the complete command argv, explain them, and ask permission.
Do not generate, rewrite, or redesign the helper or form.
Use this reviewed pair without modification:
* Helper: `https://raw.githubusercontent.com/NVIDIA/NemoClaw/15bd0dd25b185eafae02a067532fe18718b2be23/scripts/local-credential-helper.mts` (SHA-256 `f7c255120735307c93767c348bfcd54e7c7008275f9f5215f249e4c1a9daa9be`).
* Form: `https://raw.githubusercontent.com/NVIDIA/NemoClaw/15bd0dd25b185eafae02a067532fe18718b2be23/docs/resources/local-credential-form.html` (SHA-256 `cdd85dc6a0b31a8b9773e7ddaacb38a4e8162b0a13b70bebef3dc297ae7a6c44`).
* Treat the two immutable URL and digest pairs as one reviewed trust boundary; before executing the helper, compute the SHA-256 digest of both downloaded files and compare each result with its pinned digest.
* If either digest differs, do not execute the helper; delete both temporary files and stop.
* Store them in a private temporary directory and delete them afterward.
* The helper requires Node.js 22.19 or newer.
* If Node is unavailable, use an existing secure local application prompt or secure terminal prompt; never use chat or generated credential code.
* Keep the helper bound to `http://127.0.0.1`, accept only one valid submission, and run only the already-approved command.
* Use `:secret` for secrets and `:text` only for non-secret values.
* Use `--execution-profile isolated` for stateless commands.
* For persistent install or onboarding, use `--execution-profile account-home --cwd <approved-absolute-directory>` and ask permission for both.
* Pass every `--field NAME:type`, then a literal `--`, an absolute executable path, and the approved argv.
* Never omit the literal `--`.
* Never use a relative, alias-only, or PATH-only approved executable.
* Never put credentials in argv.
* Command shape: `node <helper> --execution-profile <profile> --form <form> --field NAME:secret -- <absolute-executable> <approved-args...>`.
* Use **Preview Credentials**, **Edit**, then **Confirm and Run Approved Command**.
* If the outcome is unknown, check whether the command ran; do not retry or resubmit blindly.
* Keep secrets in memory only long enough to start the command.
* Treat deletion as exposure minimization, not guaranteed erasure.
* Prefer letting an account-persistent command use its own reviewed secure credential prompt when available.
* For credential-bearing installation, use the reviewed helper only with an already-downloaded and verified installer.
* Do not hand-assemble a `curl | bash` wrapper around credentials.
* Never print, log, commit, cache, or paste secrets.
Use this provider mapping for non-interactive setup:
* NVIDIA Endpoints: `NEMOCLAW_PROVIDER=build`, `NVIDIA_INFERENCE_API_KEY`.
* OpenRouter: `NEMOCLAW_PROVIDER=openrouter`, `OPENROUTER_API_KEY`.
* OpenAI: `NEMOCLAW_PROVIDER=openai`, `OPENAI_API_KEY`.
* Anthropic: `NEMOCLAW_PROVIDER=anthropic`, `ANTHROPIC_API_KEY`.
* Gemini: `NEMOCLAW_PROVIDER=gemini`, `GEMINI_API_KEY`.
* Hermes Provider: `NEMOCLAW_PROVIDER=hermes-provider`; Hermes only.
* Model Router: `NEMOCLAW_PROVIDER=routed`, `NVIDIA_INFERENCE_API_KEY`.
* OpenAI-compatible: `NEMOCLAW_PROVIDER=custom`, endpoint, model, `COMPATIBLE_API_KEY`.
* Anthropic-compatible: `NEMOCLAW_PROVIDER=anthropicCompatible`, endpoint, model, `COMPATIBLE_ANTHROPIC_API_KEY`.
* Ollama: `NEMOCLAW_PROVIDER=ollama`, optional `NEMOCLAW_MODEL`.
* Existing vLLM: `NEMOCLAW_PROVIDER=vllm`; on native N1x, this value supplies explicit standard-onboarding intent, but the route remains unvalidated.
* Managed vLLM: `NEMOCLAW_PROVIDER=install-vllm`; on native N1x, this value supplies explicit Deferred preview intent. Qualifying N1x WSL hosts instead follow the Windows WSL asset’s managed llama.cpp path. Use an approved optional model override only when the selected platform supports it.
Do not offer Hermes Provider for OpenClaw or Deep Agents.
## Credential Form and SSH
Ask whether I use SSH only after the helper starts and prints its complete one-time URL: “Are you connected to this computer through SSH?”
Choices:
1. No, I am using it directly.
2. Yes, this is a remote SSH computer.
3. I am not sure.
* Treat the helper’s complete URL as an opaque, sensitive, one-time capability.
* Preserve its scheme, host, port, `/local-credential-form.html` path, complete `field=` query string, and `#cap=` fragment exactly.
* Never replace it with a reconstructed bare `http://127.0.0.1:<port>` URL.
* If local, give me the complete original URL unchanged.
* If remote, read its port and ask me to run: `ssh -N -L <port>:127.0.0.1:<port> <username>@<host>`.
* Fill in the actual port, username, and host when known.
* Explain that it runs on my workstation, normally prints nothing, and must remain open until credential entry finishes.
* After the tunnel starts, give me the helper’s original complete URL unchanged.
* Require the same port on both sides; do not remap the helper to another local port.
* If that local port is occupied, stop the unused helper safely, resolve the conflict or start a fresh helper session, and use only the new complete URL.
* Never reuse an old URL or expose the form through `0.0.0.0`, LAN, public URL, shared tunnel, or unauthenticated proxy.
* Tell me when it is safe to stop the forwarding command.
## Messaging During Initial Onboarding
For OpenClaw or Hermes, ask before the first sandbox build: “Do you want to configure a messaging channel during onboarding?”
Before offering choices, read the selected agent’s current **Enable Channels During Onboarding** page and present every channel in that picker; do not rely on a copied channel list.
Skip messaging for Deep Agents.
Configure one channel at a time, then ask whether to add another.
Collect messaging before policy selection so the first image includes channel configuration and matching network presets.
* Telegram requires `TELEGRAM_BOT_TOKEN`; optional settings include allowed IDs, mention mode, and OpenClaw group policy.
* Discord requires `DISCORD_BOT_TOKEN`; optional settings include server ID, user ID, and mention mode.
* Slack requires `SLACK_BOT_TOKEN` and `SLACK_APP_TOKEN`; optional settings include allowed users and channels.
* WhatsApp uses documented allowed IDs for non-interactive selection, followed by QR pairing after startup.
* WeChat requires an interactive QR handshake; explain the limitation before installation and never leave an unsupported UI waiting.
* Microsoft Teams is experimental and requires `MSTEAMS_APP_ID`, `MSTEAMS_APP_PASSWORD`, and `MSTEAMS_TENANT_ID`, plus a public HTTPS messaging endpoint ending in `/api/messages`; optional settings include an Entra user allowlist, webhook port, and mention mode.
* Google Chat is experimental and requires service-account JSON. Follow the selected agent’s setup page: OpenClaw uses an interactive public `/googlechat` webhook enrollment, while Hermes requires a Google Cloud project ID, complete Pub/Sub subscription name, and email sender allowlist.
Collect messaging secrets through the reviewed helper and URL-specific SSH flow.
Do not manually set `NEMOCLAW_MESSAGING_PLAN_B64`; NemoClaw compiles the selected messaging configuration into this derived sandbox image build artifact and removes the full plan from the runtime environment.
The plan contains OpenShell credential placeholders instead of raw messaging credentials.
Use `channels add` and rebuild only for channels omitted from initial onboarding or changed later.
## Policy, Approval, and Verification
* If a loaded platform asset selects its approved install path, follow its policy requirement and skip the policy-tier question.
* For installation outside an accepted platform-asset path, ask for Balanced, Restricted, or Open policy.
* Explain that messaging and web-search selections add required endpoints.
* Before installation outside an accepted platform-asset path, summarize platform, administrator access, agent, provider, model, validation warning, downloads, storage, sandbox, web search, messaging, policy, credential names without their values, and system changes.
* Ask for final permission before installation outside an accepted platform-asset path.
* When a platform asset delegates consent to the official installer, let the installer present its notice and final Express confirmation instead of pre-accepting them.
* For other accepted platform-asset install paths, treat the asset’s confirmation as final permission and do not ask again.
* Set `NEMOCLAW_ACCEPT_THIRD_PARTY_SOFTWARE=1` and `NEMOCLAW_YES=1` only after their approvals.
* Keep credentials in the approved environment and never display them.
* Verify the command and version, sandbox status, provider, model, `inference.local`, GPU access when applicable, messaging bridges when configured, and dashboard route when available.
* If `curl | bash` returns no output, verify installation; if absent, ask permission to download and inspect the official installer before retrying.
* For remote dashboards, use private loopback SSH forwarding, preserve authenticated URLs, and treat them as secrets.
* Ask permission before sending a live channel test or harmless first agent prompt.
* Declare success only after the sandbox is ready and the agent responds.
* Summarize what was installed, how to reconnect, what starts after reboot, and anything skipped.
## Use Docs for Information
* Use clean `.md` pages for searching more information in the selected agent’s documentation. Example URLs:
* [Documentation index for AI clients](https://docs.nvidia.com/nemoclaw/llms.txt)
* [OpenClaw quickstart](https://docs.nvidia.com/nemoclaw/latest/user-guide/openclaw/get-started/quickstart.md)
* [Hermes quickstart](https://docs.nvidia.com/nemoclaw/latest/user-guide/hermes/get-started/quickstart.md)
* [Deep Agents quickstart](https://docs.nvidia.com/nemoclaw/latest/user-guide/deepagents/get-started/quickstart.md)
* Suggest to add the docs MCP server `https://docs.nvidia.com/nemoclaw/_mcp/server` if the coding agent supports MCP.If you prefer to control setup directly, use Set Up with the Interactive Installer on Your Terminal.
Set Up with the Interactive Installer on Your Terminal
If you use the coding-agent prompt in the preceding section, you can skip this procedure or keep it as reference. The prompt directs your coding agent to this quickstart, so it has the full setup context.
Complete Onboarding
The explicit NEMOCLAW_AGENT=langchain-deepagents-code setting keeps Deep Agents selected through interactive or Express setup.
On supported platforms other than N1x, the installer can display Run express install with these settings? [Y/n]: before ordinary onboarding.
N1x instead displays Run the Deferred N1x preview with these settings? [Y/n]:.
Press Enter to use the recommended express install mode for that platform.
This mode applies preset settings and runs the remaining onboarding non-interactively.
Express install mode preserves the explicit Deep Agents selection in the install command.
Enter n if you want to select a sandbox name, an inference provider, and a model interactively.
On N1x, the selected provider must meet its existing requirements, and local NVIDIA NIM remains unavailable.
Refer to Use a container runtime and supported platforms for more information.
The install command creates the my-deepagents sandbox used in the commands that follow.
If you accept Express setup, wait for the installer to finish, then continue with Confirm the Sandbox Is Ready; Express selects the provider and model non-interactively.
If the installer does not offer Express setup, or if you enter n at the Express prompt, choose an inference provider and model, then provide its credential when prompted.
For that interactive path, accept the suggested network policy tier on a first run.
With the OpenShell Docker driver, stock Deep Agents Code onboarding normally uses the release’s exact managed-image digest.
If registry or catalog availability prevents resolution, stock onboarding stops before sandbox creation and does not build a shipped Dockerfile.
Invalid or inconsistent catalog evidence fails closed before sandbox creation.
An explicit nemo-deepagents onboard --from <Dockerfile> remains a separate custom-image path.
Start a custom Dockerfile from the published complete image, FROM ghcr.io/nvidia/nemoclaw/langchain-deepagents-code-sandbox@sha256:<digest>, which already carries every managed Deep Agents Code layer.
Releases publish that image with :<release> and :<revision> tags alongside openclaw-sandbox and hermes-sandbox; pin the digest rather than a tag so rebuilds stay reproducible.
Run Your First Prompt
Start the Deep Agents terminal UI from the host.
nemo-deepagents launch runs the complete preflight or, on Linux, validates an existing fixed 24-hour launch-readiness lease before it starts dcode in your terminal.
On macOS, launch runs the complete preflight every time and does not publish a launch-readiness lease.
On Linux, if the recorded configuration or live runtime has changed, NemoClaw durably invalidates prior evidence before it runs the complete preflight.
If old evidence might remain acceptable and cannot be invalidated, launch stops before preflight or recovery and tells you to repair the secure OS per-user runtime authority or NemoClaw state permissions.
To open a sandbox shell first and start dcode yourself, run these commands instead.
Installation and Runtime Details
Use these details when you need more control during setup or after the first sandbox is running.
Use a container runtime and supported platforms
Review Prerequisites for container-runtime requirements and the setup-oriented platform table.
Docker is the default runtime provider and primary path.
On Linux, the installer can install Docker.
If the installer prints a newgrp docker command, run that command before you retry the installer.
On macOS, start Docker Desktop or Colima first.
On a qualified Linux host, you can instead select native rootless Podman explicitly with NEMOCLAW_GATEWAY_RUNTIME=podman.
This path does not require the Docker CLI or daemon.
Review the native Podman requirements and limitations in Platform Support and Troubleshooting before onboarding.
Before you install from Windows, follow Prepare a Windows Machine to Install NemoClaw. Before you install on DGX Station, follow Prepare DGX Station to Install NemoClaw.
DGX Spark, qualifying DGX Station, and Windows Subsystem for Linux (WSL) hosts can offer the recommended express install mode after the third-party software notice.
N1x can offer a Deferred preview after the notice, but full physical NemoClaw Express E2E validation is pending.
N1x remains outside the supported-platform set until that validation passes and the platform matrix status is promoted.
Press Enter at the express install prompt to apply preset settings, switch the remaining onboarding to non-interactive mode, and select the managed local inference path for that platform.
On N1x, accept the preview prompt to apply those settings as explicit Deferred preview intent.
Enter n to continue with interactive onboarding when you want to select the agent or other settings yourself.
On N1x, setting NEMOCLAW_NO_EXPRESS=1 also continues with ordinary onboarding.
Set NEMOCLAW_PROVIDER=install-vllm to bypass the prompt with managed-vLLM preview intent, or set a recognized provider other than Local NVIDIA NIM or install-vllm to enter standard onboarding directly.
The N1x preview selects one-host managed vLLM with nvidia/Qwen3.6-35B-A3B-NVFP4.
Refer to Set Up vLLM for managed model profiles and headless setup. Refer to Set Up vLLM on Two DGX Stations for the Deferred paired workflow. Refer to Platform Support for current validation status.
Onboarding and runtime behavior
Installation and Onboarding Details
The hosted installer follows the last-known-good (lkg) release tag by default, so the install command selects the maintained Deep Agents-capable build without a version override. If NemoClaw is already installed, run nemo-deepagents onboard to start Deep Agents onboarding directly.
You can use the canonical agent ID or a short alias instead of nemo-deepagents.
The wizard asks for an inference provider, model, required credential, and sandbox name before it prints the review summary. The review offers these actions:
- Apply configuration continues to provider registration.
- Edit inference provider or model returns to provider and model selection.
- Edit sandbox name prompts for the sandbox name again.
- Exit onboarding stops onboarding before provider registration.
When you edit inference, NemoClaw clears the credential staged for the discarded selection. NemoClaw preserves the sandbox name. When you edit the sandbox name, NemoClaw preserves the inference selection. The sandbox prompt shows the prior name as its default. After you apply the configuration, routine editing ends. If inference setup fails and offers a back recovery action, you can return to provider and model selection and then review the updated configuration again. Provider registration, inference setup, policy selection, and sandbox creation then continue forward. The default Deep Agents sandbox name is deepagents-code. Use a distinct name, such as my-deepagents, when you run Deep Agents, Hermes, and OpenClaw sandboxes side by side. Refer to Choose an Inference Provider for provider-specific prompts.
The image installs hash-locked Deep Agents Code 0.1.55 with NVIDIA provider support. After the terminal smoke checks, onboarding runs dcode --version and compares the result with the version required by the agent manifest. Fresh and resumed onboarding exit nonzero instead of reporting the runtime ready when the installed version is too old, uses an incompatible version scheme, or cannot be verified. If the version check fails, review the reported version error and run nemo-deepagents <sandbox-name> rebuild before resuming onboarding. NemoClaw writes /sandbox/.deepagents/config.toml with an OpenAI-compatible provider pointed at https://inference.local/v1, uses a scoped placeholder API key for that managed route, and sets use_responses_api = false for Chat Completions compatibility. When onboarding records a reasoning effort on a compatible-endpoint route that uses openai-completions, managed startup writes that value to a root-owned file and Deep Agents Code model requests carry it as an extra_body.reasoning_effort request parameter. Leave NEMOCLAW_REASONING_EFFORT unset to keep the endpoint’s own default. Deep Agents Code has no runtime inference set path, so re-onboard the sandbox with nemo-deepagents onboard --fresh --name <sandbox-name> --recreate-sandbox to change the recorded effort. When you use NVIDIA Endpoints without selecting another model, new Deep Agents Code sandboxes default to nvidia/nemotron-3-ultra-550b-a55b. For this model, the managed image maps the OpenAI-compatible route to Deep Agents 0.7.5’s native Nemotron 3 Ultra harness profile, including model-specific tool-calling, filesystem, retry, context, and final-answer safeguards. Rebuild existing Deep Agents Code sandboxes after upgrading to NemoClaw v0.0.76 or later so their image includes this profile. This agent-specific default does not change the shared Nemotron 3 Super default for OpenClaw and Hermes. NemoClaw/OpenShell keeps real provider credentials in credential handling and does not write them into the Deep Agents config file. Deep Agents Code reaches inference.local through the managed OpenShell L7 proxy rather than direct sandbox DNS. The image launcher normalizes the runtime proxy environment for interactive, login-shell, and direct-exec paths and removes inherited proxy credentials and bypass entries before dcode starts. Managed interactive sessions pre-complete Deep Agents Code’s optional first-run onboarding, skip its dependency and model selection screens, then open the TUI with the model selected during NemoClaw onboarding. The image includes ripgrep and dos2unix, and ordinary sessions suppress the optional Tavily warning unless web search is configured or invoked.
Run the managed runtime
Continue with Run Deep Agents Code for sandbox selection, interactive and headless tasks, the JSON output contract, runtime restrictions, thread auto-approval, and identity checks.
Manage Python and sandbox state
Python Environment
Deep Agents Code runs from a NemoClaw-managed Python virtual environment at /opt/venv. The sandbox puts /opt/venv/bin on PATH before the system Python directories, so python3 and pip3 resolve to that managed environment. NemoClaw keeps /opt/venv read-only to protect the installed harness. For project-specific Python dependencies, create a separate virtual environment under /sandbox and activate it before installing packages.
State and Backup
Deep Agents Code state lives under /sandbox/.deepagents. NemoClaw snapshot and rebuild flows preserve the app state directory and skills when those paths exist. During managed re-onboarding, NemoClaw restores the allowlisted UI and thread preferences, validated native interpreter settings, and native startup.mode from config.toml. Freshly generated model routing, update settings, and provider metadata remain authoritative; unknown, privileged, invalid, and security-sensitive keys are dropped. User-authored hooks.json is also preserved, so review its executable commands before restoring a snapshot from another workspace. NemoClaw recreates the sandbox when its live dcode identity output is unreadable or does not match the selected provider and model, then records the selection only after the restored runtime passes the same check. Run nemoclaw <sandbox-name> snapshot create after active dcode tasks finish. For langchain-deepagents-code sandboxes, NemoClaw refuses backup when it detects an active dcode task or cannot verify that the state tree is idle. .deepagents/.mcp.json is the agent-native MCP source. Managed entries contain only URLs and OpenShell placeholders, and rebuild carries them through its bounded transaction handoff rather than reconstructing them from the host registry. Service credentials remain in OpenShell provider state. NemoClaw intentionally does not back up .deepagents/.env. If .deepagents/.state/auth.json contains upstream credentials, or .deepagents/.state/chatgpt-auth.json exists, the managed Deep Agents Code launch paths refuse to start until that credential state is removed. Before a managed Deep Agents Code rebuild changes the sandbox, NemoClaw selects its recorded OpenShell gateway, tests the recorded inference route through https://inference.local, and prepares the replacement from the current agent configuration, OpenShell policy and providers, model, and build inputs with a pinned base and fingerprinted context. Initial failures stop before backup. After backup, NemoClaw rechecks the target, route, and retained build inputs before changing MCP state, then checks again after MCP preparation and before stopping inference or deleting the old sandbox. If the final check fails, NemoClaw restores the previous source state and keeps the existing sandbox intact. Rebuild carries the complete current OpenShell policy forward, including Deep Agents Code tavily, custom entries, and trusted host-side edits. The recorded observability choice is preserved unless explicitly overridden.
Enable Tavily egress
Optional Tavily Egress
Deep Agents Code does not currently have a NemoClaw-managed web-search feature. If your project code or a manually configured tool needs Tavily, opt the sandbox Python egress path into Tavily explicitly. Register the raw key only with the OpenShell gateway on the host, not inside the sandbox, in .env, or in Deep Agents config files. The gateway injects it at egress instead. The managed Deep Agents Code entry points reject credential-shaped process environment values, disable project .env and global /sandbox/.deepagents/.env loading, and block upstream /auth, /connect, startup/onboarding credential prompts, model-selector credential prompts, notification-service key prompts, and ChatGPT OAuth. These controls apply to Deep Agents Code and do not sanitize arbitrary Python programs in the sandbox. Use NemoClaw-managed credential paths when support is available instead of storing service keys inside Deep Agents Code state. NemoClaw does not enable Tavily or observability by default for this harness. The sandbox policy denies api.tavily.com until you opt into Tavily and continues to deny direct api.smith.langchain.com egress when you enable observability.
To allow Tavily egress for the target sandbox, apply the maintained tavily policy preset, register the credential with the OpenShell gateway, then rebuild the sandbox so the new provider attaches. The policy preset is a per-sandbox managed-Python opt-in, but provider registration is gateway-wide: tavily-search attaches to every sandbox that you build or rebuild afterward.
The shared tavily preset only opens POST /search and POST /extract egress to api.tavily.com:443. Attaching the credential provider alone does not authorize the managed Python interpreter; the explicit policy preset is the interpreter-level opt-in. Export TAVILY_API_KEY only for registration, then remove it from the host shell; the gateway injects the stored value at egress, and the sandbox never sees the raw value. NemoClaw does not bake TAVILY_API_KEY into the managed config or image, and the managed wrapper rejects direct service-key injection into dcode. Because OpenShell attributes the harness’s calls to the sandbox python3 interpreter, this egress is process-wide for sandbox Python rather than a dcode-only boundary.
Remove the target sandbox’s managed-Python opt-in when it is no longer needed.
This does not unregister the gateway-wide tavily-search provider; its credential and Node/curl routes remain available to sandboxes that attach it. When no sandbox needs the provider, remove it globally with nemo-deepagents credentials reset tavily-search --yes. The command detaches current sandbox attachments, removes the gateway provider, and reports every detached sandbox that you must rebuild after registering a replacement.
Export traces through a local collector
Deep Agents trace export now has focused Monitoring pages.
Review Understand Deep Agents Trace Export before you enable the exporter.
Follow Set Up Deep Agents Trace Export to configure the policy and host collector.
Use Verify Deep Agents Trace Export to prove delivery or diagnose a failure.
Use Manage Deep Agents Trace Export to stop, disable, reconfigure, or remove tracing.
Troubleshooting
Use normal sandbox lifecycle commands through either nemo-deepagents or nemoclaw:
If you upgrade from a release that persisted LangSmith environment values, rebuild each existing Deep Agents Code sandbox so its image includes the corrected start.sh. If an existing sandbox displays Choose a Recommended Model, rebuild it so its image includes the managed startup behavior.
status reports the selected harness as a terminal runtime and prints the interactive/headless command shape. If status reports Runtime health: degraded with an OOM kill count, rebuild the sandbox to restore the terminal runtime. Proxy launchers and startup scripts are baked into the sandbox image. After upgrading NemoClaw from a release with older Deep Agents Code routing, rebuild each existing sandbox before troubleshooting inference.local connectivity. NemoClaw v0.0.78 and newer clients fail closed when a pre-v0.0.78 sandbox image lacks the trusted /usr/local/lib/nemoclaw/dcode-managed-exec route-probe helper, even when the installed Deep Agents Code version still matches the managed manifest. Rebuild the sandbox to install that image-owned helper before retrying status, doctor, connect, or onboarding recovery. There is no dashboard port or long-running gateway process for this harness.
Next Steps
- Run Deep Agents Code explains interactive and headless operation, automation output, and approval boundaries.
- Choose an Inference Provider explains how to choose a provider and model.
- Understand Sandbox State explains
/sandbox/.deepagents, memory, skills, and what NemoClaw preserves. - Create and Restore Snapshots explains snapshot and rebuild preservation.
- Set Up Deep Agents Trace Export configures the policy and host collector.
- Network Policies explains the local collector egress preset.
- Troubleshooting covers common setup and runtime issues.
- Add an MCP Server explains managed MCP configuration for Deep Agents sandboxes.
- Deep Agents Code overview explains upstream
dcodecapabilities and commands.