NVIDIA NeMo Fabric

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.

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["Fabric Rust core\nresolve | plan | create | invoke | destroy"]
  Adapter["Selected 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 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 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 Fabric from the source checkout:

just build-all
just wheels

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

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

If you are working from a local Hermes 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, Fabric falls back to python3.

Use ADAPTER_PYTHON when the harness is installed in a separate environment from Fabric. The environment must have the adapter package installed, the adapters tend to be small and self-contained 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.

Claude Adapter

Build the local wheels and install 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, multi-turn resume, 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")

  Hermes maps these names 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. The Hermes adapter lives under adapters/hermes/; the Codex SDK adapter lives under adapters/codex/; the Claude adapter lives under adapters/claude/; the LangChain Deep Agents adapter lives under adapters/deepagents/. Harness-specific extensions belong under harness.settings so the normalized contract can remain stable.

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

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

• 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 Fabric into an application through the Python SDK.
• Getting Started overview: interface selection and the end-to-end Fabric workflow.
• Harbor examples: validate the integration with a deterministic, credential-free calculator smoke, optionally run the same task with Hermes or Claude, and evaluate real coding tasks with SWE-Bench.
• Adapter guides: Hermes, Codex SDK, and Deep Agents.

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