New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Cosmos Policy Evaluation

by Orchestra-Research in Orchestra-Research/AI-Research-SKILLs

Sets up and runs NVIDIA Cosmos Policy evaluations on the LIBERO and RoboCasa simulators, including headless GPU rendering and inference latency profiling.

MITAuto-check passedAI & LLM Engineering

Install Cosmos Policy Evaluation

skills CLI
$ npx skills add Orchestra-Research/AI-Research-SKILLs --skill evaluating-cosmos-policy -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install Orchestra-Research/AI-Research-SKILLs evaluating-cosmos-policy --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/Orchestra-Research/AI-Research-SKILLs.git skills-src && mkdir -p .claude/skills && cp -r skills-src/18-multimodal/cosmos-policy .claude/skills/evaluating-cosmos-policy && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
evaluating-cosmos-policy
GitHub stars
13k
Token cost
~3.7k tokens
SKILL.md length
689 words
Files
3 (incl. references)
Skills in repo
96
Repo updated
First seen
Licence
MIT

At a glance

Sets up and runs NVIDIA Cosmos Policy evaluations on the LIBERO and RoboCasa simulators, including headless GPU rendering and inference latency profiling.

  • Evaluating Cosmos Policy on the LIBERO or RoboCasa benchmarks
  • SKILL.md covers Quick start, Core concepts, Compute requirements and When to use vs alternatives, plus 8 more sections
  • Calls uv, python and git; reaches github.com
  • Running headless EGL rendering for robot simulation on a GPU cluster

What it does

NVIDIA Cosmos Policy is described as a vision-language-action model that turns visual observations into discrete tokens with Cosmos Tokenizer and predicts robot actions from language instructions. The skill covers blank-machine setup, evaluation through the public `run_libero_eval` and `run_robocasa_eval` modules, headless runs with EGL rendering, and profiling of latency and throughput on cluster or local GPUs. The quick start uses `uv run` with an extra named `cu128`, the `libero` dependency group and Python 3.10.

A compute table sets expectations: a one-trial LIBERO smoke test takes about 5-10 minutes on a single A40 or A100 with roughly 16 GB of VRAM, a full 50-trial run takes 2-4 hours, and RoboCasa needs about 18 GB. Training or fine-tuning, OpenVLA-based policies, pi0 models and real-robot evaluation are sent to other resources, and reference files list the LIBERO and RoboCasa commands.

When your agent uses it

  • Evaluating Cosmos Policy on the LIBERO or RoboCasa benchmarks
  • Running headless EGL rendering for robot simulation on a GPU cluster
  • Profiling Cosmos Policy inference latency on a local or cluster GPU

Example prompts

  • “Set up cosmos-policy on a fresh GPU node and run a one-trial LIBERO smoke eval.”
  • “Run the RoboCasa single-task evaluation headless with EGL rendering.”
  • “Profile Cosmos Policy inference latency on this A100 machine.”

Requirements

  • A GPU such as an A40 or A100 with about 16 to 18 GB of VRAM
  • `uv` and the public `cosmos-policy` repository

What it can do on your machine

Read from SKILL.md and the folder at commit 773a529. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • uv
    • python
    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • github.com

    Also links to:

    • mujoco.readthedocs.io

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Cosmos Policy Evaluation loads about 3.7k tokens when it runs, and up to ~6.8k if it reads all its reference files. Until then it costs about 73 tokens; SKILL.md has 689 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~73
When it runs · the whole SKILL.md, loaded when a task matches
~3.7k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~6.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from Orchestra-Research/AI-Research-SKILLs at commit 773a529, republished under its MIT licence (© Orchestra-Research). 689 words, ~3,652 tokens.

