NVIDIA NeMo Fabric

NeMo Fabric gives users one configurable, observable way to run applications across multiple agent harnesses. It standardizes configuration, lifecycle management, and results without requiring a separate integration for every harness.

NeMo Fabric lets you change harnesses without rebuilding each integration, isolate conflicting runtime dependencies, and manage harness configuration, execution, and observability consistently. Every run returns normalized results, artifacts, and telemetry for downstream systems to consume.

It provides:

• a versioned, typed configuration contract;
• ordinary Python composition for experiment variants;
• adapter integrations for harness-specific launch and control;
• a Python SDK backed by the Rust core;
• normalized run results, artifact manifests, and telemetry references.

Supported Harnesses

NeMo Fabric provides the following harness integrations. The package expressions install the components shown in each column:

Agent Harness	Runtime, Adapter, and Harness	Adapter and Harness	Adapter Only
Claude Code	nemo-fabric[claude]	nemo-fabric-adapters-claude[harness]	nemo-fabric-adapters-claude
Codex	nemo-fabric[codex]	nemo-fabric-adapters-codex[harness]	nemo-fabric-adapters-codex
Hermes Agent	Install Hermes Agent separately, then install nemo-fabric[hermes-agent]	Install Hermes Agent separately, then install nemo-fabric-adapters-hermes	nemo-fabric-adapters-hermes
LangChain Deep Agents	nemo-fabric[deepagents]	nemo-fabric-adapters-deepagents[harness]	nemo-fabric-adapters-deepagents
mini-SWE-agent	nemo-fabric[mini-swe-agent]	nemo-fabric-adapters-mini-swe-agent[harness]	nemo-fabric-adapters-mini-swe-agent

The nemo-fabric package always installs the runtime. Package-installable harnesses provide root extras that add the corresponding adapter and supported harness. Hermes Agent 0.20 and later is not available from PyPI; install it by following the Hermes Agent installation guide, then install the bare Hermes adapter package. Use the adapter-package forms for split environments or environments that already manage the harness. For harness, full, and Relay behavior, refer to the installation guide.

Capabilities vary by harness. Review the compatibility matrix and use plan() and doctor() before relying on optional capabilities such as MCP, skills, blocked tools, subagents, or telemetry.

Supported Platforms

NeMo Fabric supports the following platforms:

• Linux (x86_64, arm64)
• macOS (arm64)
• Windows (x86_64)

Quick Start

The following example runs NeMo Fabric, the Hermes Agent adapter, and Hermes Agent in one Python environment.

Install NeMo Fabric and Hermes Agent

Hermes Agent supports Python 3.11 through 3.13. Hermes Agent 0.20 and later is not installable from PyPI. Install it with a supported method from the Hermes Agent installation guide. Then install NeMo Fabric and the Hermes adapter into the Python environment that runs Hermes Agent:

pip install "nemo-fabric[hermes-agent]"

For local development from this repository, run just install-hermes-agent instead. The recipe checks out the pinned Hermes Agent source and synchronizes it into the project environment.

Set the API Key

Create an API key in the NVIDIA API Catalog, then set the NVIDIA_API_KEY environment variable:

export NVIDIA_API_KEY="<your-api-key>"

Run Hermes Agent

Run the following Python example:

import asyncio

from nemo_fabric import (
    Fabric,
    FabricConfig,
    HarnessConfig,
    MetadataConfig,
    ModelConfig,
    RuntimeConfig,
)

config = FabricConfig(
    metadata=MetadataConfig(name="quickstart-agent"),
    harness=HarnessConfig(adapter_id="nvidia.fabric.hermes"),
    runtime=RuntimeConfig(max_turns=1),
    models={
        "default": ModelConfig(
            provider="nvidia",
            model="nvidia/nemotron-3-nano-omni-30b-a3b-reasoning",
            api_key_env="NVIDIA_API_KEY",
            base_url="https://integrate.api.nvidia.com/v1",
        )
    },
)

result = asyncio.run(Fabric().run(config, input="Who are you?"))
print(result.output.response)

HarnessConfig.adapter_id selects the Hermes Agent adapter. To use another supported harness, install its package extra and set the corresponding adapter ID. Pass harness-specific options through HarnessConfig.settings only when the selected adapter descriptor declares them in settings_schema. Adapters that expose selectable executables can accept FabricConfig.workflow; the selected Adapter Target Descriptor defines the workflow entry point and validates its settings.

For a guided version of this example, refer to the 01_quickstart.ipynb notebook. The example notebooks overview describes the other available notebooks.

Deployment Scenarios

Scenario 1: Runtime and Harness in the Same Environment

This is the simplest deployment. The nemo-fabric package, selected adapter, and supported harness share one Python environment. The quick start above uses this model with Hermes Agent installed separately from nemo-fabric and nemo-fabric-adapters-hermes.

Scenario 2: Isolated Sandbox for Task Execution

