NeMo Flow

What Is NeMo Flow?

NeMo Flow is a portable execution runtime for agent systems that already have a framework, model provider, policy layer, or observability backend. It gives those systems one consistent way to describe, control, and observe what happens when an agent crosses a request, tool, or LLM boundary.

Agent applications rarely live inside one clean abstraction. A production stack might combine NeMo Agent Toolkit, LangChain, LangGraph, provider SDKs, custom harness code, NeMo Guardrails, tracing systems, and evaluation pipelines. NeMo Flow sits underneath those choices as the shared runtime contract for scopes, middleware, plugins, lifecycle events, adaptive behavior, and observability.

Built as a Rust core with primary Rust, Python, and Node.js bindings, NeMo Flow lets applications keep their orchestration model while runtime behavior stays consistent across frameworks and languages.

Why Use It?

• 🧭 Own execution context across the whole agent run: Hierarchical scopes attach tools, LLM calls, middleware, subscribers, and events to the same parent-child execution tree.
• 🛡️ Package policy once: Guardrails and intercepts can block work, sanitize observability payloads, transform requests, or wrap execution without rewriting every call site.
• 📡 Emit one lifecycle stream: Subscribers consume canonical runtime events in-process or export them as ATIF v1.6 trajectories, OpenTelemetry traces, or OpenInference-compatible traces.
• 🧩 Integrate without a framework migration: NeMo Flow can sit below NeMo ecosystem components, third-party agent frameworks, provider adapters, or direct application code.
• ⚙️ Install reusable runtime behavior: Plugins configure middleware, subscribers, adaptive components, observability exporters, and custom runtime behavior from one shared system.

What You Get

• ✅ Managed tool and LLM execution: Run call boundaries through consistent lifecycle helpers and middleware ordering.
• ✅ Concurrent request isolation: Keep request-local middleware and subscribers attached to the scope that owns them, then clean them up when that scope closes.
• ✅ Multi-language semantics: Use the same runtime model from Rust, Python, and Node.js.
• ✅ Observability-ready events: Preserve model metadata, tool call IDs, inputs, outputs, scope relationships, and lifecycle timing for downstream analysis.
• ✅ Built-in observability plugin: Configure Agent Trajectory Observability Format (ATOF), ATIF, OpenTelemetry, and OpenInference exporters without registering subscribers by hand.
• ✅ Extension points for framework authors: Wrap stable tool and provider callbacks while preserving framework-owned scheduling, retries, memory, and result handling.

flowchart LR
    App[Application or Framework]

    subgraph Runtime[NeMo Flow Runtime]
        direction TB
        Scopes[Scopes]
        Middleware[Middleware]
        Plugins[Plugins]
        Events[Lifecycle Events]
    end

    Output[Subscribers and Exporters]

    App --> Scopes
    App --> Middleware
    Plugins --> Middleware
    Scopes --> Events
    Middleware --> Events
    Events --> Output

Loading

Installation

Install the published package for your language:

# Rust
cargo add nemo-flow

# Python
uv add nemo-flow

# Node.js
npm install nemo-flow-node

The NeMo Flow CLI is offered as a separate crate:

cargo install nemo-flow-cli

For source builds, testing, and contribution workflow, see CONTRIBUTING.md.

Documentation

End-user documentation lives at nvidia.github.io/NeMo-Flow.

The primary documentation track covers Rust, Python, and Node.js.

The Go, WebAssembly, and raw FFI surfaces are currently experimental and remain source-first under go/nemo_flow, crates/wasm, and crates/ffi.

Binding Status

The table below summarizes the support level for each binding surface.

Binding	Status	Notes
Python	✅ Fully Supported	Fully documented with Quick Start and Guides
Node.js	✅ Fully Supported	Fully documented with Quick Start and Guides
Rust	✅ Fully Supported	Fully documented with Quick Start and Guides
NeMo Flow CLI	🚧 Experimental	Install with cargo install nemo-flow-cli.
Go	🚧 Experimental	Source-first under go/nemo_flow.
WebAssembly	🚧 Experimental	Source-first under crates/wasm.
FFI	🚧 Experimental	Source-first under crates/ffi.

Agent Harness Support

NeMo Flow CLI offers experimental support for several agent harnesses. Refer to the NeMo Flow CLI documentation for additional information.

Below is our support matrix for agent harnesses.

Agent	Observability	Security	Optimization	Notes
Claude Code	✅ Yes	❌ No	❌ No	Observability only; no known issues
Codex	✅ Yes	❌ No	❌ No	Observability only; missing some necessary hooks for full features
Hermes Agent	✅ Yes	❌ No	❌ No	Observability only; no known issues
Cursor	✅ Yes	❌ No	❌ No	Observability only; not feature-rich, missing hooks under cursor-agent

Third-Party Integrations

Some framework integrations are maintained as packages in this repository. Other sample integrations are maintained as patch sets against upstream projects.

Public API Integrations

Some integrations can be implemented using public APIs without patching. Public API-based integrations live under language-specific integration packages such as python/nemo_flow/integrations/ and integrations/.

Below is the support matrix for our public API integrations.

Agent / Library	Observability	Security	Optimization	Notes
LangChain	✅ Yes	✅ Yes	✅ Yes	Wrapped Tool and LLM calling
LangGraph	✅ Yes	✅ Yes	✅ Yes	Wrapped Tool and LLM calling
Deep Agents	✅ Yes	✅ Yes	✅ Yes	Wrapped Tool and LLM calling
OpenClaw	✅ Yes	❌ No	❌ No	Observability support; missing middleware for wrapped execution

LangChain

The Python nemo-flow package ships several extras that offer comprehensive middleware support for the following packages:

• LangChain
• LangGraph
• Deep Agents

See the Python package README for more information.

OpenClaw

An OpenClaw plugin is available as a Node package nemo-flow-openclaw. It relies on OpenClaw public plugin hooks plus the generic NeMo Flow plugin configuration shape to export telemetry. See the OpenClaw package README for more information.

Patch-based Integrations

Patch-based integrations offer experimental support. Our roadmap includes switching over to first-party plugins and packages where upstream extension points allow it.

Use third_party/README.md for the clone, checkout, and patch-application workflow for those integrations.

The following table summarizes maintained third-party integrations and whether each provides observability, security, and optimization support.

Integration	Observability	Security	Optimization	Notes
LangChain, LangGraph, LangChain NVIDIA	✅ Yes	✅ Yes	✅ Yes	Directly patches behavior into code requiring no middleware
opencode	✅ Yes	✅ Yes	✅ Yes	Directly patches behavior into code
OpenClaw	✅ Yes	✅ Yes	✅ Yes	Adds new middleware support to OpenClaw and a built-in plugin
Hermes Agent	✅ Yes	✅ Yes	✅ Yes	Directly patches behavior into code

Roadmap

The following roadmap outlines planned features and integrations for upcoming releases.

• NemoClaw support and integration for managed tool and LLM execution flows.
• Deeper NVIDIA NeMo ecosystem integration across agent, guardrail, evaluation, and observability workflows.
• Expanded adaptive optimization capabilities for performance-aware scheduling, hints, and cache behavior.
• First-party plugins and/or packages for common agent runtimes and frameworks.

License

NeMo Flow is licensed under the Apache License 2.0.