Download SKILL.mdSave it as .claude/skills/evaluating-cosmos-policy/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
evaluating-cosmos-policy
description
Evaluates NVIDIA Cosmos Policy on LIBERO and RoboCasa simulation environments. Use when setting up cosmos-policy for robot manipulation evaluation, running headless GPU evaluations with EGL rendering, or profiling inference latency on cluster or local GPU machines.
version
1.0.0
author
Orchestra Research
license
MIT
tags
Cosmos Policy, VLA, Robotics, LIBERO, RoboCasa, Simulation, Evaluation, Profiling, EGL Rendering
dependencies
torch>=2.1.0, mujoco>=3.0.0, robosuite>=1.4.0, robocasa @ git+https://github.com/moojink/robocasa-cosmos-policy.git, transformers>=4.40.0, cosmos-policy @…

Cosmos Policy Evaluation

Evaluation workflows for NVIDIA Cosmos Policy on LIBERO and RoboCasa simulation environments from the public cosmos-policy repository. Covers blank-machine setup, headless GPU evaluation, and inference profiling.

Quick start

Run a minimal LIBERO evaluation using the official public eval module:

bash
uv run --extra cu128 --group libero --python 3.10 \
  python -m cosmos_policy.experiments.robot.libero.run_libero_eval \
    --config cosmos_predict2_2b_480p_libero__inference_only \
    --ckpt_path nvidia/Cosmos-Policy-LIBERO-Predict2-2B \
    --config_file cosmos_policy/config/config.py \
    --use_wrist_image True \
    --use_proprio True \
    --normalize_proprio True \
    --unnormalize_actions True \
    --dataset_stats_path nvidia/Cosmos-Policy-LIBERO-Predict2-2B/libero_dataset_statistics.json \
    --t5_text_embeddings_path nvidia/Cosmos-Policy-LIBERO-Predict2-2B/libero_t5_embeddings.pkl \
    --trained_with_image_aug True \
    --chunk_size 16 \
    --num_open_loop_steps 16 \
    --task_suite_name libero_10 \
    --num_trials_per_task 1 \
    --local_log_dir cosmos_policy/experiments/robot/libero/logs/ \
    --seed 195 \
    --randomize_seed False \
    --deterministic True \
    --run_id_note smoke \
    --ar_future_prediction False \
    --ar_value_prediction False \
    --use_jpeg_compression True \
    --flip_images True \
    --num_denoising_steps_action 5 \
    --num_denoising_steps_future_state 1 \
    --num_denoising_steps_value 1 \
    --data_collection False

Core concepts

What Cosmos Policy is: NVIDIA Cosmos Policy is a vision-language-action (VLA) model that uses Cosmos Tokenizer to encode visual observations into discrete tokens, then predicts robot actions conditioned on language instructions and visual context.

Key architecture choices:

ComponentDesign
Visual encoderCosmos Tokenizer (discrete tokens)
Language conditioningCross-attention to language embeddings
Action predictionAutoregressive action token generation

Public command surface: The supported evaluation entrypoints are cosmos_policy.experiments.robot.libero.run_libero_eval and cosmos_policy.experiments.robot.robocasa.run_robocasa_eval. Keep reproduction notes anchored to these public modules and their documented flags.

Compute requirements

TaskGPUVRAMTypical wall time
LIBERO smoke eval (1 trial)1x A40/A100~16 GB5-10 min
LIBERO full eval (50 trials)1x A40/A100~16 GB2-4 hours
RoboCasa single-task (2 trials)1x A40/A100~18 GB10-15 min
RoboCasa all-tasks1x A40/A100~18 GB4-8 hours

When to use vs alternatives

Use this skill when:

  • Evaluating NVIDIA Cosmos Policy on LIBERO or RoboCasa benchmarks
  • Profiling inference latency and throughput for Cosmos Policy
  • Setting up headless EGL rendering for robot simulation on GPU clusters

Use alternatives when:

  • Training or fine-tuning Cosmos Policy from scratch (use official Cosmos training docs)
  • Working with OpenVLA-based policies (use fine-tuning-openvla-oft)
  • Working with Physical Intelligence pi0 models (use fine-tuning-serving-openpi)
  • Running real-robot evaluation rather than simulation

Workflow 1: LIBERO evaluation

Copy this checklist and track progress:

