NVIDIA NeMo Fabric

NeMo Fabric is a runtime execution layer for agents. It turns multiple agent harnesses into one configurable, observable lifecycle surface.

Architecture

NeMo Fabric standardizes how applications configure, launch, invoke, and collect artifacts from agent harnesses.

NeMo Fabric provides:

• a versioned, typed FabricConfig contract constructed through the SDK;
• ordinary Python composition for harness and experiment variants;
• adapter descriptors for harness-specific launch and control;
• a Rust core, Python SDK, and standalone experimentation CLI;
• JSON Schema snapshots for the public config and runtime contract;
• normalized run results, artifact manifests, and telemetry references.

flowchart TB
  Consumer["Consumer\nCLI | Python SDK | integrations"]
  Config["Typed source\nFabricConfig"]
  Core["NeMo Fabric Rust core\nresolve | plan | create | invoke | destroy"]
  Adapter["Selected NeMo Fabric adapter"]
  Harness["Agent harness runtime\nHermes | Codex | custom"]
  Artifacts["Artifact manifest\noutput | logs | patches | telemetry refs"]
  Relay["NeMo Relay\nATOF / ATIF when enabled"]

  Consumer --> Core
  Config --> Core
  Core --> Adapter
  Adapter --> Harness
  Harness --> Artifacts
  Core --> Artifacts
  Core -. telemetry config .-> Relay
  Harness -. harness telemetry .-> Relay

Loading

Quick Start: Experimentation CLI

The nemo-fabric CLI is a maintained, experimental developer interface for quick harness experiments, smoke tests, examples, planning, and diagnostics. Its command contract can evolve as experiments mature. The Python SDK remains the stable application-facing contract.

Install the Rust CLI from this source checkout, verify it, and run the credential-free preset:

cargo install --path crates/fabric-cli --locked
nemo-fabric --version
nemo-fabric preset show scripted
nemo-fabric run --preset scripted --input "fabric works"

Copy an editable Python starting point with:

nemo-fabric example init code-review ./my-agent --language python

See the experimentation CLI guide for the CLI's intent and boundaries.

Quick Start: Hermes Agent

This path installs NeMo Fabric, installs Hermes Agent in a separate Python environment, and runs one input through the Hermes Agent adapter.

Prerequisites:

• Rust and Cargo
• Python 3.11+ for NeMo Fabric
• Python 3.11-3.13 for Hermes Agent
• uv
• just 1.50.0+
• NVIDIA_API_KEY for NVIDIA-hosted model access

Install just if not already installed.

cargo install just --locked

Ensure the local Cargo bin directory is in your PATH, if not set it with:

export PATH="$HOME/.cargo/bin:$PATH"

Refer to the official installation guide for more details.

Install NeMo Fabric from the source checkout:

just build-all
just wheels

Install NeMo Fabric, Hermes Agent, and the Hermes Agent adapter into an environment:

# Use any Python 3.11-3.13 interpreter for Hermes Agent.
python3 -m venv .tmp/hermes-venv
.tmp/hermes-venv/bin/python -m pip install --find-links dist "nemo-fabric[hermes, hermes-agent]"

If you are working from a local Hermes Agent checkout, replace the final install line with:

.tmp/hermes-venv/bin/python -m pip install -e ../hermes-agent
.tmp/hermes-venv/bin/python -m pip install --find-links <path-fabric-repo>/dist nemo-fabric-adapters-hermes

Run the code-review example:

export NVIDIA_API_KEY=...
export ADAPTER_PYTHON="$PWD/.tmp/hermes-venv/bin/python"

.venv/bin/python -m examples.code_review_agent \
  --input "Reply with exactly: fabric works"

ADAPTER_PYTHON selects the interpreter used to launch any Python adapter. An explicit harness.settings.python or harness.settings.python_env takes precedence. If none is configured and ADAPTER_PYTHON is unset, NeMo Fabric falls back to python3.

Use ADAPTER_PYTHON when the harness is installed in a separate environment from NeMo Fabric. The environment must have the adapter package installed. The adapters Python packages are designed to be small with minimal dependencies.

The run returns a normalized RunResult JSON payload and writes logs/artifacts under examples/code_review_agent/artifacts/hermes/. Its complete base config and clone-based variants live in examples/code_review_agent/config.py.

Next Steps

• Follow the Example Notebooks for a guided tour of the Python SDK.
• Refer to the Python SDK guide: typed configuration, planning, diagnostics, requests, multi-turn runtimes, parallelism, results, and errors.