This is the Harbor deployment model. The Harbor host constructs and serializes the final typed FabricConfig. Harbor then installs and runs NeMo Fabric, the selected adapter, and the harness inside an isolated task environment such as a Docker container or Daytona sandbox. Adapter discovery and task-path resolution occur inside that sandbox.

Install nemo-fabric[harbor]==0.3.0 in the host environment. For a Hermes Agent task, use a task image that installs Hermes Agent according to its installation guide, then install nemo-fabric, nemo-fabric-adapters-hermes, and optionally nemo-fabric[relay] in that environment. For Claude or Codex Relay streaming, also provision the external NeMo Relay CLI in the task environment. Refer to the Harbor execution model for details.

Scenario 3: Runtime and Harness in Separate Python Environments

NeMo Fabric can run the runtime and agent harness in separate, locally accessible Python environments. This setup isolates their Python dependencies while the runtime launches the adapter through the adapter environment's interpreter.

Create an environment for the NeMo Fabric runtime:

python -m venv .venv-fabric
source .venv-fabric/bin/activate
python -m pip install "nemo-fabric==0.3.0"

Install Hermes Agent by following its installation guide. Then install the Hermes adapter into the Hermes-managed Python environment:

if [ -z "${ADAPTER_PYTHON:-}" ]; then
  if [ -x "$HOME/.hermes/hermes-agent/venv/bin/python" ]; then
    ADAPTER_PYTHON="$HOME/.hermes/hermes-agent/venv/bin/python"
  else
    ADAPTER_PYTHON="/usr/local/lib/hermes-agent/venv/bin/python"
  fi
fi
if [ ! -x "$ADAPTER_PYTHON" ]; then
  echo "Hermes Agent Python is not executable: $ADAPTER_PYTHON" >&2
  exit 1
fi
export ADAPTER_PYTHON
"$ADAPTER_PYTHON" -m pip install "nemo-fabric-adapters-hermes==0.3.0"

The adapter package keeps the Hermes environment independent from the nemo-fabric runtime distribution and does not install Hermes Agent. Keep the NeMo Fabric environment active and ADAPTER_PYTHON set when running NeMo Fabric. Use matching NeMo Fabric release versions for the runtime and adapter package unless a different pairing has been explicitly validated.

For package options and platform-specific instructions, refer to the installation guide.

Execution Flow

The following diagram shows how configuration moves through the core and selected adapter to the harness, normalized results, artifacts, and telemetry:

flowchart TB
  Consumer["Consumer\nDeployment Platform | Evaluation Harnesses"]
  Config["Typed configuration\nFabricConfig"]
  Core["NeMo Fabric Rust core\nresolve | plan | create | invoke | destroy"]
  Adapter["Selected NeMo Fabric adapter"]
  Harness["Agent harness runtime\nHermes Agent | Codex | Claude Code | LangChain Deep Agents | custom"]
  Artifacts["Normalized results and artifacts\nresponse | logs | patches | telemetry refs"]
  Relay["NVIDIA NeMo Relay\nATOF | ATIF | OTel | OpenInference when enabled"]

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

Loading

Next Steps

Learn and Experiment

Use the following resources to learn about NeMo Fabric:

• Example Notebooks provide a guided tour of the Python SDK.
• Python SDK guide: typed configuration, planning, diagnostics, requests, multi-turn runtimes, native OpenAI streaming, NeMo Relay streaming, parallelism, results, and errors.
• Experimentation CLI: presets, maintained examples, editable application scaffolds, and explicit non-goals.
• Getting Started overview: interface selection and the end-to-end NeMo Fabric workflow.

Consumer Integrations

Consumer integrations are northbound: they connect applications, evaluation systems, and platforms to NeMo Fabric through its public interfaces. Use the following resources to build or validate a consumer integration:

• Consumer integration skills provide repository-local coding-agent workflows for integrating NeMo Fabric into an application through the Python SDK.
• The Harbor integration explains how to validate the integration with a deterministic, credential-free calculator verification test. You can also run the same task with Hermes Agent or Claude and evaluate coding tasks with SWE-Bench.

Harness Integrations

Harness integrations are southbound: they connect NeMo Fabric to agent harnesses through adapters. Use the following reference to compare the integrations:

• Adapter compatibility and guides: compare bundled harness support, runtime ownership, telemetry integration, and package guides.
• Adapter contract: build third-party adapters against the canonical schemas or the dependency-free Python and TypeScript contract bindings.

Roadmap

• Custom harness adapter contract: Publish and evolve canonical schemas and dependency-free language bindings for third-party harness integrations.
• Experimental NVIDIA NeMo Agent Toolkit adapter: Develop an experimental adapter for running NeMo Agent Toolkit workflows through the NeMo Fabric lifecycle.
• OOAgents: Add support for OOAgents.
• Remote agents: Add support for invoking remotely hosted agents through the NeMo Fabric lifecycle.
• Pi coding harness: Add support for the Pi coding harness.