text
LIBERO Eval Progress:
- [ ] Step 1: Install environment and dependencies
- [ ] Step 2: Configure headless EGL rendering
- [ ] Step 3: Run smoke evaluation
- [ ] Step 4: Validate outputs and parse results
- [ ] Step 5: Run full benchmark if smoke passes

Step 1: Install environment

bash
git clone https://github.com/NVlabs/cosmos-policy.git
cd cosmos-policy
# Follow SETUP.md to build and enter the supported Docker container.
# Then, inside the container:
uv sync --extra cu128 --group libero --python 3.10

Step 2: Configure headless rendering

bash
export CUDA_VISIBLE_DEVICES=0
export MUJOCO_EGL_DEVICE_ID=0
export MUJOCO_GL=egl
export PYOPENGL_PLATFORM=egl

Step 3: Run smoke evaluation

bash
uv run --extra cu128 --group libero --python 3.10 \
  python -m cosmos_policy.experiments.robot.libero.run_libero_eval \
    --config cosmos_predict2_2b_480p_libero__inference_only \
    --ckpt_path nvidia/Cosmos-Policy-LIBERO-Predict2-2B \
    --config_file cosmos_policy/config/config.py \
    --use_wrist_image True \
    --use_proprio True \
    --normalize_proprio True \
    --unnormalize_actions True \
    --dataset_stats_path nvidia/Cosmos-Policy-LIBERO-Predict2-2B/libero_dataset_statistics.json \
    --t5_text_embeddings_path nvidia/Cosmos-Policy-LIBERO-Predict2-2B/libero_t5_embeddings.pkl \
    --trained_with_image_aug True \
    --chunk_size 16 \
    --num_open_loop_steps 16 \
    --task_suite_name libero_10 \
    --num_trials_per_task 1 \
    --local_log_dir cosmos_policy/experiments/robot/libero/logs/ \
    --seed 195 \
    --randomize_seed False \
    --deterministic True \
    --run_id_note smoke \
    --ar_future_prediction False \
    --ar_value_prediction False \
    --use_jpeg_compression True \
    --flip_images True \
    --num_denoising_steps_action 5 \
    --num_denoising_steps_future_state 1 \
    --num_denoising_steps_value 1 \
    --data_collection False

Step 4: Validate and parse results

python
import json
import glob

# Find latest evaluation result from the official log directory
log_files = sorted(glob.glob("cosmos_policy/experiments/robot/libero/logs/**/*.json", recursive=True))
with open(log_files[-1]) as f:
    results = json.load(f)

print(results)

Step 5: Scale up

Run across all four LIBERO task suites with 50 trials:

bash
for suite in libero_spatial libero_object libero_goal libero_10; do
  uv run --extra cu128 --group libero --python 3.10 \
    python -m cosmos_policy.experiments.robot.libero.run_libero_eval \
      --config cosmos_predict2_2b_480p_libero__inference_only \
      --ckpt_path nvidia/Cosmos-Policy-LIBERO-Predict2-2B \
      --config_file cosmos_policy/config/config.py \
      --use_wrist_image True \
      --use_proprio True \
      --normalize_proprio True \
      --unnormalize_actions True \
      --dataset_stats_path nvidia/Cosmos-Policy-LIBERO-Predict2-2B/libero_dataset_statistics.json \
      --t5_text_embeddings_path nvidia/Cosmos-Policy-LIBERO-Predict2-2B/libero_t5_embeddings.pkl \
      --trained_with_image_aug True \
      --chunk_size 16 \
      --num_open_loop_steps 16 \
      --task_suite_name "$suite" \
      --num_trials_per_task 50 \
      --local_log_dir cosmos_policy/experiments/robot/libero/logs/ \
      --seed 195 \
      --randomize_seed False \
      --deterministic True \
      --run_id_note "suite_${suite}" \
      --ar_future_prediction False \
      --ar_value_prediction False \
      --use_jpeg_compression True \
      --flip_images True \
      --num_denoising_steps_action 5 \
      --num_denoising_steps_future_state 1 \
      --num_denoising_steps_value 1 \
      --data_collection False
