Skip to content

docs: update 0.6 release notes #450

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
rapids-bot merged 1 commit into from
Jul 16, 2026
Merged

docs: update 0.6 release notes #450

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
175 changes: 115 additions & 60 deletions docs/about-nemo-relay/release-notes/highlights.mdx
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,73 +1,128 @@
---
title: "Highlights"
description: ""
description: "Explore the notable capabilities in NVIDIA NeMo Relay 0.6."
position: 1
---
{/* SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
SPDX-License-Identifier: Apache-2.0 */}

This page summarizes the notable capabilities in the current release
documentation set.
This page focuses on the changes that are most likely to affect how you run,
instrument, or extend NeMo Relay.

## NVIDIA NeMo Relay 0.5
## NVIDIA NeMo Relay 0.6

NVIDIA NeMo Relay 0.5 adds dynamic plugin SDKs and controls, verified CLI
installation and diagnostics, clearer runtime contracts, and improved lineage
for managed LLM requests.
NVIDIA NeMo Relay 0.6 focuses on reliable evidence. It starts Relay before a
coding agent needs it, keeps sensitive data out of emitted events, preserves
the right context in each export, and gives embedding hosts direct control of
dynamic plugins.

### Coding-Agent Gateway and Skills

- Coding agents now connect through `nemo-relay mcp`, which starts or adopts
the authenticated gateway before it reads MCP protocol frames. Codex, Claude
Code, and Hermes clients can share the gateway, keep it alive while they are
connected, and coordinate a single recovery attempt before idle shutdown.
- Installed integrations now use agent-owned hooks, generated MCP entries,
generation fencing, transactional rollback, and user-scoped configuration.
Generated configuration carries approved environment variable names, not
their secret values.
- Relay now emits tool-parented `skill.load` marks when an agent uses a
first-class skill tool or requests a complete read of a `SKILL.md` file. The
behavior covers coding agents, direct tools, LangChain, LangGraph, and Deep
Agents.
- The public skill catalog now starts from the task at hand: install Relay,
reach a first useful result, instrument an application, configure a plugin,
migrate, or debug. Its guidance favors installers pinned to immutable release
tags, synthetic non-sensitive exporter checks, runtime-injected secrets, and
tightly scoped migration writes.

### Event Security and Runtime Semantics

- You can now sanitize mark, scope-start, and scope-end events globally, within
a scope, or from a plugin context. Rust, Python, and Node.js expose the same
lifecycle, along with experimental Go and C bindings, native plugins, and
`grpc-v1` workers.
- The built-in PII redaction plugin now cleans mark data, category profiles,
metadata, and generic scope inputs and outputs before subscribers or
exporters receive them.
- Relay now tracks LLM event-history freshness per agent. A new agent and the
first LLM start after a `compaction` mark retain the complete sanitized
history. Later starts keep the system instructions, latest user turn, and
following messages. The provider request itself does not change.
- A central provider-codec factory now resolves canonical provider names and
the built-in request, response, and streaming codecs.

### Observability and Optimization

- Observability configuration version 2 gives each ATOF file or stream sink
its own settings. One component can send every event to several destinations,
including named HTTP sinks whose credentials come from environment variables.
- OpenTelemetry and OpenInference now project top-level event data into typed
OTLP attributes instead of raw JSON payload attributes. Optional
`attribute_mappings` keep backend-specific aliases available during
migration.
- Trace exporters can show selected marks as visible, zero-duration tool spans.
OpenInference also exposes the projected tool name, output, and metadata in
its standard fields.
- A single `session.start` mark now carries the IDs that correlate startup
sessions across ATOF, ATIF, OpenTelemetry, and OpenInference.
- Relay now accepts plugin-neutral LLM optimization evidence and combines it
into bounded summaries of baseline and effective models, token effects,
estimated cost, evidence quality, and pricing provenance.
- ATIF now attributes each LLM step to the effective normalized response model.
ATOF remains the canonical mark stream, while ATIF remains a step-oriented
trajectory projection.

### Dynamic Plugin Hosts

