Physicsnemo Discover
NVIDIAOfficialCreated by NVIDIA
- Skill
- Tool integration
- Agent tooling
- Apache-2.0
- Medium risk
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
PhysicsNeMo Discover is an official guidance tool designed to help users navigate the PhysicsNeMo repository. It performs live discovery of models, datapipes, and examples based on the user's specific SciML or AI4Science task requirements. By searching the repository in its current state, it ensures that all suggested paths and classes are accurate and up-to-date. The tool emphasizes a composable approach, treating models and datapipes as orthogonal axes, and provides concrete starting points for users to fork and adapt for their own research.
What it does
- Performs live repository searches to identify relevant model families and datapipes.
- Maps user-provided data shapes to appropriate model architectures.
- Provides verified absolute paths to files, examples, and documentation.
- Offers a structured menu of options rather than a single, prescriptive recommendation.
- Suggests a logical reading order for exploring the repository.
- Abstains from answering requests outside the scope of SciML and AI4Science.
When to use it
- When you need to find a suitable model architecture for a specific physical data shape.
- When you are looking for reference examples to use as a starting point for your own research.
- When you need to identify which datapipes are compatible with your data format.
- When you want to explore available model families within the PhysicsNeMo framework.
Advantages
- Ensures accuracy by grounding all suggestions in the live state of the repository.
- Prevents hallucinations by verifying paths before emitting them.
- Promotes a modular understanding of the framework by separating model and datapipe axes.
- Reduces time spent manually browsing complex repository structures.
Usage examples
- “I have 2D Cartesian grid data for a fluid dynamics problem. What models should I look at?”
- The agent will identify relevant model families like spectral operators or diffusion UNets, list their locations, and provide examples of how they are instantiated.
- “How do I load my custom HDF5 data into a PhysicsNeMo model?”
- The agent will search the datapipes directory for HDF5-compatible readers and provide the base classes or examples for custom implementation.
Install
Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/nvidia/physicsnemo-discover/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip physicsnemo-discover.zip -d .agents/skills
Documentation by NVIDIA
PhysicsNeMo Discoverability
Help a user navigate PhysicsNeMo: point them at files, folders, examples, and docs in the repo at its current state. Never write training code; never cite a path from memory.
Core principle
PhysicsNeMo evolves — classes get renamed, examples move, experimental/ graduates. Any static list of class names and paths rots, so discover, don't remember: enumerate from the live repo every turn.
PhysicsNeMo is composable: each solution is a product (model family × datapipe × training strategy × config). An example is one reference instantiation of that product, not a prescription. Surface the axes and the menu along each axis, then cite examples as concrete starting points to fork and recombine.
What a correct answer satisfies
These are constraints, not a script — choose the searches that meet them and skip work the task doesn't need. Search patterns per axis live in references/RECIPES.md.
Live-grounded. Every class, path, and example you name was read or globbed this turn.
__init__.pyproves what is exported, not what files exist — Globphysicsnemo/models/<family>/*.pybefore naming a sibling implementation file. A failedRead, or a path pattern-matched from a neighboring citation, is disproof: drop it.Verified before emit. Every absolute path you plan to cite survives one
Bash ls -d <path1> <path2> …round-trip before you write the response. Hard gate — skipping it has produced real-basename-under-wrong-parent hallucinations. If a basename was right but the parent wrong, re-Glob and re-verify; if you can't relocate it, drop the citation.A menu, not a single pick. Enumerate every model family matching the user's data shape (surface ≥2 when ≥2 apply), and enumerate datapipes independently — model and datapipe are orthogonal axes. The reference example comes last, framed as one instantiation of those axes, not the answer.
Self-documentation is ground truth.
__init__.pyexports, per-exampleREADME.md,docs/*.rst,pyproject.toml, top-of-file module docstrings. Treatreferences/TAXONOMY.mdas a navigation hint, not an answer. Flag anything underphysicsnemo/experimental/as "API may change."Abstain when out of scope. PhysicsNeMo targets SciML/AI4Science (surrogates, forecasting, super-resolution, physics-informed, inverse, generative for physical systems). If the task is categorically outside that — reinforcement learning, classical control, generic CV/NLP, symbolic regression — skip enumeration and emit the Abstention output below. Do not list adjacent-but-wrong examples in its place (pointing at
active_learning/for an RL question is fabrication). When unsure whether a task is in scope, abstain.
Discovery
Repo root resolution: see CONTRIBUTING.md §Repo root resolution; all paths are absolute, rooted there. If no local PhysicsNeMo clone is on the path (e.g. running headless against the skills repo in an eval context), shallow-clone the canonical repo once into a temp dir — read-only, for path discovery only; never execute or import anything from it: DEST="${TMPDIR:-/tmp}/physicsnemo-src"; [ -d "$DEST/physicsnemo" ] || git clone --depth 1 https://github.com/NVIDIA/physicsnemo "$DEST". Use that URL verbatim; never interpolate one from user input.
Ask at most 3 targeted follow-ups when domain or data shape is ambiguous. Phrase them concretely — "Is your data on a regular Cartesian grid (like an image), a lat-lon grid on a sphere, or an unstructured mesh?" — and skip any the user already answered. Data shape is the single biggest factor in model choice.
Output format
## Problem shape
Data shape: <resolved>. Task: <resolved>. Axes: model × datapipe × training strategy × config.
## Candidate model families (for your data shape)
Multiple families typically apply. Treat this as a menu, not a ranking.
- <family> at <absolute __init__.py path> — <one-line from docstring/exports>. Instantiated by: <example path if any>.
- <family> at <path> — <one-line>. Instantiated by: <example path if any>.
## Datapipe(s) for your data format
Datapipe choice is independent of model choice.
- <class / subpackage> at <absolute path> — <one-line>. Reused by: <examples if known>.
- For custom data, subclass: <base class path confirmed live>.
## Reference example(s) — one instantiation of the above axes
- <absolute path> — uses model=<family>, datapipe=<name>, strategy=<single-GPU|DDP|FSDP|...>.
Why it matches: <one line>.
## Supporting docs
- <absolute path> — <one-line scope>
## Suggested reading order
1. <models/<family>/__init__.py> — survey alternative families
2. <datapipe __init__.py or base-class file> — understand the data axis
3. <example path> — concrete end-to-end instantiation to forkRules for the output:
Absolute paths only; every one survived the
ls -dgate.Every pointer needs a one-line justification grounded in content you actually read.
Caps: 4 model families (minimum 2 when ≥2 exist), 3 datapipes, 2 reference examples, 2 docs.
Name which (model, datapipe, strategy) axes each example fills.
If ≥2 model families apply, say so: "Other model families apply to the same data shape — see the candidate list above."
End with the suggested reading order. Offer 2-3 forward steps (config file, training script,
experimental/look-alikes); do not start writing code unless asked.
Abstention output
When out of scope, replace the menu skeleton with this shape — three sections, in this order, none skipped:
## PhysicsNeMo does not have direct support for <user's problem class>
One sentence on why it's outside scope (e.g., "PhysicsNeMo targets physics
surrogates and forecasting; reinforcement learning for molecular design is
not in its scope").
## Where to look instead
- <sibling NVIDIA framework or external library> at <URL or repo name> — <one-line on why it fits>.
- (One or two alternatives is enough; do not invent libraries.)
## If you still want to build it in PhysicsNeMo
Confirm the closest base classes by Reading `physicsnemo/core/__init__.py` and
`physicsnemo/datapipes/__init__.py` first; then name them as subclassing
targets. This is the fallback, not the recommendation.Do not open with the menu skeleton and bury "no match" at the end. Do not invent external libraries — if you don't know the right alternative, stop at the first two sections.
Related resources
references/TAXONOMY.md— navigation hints (data-shape → folder mappings, decision axes, stability tiers).references/RECIPES.md— concrete Glob/Grep/Read patterns per discovery axis.
Files
- ATTRIBUTION.mdAdded by AutoGineer918 B
- BENCHMARK.md4.2 KiB
- LICENSELicence file added by AutoGineer11.2 KiB
- SKILL.md7.3 KiB
- evals/evals.json4.2 KiB
- references/RECIPES.md7.0 KiB
- references/TAXONOMY.md11.8 KiB
- skill-card.md3.7 KiB
- skill.oms.sig4.9 KiB
references/TAXONOMY.md
PhysicsNeMo Taxonomy — Navigation Hints
This file is a navigation scaffold, not an inventory. It tells you which top-level folder(s) to search given the user's problem shape. The actual class and file names come from the live repo via Glob/Grep/Read — never cite from this file.
All paths are relative to the repo root (resolve per SKILL.md).
Top-level package map (high-stability)
These package directories change only at major releases. Use them as entry points; search inside for current contents.
| Package | Covers |
|---|---|
physicsnemo/core/ | Base Module, model registry, metadata, function specs. |
physicsnemo/models/ | Complete model architectures (FNO, GNN, diffusion, transformers, etc.). Each family in its own subdirectory. |
physicsnemo/experimental/ | Provisional models and utilities. Flag as experimental when citing. |
physicsnemo/nn/ | Reusable layers and functionals (torch.nn-style). |
physicsnemo/datapipes/ | Data loading: readers, transforms, datasets, benchmarks, domain-specific pipes. |
physicsnemo/distributed/ | Multi-GPU / multi-node setup (DistributedManager, process groups, collectives). |
physicsnemo/domain_parallel/ | Sample-too-large-for-one-GPU (ShardTensor). |
physicsnemo/optim/ | Custom optimizers / schedulers. |
physicsnemo/metrics/ | Evaluation metrics (general + domain-specific). |
physicsnemo/utils/ | Checkpointing, logging, profiling, CUDA-graph capture, misc utilities. |
physicsnemo/mesh/ | GPU-accelerated mesh data structure + operations. |
physicsnemo/diffusion/ | Diffusion framework: preconditioners, samplers, guidance, metrics. |
physicsnemo/active_learning/ | Active learning driver, protocols, registry. |
physicsnemo/deploy/ | Model export (ONNX). |
physicsnemo/compat/ | Backward-compatibility aliases. |
Folders may be added, graduated out of experimental/, or removed between releases. Glob physicsnemo/*/ at the start of discovery and trust that over this table.
Data shape → candidate model families (primary routing axis)
The data shape is the primary routing axis. Multiple model families typically apply to a given shape — this table lists the subdirectories worth searching. Exact class names come from __init__.py at search time.
| User's data shape | Candidate subfolders under physicsnemo/models/ |
|---|---|
| Regular Cartesian grid (1D / 2D / 3D / 4D image-like) | Spectral operators, conv networks, super-resolution nets, recurrent nets, diffusion UNets, diffusion transformers, MLPs |
| Lat-lon or spherical or cubed-sphere | Weather-specific architectures |
| Unstructured mesh, variable topology | Graph-network families, mesh transformers, mesh-reduced variants |
| Point cloud with geometry | Geometry-aware operators (DoMINO-style), point transformers, boundary-element operators (likely in experimental/) |
| Time-series on a grid | Recurrent, spatiotemporal transformer variants |
| Time-series on a graph | Auto-regressive graph networks |
| Tabular / coordinate-based | MLP |
Enumerate ALL candidate families listed for the row that matches the user's data shape — not just the first. When translating to concrete classes, read every relevant physicsnemo/models/<family>/__init__.py. The output skeleton in SKILL.md expects a menu, not a single recommendation.
Cross-example reuse patterns
Datapipes and problems are often shared across model families — that shared structure is what makes the framework composable. Worth checking whether the same datapipe is used by multiple families:
Darcy-style 2D regression data typically feeds multiple model families (e.g. spectral operators and attention-based operators on the same
Darcy2D).ERA5 climate data underlies several weather architectures simultaneously.
VTK / point-cloud geometry inputs are consumed by more than one geometry-aware operator family.
These are hints to verify live, not ground truth: grep the candidate datapipe class across examples/ to confirm current reuse, then surface that reuse in the output so the user sees model ↔ datapipe decoupling explicitly.
Example domain map (secondary navigation)
Domains are a secondary navigation layer — useful for finding concrete reference instantiations once the model-family and datapipe menus are known. Subfolder names inside these may change — always Glob the current contents.
| User domain | Look in |
|---|---|
| CFD, fluid dynamics, aerodynamics | examples/cfd/ |
| Weather, climate, forecasting | examples/weather/ |
| Structural / solid mechanics, crash | examples/structural_mechanics/ |
| Healthcare, medical, biomechanics | examples/healthcare/ |
| Molecular dynamics, chemistry | examples/molecular_dynamics/ |
| Additive manufacturing, 3D printing | examples/additive_manufacturing/ |
| Geophysics, seismic, FWI | examples/geophysics/ |
| Reservoir, subsurface, multiphase | examples/reservoir_simulation/ |
| Generative design, topology | examples/generative/ |
| Active learning | examples/active_learning/ |
| Minimal / scaffolding tutorials | examples/minimal/ |
| Multi-storage / cloud-data patterns | examples/multi_storage_client/ |
If the user's domain isn't listed, Glob examples/*/ and read top-level READMEs to find the closest.
Data format → how to find a datapipe
Do not hardcode format-to-subfolder mappings here — the datapipes layout changes. Instead:
Glob
physicsnemo/datapipes/*/__init__.pyto enumerate current subpackages.Read each
__init__.pyto see what it exports and what formats its docstrings mention.If no subpackage looks right, grep by format keyword across
physicsnemo/datapipes/:Grep -l "<format>" physicsnemo/datapipes/ --type py(e.g."HDF5","zarr","xarray","pyvista","tfrecord","healpix").For custom / unsupported formats, point users at the contractual base classes:
physicsnemo/datapipes/readers/base.py,physicsnemo/datapipes/datapipe.py,physicsnemo/datapipes/transforms/base.py. Confirm these files still exist before citing them.
Task type → relevant concepts to search
| User task | Where to look |
|---|---|
| Surrogate modeling (sim → ML approximation) | examples/<domain>/ + physicsnemo/models/ matching data shape |
| Temporal forecasting (t_{i-k..i-1} → t_{i..i+n}) | Auto-regressive and recurrent families; weather examples |
| Super-resolution / downscaling | Diffusion models (physicsnemo/diffusion/ + physicsnemo/models/diffusion_unets/-style folders), SR-specific CNNs |
| Inverse problem / data assimilation | Diffusion-based inverse methods; specific examples in weather/ and geophysics/ |
| Generative modeling | physicsnemo/diffusion/ + generative examples |
| Physics-informed (data + PDE residuals) | Examples ending in _pino or _physics_informed under examples/cfd/; PhysicsInformer utilities |
| Multi-GPU / multi-node scaling | physicsnemo/distributed/ |
| Sample-too-large-for-one-GPU | physicsnemo/domain_parallel/ |
| Checkpoint save/load | physicsnemo/utils/checkpoint.py |
| Logging, MLflow, wandb | physicsnemo/utils/logging/ |
| Model export / deployment | physicsnemo/deploy/ |
| Active learning | physicsnemo/active_learning/ + examples/active_learning/ |
Documentation map
| User intent | Relevant docs folder(s) |
|---|---|
| Getting started / install | Root README.md, docs/index.rst, FAQ.md, docs/examples_introductory.rst |
| Choose a model | docs/api_models.rst, docs/api/models/ |
| Data loading | docs/api/datapipes/ |
| Scale training | docs/api/physicsnemo.distributed.rst, docs/api/physicsnemo.domain_parallel.rst |
| Meshes | docs/api/mesh/ |
| Diffusion | docs/api_diffusion.rst, docs/api/diffusion/ |
| Neural network layers | docs/api/physicsnemo.nn.rst, docs/api/physicsnemo.nn.layers.rst, docs/api/physicsnemo.nn.functionals.rst |
| Migration (v1 → v2, modulus → physicsnemo, DGL → PyG) | Root *MIGRATION* (glob to find), README.md migration section, the DGL→PyG migration markdown under examples/ (glob examples/**/*pyg*.md or examples/**/*migration*.md — exact path is not stable) |
| Contributing | Root CONTRIBUTING.md, CODING_STANDARDS/, .cursor/rules/ |
| Examples by domain | docs/examples_<domain>.rst, docs/examples_index.rst |
Always Glob docs/ before citing — the RST layout evolves.
External resources and companion packages
URLs for hosted docs, the dev blog, the pretrained-model catalog, the Jupyter collection, the forum, and companion repos (CFD inference, Curator, Symbolic, Earth-2 Studio) rot and should not be hardcoded here. Look them up from the canonical sources in the repo itself:
Root
README.md— links section and companion-package mentions.Root
FAQ.md— hosts current URLs for forum, NGC catalog, and related repos.
Grep these two files for https:// when you need a URL, and cite what you find — don't recite from memory.
Decision hints (axes of choice, not class names)
Use these to ask the right disambiguating question. Do not emit a concrete class or family name from this section — resolve current names via live discovery in physicsnemo/models/ and the relevant examples/<domain>/.
Super-resolution / downscaling: deterministic vs stochastic (diffusion-based). Ask which.
Surrogate for a CFD sim on a geometry: surface-only vs surface+volume input. Ask which, then search
physicsnemo/models/for operators that take the right input shape.Global weather forecasting: multiple architecture families coexist (spectral, mesh-graph, 3D transformer). Read
examples/weather/andphysicsnemo/models/__init__.pyfiles to see the current options.Regional km-scale weather: typically different from global — confirm scope, then discover candidates in
examples/weather/.PDE with arbitrary geometry: point-cloud / transformer operators; some may still live in
experimental/.Molecular / particle dynamics: graph networks with nearest-neighbor or radius-based connectivity.
Learn a solution operator for a PDE: regular-grid vs irregular-geometry is the splitting axis; the current operator families differ on each side.
These hints are deliberately vague on class names — the skill must confirm against the live repo before emitting any.
Common axis-collapse traps to flag
Axes of choice users frequently collapse. Surface the distinction; let live discovery name the current candidates — do not hardcode family names.
Grid vs mesh conflation. Cartesian grid and triangulated mesh need different model families.
Weather scope. Global vs regional km-scale forecasting typically route to different architectures.
CFD with geometry + fields. Surface-only vs surface+volume is the splitting axis.
Super-resolution / downscaling. Deterministic vs stochastic (diffusion-based) is the user's call.
Physics-informed ≠ PINN. Physics loss on a neural operator, coordinate MLP + PDE residuals, or hybrid map to different parts of the repo.
GNN backend migration. PhysicsNeMo is moving from DGL to PyG. Locate the migration doc by globbing —
Glob examples/**/*pyg*.mdorGlob examples/**/*migration*.md. Do not cite a path from memory.modulus → physicsnemo rename. If snippets import
modulus, point at the migration guide by globbing*MIGRATION*.
Stability of what you cite
High stability: top-level folders directly under
physicsnemo/, theexamples/<domain>/split, thedocs/Sphinx layout. Use as navigation anchors; Glob current contents at the start of discovery.Medium stability: subdirectories inside top-level folders, example folder names.
Low stability: specific class names, specific file paths inside subdirectories, anything under
experimental/.
When citing from a medium- or low-stability area, confirm it exists now before returning it.
Requirements and compatibility
Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta
“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.
Security
What our scanner noticed· Medium risk
- Large base64-encoded blobs
A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.
Attribution and licence
- Created by
- NVIDIA
- Publisher
- NVIDIA (Official)
- Source
- NVIDIA/skills · skills/physicsnemo-discover · commit fce3cca
- Licence
- Apache License 2.0 (redistribution allowed)
- LICENSE (added by AutoGineer from LICENSE-APACHE)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
AutoGineer is not affiliated with or endorsed by NVIDIA.
Related skills
Setup Matt Pocock Skills
Matt Pocock· Community
Initializes repository configuration for Matt Pocock's engineering agent skills.
Agent toolingClaude CodeClaude appsOpenAI Codex+14 moreMITGitHub stars of the source repository317.5k
Writing For Agents
Matt Pocock· Community
A framework for writing effective, maintainable documentation and skill definitions for AI agents.
Agent toolingClaude CodeClaude appsOpenAI Codex+14 moreMITGitHub stars of the source repository317.5k
Loop Me
Matt Pocock· Community
A systematic grilling process to define and document recurring workflow specifications.
Agent toolingClaude CodeClaude appsOpenAI Codex+14 moreMITGitHub stars of the source repository317.5k
Writing Skills
Jesse Vincent (obra)· Community
A Test-Driven Development framework for creating, verifying, and maintaining robust agent skills.
Agent toolingClaude CodeClaude appsOpenAI Codex+14 moreMITLow riskHas scriptsGitHub stars of the source repository314k
Diagnosing Superpowers
Jesse Vincent (obra)· Community
A systematic workflow for investigating and reporting issues within AI agent sessions.
Agent toolingClaude CodeClaude appsOpenAI Codex+14 moreMITGitHub stars of the source repository314k
Skill Creator
AnthropicOfficial
A comprehensive framework for building, testing, evaluating, and optimizing AI agent skills.
Agent toolingClaude CodeClaude appsOpenAI Codex+14 moreApache-2.0Low riskHas scriptsGitHub stars of the source repository188.6k
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download physicsnemo-discover.zip