NeMo Relay - Moses Yebei

The Problem

Agent runtimes currently lack shared primitives for scope management, lifecycle events, and middleware across tool and LLM calls. Teams building or integrating coding agents must either piece together ad-hoc observability or accept opaque execution trails with no structured control surface. This repo addresses that gap by providing a multi-language runtime explicitly designed for scope, policy, plugins, and lifecycle events—without requiring changes to existing agent stacks.

What This Does

NeMo-Relay is a multi-language agent runtime and library (1261 files total) written primarily in Rust (584 files), with Python (119), Go (64), and TypeScript (36) bindings. The codebase is organized into crates: core (core runtime primitives), adaptive (adaptive execution), and cli (command-line tooling). A fourth crate, cli/assets/pi-extension, ships a TypeScript extension point. The repository exposes five publishable crates on crates.io (nemo-relay, nemo-relay-adaptive, nemo-relay-cli) and corresponding npm/pypi packages.

The architecture follows a crate pattern: core defines the foundation, adaptive builds scope-and-policy on top, and cli provides the user-facing entry point. Go and Python integrations live in separate subdirectories, while the skills/ folder contains operational runbooks (maintenance, CI, packaging, observability) rather than application code.

How It Is Wired

Execution flows through a small, well-defined set of entry points. The CLI boots from crates/cli/src/main.rs, which delegates to crates/cli/src/lib.rs. The core runtime is initialized from crates/core/src/lib.rs, and the adaptive layer from crates/adaptive/src/lib.rs. Plugin schemas, including the detected secret-shaped paths in crates/cli/src/plugins/schema/secrets.rs, are validated at startup. The CLI also serves a TypeScript extension at crates/cli/assets/pi-extension/index.ts for editor/plugin integration.

The call graph is linear: CLI → core crate → adaptive crate → plugin schema validation → runtime execution. No cycles were detected in the mapped entries. The widest blast radius resides in crates/core/src/lib.rs, which is depended on by all three primary crates; a change there ripples across the Rust runtime, Python bindings, and Go bindings simultaneously.

How To Use It