- Embedding hosts can now own a `PluginHostActivation` for explicit native and
worker plugins. Static configuration initializes first, dynamic components
are added in the same transaction, and teardown clears callbacks and flushes
subscribers before releasing resources that it can unload safely.
- Python and Node.js can now activate explicitly specified dynamic plugins and
clean them up asynchronously. Experimental C and Go entry points expose the
same owned lifecycle for source-first evaluation.

### CLI Configuration and Operations

- `nemo-relay plugins edit` now understands recursive lists, string maps, and
tagged unions. You can edit nested Adaptive, NeMo Guardrails, PII,
Observability, and other built-in configuration without editing raw JSON.
- Operational commands now initialize process-wide logging before they run.
Logs always go to stderr and can also flow to bounded asynchronous file sinks
in human-readable or JSONL form. `nemo-relay config` and
`nemo-relay plugins edit` skip initialization so invalid logging
configuration cannot block its own repair.

### Switchyard Decision Routing (Experimental)

- The published `nemo-relay-switchyard` crate and optional CLI feature connect
Relay to a separately running Switchyard Decision API. Relay validates the
selected backend, translates supported provider protocols in process, and
dispatches to targets that Relay owns.
- You can run in enforce or observe-only mode, use bounded retry-aware routing,
use trusted same-protocol fallbacks, and route buffered or streaming calls.
Relay records the resulting model-routing optimization evidence.
- Startup health checks validate the Switchyard service, and named ATOF
stream-sink checks protect history-backed profiles. When every configured
target uses the inbound protocol, Relay preserves supported provider
extensions. Mixed-protocol configurations still enforce portability checks.

### Compatibility and Migration

- Move plugin configuration from `config.toml` into `plugins.toml`. The
`--plugin-config` CLI option and hook-forwarding input have been removed.
- Update every registered LLM request and tool execution intercept to return
its canonical outcome. The outcomes can include ordered pending marks while
Relay retains lifecycle ownership.
- Rebuild development native plugins and `grpc-v1` workers against 0.5 because
the native ABI and worker outcome contracts are now finalized.
- Migrate away from the removed experimental `nemo-relay-wasm` package, Cursor
CLI support, and patch-based integrations.

### Dynamic Plugins and Configuration

- Added dynamic plugin discovery from `plugins.toml`, host policy and
attestation gates, and lifecycle commands for inspecting, validating,
enabling, and disabling plugins.
- Added the Rust SDK for trusted in-process `rust_dynamic` plugins and the
`grpc-v1` worker protocol with Rust and Python worker SDKs.
- Added schema-aware dynamic-plugin configuration, validation, secret-aware
editing, and merged TOML preview in the CLI.
- Added Python worker-environment management and worker invocation
cancellation.

### CLI Installation and Diagnostics

- Added verified Unix and Windows installers that select the release asset,
verify its SHA-256 checksum, and support version pinning.
- Expanded `nemo-relay doctor` with agent-host readiness checks, persistent
host-plugin diagnostics, and discovered `plugins.toml` source and validation
reporting.
- Added gateway status reporting for bind, exporter, and remote ATIF storage
destinations.

### Runtime and Observability

- Added canonical LLM request and tool execution outcomes across Rust, Python,
Node.js, Go, C FFI, native plugins, and worker plugins.
- Added ordered pending marks to managed LLM and tool lifecycles without adding
control data to application-visible requests or tool results.
- Added automatic Dynamo session and parent-session headers to managed LLM
requests, plus bounded CLI turn scopes for trace correlation.
- Documented stable normalized token and cost semantics, including provider
mapping and exporter projection behavior.
- Hardened ATOF HTTP output and ensured gateway shutdown flushes queued events.

### Documentation and Tooling

- Added public contract references for LLM request and tool execution intercept
outcomes.
- Expanded dynamic plugin, configuration, runtime-contract, installation, and
integration examples.
- Updated package, build, test, and release guidance for the primary Rust, Python, and Node.js surfaces, plus experimental Go and raw C FFI notes.