done

Workflow 2: RoboCasa evaluation

Copy this checklist and track progress:

text
RoboCasa Eval Progress:
- [ ] Step 1: Install RoboCasa assets and verify macros
- [ ] Step 2: Run single-task smoke evaluation
- [ ] Step 3: Validate outputs
- [ ] Step 4: Expand to multi-task runs

Step 1: Install RoboCasa

bash
git clone https://github.com/moojink/robocasa-cosmos-policy.git
uv pip install -e robocasa-cosmos-policy
python -m robocasa.scripts.setup_macros
python -m robocasa.scripts.download_kitchen_assets

This fork installs the robocasa Python package expected by Cosmos Policy while preserving the patched environment changes used in the public RoboCasa eval path. Verify macros_private.py exists and paths are correct.

Step 2: Single-task smoke evaluation

bash
uv run --extra cu128 --group robocasa --python 3.10 \
  python -m cosmos_policy.experiments.robot.robocasa.run_robocasa_eval \
    --config cosmos_predict2_2b_480p_robocasa_50_demos_per_task__inference \
    --ckpt_path nvidia/Cosmos-Policy-RoboCasa-Predict2-2B \
    --config_file cosmos_policy/config/config.py \
    --use_wrist_image True \
    --num_wrist_images 1 \
    --use_proprio True \
    --normalize_proprio True \
    --unnormalize_actions True \
    --dataset_stats_path nvidia/Cosmos-Policy-RoboCasa-Predict2-2B/robocasa_dataset_statistics.json \
    --t5_text_embeddings_path nvidia/Cosmos-Policy-RoboCasa-Predict2-2B/robocasa_t5_embeddings.pkl \
    --trained_with_image_aug True \
    --chunk_size 32 \
    --num_open_loop_steps 16 \
    --task_name TurnOffMicrowave \
    --obj_instance_split A \
    --num_trials_per_task 2 \
    --local_log_dir cosmos_policy/experiments/robot/robocasa/logs/ \
    --seed 195 \
    --randomize_seed False \
    --deterministic True \
    --run_id_note smoke \
    --use_variance_scale False \
    --use_jpeg_compression True \
    --flip_images True \
    --num_denoising_steps_action 5 \
    --num_denoising_steps_future_state 1 \
    --num_denoising_steps_value 1 \
    --data_collection False

Step 3: Validate outputs

  • Confirm the eval log prints the expected task name, object split, and checkpoint/config values.
  • Inspect the final Success rate: line in the log.

Step 4: Expand scope

Increase --num_trials_per_task or add more tasks. Keep --obj_instance_split fixed across repeated runs for comparability.

Workflow 3: Blank-machine cluster launch

text
Cluster Launch Progress:
- [ ] Step 1: Clone the public repo and enter the supported runtime
- [ ] Step 2: Sync the benchmark-specific dependency group
- [ ] Step 3: Export rendering and cache environment variables before eval

Step 1: Clone and enter the supported runtime

bash
git clone https://github.com/NVlabs/cosmos-policy.git
cd cosmos-policy
# Follow SETUP.md, start the Docker container, and enter it before continuing.

Step 2: Sync dependencies

bash
uv sync --extra cu128 --group libero --python 3.10
# or, for RoboCasa:
uv sync --extra cu128 --group robocasa --python 3.10
# then install the Cosmos-compatible RoboCasa fork:
git clone https://github.com/moojink/robocasa-cosmos-policy.git
uv pip install -e robocasa-cosmos-policy

Step 3: Export runtime environment

bash
export CUDA_VISIBLE_DEVICES=0
export MUJOCO_EGL_DEVICE_ID=0
export MUJOCO_GL=egl
export PYOPENGL_PLATFORM=egl
export HF_HOME=${HF_HOME:-$HOME/.cache/huggingface}
export TRANSFORMERS_CACHE=${TRANSFORMERS_CACHE:-$HF_HOME}
Show full SKILL.md (284 more words)Show less

