Paidf Cosmos Predict
NVIDIAOfficialCreated by NVIDIA Corporation
- Skill
- Workflow
- Data and AI
- Apache-2.0
- Medium risk
- Has scripts
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
This skill provides a structured workflow to generate synthetic videos from existing media samples using the PAIDF Cosmos Predict model. It manages the end-to-end process, including VLM-based captioning, configuration preparation, containerized execution, and the generation of a final handoff mapping input IDs to their corresponding generated video paths.
What it does
- Verifies connectivity to an OpenAI-compatible VLM captioning endpoint.
- Prepares configuration files and maps input media to unique generation tasks.
- Executes PAIDF video generation within a containerized environment.
- Deduplicates generation tasks for shared source media to optimize performance.
- Generates a final JSONL handoff mapping input IDs to generated video outputs.
- Provides audit logs for failed generation attempts.
When to use it
- When you need to generate synthetic video content from existing media samples.
- When integrating PAIDF Cosmos Predict into a larger DEFT media processing pipeline.
- When you have a VLM captioning service ready for media analysis.
- When you need to track and audit the success of video generation tasks.
Advantages
- Ensures deterministic mapping between source media and generated outputs.
- Optimizes compute resources by deduplicating generation tasks for identical source media.
- Provides clear audit trails for both successful and failed generation attempts.
- Standardizes the configuration and execution process for PAIDF workflows.
Usage examples
- “Run PAIDF Cosmos Predict for my media samples located in /data/videos using the input list at /data/input.jsonl.”
- The agent will verify the VLM endpoint, prepare the configuration, launch the PAIDF container, and produce the final handoff files in the specified output directory.
Install
Download the skill as a ZIP:
https://autogineer.com/agent-skills/nvidia/paidf-cosmos-predict/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip paidf-cosmos-predict.zip -d .agents/skills
Documentation by NVIDIA Corporation
PAIDF Cosmos Predict Generation
Prepare and run PAIDF Cosmos Predict generation for media samples. The skill emits a JSONL handoff that maps each input id to the original media path and generated video path.
Purpose
Use this skill when a DEFT workflow already has media samples and needs synthetic/generated videos from PAIDF Cosmos Predict. This skill does not start the VLM captioning service. A reachable OpenAI-compatible base URL for the model used to caption input media must be provided at runtime.
Prerequisites
Docker with NVIDIA GPU support and
nvidia-container-toolkit.Access to the PAIDF augmentation image declared by
images.metropolis_sdg.paidf_augmentationinversions.yaml.A running VLM captioning service with an OpenAI-compatible API base URL. The base URL must be provided by the user or upstream workflow at runtime; reuse that exact base URL for every
--vlm-captioning-endpointargument. Do not include/modelsinVLM_CAPTIONING_ENDPOINT.HF_TOKENin the run environment when Cosmos model downloads require HuggingFace access — exported, or in a user-approved env file (bareKEY=valuelines) that the run block sources.VLM_API_KEYin the run environment the same way when the VLM captioning endpoint requires authentication.Input media paths that are absolute paths on the host under the required media directory. Pass the host media directory with
--media-dir; the skill mounts it into the PAIDF container at the exact same path.
Inputs
| Input | Required | Notes |
|---|---|---|
| Input JSONL | Yes | Path to the generic media JSONL. The user or upstream workflow must provide it. Each row must include string fields id and media_path; id values must be unique. |
| Output directory | Yes | Host directory for prepared PAIDF config, generated videos, captions, metadata, logs, and final handoff. The user or upstream workflow must provide it. |
| VLM captioning endpoint base URL | Yes | The user or upstream workflow must provide this OpenAI-compatible base URL, for example a URL ending in /v1. Do not include /models. Pass the exact same base URL to verify_vlm_captioning_base_url.py before any other step and to prepare_paidf_config.py when writing config.yaml. |
| Generation settings | No | If the user provides a generation settings JSON, use it. Otherwise set GENERATION_SETTINGS to skills/data/paidf-cosmos-predict/assets/default_generation_settings.json. Always pass the resolved path to prepare_paidf_config.py with --generation-settings. |
| PAIDF GPU count | Yes | Number of GPUs for PAIDF augmentation. Pass it to prepare_paidf_config.py with --paidf-num-gpus N and to Docker with --gpus "$PAIDF_NUM_GPUS". |
| Media directory | Yes | Host directory containing the input media referenced by media_path. Pass it as --media-dir /path/to/media_dir to prepare_paidf_config.py and mount it into Docker 1:1. |
| VLM captioning prompt | Yes | Prompt text file for VLM captioning. Pass it to prepare_paidf_config.py with --caption-prompt-file; the script inlines the prompt into config.yaml. |
HF_TOKEN | Yes for Cosmos model downloads | The agent checks that HF_TOKEN is already set in the run environment, whether exported or sourced from a user-approved env file, and forwards it to Docker with -e HF_TOKEN. |
VLM_API_KEY | Yes when the VLM captioning endpoint requires authentication | The agent warns when VLM_API_KEY is not set, then forwards it to Docker with -e VLM_API_KEY when present. If the endpoint does not require authentication, PAIDF can run without it. |
Input JSONL row shape:
{"id": "stable-sample-id", "media_path": "/abs/input.mp4"}The input JSONL may contain duplicate media_path values, but every id must be unique. This lets an upstream workflow attach multiple logical samples to the same source video while avoiding repeated PAIDF generation for that video.
Example:
{"id": "sample-a-question-1", "media_path": "/abs/video_a.mp4"}
{"id": "sample-a-question-2", "media_path": "/abs/video_a.mp4"}
{"id": "sample-b-question-1", "media_path": "/abs/video_b.mp4"}prepare_paidf_config.py converts media_path values to absolute paths and deduplicates them before writing config.yaml, so each unique video appears only once in PAIDF data[] and goes through captioning/generation only once. write_paidf_handoff.py then expands back to the input row level so every original id appears in either generated_videos.jsonl or failed_videos.jsonl, with duplicate media rows pointing to the same generated or expected-generated video path.
Runtime Image
The PAIDF augmentation image is resolved from images.metropolis_sdg.paidf_augmentation in versions.yaml; users do not need to provide it for the standard workflow.
Agent Run Procedure
Before running, determine these runtime values from the user request or upstream workflow output:
INPUT_JSONL: path to the media JSONL.OUTPUT_DIR: path to the PAIDF output directory.VLM_CAPTIONING_ENDPOINT: user-provided VLM captioning OpenAI-compatible base URL. Do not include/models.GENERATION_SETTINGS: user-provided generation settings JSON, orskills/data/paidf-cosmos-predict/assets/default_generation_settings.jsonwhen the user did not provide one.PAIDF_NUM_GPUS: PAIDF GPU count.MEDIA_DIR: media directory to mount 1:1 into Docker.CAPTION_PROMPT_FILE: VLM captioning prompt file.
If required values are missing, ask the user for them before launching PAIDF.
Set the runtime values:
INPUT_JSONL="<user-provided-input-jsonl>"
OUTPUT_DIR="<user-provided-output-dir>"
VLM_CAPTIONING_ENDPOINT="<user-provided-vlm-captioning-base-url>"
GENERATION_SETTINGS="skills/data/paidf-cosmos-predict/assets/default_generation_settings.json"
PAIDF_NUM_GPUS="<user-provided-paidf-gpu-count>"
MEDIA_DIR="<user-provided-media-dir>"
CAPTION_PROMPT_FILE="<user-provided-caption-prompt-file>"If the user provides a generation settings JSON, replace GENERATION_SETTINGS with that path.
Check the VLM captioning base URL before preparing PAIDF inputs. This sends a preflight request to <VLM_CAPTIONING_ENDPOINT>/models only to verify that the base URL is reachable and OpenAI-compatible. PAIDF still receives VLM_CAPTIONING_ENDPOINT itself in config.yaml, not the derived /models URL.
python skills/data/paidf-cosmos-predict/scripts/verify_vlm_captioning_base_url.py \
--vlm-captioning-endpoint "$VLM_CAPTIONING_ENDPOINT"If this fails, stop the PAIDF workflow and issue an error indicating that the user-provided base URL did not pass the OpenAI-compatible /models preflight check.
Prepare the PAIDF output directory:
python skills/data/paidf-cosmos-predict/scripts/prepare_paidf_config.py \
--input-jsonl "$INPUT_JSONL" \
--output-dir "$OUTPUT_DIR" \
--vlm-captioning-endpoint "$VLM_CAPTIONING_ENDPOINT" \
--media-dir "$MEDIA_DIR" \
--generation-settings "$GENERATION_SETTINGS" \
--paidf-num-gpus "$PAIDF_NUM_GPUS" \
--caption-prompt-file "$CAPTION_PROMPT_FILE"prepare_paidf_config.py performs a writeability preflight, writes config.yaml, writes path_map.jsonl, writes run_metadata.json, and creates container-writable output directories. If an existing mounted directory or file is not writable by the agent, it fails early with a permission-fix command.
The generated config uses VLM-only captioning plus Cosmos Predict text-to-world generation. PAIDF's separate LLM prompt-augmentation step is disabled by omission: captioning.llm is not present. prepare_paidf_config.py inlines CAPTION_PROMPT_FILE into captioning.vlm.user_prompt.
Prepared helper files:
path_map.jsonlmaps each unique absolute inputmedia_pathto the deterministic generated video path, caption path, and metadata path.write_paidf_handoff.pyuses it to produce one generated or failed handoff row per input row.run_metadata.jsonrecords the VLM captioning endpoint, captioning model, and PAIDF GPU count used whenconfig.yamlwas prepared. It is provenance only.
Run PAIDF:
set -a; source /path/to/.env; set +a # omit if already exported
[ -n "${HF_TOKEN:-}" ] || {
echo "MISSING: HF_TOKEN is not set. Export it, or point the loader above at a user-approved env file."
exit 1
}
if [ -z "${VLM_API_KEY:-}" ]; then
echo "WARNING: VLM_API_KEY is not set. Continue only if the VLM captioning endpoint does not require authentication."
fi
PAIDF_IMAGE="$(scripts/resolve_versions_key.py images.metropolis_sdg.paidf_augmentation)"
set -o pipefail
docker run --rm \
--gpus "$PAIDF_NUM_GPUS" \
--shm-size=8g \
--network host \
-e HF_TOKEN \
-e VLM_API_KEY \
-v "$MEDIA_DIR:$MEDIA_DIR:ro" \
-v "$OUTPUT_DIR:$OUTPUT_DIR" \
"$PAIDF_IMAGE" \
--config "$OUTPUT_DIR/config.yaml" \
2>&1 | tee "$OUTPUT_DIR/paidf_docker.log"The Docker command resolves the PAIDF image from versions.yaml, mounts MEDIA_DIR 1:1 read-only, mounts OUTPUT_DIR 1:1 writable, forwards HF_TOKEN and VLM_API_KEY, and keeps a copy of Docker stdout/stderr in $OUTPUT_DIR/paidf_docker.log via tee. set -o pipefail preserves the Docker exit status when using tee.
Create the handoff after PAIDF writes the generated videos:
python skills/data/paidf-cosmos-predict/scripts/write_paidf_handoff.py \
--input-jsonl "$INPUT_JSONL" \
--path-map "${OUTPUT_DIR}/path_map.jsonl" \
--generated-jsonl "${OUTPUT_DIR}/generated_videos.jsonl" \
--failed-jsonl "${OUTPUT_DIR}/failed_videos.jsonl"Workflow
Verify the user-provided VLM captioning base URL with
verify_vlm_captioning_base_url.py. If this fails, stop and report the OpenAI-compatible/modelspreflight error.Run
prepare_paidf_config.pyon the input media JSONL using that same endpoint. It reads VLM captioning and PAIDF generation values from the generation settings, preflights write access, writes the PAIDF config and path map, and dedupes PAIDF generation to one entry per unique media path.Run the PAIDF Docker command. The agent should monitor Docker output, Docker exit status, and generated output counts.
Run
write_paidf_handoff.pyto producegenerated_videos.jsonlandfailed_videos.jsonl.
Long-Running Run Updates
PAIDF generation can run for a long time. During an agent-driven run, keep the user informed without requiring them to ask for status.
Before launching PAIDF, report the output directory, unique media count from
path_map.jsonl, PAIDF GPU count, and media directory.While PAIDF is running, provide a short progress update every 30 minutes. Include elapsed time, generated video count under
generated/videos/, expected unique media count, and the latest useful PAIDF log signal if available.If using a tool environment where one foreground Docker command would block user-facing updates, launch PAIDF in a monitorable way, then poll Docker status/logs and filesystem output counts between updates.
On completion, report whether the container exited successfully, generated video count, missing output count if any, and the
generated_videos.jsonlandfailed_videos.jsonlpaths after runningwrite_paidf_handoff.py.On failure, report the container exit code, the relevant Docker output, and whether any partial generated videos were produced.
Reference Files
assets/default_generation_settings.json is the default VLM captioning and Cosmos Predict generation settings file. If the user provides a different generation settings JSON, set GENERATION_SETTINGS to that path; otherwise set it to the default asset path. Always pass the resolved path with --generation-settings. Use assets/paidf_config_template.yaml only as a readable shape for the generated PAIDF config.
Deterministic Mapping
The helper converts each media_path to an absolute path, hashes that absolute path with SHA-256, and uses the first 16 hex characters as the sample id.
For each unique media path:
generated video: <output_dir>/generated/videos/<hash16>.mp4
caption: <output_dir>/captions/<hash16>.txt
metadata: <output_dir>/generated/metadata/<hash16>.jsonDuplicate input media paths share one generated path. The handoff still writes one row per input row, so multiple unique input ids may point to the same generated video.
Outputs
| Output | Producer | Notes |
|---|---|---|
config.yaml | prepare_paidf_config.py | PAIDF config with one entry per unique absolute media path. |
path_map.jsonl | prepare_paidf_config.py | Internal helper file mapping each unique absolute media path to its expected generated video, caption, and metadata paths. write_paidf_handoff.py uses this file to emit one generated or failed row per input JSONL row. Host/container paths are identical. |
run_metadata.json | prepare_paidf_config.py | Internal provenance file recording the VLM captioning endpoint/model and PAIDF GPU count used to prepare the config. |
paidf_docker.log | Docker command | Docker stdout/stderr captured with tee during PAIDF generation. |
generated/videos/*.mp4 | PAIDF | One generated video per unique absolute media path. |
generated_videos.jsonl | write_paidf_handoff.py | JSONL for successful PAIDF outputs; one row per input row whose generated video exists. |
failed_videos.jsonl | write_paidf_handoff.py | JSONL audit for missing generated videos; one row per input row whose expected generated video is absent. |
Each generated_videos.jsonl row has exactly:
{"id": "stable-sample-id", "original_media_path": "/abs/input.mp4", "generated_video_path": "/abs/generated.mp4"}Each failed_videos.jsonl row has exactly:
{"id": "stable-sample-id", "original_media_path": "/abs/input.mp4", "expected_generated_video_path": "/abs/generated.mp4", "error": "missing_generated_video"}Troubleshooting
| Symptom | Likely Cause | Agent Response |
|---|---|---|
| VLM captioning base URL preflight fails | The captioning service is not running, the base URL is wrong, /v1 is missing, the OpenAI-compatible /models probe is unavailable, or the service is not reachable from the agent host | Report the base URL, the derived /models probe URL, and error detail. The agent does not have enough context to start or repair the service; ask the user whether to provide a different base URL, start the service externally, or stop the run. |
| PAIDF fails after launch | The PAIDF container exited non-zero | Report the exit status, the relevant Docker output, and the count of generated videos under <output_dir>/generated/videos/ versus expected unique media count from path_map.jsonl. Then ask the user how to proceed before retrying, deleting outputs, changing settings, or continuing with partial results. |
| Cosmos checkpoint download fails | HF_TOKEN is unset, expired, or lacks access to the gated Cosmos repo | Report the authentication/download error. Suggest that the user accept the model license if needed and make HF_TOKEN available before retrying, by exporting it or adding it to a user-approved env file the run sources. Do not ask the user to paste the token into chat; never create the token value yourself and never print it. |
| VLM captioning returns authentication errors | VLM_API_KEY is unset, expired, or not authorized for the provided VLM captioning endpoint | Report the authentication error from paidf_docker.log. Ask the user to export VLM_API_KEY or add it to a user-approved env file the run sources before retrying. After the user says to proceed, double-check that VLM_API_KEY is set before launching PAIDF again. Do not ask the user to paste the key into chat; never create the key value yourself and never print it. |
| User has not provided PAIDF GPU count | The skill cannot infer the correct PAIDF GPU count from hardware alone because the desired allocation depends on the run plan and shared resources | Ask the user for PAIDF_NUM_GPUS before prepare/run. Do not guess. |
| PAIDF appears to use the wrong GPU count | PAIDF_NUM_GPUS was set incorrectly for the run | Report the value used for --paidf-num-gpus and Docker --gpus. Ask the user for the corrected GPU count; if they provide it, rerun prepare_paidf_config.py and then the Docker command with the same corrected value. |
prepare_paidf_config.py fails with file is not writable | A previous Docker run or manual setup left root-owned or read-only files under output_dir | Report the exact path and permission error. If the script printed a chown/chmod command, ask the user before running it because it changes file ownership/permissions. |
| PAIDF cannot write outputs | output_dir is not writable by the container, or the container is writing outside the prepared output directories | Report the failing output path from Docker output when available and the current ownership/permissions of OUTPUT_DIR. Ask the user whether to fix permissions, choose a different output directory, or stop. |
| PAIDF cannot read input media | One or more media_path values are outside MEDIA_DIR, missing on the host, or not visible in Docker through the 1:1 mount | Report the failing media path and MEDIA_DIR. Ask the user whether to correct media.jsonl, provide a different media directory, or stop. |
failed_videos.jsonl is non-empty | PAIDF did not produce every expected .mp4 | Report failed row count, generated row count, expected unique media count, and generated video count. |
| Missing input field error | An input row is missing id or media_path | Report the input file and row number from the error. Ask the user or upstream workflow to provide a corrected input JSONL; do not fabricate ids or media paths. |
Files
- ATTRIBUTION.mdAdded by AutoGineer930 B
- BENCHMARK.md7.0 KiB
- LICENSELicence file added by AutoGineer11.2 KiB
- SKILL.md17.9 KiB
- assets/default_generation_settings.json728 B
- assets/paidf_config_template.yaml1.7 KiB
- config/skillspector-baseline.yaml1.5 KiB
- evals/evals.json807 B
- scripts/paidf_common.pyScript12.1 KiB
- scripts/prepare_paidf_config.pyScript5.1 KiB
- scripts/test_paidf_cosmos_predict.pyScript17.0 KiB
- scripts/verify_vlm_captioning_base_url.pyScript962 B
- scripts/write_paidf_handoff.pyScript2.9 KiB
- skill-card.md3.8 KiB
- skill.oms.sig6.4 KiB
LICENSE
Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
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.
Needs: Declares allowed tools, Needs an API key, Needs a command-line tool, Needs Python
The author says: Requires docker + nvidia-container-toolkit, a reachable OpenAI-compatible VLM captioning endpoint, and access to the PAIDF augmentation image.
Security
What our scanner noticed· Medium risk
- Large base64-encoded blobs
- Scripts that your agent may run
This skill includes scripts that your agent may run. Read them before you use it.
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 Corporation
- Publisher
- NVIDIA (Official)
- Source
- NVIDIA/skills · skills/paidf-cosmos-predict · 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 Corporation or NVIDIA.
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download paidf-cosmos-predict.zip