NVIDIA NeMo Fabric

NeMo Fabric gives applications 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:

Agent Harness	Package Extra
Claude Code	nemo-fabric[claude]
Codex	nemo-fabric[codex]
Hermes Agent	nemo-fabric[hermes]
LangChain Deep Agents	nemo-fabric[deepagents]

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

Create and activate a virtual environment, then install the required packages:

python -m venv .venv
source .venv/bin/activate
pip install "nemo-fabric[runtime, hermes-agent]"

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,
)

config = FabricConfig(
    metadata=MetadataConfig(name="quickstart-agent"),
    harness=HarnessConfig(adapter_id="nvidia.fabric.hermes"),
    models={
        "default": ModelConfig(
            provider="nvidia",
            model="nvidia/nemotron-3-nano-30b-a3b",
            api_key_env="NVIDIA_API_KEY",
        )
    },
)

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.

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

Use Separate Environments

The quick start uses one Python environment. Real-world deployments commonly separate the application or evaluation host from the task environment where NeMo Fabric and the selected harness run. For example, Harbor constructs FabricConfig in its host process, then runs NeMo Fabric, the adapter, and the harness inside an isolated task container. Refer to the Harbor execution model for details.

NeMo Fabric can also operate with the NeMo Fabric runtime and the agent harness in separate Python environments. This setup can match existing deployment boundaries and isolate their dependencies.

Create an environment for the NeMo Fabric runtime:

python -m venv .venv-fabric
source .venv-fabric/bin/activate
pip install "nemo-fabric[runtime]"

Create another environment for the adapter and harness. For example, install the Hermes Agent integration:

python -m venv .venv-hermes
source .venv-hermes/bin/activate
pip install "nemo-fabric[hermes-agent]"

Note: The nemo-fabric[hermes-agent] package extra installs the Hermes Agent adapter and Hermes Agent itself, to install just the adapter, use nemo-fabric[hermes].

Run NeMo Fabric from its environment and set ADAPTER_PYTHON to the interpreter that contains the adapter and harness:

source .venv-fabric/bin/activate
export ADAPTER_PYTHON="$PWD/.venv-hermes/bin/python"

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["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, 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.

Roadmap

• Custom harnesses: Publish the NeMo Fabric adapter contract so third-party developers can build integrations that are compatible with NeMo Fabric. Support integrations maintained by NeMo Fabric and compatible third-party integrations.
• Custom agents: Support custom agents built on maintained or third-party harness integrations without requiring an additional, agent-specific adapter. Preserve the normalized NeMo Fabric lifecycle, results, artifacts, and telemetry.