Quick Start | NVIDIA NeMo Relay

Choose a Quick Start path based on the boundary that you want Relay to observe or control:

Use the CLI path when a local coding-agent harness owns the invocation.
Use a binding quick start when your application owns the tool or LLM call.
Use a supported integration guide when a framework or agent harness owns the boundary.

If you still need the shared runtime vocabulary for scopes, middleware, events, or plugins, refer to the Agent Runtime Primer or Concepts first.

Examples by Integration Layer

Use this map when you know what Relay boundary you want to verify, but you do not yet know which guide owns the working path.

Layer	Use When	Start Here	Success Check
CLI and gateway	A coding-agent harness owns invocation and provider routing	CLI Basic Usage	The wrapped agent runs with Relay active and emits hook output, plus gateway-routed LLM lifecycle output when provider routing is active.
Persistent host-plugin installs	You want the maintained install path for Codex or Claude Code instead of the transparent wrapper	Plugin Installation	`nemo-relay doctor --plugin <host>` confirms the installed host plugin is registered and ready.
Direct Python or Node.js application APIs	Your application owns the tool or LLM callback	Python Quick Start or Node.js Quick Start	The sample prints event lines plus tool and LLM results.
Direct Rust application APIs	Your Rust application owns the tool or LLM callback	Rust Quick Start	The sample prints scope, tool, and LLM lifecycle output plus the `initialized` mark event.
Plugin-managed runtime setup	You need process-level exporter or plugin behavior from `plugins.toml`	Plugin Configuration Files	The selected plugin path activates and writes the expected output or behavior.
Managed middleware	You want policy, redaction, routing, or execution wrapping around managed calls	Add Middleware	One allowed request succeeds, one rejected request stops before execution, and observed payloads match the policy.
Framework integrations	A framework such as LangChain, LangGraph, or Deep Agents owns callbacks or scheduling	Supported Integrations	The integration guide’s verify step confirms the expected framework-owned output.
OpenClaw plugin path	OpenClaw owns plugin setup and Relay observes the OpenClaw-managed boundary	OpenClaw	The OpenClaw guide’s verify step confirms plugin setup and runtime output.
Manual or CI workflows	You need explicit config files, deterministic commands, or non-interactive automation	CLI Basic Usage and Plugin Configuration Files	The explicit command uses the intended config files without interactive setup.

Local Coding-Agent Runs

Use the NVIDIA NeMo Relay CLI when you want to observe a local Codex, Claude Code, or Hermes Agent session without changing application code.

CLI Basic Usage

Run a coding-agent CLI through Relay, forward hooks, route model traffic through the local gateway, and export traces or trajectories.

Framework or Agent-Harness-Owned Code

Use a supported integration guide when LangChain, LangGraph, Deep Agents, or OpenClaw owns scheduling, callbacks, tool execution, provider payloads, or agent lifecycle hooks. If you are building or reviewing a framework integration that is not covered by a maintained guide, use the generic framework integration workflow instead.

Supported Integrations

Choose the maintained integration path and support level for LangChain, LangGraph, Deep Agents, or OpenClaw.

Integrate Into Frameworks

Choose the generic workflow for unsupported frameworks, provider adapters, or new public-API integrations.

Framework Integration Concepts

Ensure you understand what the framework owns, what Relay owns, and which runtime semantics each integration boundary preserves.

Application-Owned Code

Use a binding Quick Start when your application owns the LLM or tool call and you want to instrument that boundary directly.

Python Quick Start

Smallest Python workflow that emits scope, tool, and LLM events.

Node.js Quick Start

Smallest Node.js workflow that emits scope, tool, and LLM events.

Rust Quick Start

Smallest Rust workflow for direct runtime ownership that emits scope, tool, and LLM events.