> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/nemo/relay/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/nemo/relay/_mcp/server.

# Quick Start

> Choose a NeMo Relay quick start for CLI, application, framework, or plugin-managed integration.

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](/getting-started/agent-runtime-primer)
or [Concepts](/about-nemo-relay/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](/nemo-relay-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-cli/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](/getting-started/quick-start/python) or [Node.js Quick Start](/getting-started/quick-start/nodejs)        | 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](/getting-started/quick-start/rust)                                                                          | 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](/configure-plugins/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](/instrument-applications/advanced-guide)                                                                      | 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](/supported-integrations/about)                                                                        | 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](/supported-integrations/openclaw-plugin)                                                                            | 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](/nemo-relay-cli/basic-usage) and [Plugin Configuration Files](/configure-plugins/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.

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.

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

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

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.

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

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

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