# How the NVIDIA Plugin Demonstrates the Generated-Plugin Pattern

> Explore how the NVIDIA plugin showcases the generated-plugin pattern. Learn how skill definitions transform into complete Codex plugins with manifests, agents, and commands.

- Repository: [OpenAI/plugins](https://github.com/openai/plugins)
- Tags: deep-dive
- Published: 2026-09-13

---

**The NVIDIA plugin demonstrates the generated-plugin pattern by maintaining declarative skill definitions—OMS signatures and skill cards—that the built-in `plugin-creator` skill transforms into complete Codex plugins with manifests, agents, and commands.**

The openai/plugins repository implements a **generated-plugin pattern** to streamline plugin development, allowing developers to define capabilities without writing repetitive scaffolding code. The NVIDIA plugin serves as the canonical reference implementation, showing how minimal skill definitions evolve into full-featured runtime components. By separating the **definition of a capability** from the **scaffolding of a full-featured Codex plugin**, this approach enables rapid extension of NVIDIA's Physical AI capabilities through declarative files rather than imperative boilerplate.

## Skill-First Definition with OMS Signatures

The generated-plugin pattern begins with a **skill-first definition** approach. Instead of starting with plugin manifests or agent code, developers write pure skill declarations that describe what the capability does and its interface.

### OMS Signature Files

Each NVIDIA capability is defined by an OMS (OpenAI Model Signature) file located in the `skills/` directory. These files declare the function interface, parameters, and return types in a machine-readable format. For example, the "Physical AI Neural Reconstruction" skill is defined at:

```

plugins/nvidia/skills/physical-ai-neural-reconstruction/skill.oms.sig

```

This signature serves as the single source of truth for the skill's contract, which the `plugin-creator` skill ingests to generate appropriate runtime bindings.

### Human-Readable Skill Cards

Alongside the OMS signature, each skill includes a [`skill-card.md`](https://github.com/openai/plugins/blob/main/skill-card.md) file that provides human-readable documentation. Located at:

```

plugins/nvidia/skills/physical-ai-neural-reconstruction/skill-card.md

```

This markdown file describes the skill's purpose, usage examples, and requirements, appearing in marketplace UIs and developer documentation.

## Automatic Plugin Scaffolding via plugin-creator

The transformation from skill definition to executable plugin is handled by the **plugin-creator** skill, documented in [`.agents/skills/plugin-creator/SKILL.md`](https://github.com/openai/plugins/blob/main/.agents/skills/plugin-creator/SKILL.md). This built-in agent reads the OMS signatures and skill cards, then synthesizes the complete plugin infrastructure.

According to the source documentation in [`.agents/skills/plugin-creator/SKILL.md`](https://github.com/openai/plugins/blob/main/.agents/skills/plugin-creator/SKILL.md), the creator generates a mandatory `.codex-plugin` manifest ([`plugin.json`](https://github.com/openai/plugins/blob/main/plugin.json)) alongside ancillary assets, agents, commands, and hooks required to expose the skill to the Codex runtime. The entry shape of a generated plugin is described verbatim in the creator's documentation, ensuring consistent output across all generated plugins.

This automation eliminates manual scaffolding, ensuring that the [`plugin.json`](https://github.com/openai/plugins/blob/main/plugin.json) manifest correctly wires the original skill signatures into the runtime without human error.

## Resulting Plugin Structure

After the `plugin-creator` skill processes the NVIDIA skill definitions, the plugin directory contains a complete, runnable structure:

- **[`plugins/nvidia/.codex-plugin/plugin.json`](https://github.com/openai/plugins/blob/main/plugins/nvidia/.codex-plugin/plugin.json)** – The machine-readable manifest defining the plugin's name, version, and exposed capabilities.
- **`skills/`** – The original OMS signatures and skill cards, now referenced by the manifest.
- **`assets/`** – Auto-generated icons and images packaged with the plugin.
- **`agents/`** – Auto-generated runtime agents implementing the skill logic.
- **`commands/`** – Auto-generated command definitions exposing the skill via the Codex API.
- **[`hooks.json`](https://github.com/openai/plugins/blob/main/hooks.json)** – Auto-generated lifecycle hooks integrating the plugin with the chat interface.

This structure demonstrates the hallmark of the generated-plugin pattern: **a minimal, declarative skill definition transforms into a fully-functional Codex plugin without hand-written scaffolding**.

## Practical Implementation Examples

The following examples illustrate how the generated-plugin pattern works in practice, from skill definition to runtime execution.

### Generating a Plugin from a Skill Definition

While the actual execution is performed by the built-in `plugin-creator` skill, the following Python pseudocode demonstrates the transformation logic:

```python
import json
import os

# 1. Load the OMS signature from the NVIDIA skill

skill_path = "plugins/nvidia/skills/physical-ai-neural-reconstruction/skill.oms.sig"
with open(skill_path, "r") as f:
    oms_sig = f.read()

# 2. Invoke the plugin-creator skill via the Codex SDK

generated = codex.call_skill(
    name="plugin-creator",
    inputs={"oms_signature": oms_sig}
)

# 3. Write the generated plugin manifest

os.makedirs("plugins/nvidia/.codex-plugin", exist_ok=True)
with open("plugins/nvidia/.codex-plugin/plugin.json", "w") as f:
    json.dump(generated["plugin_manifest"], f, indent=2)

# 4. Persist generated agents, commands, and assets

for path, content in generated["files"].items():
    full_path = os.path.join("plugins/nvidia", path)
    os.makedirs(os.path.dirname(full_path), exist_ok=True)
    with open(full_path, "w") as f:
        f.write(content)

```

This process creates the complete plugin structure automatically, ensuring consistency with the repository's architectural standards.

### Using the Generated NVIDIA Plugin

Once generated, the plugin exposes its skills through the Codex runtime. The following example shows how a chat interface invokes the generated "Physical AI Neural Reconstruction" skill:

```python

# Execute the skill through the generated plugin infrastructure

response = codex.run_plugin(
    plugin_name="nvidia",
    skill="physical-ai-neural-reconstruction",
    inputs={
        "model_url": "s3://my-model",
        "scene_usd": "s3://scene-description.usda"
    }
)
print(response["result"])

```

The runtime uses the generated [`plugin.json`](https://github.com/openai/plugins/blob/main/plugin.json) manifest and agent code to route the request to the appropriate skill implementation.

## Summary

- The **NVIDIA plugin** implements the generated-plugin pattern by separating skill definitions from plugin scaffolding.
- **OMS signatures** (`skill.oms.sig`) and **skill cards** ([`skill-card.md`](https://github.com/openai/plugins/blob/main/skill-card.md)) serve as the declarative source of truth for each capability.
- The **plugin-creator** skill (defined in [`.agents/skills/plugin-creator/SKILL.md`](https://github.com/openai/plugins/blob/main/.agents/skills/plugin-creator/SKILL.md)) automatically generates the [`.codex-plugin/plugin.json`](https://github.com/openai/plugins/blob/main/.codex-plugin/plugin.json) manifest and supporting files.
- Generated outputs include `agents/`, `commands/`, `assets/`, and [`hooks.json`](https://github.com/openai/plugins/blob/main/hooks.json), creating a complete runtime environment without manual boilerplate.
- This pattern enables rapid capability expansion by adding new skill signatures rather than writing full plugin infrastructure.

## Frequently Asked Questions

### What is the generated-plugin pattern in the openai/plugins repository?

The generated-plugin pattern is an architectural approach where developers define capabilities through declarative skill files (OMS signatures and markdown skill cards), then use the `plugin-creator` skill to automatically scaffold the complete plugin structure. This separates the semantic definition of a skill from the technical boilerplate required to expose it in the Codex runtime, ensuring consistency and reducing maintenance overhead.

### How does the NVIDIA plugin create its plugin.json manifest?

The NVIDIA plugin does not hand-write its [`plugin.json`](https://github.com/openai/plugins/blob/main/plugin.json) manifest. Instead, the manifest at [`plugins/nvidia/.codex-plugin/plugin.json`](https://github.com/openai/plugins/blob/main/plugins/nvidia/.codex-plugin/plugin.json) is auto-generated by the `plugin-creator` skill, which ingests the OMS signatures found in `plugins/nvidia/skills/` and produces the machine-readable description of the plugin's name, version, and capabilities according to the entry shape defined in [`.agents/skills/plugin-creator/SKILL.md`](https://github.com/openai/plugins/blob/main/.agents/skills/plugin-creator/SKILL.md).

### What files constitute a skill definition in the NVIDIA plugin?

Each skill requires two files: an OMS signature file (conventionally named `skill.oms.sig`) containing the machine-readable function interface, and a [`skill-card.md`](https://github.com/openai/plugins/blob/main/skill-card.md) file providing human-readable documentation. These files reside in subdirectories under `plugins/nvidia/skills/`, such as `physical-ai-neural-reconstruction/`.

### Can developers modify the auto-generated agents and commands in the NVIDIA plugin?

While developers *can* modify the generated files in `agents/` and `commands/`, the generated-plugin pattern encourages modifying the source **skill definitions** instead and regenerating the plugin. This ensures that the OMS signatures remain the single source of truth and that the runtime bindings stay synchronized with the declared capability interfaces.