Supported Agent Harnesses

Choose a bundled agent harness based on your model ecosystem and application needs. Every harness supports persistent multi-turn local runtimes through the same NeMo Fabric lifecycle and returns normalized results, artifacts, and telemetry references.

Agent harness	Choose it for	Model ecosystem	Key capabilities	Observability
Claude	Claude-native coding and tool-use workflows	Anthropic and NVIDIA-hosted Anthropic Messages-compatible models	Tool guardrails, MCP, skills, and persistent Claude sessions	NeMo Relay
Codex	Codex-native coding workflows	OpenAI and NVIDIA-hosted Responses-compatible models	MCP, skills, and persistent Codex threads	NeMo Relay and native OpenTelemetry
LangChain Deep Agents	Composable LangChain and LangGraph agents	LangChain model providers	Built-in and MCP tools, guardrails, skills, and local subagents	NeMo Relay and native OpenTelemetry/OpenInference
Hermes Agent	Hermes Agent workflows with custom model endpoints	Configurable provider, model, and base URL	Toolsets, guardrails, MCP, skills, and persistent conversation history	NeMo Relay

For package names, exact compatibility and limitations, runtime ownership, and individual harness guides, refer to the adapter compatibility reference.

Claude Adapter

Build the local wheels and install NeMo Fabric with the independent Claude adapter:

just wheels
python -m pip install --find-links dist "nemo-fabric[claude]"

Refer to the Claude adapter guide for typed configuration, normalized tools, MCP and skills, persistent multi-turn runtimes, authentication, and execution details.

Core Concepts

• Typed config: callers construct a complete FabricConfig in Python. Start with the Python SDK guide, and refer to examples/code_review_agent/config.py for a complete application example.

• Variants: ordinary Python functions copy and modify complete configs to vary the harness, model, MCP, tools, skills, telemetry, or environment.

• Experimentation CLI: presets provide quick probes, examples provide maintained runnable workflows, and example init generates editable Python or Rust applications that call a language API directly.

• Tools policy: use top-level tools.blocked for harness-neutral blocked tool policy. Names are interpreted by the selected adapter:

  config.block_tools("browser", "shell")

  The selected adapter interprets these names: Hermes Agent maps them to disabled toolsets, Claude maps them to disallowed_tools, Deep Agents enforces them with middleware, and adapters without a native deny mechanism route the policy as unsupported.

• Adapters: harness-specific integrations selected by harness.adapter_id. Harness-specific extensions belong under harness.settings so the normalized contract can remain stable. Refer to the adapter compatibility reference for bundled package and implementation details.

• Artifacts: normalized output, logs, patches, and telemetry references returned through an ArtifactManifest.

NeMo Fabric accepts complete typed configs. Compose variants in Python before calling the SDK. Refer to the Python SDK guide for the complete public API, type definitions, lifecycle semantics, and error behavior.

run(...) owns the complete start, invoke, and stop lifecycle. For typed in-memory configuration, planning and diagnostics, explicit requests, multi-turn runtimes, application-owned parallelism, results, and errors, see the Python SDK guide. Exact signatures are in the generated Python API reference.

More Workflows

• Example Notebooks provide a guided tour of the Python SDK.
• Python SDK guide: typed configuration, planning, diagnostics, requests, multi-turn runtimes, parallelism, results, and errors.
• Experimentation CLI: presets, maintained examples, editable application scaffolds, and explicit non-goals.
• Consumer integration skills: repository-local coding-agent skills for integrating NeMo Fabric into an application through the Python SDK.
• Getting Started overview: interface selection and the end-to-end NeMo Fabric workflow.
• Harbor examples: validate the integration with a deterministic, credential-free calculator smoke, optionally run the same task with Hermes Agent or Claude, and evaluate real coding tasks with SWE-Bench.
• Adapter compatibility and guides: compare bundled harness support, runtime ownership, telemetry integration, and package guides.

Tests

To run the full test suite, bootstrap a virtual environment with the optional dependencies.

uv venv --seed .venv --python 3.12
source .venv/bin/activate
uv sync --all-groups --all-extras

Build NeMo Fabric and the Python extension. Because the virtual environment is already bootstrapped, pass no_uv=true to avoid reinstalling dependencies.

just no_uv=true build-all

Run both Rust and Python tests:

just no_uv=true test-all

Run just the Rust tests:

just no_uv=true test-rust

Run just the Python tests:

just no_uv=true test-python

Running pytest directly:

pytest