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.
- 🧭 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.
- ✅ 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
Install the published package for your language:
# Rust
cargo add nemo-flow
# Python
uv add nemo-flow
# Node.js
npm install nemo-flow-nodeFor source builds, testing, and contribution workflow, see CONTRIBUTING.md.
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.
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 |
| Coding-Agent 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. |
Some framework integrations are maintained as packages in this repository. Other sample integrations are maintained as patch sets against upstream projects.
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/.
The OpenClaw observability plugin is available under integrations/openclaw/
and uses OpenClaw public plugin hooks to export NeMo Flow telemetry. See the
OpenClaw package README.
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, request intercepts, execution intercepts, and conditional execution.
| Integration | Method | Observability | Request Intercepts | Execution Intercepts | Conditional Execution |
|---|---|---|---|---|---|
| LangChain, LangGraph, LangChain NVIDIA | 🚧 Patch | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes |
| opencode | 🚧 Patch | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes |
| OpenClaw | nemo-flow-openclaw package, nemo-flow plugin ID |
✅ Yes | ❌ No | ❌ No | ❌ No |
| Coding-Agent CLI | nemo-flow-cli package for closed harnesses |
✅ Yes | ❌ No | ❌ No | ❌ No |
| Hermes Agent | 🚧 Patch | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes |
Patch-based integrations offer experimental support. Our roadmap includes switching over to first-party plugins and packages where upstream extension points allow it.
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.
NeMo Flow is licensed under the Apache License 2.0. All source files must include SPDX license headers.