The complete changelog and release artifacts can be viewed on
- Reinstall persistent coding-agent integrations so they use the MCP-owned
gateway lifecycle.
- Move ATOF plugin configuration to Observability configuration version 2, and
use typed sinks for manually constructed exporters. Move OTLP queries to the
typed attribute paths at the same time.
- Check ATIF and event consumers for assumptions about marks, requested model
names, or complete request histories.
- Update Rust exhaustive matches, direct struct literals, and editor metadata
consumers for the new public variants and fields.
- Point any automation that opens public skills by directory name at the new
task-oriented catalog.

For the exact migration actions, documentation, and originating PRs, refer to
[Known Issues and Compatibility Notes](/about-nemo-relay/release-notes/known-issues#compatibility-and-migration-notes).
The complete PR-by-PR history and release artifacts are available on
[GitHub Releases](https://github.com/NVIDIA/NeMo-Relay/releases).
106 changes: 70 additions & 36 deletions docs/about-nemo-relay/release-notes/index.mdx
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,59 +6,93 @@ position: 5
{/* SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
SPDX-License-Identifier: Apache-2.0 */}

This page summarizes the current documentation-visible release state. GitHub
Releases remain the source of truth for complete release history and
tag-specific notes.
This page gives you the short version of the current release. For the complete
PR-by-PR history, release artifacts, and notes for a specific tag, use
[GitHub Releases](https://github.com/NVIDIA/NeMo-Relay/releases).

## Current Release

NVIDIA NeMo Relay 0.5 adds dynamic plugin SDKs and lifecycle controls, verified
CLI installers and readiness diagnostics, stable token and cost field semantics,
and stronger request and trace lineage behavior.
NVIDIA NeMo Relay 0.6 makes local coding-agent sessions easier to start,
observe, and extend. It adds an MCP-managed shared gateway, broader event
sanitization, richer observability and optimization evidence, direct control
of dynamic plugin lifecycles for embedding hosts, configurable operational
logging, and an experimental Switchyard Decision API integration.

The most important compatibility notes are:
If you're upgrading from 0.5, plan for these changes:

- Plugin configuration now lives in `plugins.toml`. Move plugin settings out of
`config.toml`; the `--plugin-config` CLI option has been removed.
- Registered LLM request and tool execution intercepts now return canonical
outcomes. Rebuild development native plugins and `grpc-v1` workers against
0.5.
- The experimental `nemo-relay-wasm` package, Cursor CLI support, and
patch-based integrations have been removed.
- Go and the raw C FFI remain experimental and source-first. Node.js 24 or
newer remains the minimum supported Node.js version.
- Reinstall your Codex, Claude Code, and Hermes integrations with
`nemo-relay install <agent> --force` or `nemo-relay install all --force`.
Installations generated by 0.5 do not use the 0.6 gateway lifecycle.
- Move Observability plugin ATOF configuration to
`components.config.version = 2` and the tagged `atof.sinks` list. If you
query OTLP data, replace removed raw `*_json` attributes with the new typed
paths.
- Review event consumers that assume sanitizer failures are fail-open, every
LLM event contains the full request history, ATIF contains marks, or
`step.model_name` always matches the requested model.
- Update Rust code that exhaustively matches public enums or directly
constructs mark types, ATOF sink types, or editor metadata types. The
provided builders and constructors are the safest migration path.
- Replace direct references to old public skill directories with the
task-oriented `nemo-relay-install`, `nemo-relay-get-started`,
`nemo-relay-instrument-*`, and `nemo-relay-plugin-*` entry points.

Use the child pages for release highlights and support notes. For the complete
PR-by-PR changelog, release artifacts, and tag-specific history, use
[GitHub Releases](https://github.com/NVIDIA/NeMo-Relay/releases).
Before you upgrade, work through the complete
[Compatibility and Migration Notes](/about-nemo-relay/release-notes/known-issues#compatibility-and-migration-notes)
for the exact actions, documentation, and implementation PRs. Go and the raw C
FFI remain experimental and source-first. Node.js 24 or newer remains the
minimum supported Node.js version.

## Release Scope

This release includes:
Here's what changed across the main product surfaces:

- Dynamic plugin discovery, trust policy and attestation gates, and lifecycle
controls through the `nemo-relay` CLI.
- A Rust native plugin SDK for trusted in-process `rust_dynamic` plugins, plus
`grpc-v1` worker support through Rust and Python SDKs.
- Schema-aware dynamic-plugin configuration and editing through `plugins.toml`.
- Verified Unix and Windows CLI installers, and expanded `nemo-relay doctor`
readiness diagnostics for agent hosts and plugin configuration.
- Canonical LLM request and tool execution intercept outcomes with ordered
pending marks across the runtime and supported bindings.
- Automatic Dynamo session-lineage headers on managed LLM requests and
turn-scoped CLI trace correlation.
- Stable normalized token and cost semantics for provider response codecs and
ATOF, ATIF, OpenInference, and OpenTelemetry projections.
- **Coding agents:** Relay starts or adopts one authenticated gateway before an
installed client emits hooks or routed provider traffic. Codex, Claude Code,
and Hermes can share that gateway, coordinate a single recovery attempt, and
let it shut down after it becomes idle.
- **Events and security:** Mark, scope-start, and scope-end sanitizers now work
at global, scope-local, and plugin levels. The PII plugin sanitizes those
surfaces, later LLM events can omit stale history, and Relay records
skill-load attempts with `skill.load` marks.
- **Observability and optimization:** ATOF can send every event to multiple
file and stream sinks. OTLP exporters use typed attributes, trace exporters
can show marks as tool spans, session identifiers correlate across formats,
ATIF reports the effective response model, and plugins can contribute
optimization evidence.
- **Plugins and configuration:** Rust, Python, and Node.js embedding hosts can
own native and worker dynamic plugin lifecycles. Experimental C and Go entry
points expose the same lifecycle, and the CLI can edit nested lists, maps, and
tagged unions in built-in plugin configuration.
- **Operational logging:** Commands can write configurable human-readable or
JSONL logs to stderr and asynchronous file sinks without writing to stdout.
- **Decision routing:** The opt-in experimental Switchyard plugin validates and
routes buffered or streaming requests across OpenAI Chat Completions, OpenAI
Responses, and Anthropic Messages.
- **Agent skills:** The public catalog now follows task-oriented workflows for
installation, getting started, instrumentation, plugin configuration,
migration, and debugging. The guidance calls for installers pinned to
immutable release tags, runtime-injected secrets, non-sensitive exporter
checks, and tightly scoped migration writes.

## Feature Documentation

For the major 0.5 additions, start with:
Use these guides to explore the main 0.6 capabilities:

- [Installation](/getting-started/installation)
- [NeMo Relay CLI](/nemo-relay-cli/about)
- [CLI Basic Usage](/nemo-relay-cli/basic-usage)
- [Coding Agent Installation and Diagnostics](/nemo-relay-cli/plugin-installation)
- [Build Plugins](/build-plugins/about)
- [Plugin Configuration Files](/configure-plugins/plugin-configuration-files)
- [Installation](/getting-started/installation)
- [Plugin Installation and Diagnostics](/nemo-relay-cli/plugin-installation)
- [Events](/about-nemo-relay/concepts/events)
- [Event Sanitizers](/reference/event-sanitizers)
- [LLM Request Intercept Outcomes](/reference/llm-request-intercept-outcomes)
- [Tool Execution Intercept Outcomes](/reference/tool-execution-intercept-outcomes)
- [Instrument an LLM Call](/instrument-applications/instrument-llm-call)
- [Provider Response Codecs and Model Pricing](/integrate-into-frameworks/provider-response-codecs)
- [Observability Configuration](/configure-plugins/observability/configuration)
- [ATOF Export](/configure-plugins/observability/atof)
- [OpenTelemetry Export](/configure-plugins/observability/opentelemetry)
- [OpenInference Export](/configure-plugins/observability/openinference)
- [Switchyard (Experimental)](/configure-plugins/switchyard/about)
Loading
Loading