Expected performance benchmarks

Reference values from official evaluation (tied to specific setup and seeds):

Task SuiteSuccess RateNotes
LIBERO-Spatial98.1%Official LIBERO spatial result
LIBERO-Object100.0%Official LIBERO object result
LIBERO-Goal98.2%Official LIBERO goal result
LIBERO-Long97.6%Official LIBERO long-horizon result
LIBERO-Average98.5%Official average across LIBERO suites
RoboCasa67.1%Official RoboCasa average result

Reproduction note: Published success rates still depend on checkpoint choice, task suite, seeds, and simulator setup. Record the exact command and environment alongside any reported number.

Non-negotiable rules

  • EGL alignment: Always set CUDA_VISIBLE_DEVICES, MUJOCO_EGL_DEVICE_ID, MUJOCO_GL=egl, and PYOPENGL_PLATFORM=egl together on headless GPU nodes.
  • Official runtime first: If host-Python installs hit binary compatibility issues, fall back to the supported container workflow from SETUP.md before debugging package internals.
  • Cache consistency: Use the same cache directory across setup and eval so Hugging Face and dependency caches are reused.
  • Run comparability: Keep task name, object split, seed, and trial count fixed across repeated runs.

Common issues

Issue: binary compatibility or loader failures on host Python

Fix: rerun inside the official container/runtime from SETUP.md. Do not assume host-package rebuilds will match the public release environment.

Issue: LIBERO prompts for config path in a non-interactive shell

Fix: pre-create LIBERO_CONFIG_PATH/config.yaml:

python
import os, yaml

config_dir = os.path.expanduser("~/.libero")
os.makedirs(config_dir, exist_ok=True)
with open(os.path.join(config_dir, "config.yaml"), "w") as f:
    yaml.dump({"benchmark_root": "/path/to/libero/datasets"}, f)

Issue: EGL initialization or shutdown noise

Fix: align EGL environment variables first. Treat teardown-only EGL_NOT_INITIALIZED warnings as low-signal unless the job exits non-zero.

Issue: Kitchen object sampling NaNs or asset lookup failures in RoboCasa

Fix: rerun asset setup and confirm the patched robocasa install is intact:

bash
python -m robocasa.scripts.download_kitchen_assets
python -c "import robocasa; print(robocasa.__file__)"

Issue: MuJoCo rendering mismatch

Fix: verify GPU device alignment:

python
import os
cuda_dev = os.environ.get("CUDA_VISIBLE_DEVICES", "not set")
egl_dev = os.environ.get("MUJOCO_EGL_DEVICE_ID", "not set")
assert cuda_dev == egl_dev, f"GPU mismatch: CUDA={cuda_dev}, EGL={egl_dev}"
print(f"Rendering on GPU {cuda_dev}")

Advanced topics

LIBERO command matrix: See references/libero-commands.md RoboCasa command matrix: See references/robocasa-commands.md

Resources

© Orchestra-Research, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files (references) in 18-multimodal/cosmos-policy of Orchestra-Research/AI-Research-SKILLs.

  • SKILL.md
  • references/libero-commands.md
  • references/robocasa-commands.md

Open the folder on GitHubat commit 773a529

Compare with similar skills

Cosmos Policy Evaluation next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Cosmos Policy Evaluation compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Cosmos Policy Evaluation this skillOrchestra-Research/AI-Research-SKILLs13k—~3.7kAutomated safety check: PassMIT
Megatron-LM on SLURMNVIDIA/Megatron-LM18k—~1.8kAutomated safety check: PassApache-2.0
DGX Spark Training Gotchaswshobson/agents40k—~2kAutomated safety check: PassMIT
GPU OptimizerMathews-Tom/armory329—~3.5kAutomated safety check: NotesMIT
Graphsignalgraphsignal/graphsignal257—~6.3kAutomated safety check: PassApache-2.0
Hyperpod Version Checkerawslabs/agent-plugins916—~910Automated safety check: PassApache-2.0

