Generated banner for Paidf Cosmos Predict
Generated logo for Paidf Cosmos Predict

Paidf Cosmos Predict

NVIDIAOfficialCreated by NVIDIA Corporation

  • Skill
  • Workflow
  • Data and AI
  • Apache-2.0
  • Medium risk
  • Has scripts

From the author

Prepare and run PAIDF Cosmos Predict video generation for DEFT media samples.
— the description by NVIDIA Corporation

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

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/nvidia/paidf-cosmos-predict/download
  2. Unzip 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_augmentation in versions.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-endpoint argument. Do not include /models in VLM_CAPTIONING_ENDPOINT.

  • HF_TOKEN in the run environment when Cosmos model downloads require HuggingFace access — exported, or in a user-approved env file (bare KEY=value lines) that the run block sources.

  • VLM_API_KEY in 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

InputRequiredNotes
Input JSONLYesPath 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 directoryYesHost 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 URLYesThe 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 settingsNoIf 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 countYesNumber 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 directoryYesHost 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 promptYesPrompt 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_TOKENYes for Cosmos model downloadsThe 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_KEYYes when the VLM captioning endpoint requires authenticationThe 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, or skills/data/paidf-cosmos-predict/assets/default_generation_settings.json when 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.jsonl maps each unique absolute input media_path to the deterministic generated video path, caption path, and metadata path. write_paidf_handoff.py uses it to produce one generated or failed handoff row per input row.

  • run_metadata.json records the VLM captioning endpoint, captioning model, and PAIDF GPU count used when config.yaml was 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

  1. Verify the user-provided VLM captioning base URL with verify_vlm_captioning_base_url.py. If this fails, stop and report the OpenAI-compatible /models preflight error.

  2. Run prepare_paidf_config.py on 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.

  3. Run the PAIDF Docker command. The agent should monitor Docker output, Docker exit status, and generated output counts.

  4. Run write_paidf_handoff.py to produce generated_videos.jsonl and failed_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.jsonl and failed_videos.jsonl paths after running write_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>.json

Duplicate 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

OutputProducerNotes
config.yamlprepare_paidf_config.pyPAIDF config with one entry per unique absolute media path.
path_map.jsonlprepare_paidf_config.pyInternal 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.jsonprepare_paidf_config.pyInternal provenance file recording the VLM captioning endpoint/model and PAIDF GPU count used to prepare the config.
paidf_docker.logDocker commandDocker stdout/stderr captured with tee during PAIDF generation.
generated/videos/*.mp4PAIDFOne generated video per unique absolute media path.
generated_videos.jsonlwrite_paidf_handoff.pyJSONL for successful PAIDF outputs; one row per input row whose generated video exists.
failed_videos.jsonlwrite_paidf_handoff.pyJSONL 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

SymptomLikely CauseAgent Response
VLM captioning base URL preflight failsThe 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 hostReport 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 launchThe PAIDF container exited non-zeroReport 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 failsHF_TOKEN is unset, expired, or lacks access to the gated Cosmos repoReport 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 errorsVLM_API_KEY is unset, expired, or not authorized for the provided VLM captioning endpointReport 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 countThe skill cannot infer the correct PAIDF GPU count from hardware alone because the desired allocation depends on the run plan and shared resourcesAsk the user for PAIDF_NUM_GPUS before prepare/run. Do not guess.
PAIDF appears to use the wrong GPU countPAIDF_NUM_GPUS was set incorrectly for the runReport 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 writableA previous Docker run or manual setup left root-owned or read-only files under output_dirReport 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 outputsoutput_dir is not writable by the container, or the container is writing outside the prepared output directoriesReport 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 mediaOne or more media_path values are outside MEDIA_DIR, missing on the host, or not visible in Docker through the 1:1 mountReport 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-emptyPAIDF did not produce every expected .mp4Report failed row count, generated row count, expected unique media count, and generated video count.
Missing input field errorAn input row is missing id or media_pathReport 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

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