Setup: Install the CLI from PyPI (pip install nemo-relay-cli-bin) or via the install script (curl -fsSL https://raw.githubusercontent.com/NVIDIA/NeMo-Relay/main/install.sh | sh). Python users can pull the matching CLI with pip install "nemo-relay[cli]". The Rust crates are consumed via cargo add nemo-relay et al.

Configuration: No secret keys are required for local trajectory recording. The repo contains a secrets schema (crates/cli/src/plugins/schema/secrets.rs) that validates secret-shaped paths—verify this file against your environment before running the CLI.

Running it: Start a recorded agent run with nemo-relay record --local-exporter or invoke the Python API to instrument LLM/tool calls. The CLI writes raw events and a normalized trajectory file to disk for later inspection.

Real-World Use

A team integrating Claude Code can install the CLI, enable the local observability exporter, and route agent runs through Relay. After the run, Relay emits raw event JSONs and a trajectory file that can be fed into evaluation pipelines or OpenTelemetry backends. The Go and Python bindings allow framework integrations (LangChain, LangGraph, Deep Agents) to hook into scope management without modifying their core loops.

Code Health & Issues

Low/Security: Secret-shaped paths present in crates/cli/src/plugins/schema/secrets.rs—the code-health audit will confirm or clear them.
Test coverage: 391 test files found across the crates; the adaptive and core modules have the densest unit test suites.
Documentation: 159 doc files present; the docs/ folder and crate-level READMEs are the primary surfaces.

Beyond the measured findings: the repository is MIT-licensed (SPDX: Apache-2.0), CI runs on GitLab with multiple job families (ci.yaml, ci_go.yml, ci_node.yml), and no license file was detected in the clone root—verify LICENSE exists at the repo root before redistribution.

The Bottom Line

NeMo-Relay delivers a functional, multi-language runtime for agent scope and lifecycle management with a clean crate architecture and solid test coverage. The Rust core is the primary dependency surface, and the secret-schema file merits a look before deployment. It is best suited for teams building or integrating coding agents who need structured execution trails without forking their entire stack. Teams already heavily invested in a single language or framework may find the multi-language surface area broader than needed.

What the analyser found

Deployment readiness

5/7

Container image
CI pipeline
Lockfile committed
Test suite
README
License
No committed secrets

Composition

1,261 files

Rust584
Python119
Markdown118
Go64
TOML38
JSON37

ReactLangChainCUDA

Architecture

Top-level areas of the codebase, sized by module count. Arrows show how many imports cross from one area into another.

graph TD g0["python 77 modules"] g1["crates 48 modules"] g2["scripts 39 modules"] g3["integrations 38 modules"] g4["examples 7 modules"] g5["fern 2 modules"] g1 -->|2| g2

Module dependencies

The 10 most depended-upon modules of 214, from static import analysis. Red outline marks a module in an import cycle.

graph LR n0_crates_node_plugin["plugin"] n1_grations_openclaw_src_config["config"] n2_rations_openclaw_src_modules["modules"] n3_claw_src_openclaw_hook_types["openclaw-hook-types"] n4_claw_src_hook_replay_session["session"] n5_s_openclaw_src_hooks_backend["hooks-backend"] n6_enclaw_src_hook_replay_marks["marks"] n7_tency_benchmark_src___init__["__init__"] n8_tency_benchmark_src_fixtures["fixtures"] n9__src_hook_replay_correlation["correlation"] n6_enclaw_src_hook_replay_marks --> n3_claw_src_openclaw_hook_types n6_enclaw_src_hook_replay_marks --> n4_claw_src_hook_replay_session n6_enclaw_src_hook_replay_marks --> n2_rations_openclaw_src_modules n4_claw_src_hook_replay_session --> n1_grations_openclaw_src_config n4_claw_src_hook_replay_session --> n9__src_hook_replay_correlation n4_claw_src_hook_replay_session --> n3_claw_src_openclaw_hook_types n4_claw_src_hook_replay_session --> n2_rations_openclaw_src_modules n4_claw_src_hook_replay_session --> n6_enclaw_src_hook_replay_marks n5_s_openclaw_src_hooks_backend --> n1_grations_openclaw_src_config n5_s_openclaw_src_hooks_backend --> n6_enclaw_src_hook_replay_marks n5_s_openclaw_src_hooks_backend --> n9__src_hook_replay_correlation n5_s_openclaw_src_hooks_backend --> n4_claw_src_hook_replay_session n5_s_openclaw_src_hooks_backend --> n2_rations_openclaw_src_modules n5_s_openclaw_src_hooks_backend --> n3_claw_src_openclaw_hook_types classDef cyc stroke:#ef4444,stroke-width:2px; class n4_claw_src_hook_replay_session,n6_enclaw_src_hook_replay_marks cyc;

Dependencies

61 declared dependencies, none a major version behind. Resolved 0 of 61 against the registry.

Findings

LowSecret-shaped paths present; the code-health audit confirms or clears them crates/cli/src/plugins/schema/secrets.rs

What would stop me shipping this

Ranked by severity × confidence × production reach. Reach is the honest discriminator across a collection that is mostly other people's code: the same finding matters more in something that ships.

high1

medium3

Upgrade the pinned dependency carrying a published advisoryhigh16 occurrences

tokio@1 CVE-2021-45710 (high) +7 more; regex@1 CVE-2022-24713 (high) +1 more; rustls@0.23 CVE-2024-32650 (high) +1 more; futures-util@0.3 CVE-2020-35908 (medium) +1 more; and 1 more package(s)

The pinned version is the one that installs, so a published advisory against it describes this deployment rather than a hypothetical one, and the advisory is also a public description of how to exploit it.

Fix: Upgrade to the fixed version named in the advisory, then commit the lockfile.

Enable Dependabot or Renovatemedium

21 manifest(s), no update bot configured

Without a bot a published advisory sits unpatched until someone audits by hand, which across 1,322 repositories means never.

Fix: Commit .github/dependabot.yml covering the repo ecosystems plus github-actions.

Install from the lockfile in CImedium

.github/workflows

npm install with a committed package-lock.json

A fresh resolution in CI means the tested dependency set is not the locked one, so the failure only appears after merge.

Fix: Use npm ci, yarn install --immutable, or pnpm install --frozen-lockfile.

Gate pull requests on a dependency vulnerability scanmedium

.github/workflows

no dependency scan in CI

This is the one gate that would catch a known-vulnerable package before it reaches a build, and no repository in the sample had it.

Fix: Add dependency-review-action on pull_request, or osv-scanner on push and a schedule.

Checked deterministically against the repository tree and a bounded set of its files: committed credentials, unpinned actions and base images, missing lockfiles and update bots, workflows that discard failures, published advisories against the declared dependencies, runtime configuration, licensing and notebook reproducibility. No language model is involved in this section.