Similar skills

  • Megatron-LM on SLURM

    NVIDIA/Megatron-LM

    Official

    Shows how to launch distributed Megatron-LM training on a SLURM cluster: sbatch skeleton, torch.distributed.run setup, CUDA_DEVICE_MAX_CONNECTIONS rules and failure diagnosis.

    18k GitHub stars~1.8k tokensUpdated today
    AI & LLM EngineeringAuto-check passed

  • DGX Spark Training Gotchas

    wshobson/agents

    Preflight checks and diagnosis for ten known failure modes of ML training on NVIDIA DGX Spark's GB10, spanning launch errors, memory, thermals, bandwidth and precision.

    40k GitHub stars~2k tokensUpdated 6 days ago
    AI & LLM EngineeringAuto-check passed

  • GPU Optimizer

    Mathews-Tom/armory

    GPU optimization for consumer NVIDIA GPUs (8-24GB VRAM) covering mixed precision, gradient checkpointing, XGBoost GPU, CuPy/cuDF migration, and torch.compile.

    329 GitHub stars~3.5k tokensUpdated 5 days ago
    AI & LLM EngineeringAuto-check: notes

  • Graphsignal

    graphsignal/graphsignal

    Profile AI inference workloads (vLLM, SGLang, TensorRT-LLM, PyTorch, any GPU application) with the Graphsignal profiler and read the results from its local /signals JSON endpoint.

    257 GitHub stars~6.3k tokensUpdated yesterday
    AI & LLM EngineeringAuto-check passed

  • Hyperpod Version Checker

    awslabs/agent-plugins

    Official

    Check and compare software component versions on SageMaker HyperPod cluster nodes - NVIDIA drivers, CUDA toolkit, cuDNN, NCCL, EFA, AWS OFI NCCL, GDRCopy, MPI, Neuron SDK (Trainium/Inferentia)…

    916 GitHub stars~910 tokensUpdated yesterday
    AI & LLM EngineeringAuto-check passed

  • MUSA GPU Training Optimizer

    open-infra-skills/infra-skills

    Profiles, benchmarks and tunes AI training workloads on Moore Threads MUSA GPUs with a measurement-first process that keeps model behavior unchanged.

    141 GitHub stars~1.7k tokensUpdated 3 mo ago
    AI & LLM EngineeringAuto-check passed

More from Orchestra-Research/AI-Research-SKILLs

All 96 skills in this repo

  • AudioCraft Audio Generation

    Orchestra-Research/AI-Research-SKILLs

    Generates music from text descriptions with MusicGen and sound effects with AudioGen, using Meta's AudioCraft PyTorch library with melody and style conditioning.

    13k GitHub starsUsed in 8 repos~3.9k tokens
    Auto-check passed

  • LLM Benchmarking with lm-evaluation-harness

    Orchestra-Research/AI-Research-SKILLs

    Runs lm-evaluation-harness to benchmark language models on academic suites such as MMLU, GSM8K and HumanEval, compare models and track training checkpoints.

    13k GitHub starsUsed in 8 repos~3k tokens
    Auto-check passed

  • Segment Anything Model Guide

    Orchestra-Research/AI-Research-SKILLs

    Guide to using Meta's Segment Anything Model for zero-shot image segmentation with point, box or mask prompts, or automatic mask generation.

    13k GitHub starsUsed in 8 repos~3.3k tokens
    Auto-check passed

  • Chroma Vector Database

    Orchestra-Research/AI-Research-SKILLs

    Shows how to store documents and embeddings in Chroma, query them by similarity with metadata filters, and persist them to disk for RAG and semantic search projects.

    13k GitHub starsUsed in 7 repos~2.3k tokens
    Auto-check passed

  • CLIP Image-Text Matching

    Orchestra-Research/AI-Research-SKILLs

    Explains OpenAI's CLIP model for zero-shot image classification, image-text similarity, semantic image search and content moderation, with install steps and code patterns.

    13k GitHub starsUsed in 7 repos~1.7k tokens
    Auto-check passed

  • Whisper Speech Recognition

    Orchestra-Research/AI-Research-SKILLs

    Transcribes audio with OpenAI's Whisper: 99 languages, translation to English, language detection, six model sizes and word-level timestamps, from Python or the CLI.

    13k GitHub starsUsed in 7 repos~1.9k tokens
    Auto-check: notes

