> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/nemo/fabric/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/nemo/fabric/_mcp/server.

# NVIDIA NeMo Fabric Documentation

> Configure, plan, run, and observe agent harnesses and custom agents through one typed execution contract.

NVIDIA NeMo Fabric is the integration layer that turns agent harnesses and
custom agents into one configurable, observable execution surface.
Applications use the same versioned config, lifecycle, result, artifact, and
telemetry contracts whether the selected Adapter Target is
[Hermes Agent](https://hermes-agent.nousresearch.com/docs/),
[Codex SDK](https://openai.com/codex/), a registered workflow behind a shared
framework adapter, or a dedicated custom agent.

NeMo Fabric owns the seam between an application and its Adapter Target. It
resolves configuration, selects an adapter, drives the runtime lifecycle, and
returns normalized evidence without leaking target-specific control code into
the caller.

## What NeMo Fabric Gives You

#### Typed Configuration

Construct a complete, versioned `FabricConfig` in Python. Applications
create variants with ordinary functions and typed copies.

#### Target-Neutral Execution

Plan and invoke harnesses and custom agents through one Rust core, CLI, and
Python SDK instead of embedding target launch logic in every consumer.

#### Typed Lifecycle Contracts

Resolve configs, inspect capabilities, run single-invocation jobs, and hold
multi-turn runtimes with typed requests, plans, handles, and results.

#### Normalized Evidence

Collect output, errors, lifecycle events, artifact manifests, and telemetry
references in stable contracts suitable for platforms and evaluations.

## Choose Your Interface

Use the following table to choose the NeMo Fabric interface that best fits how
your application works with Adapter Targets:

| Interface         | Use it when                                                                                   | Start with                                                                                     |
| ----------------- | --------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| Python SDK        | Your application owns job config, runtime lifecycle, or multi-turn state                      | [Client API](/nemo/fabric/dev/reference/api/python-library-reference/client)                   |
| Runtime API       | You need multiple ordered turns over one live harness runtime                                 | [Runtime](/nemo/fabric/dev/reference/api/python-library-reference/runtime)                     |
| Streaming API     | You need live ATOF records generated by NeMo Relay during a runtime turn                      | [Streaming](/nemo/fabric/dev/reference/api/python-library-reference/streaming)                 |
| `nemo-fabric` CLI | You are experimenting with harnesses, running maintained examples, or troubleshooting configs | [Experimentation CLI](/nemo/fabric/dev/experimentation/cli)                                    |
| JSON Schema       | You are building editors, validation, code generation, or another language binding            | Committed schemas in the [repository](https://github.com/NVIDIA/NeMo-Fabric/tree/main/schemas) |

Use `FabricConfig` as the canonical configuration contract. CLI selectors
obtain complete typed configs from built-in presets or maintained examples.

## Core Workflow

```text
Application or evaluation harness
        |
        |  Python SDK or nemo-fabric experimentation CLI
        v
NeMo Fabric Rust core
  config -> plan -> lifecycle
        |
        |  resolved adapter contract
        v
Agent harness | shared framework target | dedicated custom agent
        |
        v
RunResult + artifacts + events + telemetry references
```

1. **Configure** a typed `FabricConfig` with a harness adapter,
   environment, models, tools, skills, MCP, and telemetry.
2. **Create variants** from deep copies to vary harness, model, environment, or
   observability settings without mutating the base config.
3. **Plan and diagnose** to resolve the adapter and check capabilities and
   requirements before spending work on a runtime.
4. **Run or start a runtime** through the shared lifecycle contract. To consume
   live ATOF records, enable NeMo Relay, start the runtime with `streaming=True`,
   and call `Runtime.invoke_stream()`.
5. **Consume evidence** from `RunResult`: output, structured failure details,
   artifacts, events, and telemetry references.

Adapter authors can follow the
[adapter contract overview](/nemo/fabric/dev/adapter-contract/overview) to choose a harness
adapter, shared framework adapter, or dedicated custom-agent adapter
and implement the minimum lifecycle.

## Learn More

Continue exploring NeMo Fabric through these resources.

* **Installation** — [Installation](/nemo/fabric/dev/getting-started/install) to set up the runtime and adapters.
* **Quickstart** — [Quickstart](/nemo/fabric/dev/getting-started/quickstart) to build from
  source and run the maintained SDK example.
* **Python SDK** — [Python SDK](/nemo/fabric/dev/sdk/python-sdk) for planning, diagnostics,
  typed requests, and multi-turn runtimes.
* **API Reference** — [Client API](/nemo/fabric/dev/reference/api/python-library-reference/client)
  to resolve, plan, diagnose, run, and start stateful runtimes.