How the NVIDIA Plugin Demonstrates the Generated-Plugin Pattern

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 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. 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, the creator generates a mandatory .codex-plugin manifest (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 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 – 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 – 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:

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:

# 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 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) serve as the declarative source of truth for each capability.
• The plugin-creator skill (defined in .agents/skills/plugin-creator/SKILL.md) automatically generates the .codex-plugin/plugin.json manifest and supporting files.
• Generated outputs include agents/, commands/, assets/, and 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 manifest. Instead, the manifest at 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.

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

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}