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 exact 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.
* Classify a system as DGX Station when its firmware identifies a Station GB300 platform, or when its exact OEM model is documented by NVIDIA or the manufacturer as based on DGX Station architecture.
* 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 exact 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 exact 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/bf46e62f901825f19e570c17f8c870a0eae04fbc/docs/resources/prompt-assets/dgx-spark.md).
* Confirmed DGX Station: [DGX Station installation instructions](https://raw.githubusercontent.com/NVIDIA/NemoClaw/bf46e62f901825f19e570c17f8c870a0eae04fbc/docs/resources/prompt-assets/dgx-station.md).
* Officially detected Windows WSL: [Windows WSL Express instructions](https://raw.githubusercontent.com/NVIDIA/NemoClaw/bf46e62f901825f19e570c17f8c870a0eae04fbc/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 no platform asset applies, or its offered install path is declined, ask: “Which inference runtime or provider would you like?”
Choices:
1. Existing vLLM, only when a ready server is detected on `localhost:8000`.
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 the exact environment-variable names and exact 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/dd61a307d7ddf7be99de8ff1e2678fb8ef42f8e6/scripts/local-credential-helper.mts` (SHA-256 `1a42bbe8dbc9003cb79d4e641b53760571aacd85293671aee97c09c0746fef33`).
* Form: `https://raw.githubusercontent.com/NVIDIA/NemoClaw/dd61a307d7ddf7be99de8ff1e2678fb8ef42f8e6/docs/resources/local-credential-form.html` (SHA-256 `5512a256e0ad7c63a26ab82cf4f5924e98652097172ab8a5dc9d9358dd4f6ae8`).
* 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 exact 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 --experimental-strip-types <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`.
* Managed vLLM: `NEMOCLAW_PROVIDER=install-vllm`; 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?”
Choices: No, Telegram, Discord, Slack, WhatsApp, WeChat (experimental).
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.
Collect messaging secrets through the reviewed helper and exact-URL SSH flow.
Do not manually set `NEMOCLAW_MESSAGING_CHANNELS_B64`; let NemoClaw generate it.
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, exact 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 exactly, 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.
Review the Prerequisites before you begin.
Complete Onboarding
Select LangChain Deep Agents Code when the installer prompts you to choose an agent.
On supported platforms, the installer can display Run express install with these settings? [Y/n]: before the agent-selection prompt.
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 installs OpenClaw by default.
If you accept, refer to NemoClaw Quickstart with OpenClaw.
Enter n if you want to select LangChain Deep Agents Code, a sandbox name, an inference provider, and a model interactively.
Refer to Use Docker and supported platforms for more information.
When prompted for the sandbox name, enter my-deepagents or press Enter to accept the suggested deepagents-code name.
If you accept the suggested name, use deepagents-code instead of my-deepagents in the commands that follow.
Choose an inference provider and model, then provide its credential when prompted.
Accept the suggested network policy tier for a first run.
Installation and Runtime Details
Use these details when you need more control during setup or after the first sandbox is running.
Use Docker and supported platforms
Review Prerequisites for Docker requirements and the setup-oriented platform table.
If the installer prints a newgrp docker command, run that command before you retry the installer.
On macOS, start Docker Desktop or Colima first.
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 hosts, and Windows Subsystem for Linux (WSL) can offer the recommended express install mode after the third-party software notice.
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.
Enter n to continue with interactive onboarding when you want to select the agent or other settings yourself.
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, sandbox name, and policy tier before it prints the review summary.
At any prompt, press Enter to accept the default shown in [brackets], type back to return to the previous prompt, or type exit to quit.
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.34 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, the managed image bakes that value into 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.0a6’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 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 only these config.toml preferences from backup: boolean ui.show_scrollbar, boolean ui.show_url_open_toast, boolean threads.relative_time, and threads.sort_order when it is updated_at or created_at.
Freshly generated model routing, update settings, provider metadata, and all other configuration remain authoritative.
NemoClaw drops all other backup settings, including ui.theme, behavior-bearing keys, unknown keys, and security-sensitive keys.
It 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.
NemoClaw intentionally does not back up .deepagents/.env or the user-owned .deepagents/.mcp.json because users may put Tavily, LangSmith, MCP service, or provider credentials there.
The managed .deepagents/.nemoclaw-mcp.json projection is also excluded because NemoClaw reconstructs it from the credential-free registry after recreation.
Service credentials remain in OpenShell provider state.
It also does not preserve hooks.json; executable Deep Agents Code hooks are disabled in the managed harness.
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 recorded provider, model, policy, 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 MCP state and keeps the existing sandbox intact.
Rebuild also preserves the standalone Deep Agents Code tavily preset, the recorded observability choice unless explicitly overridden, and recorded custom policies from their exact stored content.
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, destroy those sandboxes or detach it from each one with openshell sandbox provider detach <sandbox-name> tavily-search, then remove it globally with nemo-deepagents credentials reset tavily-search --yes.
OpenShell rejects provider deletion while any sandbox still has it attached.
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.