Works with

Categories

Questions about Cosmos Policy Evaluation

What does Cosmos Policy Evaluation do?

Sets up and runs NVIDIA Cosmos Policy evaluations on the LIBERO and RoboCasa simulators, including headless GPU rendering and inference latency profiling. NVIDIA Cosmos Policy is described as a vision-language-action model that turns visual observations into discrete tokens with Cosmos Tokenizer and predicts robot actions from language instructions. The skill covers blank-machine setup, evaluation through the public `run_libero_eval` and `run_robocasa_eval` modules, headless runs with EGL rendering, and profiling of latency and throughput on cluster or local GPUs.

When should I use Cosmos Policy Evaluation?

Cosmos Policy Evaluation fits situations like: evaluating Cosmos Policy on the LIBERO or RoboCasa benchmarks; running headless EGL rendering for robot simulation on a GPU cluster; profiling Cosmos Policy inference latency on a local or cluster GPU.

How do I install Cosmos Policy Evaluation in Claude Code?

Run `npx skills add Orchestra-Research/AI-Research-SKILLs --skill evaluating-cosmos-policy -a claude-code`. Or copy the skill folder (18-multimodal/cosmos-policy in Orchestra-Research/AI-Research-SKILLs) into .claude/skills/evaluating-cosmos-policy in your project. Claude Code loads it when a task matches its description.

How do I install Cosmos Policy Evaluation in Codex?

Run `npx skills add Orchestra-Research/AI-Research-SKILLs --skill evaluating-cosmos-policy -a codex`. Or copy the skill folder (18-multimodal/cosmos-policy in Orchestra-Research/AI-Research-SKILLs) into .agents/skills/evaluating-cosmos-policy in your project. Codex loads it when a task matches its description.

Can I use Cosmos Policy Evaluation in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add Orchestra-Research/AI-Research-SKILLs --skill evaluating-cosmos-policy -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/evaluating-cosmos-policy, .gemini/skills/evaluating-cosmos-policy, .github/skills/evaluating-cosmos-policy and .opencode/skills/evaluating-cosmos-policy in your project.

What does Cosmos Policy Evaluation need to run?

Going by SKILL.md and its folder, Cosmos Policy Evaluation needs the command-line tools its instructions call (uv, python and git). Our summary lists: A GPU such as an A40 or A100 with about 16 to 18 GB of VRAM; `uv` and the public `cosmos-policy` repository.

Does Cosmos Policy Evaluation access the network?

SKILL.md names 2 domains. In commands or code: github.com; the agent is likely to contact it when it follows the instructions. As links in the text: mujoco.readthedocs.io. This is read from the text; nothing was executed.

Is Cosmos Policy Evaluation safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Cosmos Policy Evaluation use?

Cosmos Policy Evaluation is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Cosmos Policy Evaluation use?

About 3.7k tokens (SKILL.md is roughly 15k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 3.2k tokens, read only when the agent opens those files.

What are the alternatives to Cosmos Policy Evaluation?

Skills that share tags, products or a category with Cosmos Policy Evaluation: Megatron-LM on SLURM (NVIDIA/Megatron-LM, 18k stars), DGX Spark Training Gotchas (wshobson/agents, 40k stars), GPU Optimizer (Mathews-Tom/armory, 329 stars) and Graphsignal (graphsignal/graphsignal, 257 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Cosmos Policy Evaluation?

Orchestra-Research (a GitHub organization) maintains it in Orchestra-Research/AI-Research-SKILLs, which has 13,405 GitHub stars. The repository holds 96 skills in this directory. The repository was last updated on June 16, 2026.

Source: Orchestra-Research/AI-Research-SKILLs on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.