Nv Reason Cxr
NVIDIAOfficialCreated by NVIDIA MedTech Team
- Skill
- Tool integration
- Science and research
- Apache-2.0
- Medium risk
- Has scripts
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
The nv-reason-cxr skill provides a standardized interface for interacting with the NVIDIA NV-Reason-CXR-3B model. It supports both local execution using Hugging Face Transformers and remote inference via a public Hugging Face Space API. Designed primarily for engineering smoke tests and research workflows, the skill handles image preprocessing and model output parsing while ensuring that results are returned in a structured JSON format. It is strictly intended for research and engineering purposes and must not be used for clinical diagnosis, triage, or treatment decisions.
What it does
- Executes chest X-ray reasoning tasks using the NV-Reason-CXR-3B model.
- Supports local inference on GPU/CUDA or remote inference via Hugging Face Space API.
- Provides a mock mode for deterministic command-shape smoke testing.
- Parses and returns model outputs as structured JSON.
- Handles prompt routing for general analysis, specific questions, and structured report generation.
- Validates environment setup including dependencies and CUDA availability.
When to use it
- When performing engineering smoke tests on chest X-ray reasoning pipelines.
- When integrating NV-Reason-CXR model inference into research or development workflows.
- When you need to generate structured reasoning outputs from chest X-ray images for non-clinical evaluation.
- When testing model behavior across different inference backends (local vs. API).
Advantages
- Provides a consistent interface for both local and remote model backends.
- Includes built-in support for mock testing to facilitate CI/CD integration.
- Standardizes output format for easier downstream processing and validation.
- Simplifies complex prompt routing for multi-turn reasoning tasks.
Usage examples
- “Find abnormalities in chest_xray.png using the local backend.”
- The agent executes the wrapper script with the local backend, processes the image, and returns a JSON object containing the model's findings.
- “Analyze this X-ray using the API backend.”
- The agent sends the image to the public Hugging Face Space API and returns the structured reasoning response.
- “Run a smoke test for the CXR reasoning skill.”
- The agent runs the wrapper with the --mock flag to verify the command structure and output schema without invoking the model.
Install
Download the skill as a ZIP:
https://autogineer.com/agent-skills/nvidia/nv-reason-cxr/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip nv-reason-cxr.zip -d .agents/skills
Documentation by NVIDIA MedTech Team
NV-Reason-CXR
Purpose
Used for command-shape or live NV-Reason-CXR chest X-ray reasoning smoke tests. Not for diagnosis or clinical reporting.
Use the wrapper exactly as documented; do not replace the upstream entrypoint with a handwritten implementation.
Manifest I/O: inputs are
chest_xray_image_or_fixture; outputs areresult_json.
Instructions
Read
skill_manifest.yamlbefore changing arguments, side effects, or validation gates.Run
scripts/run_nv_reason_cxr.pythrough the documented command below; pass--out-dironly for generated fixtures or harness-managed artifact directories.If a host agent exposes
run_script, userun_script("scripts/run_nv_reason_cxr.py", args=[...]); otherwise run the Bash/Python command shown below.Check the emitted JSON and paired verifier guidance before treating the run as evidence.
When reporting a completed run, return the full wrapper JSON or at minimum the complete
output.response_textexactly as emitted, including any model-generated<think>...</think>and<answer>...</answer>sections. Do not collapse the result to labels unless the user explicitly asks for a summary.
Available Scripts
| Script | Purpose | Arguments |
|---|---|---|
scripts/run_nv_reason_cxr.py | Primary entrypoint declared by skill_manifest.yaml. | PATH_TO_CXR_OR_FIXTURE [--out-dir OUT_DIR] [--backend local|hf-space-api] [--mock] [--check-setup] |
Prerequisites
Local backend requirements: GPU/CUDA when declared by the manifest; Python packages listed in
runtime.side_effects.pip_packages.API backend requirements: public network access to the Hugging Face Space; no local PyTorch, Transformers, CUDA, model cache, or Hugging Face token.
Side effects: emits result JSON on stdout; may write generated fixture artifacts under the caller's
--out-dir; may cache model assets under~/.cache/huggingface/for local inference; and may contacthttps://huggingface.co,https://github.com, orhttps://*.hf.spaceoutside--mockmode.Run commands from the repository root unless an existing section below says otherwise.
Limitations
This is a thin wrapper. Image preprocessing, model inference, and decoding are delegated to Hugging Face Transformers and the NV-Reason-CXR-3B model.
Output is not a diagnosis, clinical report, treatment recommendation, or triage decision. It is engineering evidence and must be reviewed by a qualified professional before any medical use.
The model may hallucinate findings, miss subtle abnormalities, misread support devices, or produce overconfident prose.
The committed fixture uses a generated synthetic PNG and deterministic mock response so CI can verify wrapper behavior without downloading model weights. Mock mode is not a substitute for model inference.
The
hf-space-apibackend depends on public Hugging Face Space availability and API compatibility.Not for clinical deployment, clinical interpretation, autonomous diagnosis, treatment decisions.
Troubleshooting
| Error | Cause | Fix |
|---|---|---|
| Missing dependency or import error | Runtime package drift from skill_manifest.yaml. | Install the packages declared in the manifest or use the documented setup command. |
| CUDA unavailable from an agent but available in a user terminal | The agent sandbox, container, or job wrapper may not expose NVIDIA device nodes even when the same Python environment has CUDA-capable PyTorch installed. | Compare python -c "import torch; print(torch.cuda.is_available())" and nvidia-smi inside the agent context and in the user terminal. If only the agent context fails, rerun with GPU/device access, use the host terminal, or pass --device cpu --allow-cpu only for an explicit slow CPU test. |
| API backend HTTP or schema error | The public Hugging Face Space may be unavailable, rate limited, or changed. | Re-run later or use --backend local when local dependencies and CUDA are available. |
| Empty or schema-invalid output | Wrong input path, unsupported modality, or upstream failure. | Re-run with a known fixture and inspect the wrapper JSON plus stderr. |
| Validation gate failure | Output violated a declared engineering invariant. | Keep the failed evidence pack and use the gate message to repair inputs or wrapper code. |
Runs NVIDIA-Medtech NV-Reason-CXR-3B
for chest X-ray image interpretation through either the documented local
Hugging Face Transformers inference path or the public Hugging Face Space API.
The wrapper does not reimplement the model, image preprocessing, or decoding.
Exact Runnable Surface
For command-shape smoke tests and JSON fixtures, use this repo-root wrapper path exactly:
python skills/nv-reason-cxr/scripts/run_nv_reason_cxr.py PATH_TO_CXR_OR_FIXTURE --mock --out-dir OUT_DIRFor local live image inference, omit --mock only when the user asks for live
model inference. Local is the default backend:
python skills/nv-reason-cxr/scripts/run_nv_reason_cxr.py PATH_TO_CXR_OR_FIXTURE \
--prompt "Find abnormalities and support devices." \
--backend localFor public API inference without local model packages, use:
python skills/nv-reason-cxr/scripts/run_nv_reason_cxr.py PATH_TO_CXR_OR_FIXTURE \
--prompt "Find abnormalities and support devices." \
--backend hf-space-apiDo not invent Medical AI Skills run, eval_engine/run.py, infer.py, or
python -m nv_reason_cxr commands for ordinary user runs.
Preconditions
For --backend local, install the inference dependencies in the environment
that will run the skill:
pip install torch==2.7.1 torchvision==0.22.1 transformers==4.56.1 PillowThe model weights and remote model code are loaded from
nvidia/NV-Reason-CXR-3B revision
056bd0383b35226554da9dc5866e095df174ae19 through Transformers. They may
download to the Hugging Face cache on first use.
Set TRANSFORMERS_OFFLINE=1 or pass --local-files-only only after the
weights are already cached.
CUDA is expected for practical inference. CPU execution may work for small tests but is slow and must be requested explicitly.
For --backend hf-space-api, no local PyTorch, Transformers, CUDA, model
cache, or Hugging Face token is required. The backend sends the image and
prompt to the public nvidia/nv-reason-cxr Hugging Face Space.
Check the local environment before downloading weights or running inference:
python skills/nv-reason-cxr/scripts/run_nv_reason_cxr.py --check-setupThe setup report checks importable dependencies, CUDA visibility, Hugging Face cache state, and the recommended next step.
Operational environment variables:
| Variable | When to use |
|---|---|
MOCK_NV_REASON_CXR | Set to 1 for deterministic command-shape smoke tests without model inference. |
NV_REASON_CXR_MODEL | Override the Hugging Face model id only for compatibility probes. |
HF_HOME | Point at a pre-populated Hugging Face cache. |
HF_TOKEN | Optional for local model downloads only when required by the local environment; not needed for the public API backend. |
TRANSFORMERS_OFFLINE | Set to 1 only after weights are already cached. |
HF_HUB_OFFLINE | Set to 1 only after Hugging Face assets are already cached. |
Prompt Routing
Choose both the model prompt and the user-facing output mode before running the wrapper. Routing order matters: exact model-prompt requests use pass-through/raw-only mode first; otherwise report-generation requests take precedence over general analysis and specific-question routing.
Use pass-through/raw-only mode only when the user explicitly asks to send an
exact prompt to the model, such as "call the model with this prompt exactly:
...". Pass only that exact model prompt as --prompt.
Use abnormality-analysis mode when the user asks to analyze, examine, or find
abnormalities in a chest X-ray. Treat local image paths, uploaded filenames,
backend choices such as "use API" or "use local", output delivery instructions,
and other agent orchestration text as wrapper instructions, not model prompt
content. Do not include local filesystem paths, backend names, or "use API" in
--prompt unless the user explicitly asks to send that exact text to the
model. For ordinary abnormality-finding requests, use the documented prompt,
usually --prompt "Find abnormalities and support devices.", with the
requested backend.
Use report-generation/two-call mode if the user asks to write, create, or
generate a structured report, chest X-ray report, radiology report, or report.
If sufficient raw model context for the same image is already available,
especially output from Find abnormalities and support devices., skip the context-gathering
call. Otherwise first run the wrapper with --prompt "Examine the chest X-ray." to gather context, but do not show that first call. Then run the
wrapper again with a multi-turn transcript prompt:
User: Find abnormalities and support devices.
Assistant:
<raw model context>
User: Write a structured report.Treat the second call as the completed run.
Use default-prompt/context-answer mode when the user asks a specific question
about a finding, such as presence, count, location, or characterization, or
mixes general analysis with specific questions. Run the wrapper with
--prompt "Find abnormalities and support devices." before answering the original question
in plain text prefixed exactly with Answer:. Base the answer only on the raw
model output context and the image.
Follow-up Handling
For follow-up questions about an image already analyzed in the conversation, reuse prior raw model context when it is sufficient. For report follow-ups, use report-generation/two-call mode and skip directly to the second model call if there is sufficient context. If prior context is insufficient and the same image path or image bytes are available, call the wrapper again using the prompt routing rules above. If the image is no longer available, ask the user to reattach it.
For long multi-turn prompts that include prior raw model output, prefer a quoted Bash here-doc variable so XML-like tags, apostrophes, quotes, and newlines are preserved:
IFS= read -r -d '' prompt <<'PROMPT'
User: Examine the chest X-ray.
Assistant:
<raw model context>
User: Write a structured report.
PROMPT
python skills/nv-reason-cxr/scripts/run_nv_reason_cxr.py PATH_TO_CXR.png \
--prompt "$prompt" \
--backend hf-space-apiUse IFS= read -r -d '' prompt <<'PROMPT', not command substitution, for long
pasted transcripts.
License
The upstream repository code is Apache-2.0. The model weights are released under the NVIDIA OneWay Noncommercial License Agreement. Users are responsible for complying with the model-weight terms before live inference.
Usage
From Medical AI Skills repo root:
python skills/nv-reason-cxr/scripts/run_nv_reason_cxr.py PATH_TO_CXR.png \
--prompt "Find abnormalities and support devices." \
--backend localFor public API inference without installing model packages locally:
python skills/nv-reason-cxr/scripts/run_nv_reason_cxr.py PATH_TO_CXR.png \
--prompt "Find abnormalities and support devices." \
--backend hf-space-apiFor user requests that include local path or backend instructions, keep those instructions out of the model prompt:
User request: find abnormalities in ~/Desktop/363.jpg (use API)python skills/nv-reason-cxr/scripts/run_nv_reason_cxr.py ~/Desktop/363.jpg \
--prompt "Find abnormalities and support devices." \
--backend hf-space-apiUse the wrapper script directly for agent-generated commands. Do not replace
it with eval_engine/run.py unless the user explicitly asks to run the eval
harness. Do not redirect stdout with > in generated commands: callers and
the eval harness read the wrapper's stdout JSON to verify the run. The direct
runnable surface is:
python skills/nv-reason-cxr/scripts/run_nv_reason_cxr.py PATH_TO_CXR_OR_FIXTURE \
--mock \
--out-dir runs/nv_reason_cxr_casePATH_TO_CXR_OR_FIXTURE may be a PNG/JPEG image or a JSON fixture. If the
user provides a JSON request such as
runs/.../synthetic_cxr_input.json, pass that exact JSON path as the first
argument. The script will load generated://synthetic_chest_xray fixtures,
create the temporary PNG under the output directory, and emit JSON with the
model response. Use --mock only for command-shape smoke tests or fixtures
that request mock mode; omit --mock for live model inference.
For JPEG input:
python skills/nv-reason-cxr/scripts/run_nv_reason_cxr.py PATH_TO_CXR.jpg \
--prompt "Describe the chest X-ray findings." \
--backend localFlags:
--backend local|hf-space-api— inference backend, defaultlocal.--model-id— Hugging Face model id, defaultnvidia/NV-Reason-CXR-3B.--device auto|cuda|cpu— defaultauto, using CUDA when available.--allow-cpu— required for live CPU inference; CPU runs can be very slow.--torch-dtype auto|float16|bfloat16|float32— defaultauto, using bfloat16 on CUDA and float32 on CPU, matching the published BF16 model.--max-new-tokens— generation cap, default 2048.--local-files-only— use only locally cached Hugging Face assets.--mock— deterministic dry-run response for CI and wiring checks.--prompt-preset findings|comprehensive|educational|structured— optional known-good prompt presets from the model card/demo behavior.--out-dir— optional artifact directory. Required for generated JSON fixtures; the eval harness passes it explicitly.
The tested local live path uses:
AutoModelForImageTextToText.from_pretrained(..., dtype=torch.bfloat16).eval().to("cuda")AutoProcessor.from_pretrained(..., use_fast=True)PNG/JPEG image input plus one text prompt
max_new_tokens=2048by default
The script emits JSON on stdout and writes no clinical report files. Direct
PNG/JPEG runs do not create a default output directory. Generated JSON fixtures
require --out-dir for the temporary synthetic image. The result JSON records
input image metadata, prompt, model id, runtime mode, response text, and known
limitations. If runtime.truncated_by_max_new_tokens is true, rerun with a
higher --max-new-tokens value.
Reporting reminder: for both local and hf-space-api backends, follow the
completed-run rule in Instructions.
The hf-space-api backend calls the fixed public Hugging Face Space at
https://nvidia-nv-reason-cxr.hf.space with a 300 second HTTP timeout.
Fixture Smoke Test
The committed fixture uses a generated synthetic PNG and mock mode so the eval harness can verify the wrapper without downloading weights:
python eval_engine/run.py skills/nv-reason-cxr \
--fixture skills/nv-reason-cxr/fixtures/synthetic_cxr_input.json \
--out runs/nv_reason_cxr_smokeLimits
This is research and engineering tooling only. It is not validated for clinical diagnosis, treatment decisions, triage, patient-facing reporting, or regulatory use. Model outputs can hallucinate, miss subtle findings, or overstate uncertainty. A qualified professional must review any use in a medical workflow.
Files
- ATTRIBUTION.mdAdded by AutoGineer910 B
- BENCHMARK.md3.9 KiB
- LICENSELicence file added by AutoGineer11.2 KiB
- SKILL.md15.4 KiB
- evals/evals.json1.2 KiB
- fixtures/synthetic_cxr_input.json387 B
- scripts/run_nv_reason_cxr.pyScript33.0 KiB
- skill-card.md3.8 KiB
- skill.oms.sig5.6 KiB
- skill_manifest.yaml7.3 KiB
- tests/test_nv_reason_cxr.pyScript7.6 KiB
- validators/output_schema.json2.9 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 Python
Security
What our scanner noticed· Medium risk
- Large base64-encoded blobs
- Instructions that use the network
- 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 MedTech Team
- Publisher
- NVIDIA (Official)
- Source
- NVIDIA/skills · skills/nv-reason-cxr · 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 MedTech Team or NVIDIA.
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download nv-reason-cxr.zip