Generated banner for Nvidia App
Generated logo for Nvidia App

Nvidia App

NVIDIAOfficialCreated by NVIDIA CORPORATION

  • Skill
  • Tool integration
  • Design and creative
  • Apache-2.0
  • Medium risk

From the author

NVIDIA App MCP: drivers, games, laptops, overlay. Check drivers, manage and optimize games, configure laptop features.
— the description by NVIDIA CORPORATION

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The NVIDIA App MCP skill provides a standardized interface for interacting with the NVIDIA App on Windows. It enables users to query driver status, manage game optimization presets, configure laptop-specific power and fan settings, and control the NVIDIA In-Game Overlay. The skill supports both general application management and specific overlay actions like recording, instant replay, and screenshot capture, ensuring a consistent workflow through a local MCP server or stdio bridge.

What it does

  • Retrieve and manage NVIDIA driver status and release notes.
  • List, launch, and optimize games with specific performance presets.
  • Configure laptop-specific features like Battery Boost and Whisper Mode.
  • Control In-Game Overlay functions including recording and instant replay.
  • Capture screenshots and toggle statistics overlays during gameplay.
  • Enable or disable RTX Dynamic Vibrance filters.

When to use it

  • When you need to check for driver updates or view release notes.
  • When you want to optimize a game's performance or quality settings.
  • When you need to toggle recording, instant replay, or highlights while gaming.
  • When you need to adjust laptop power or fan profiles for specific games.
  • When you need to capture a screenshot via the NVIDIA Overlay.

Advantages

  • Provides a unified interface for both general app management and overlay control.
  • Supports persistent configuration via MCP client registration.
  • Offers a reliable fallback mechanism for direct connection if registration fails.
  • Enables programmatic control over complex gaming and system settings.

Usage examples

“Check my NVIDIA driver status.”
The agent queries the NVIDIA App MCP server and returns the current driver version, available updates, and any recommended driver channels.
“Start recording my gameplay.”
The agent invokes the overlay capture tool to enable recording, confirming the action with the returned status message.
“Optimize Cyberpunk 2077 for performance.”
The agent identifies the game, applies the 'Performance' optimization preset, and confirms the change.
“Enable Whisper Mode on my laptop.”
The agent updates the global Whisper Mode settings to the requested fan volume level.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/nvidia/nvidia-app/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip nvidia-app.zip -d .agents/skills

Documentation by NVIDIA CORPORATION

NVIDIA App MCP Overlay

Purpose

Use this skill for one product integration: operating NVIDIA App through its local MCP server. It has two routed modes:

  • General NVIDIA App operations cover application listing and launch, driver status and release notes, per-game optimization, and laptop features.

  • In-Game Overlay operations use the workflow below.

The Overlay workflow supports:

  • Read high-level Overlay status.

  • Start or stop gameplay recording.

  • Enable, disable, or save Instant Replay.

  • Enable or disable Highlights.

  • Capture a screenshot to the Overlay gallery.

  • Show or hide the Statistics Overlay.

  • Enable or disable the RTX Dynamic Vibrance filter.

  • Identify the currently running game.

Connection setup supports both modes but does not authorize additional actions.

When to use this skill

Use this skill when the user asks for one of the supported application, driver, game-optimization, laptop-feature, Overlay, or connection workflows.

Do not select this skill for Desktop Capture, other Overlay filter mutations, NVIDIA Broadcast, OBS, Xbox Game Bar, or other capture software.

Inputs

  • Required: A user request for a supported NVIDIA App query, mutation, or connection diagnostic.

  • Optional: An explicit target state, game or program identifier, tool-specific values, and client connection details. Obtain authentication tokens only from the protected discovery source described in references/connection.md; never accept or expose them as ordinary tool arguments.

Resolve information in this order: explicit user instructions, fresh live MCP schema or state, current client connection configuration, then the applicable self-contained skill reference for static contract details. Never treat a previous tool result as current state.

Prerequisites

  • Windows host with NVIDIA App installed (version 11.0.9.5xx or above) and its NvContainer-hosted MCP plugin running.

  • Standard NVIDIA App executable path: %ProgramFiles%\NVIDIA Corporation\NVIDIA App\CEF\NVIDIA App.exe.

  • MCP server access is enabled when NVIDIA App exposes a master toggle.

  • NVIDIA In-Game Overlay is enabled, running, and ready before any nvapp_overlay_ call.

  • The MCP client supports Streamable HTTP over loopback or connects through the installed stdio bridge.

MCP server readiness and Overlay readiness are separate. A successful MCP connection does not establish that Overlay tools are ready.

Instructions

  1. Classify the request. Route general NVIDIA App requests through live tool discovery. Route nvapp_overlay_ requests through the Overlay workflow. Read-only Overlay status can include fields for excluded features, but that does not authorize changing them.

  2. Register nvidia-app in the current MCP client, or fall back explicitly. The client is registered only when this session's live tool catalog advertises nvapp_ tools; an open loopback port or a working stdio bridge is not registration. If those tools are absent, attempt registration per references/connection.md before the first nvapp_ call. Registration is the default path because it persists across turns and sessions. A reachable HTTP endpoint is not a reason to skip the attempt.

  3. Use the direct connection only as a declared fallback. If the user declines the configuration change, the client cannot be modified or reloaded, or registration succeeds but nvapp_ tools still do not appear in this session, connect directly to the loopback HTTP endpoint (or the stdio bridge) and continue with the same documented tool contracts. Say which path you used and that registering nvidia-app would make access persistent. Do not silently prefer the direct path.

  4. Discover general tools. For a non-Overlay request, inspect tools/list on whichever connection you established, then read references/general-tools.md before selecting or calling one of its seven documented public tools. Select only a returned tool whose description, schema, and annotations most narrowly match the user's in-scope intent, and follow any narrower live schema and annotations.

  5. Resolve an Overlay target state. For an explicit start, stop, enable, disable, show, or hide request, call the mapped mutation directly. For a true toggle with no target state, read status once and invert only the corresponding Boolean.

  6. Validate the arguments. For general tools, follow references/general-tools.md and any narrower live schema. For Overlay tools, use exactly the mapped fields below. Never invent unsupported arguments.

  7. Execute in request order. Fulfill compound requests by issuing each supported operation as its own tool call in the user's order. Make only the calls needed for the requested operations. Respect the access tier and any consent decision; never raise access or enable another feature as a workaround.

  8. Interpret the result literally. Report only returned fields and outcomes. Overlay mutations return a human-readable message; report that message without inventing structured success fields. If a mutation message is ambiguous, state that the outcome is not independently confirmed instead of making a follow-up Overlay status call solely to verify it.

Connecting

The default HTTP endpoint is:

http://127.0.0.1:13508/mcp

The installed stdio bridge is:

%ProgramFiles%\NVIDIA Corporation\NVIDIA App\McpServer\NvAppMcpServer.exe

The stdio executable relays to the persistent server; it does not start or enable that server.

General NVIDIA App operations

Read references/general-tools.md before selecting or calling a general NVIDIA App tool. It contains the seven supported tool names, exact arguments, enums, conditional schemas, and prerequisite checks.

Use only a documented tool advertised by live tools/list. The packaged instructions are self-contained and do not depend on repository-internal schema sources.

Overlay operations

Use only the tools in this table and the authorized arguments shown here:

User intentToolArguments
Read overall Overlay statusnvapp_overlay_get_status{}
Start recordingnvapp_overlay_capture{ "action": "toggle_recording", "enable": true }
Stop and save recordingnvapp_overlay_capture{ "action": "toggle_recording", "enable": false }
Enable Instant Replaynvapp_overlay_capture{ "action": "toggle_instant_replay", "enable": true }
Disable Instant Replaynvapp_overlay_capture{ "action": "toggle_instant_replay", "enable": false }
Save Instant Replaynvapp_overlay_capture{ "action": "save_instant_replay" }
Enable Highlightsnvapp_overlay_capture{ "action": "toggle_highlights", "enable": true }
Disable Highlightsnvapp_overlay_capture{ "action": "toggle_highlights", "enable": false }
Capture a screenshotnvapp_overlay_capture{ "action": "capture_screenshot" }
Show Statistics Overlaynvapp_overlay_configure_stats{ "enable": true }
Hide Statistics Overlaynvapp_overlay_configure_stats{ "enable": false }
Enable RTX Dynamic Vibrancenvapp_overlay_configure_filters{ "filter": "rtx_dvc", "enable": true }
Disable RTX Dynamic Vibrancenvapp_overlay_configure_filters{ "filter": "rtx_dvc", "enable": false }
Get current gamenvapp_overlay_get_current_game_info{}

Never invoke toggle_desktop_capture. For nvapp_overlay_configure_filters, use only the rtx_dvc filter value.

Capture and privacy

toggle_recording, toggle_instant_replay, save_instant_replay, toggle_highlights, and capture_screenshot record screen content and write media files to the user's system. Recordings and screenshots persist in the NVIDIA App Overlay gallery until the user deletes them, and this skill cannot choose their format, resolution, or destination.

Treat every one of them as a privacy-affecting operation:

  • An explicit user request to start, stop, save, enable, or capture is the authorization. Make that single mapped call without an additional confirmation prompt, then report the returned message so the user knows capture began or media was written.

  • Never initiate capture the user did not ask for. Do not start recording as a side effect of another request or as a workaround for a failed operation.

  • Ask first when the request is ambiguous, when a true toggle has no target state and the status field is missing, or when an unsupported qualifier such as a format or destination applies.

  • Enabling Instant Replay or Highlights leaves background capture running until it is disabled. Say so when you enable either one.

  • Do not enable Desktop Capture to make a capture succeed. Content outside a supported game stays out of scope for this skill.

Decision rules

  • If this session's MCP catalog has no nvapp_ tools, attempt nvidia-app registration before connecting directly. Once registration is refused or has failed, a direct HTTP or stdio connection is allowed for the rest of the session without re-asking.

  • Whichever connection you use, honor the same tool names, schemas, access tier, and Overlay restrictions. The fallback changes the transport only, never the authorized surface.

  • For a true request to toggle recording, Instant Replay, Highlights, Statistics Overlay, or RTX Dynamic Vibrance, call nvapp_overlay_get_status once and invert only recordingActive, instantReplayEnabled, highlightsEnabled, statsOverlayEnabled, or rtxDvc, respectively.

  • If the required status field is absent, ask whether to enable or disable instead of guessing. Never convert an omitted field to false.

  • nvapp_overlay_capture accepts one action, not an action list.

  • Do not add enable to save_instant_replay or capture_screenshot.

  • Do not omit enable from toggle_recording, toggle_instant_replay, toggle_highlights, or nvapp_overlay_configure_stats.

  • Pass both filter: "rtx_dvc" and enable to nvapp_overlay_configure_filters; never invent another filter value.

  • For a mixed request, execute independent supported operations in order and explain or skip unsupported operations; an unsupported sibling request must not block a fully specified supported action.

  • When an unsupported qualifier modifies an otherwise supported state-changing operation, explain the limitation and ask whether to proceed with that supported subset before making its mutation call.

  • running: false means no current game was identified. Do not invent gameName or processId. Report fullscreen only when it is returned.

Output Format

  • Follow the user's requested format; otherwise give a concise human-readable result.

  • For reads, report only structured fields that are present and distinguish an omitted field from false or null.

  • For failures, state that the operation failed and preserve the returned error code, retryability, and useful guidance.

  • Never expose authentication material. When protocol-level detail is needed, show only the request or response shape and replace tokens, authorization headers, and other secrets with placeholders such as <redacted-token>.

Limitations

  • Installed NVIDIA App versions and access levels can expose different general tools and output contracts; live tools/list is authoritative.

  • MCP readiness does not guarantee Overlay readiness, and a successful mutation message does not prove more than the returned result.

  • The Overlay workflow cannot mutate Desktop Capture or filters other than RTX Dynamic Vibrance, choose screenshot format or destination, or configure Statistics Overlay layout and styling.

  • Missing fields are unknown, not implicit false values, and unavailable tools or backend timeouts must not be replaced with inferred data.

Examples

Get driver status

For a request such as "Show my NVIDIA driver status," first check whether the current MCP client advertises nvapp_ tools. If it does not, offer to register nvidia-app; if the user declines or registration is not possible, connect directly to the loopback endpoint and say so. Then call tools/list on that connection and confirm nvapp_client_get_driver_status is advertised with an empty-object input schema. If it is unavailable, explain that the connected NVIDIA App version or access level does not expose this workflow; do not substitute a similarly named tool without validating its live schema.

Invoke:

{
  "name": "nvapp_client_get_driver_status",
  "arguments": {}
}

Use the returned structured fields literally:

  • Report systemType, installedDriver.version, optional installedDriver.channel, and installedDriver.availableActions.

  • Report preferredChannel.

  • For each item in recommendedDrivers, report name, version, channel, releaseDate, isUpdateAvailable, and availableActions.

  • If previouslyInstalledDriver is null, state that NVIDIA App reports no rollback driver is available. Otherwise, report its name, version, releaseDate, and availableActions.

This tool is read-only. Do not invoke a driver mutation; none is included in this seven-tool scope.

Start recording with an explicit target state

Call the mutation directly because the requested target state is already known:

{ "name": "nvapp_overlay_capture", "arguments": { "action": "toggle_recording", "enable": true } }

Do not read status before the call or issue a verification read afterward. The explicit request is the authorization, so no extra confirmation prompt is needed, but this call starts screen capture and writes a file; report the returned message and see Capture and privacy.

Toggle Instant Replay without a target state

First call nvapp_overlay_get_status with {}. If instantReplayEnabled is present, call nvapp_overlay_capture once with enable set to its opposite. If the field is absent, ask whether to enable or disable Instant Replay and make no mutation yet.

Handle an unsupported screenshot qualifier

For “Take a PNG screenshot in D:\Shots,” explain that the tool cannot select the format or destination. Ask whether to capture to the Overlay gallery. After confirmation, call:

{ "name": "nvapp_overlay_capture", "arguments": { "action": "capture_screenshot" } }

Troubleshooting

Error or symptomLikely causeResponse
service_disabledPersistent MCP server access is disabledAsk the user to enable MCP server access in NVIDIA App Settings; do not repeatedly spawn bridges.
overlay_not_availableMCP is connected but In-Game Overlay is not readyAsk the user to enable or start In-Game Overlay, then retry only if requested.
overlay_timeoutOverlay did not answer before the deadlinePreserve retriable; retry at most once when the result allows retrying and the retry remains within the request, then report the failure and ask before trying again.
access_level_restrictedCurrent MCP access ceiling blocks the toolReport the restriction; do not raise access implicitly.
isError: true or another backend/validation failureThe requested operation did not succeedPreserve the message and error code; do not infer data or report success.

Overlay mutations return a human-readable message rather than structured success fields. Report that message literally and do not infer additional state. If saving Instant Replay reports that it is disabled, ask before enabling it. If capture requires Desktop Capture, report the limitation rather than enabling Desktop Capture.

References

  • Read references/connection.md for client configuration, ports, discovery and authentication, protocol lifecycle, readiness, and connection troubleshooting.

  • Read references/general-tools.md for live discovery, schema use, routing, and result handling for non-Overlay NVIDIA App operations.

  • Read references/overlay-capture.md for recording, Instant Replay, Highlights, screenshots, unsupported qualifiers, access, and capture errors.

  • Read references/overlay-state.md for status routing, true toggles, Statistics Overlay visibility, RTX Dynamic Vibrance, and current-game lookup.

  • Read references/mcp-tool-contract.md for the canonical status field set and when exact Overlay schemas, outputs, access tiers, or error forms are needed.

Files

evals/evals.json

{
  "skill_name": "nvidia-app",
  "evals": [
    {
      "id": "nvidia-app-record-start-001",
      "prompt": "Use the nvidia-app skill to start recording my gameplay.",
      "expected_output": "The agent invokes nvapp_overlay_capture once with action toggle_recording and enable true, then reports only what the returned result establishes.",
      "assertions": [
        "The agent reads the nvidia-app SKILL.md before acting",
        "The agent calls nvapp_overlay_capture with { action: \"toggle_recording\", enable: true }",
        "The agent does not call nvapp_overlay_get_status before or after an explicit start request",
        "The agent uses standard access and does not request consent for nvapp_overlay_capture",
        "The agent does not invoke an unrelated capture application or out-of-scope Overlay action"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-record-stop-002",
      "prompt": "Stop the NVIDIA gameplay recording and save it.",
      "expected_output": "The agent invokes nvapp_overlay_capture once with action toggle_recording and enable false, recognizing that stopping an active recording also saves it.",
      "assertions": [
        "The agent calls nvapp_overlay_capture with { action: \"toggle_recording\", enable: false }",
        "The agent does not invent a second save-recording action",
        "The agent reports the returned mutation message if no recording is active",
        "The agent does not add unsupported output-path or file-name arguments"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-instant-replay-enable-003",
      "prompt": "Turn on NVIDIA Instant Replay.",
      "expected_output": "The agent invokes nvapp_overlay_capture with action toggle_instant_replay and enable true.",
      "assertions": [
        "The agent calls nvapp_overlay_capture with { action: \"toggle_instant_replay\", enable: true }",
        "The agent does not call nvapp_overlay_get_status first because the target state is explicit",
        "The agent reports the returned mutation message without a redundant verification call"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-instant-replay-toggle-004",
      "prompt": "Toggle Instant Replay for me.",
      "expected_output": "The agent calls nvapp_overlay_get_status once. If instantReplayEnabled is present, it invokes nvapp_overlay_capture with action toggle_instant_replay and enable set to the opposite Boolean; if the field is absent, it asks whether to enable or disable and makes no mutation call.",
      "assertions": [
        "The agent calls nvapp_overlay_get_status with {} before resolving the true toggle",
        "The agent uses only instantReplayEnabled and does not infer from another field",
        "The agent passes the opposite Boolean to toggle_instant_replay when the field is present",
        "The agent asks instead of guessing when instantReplayEnabled is missing",
        "The agent does not issue a follow-up status verification"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-instant-replay-save-005",
      "prompt": "Save the Instant Replay buffer.",
      "expected_output": "The agent invokes nvapp_overlay_capture with only action save_instant_replay and does not pass enable or a duration.",
      "assertions": [
        "The agent calls nvapp_overlay_capture with { action: \"save_instant_replay\" }",
        "The agent does not pass enable",
        "The agent does not call nvapp_overlay_get_status first",
        "If the returned message says Instant Replay is disabled, the agent reports it and asks before enabling Instant Replay"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-screenshot-006",
      "prompt": "Take a screenshot of my game right now.",
      "expected_output": "The agent invokes nvapp_overlay_capture with only action capture_screenshot and reports the returned mutation message.",
      "assertions": [
        "The agent calls nvapp_overlay_capture with { action: \"capture_screenshot\" }",
        "The agent does not pass enable, path, format, or resolution",
        "The agent surfaces a supported-game or Desktop Capture condition without enabling Desktop Capture"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-stats-007",
      "prompt": "Hide the NVIDIA performance statistics overlay.",
      "expected_output": "The agent invokes nvapp_overlay_configure_stats with enable false.",
      "assertions": [
        "The agent calls nvapp_overlay_configure_stats with exactly { enable: false }",
        "The agent does not add position, layout, opacity, logging, or metric fields",
        "The agent does not call nvapp_overlay_get_status for an explicit target state or verification"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-current-game-008",
      "prompt": "Which game does NVIDIA Overlay see running right now?",
      "expected_output": "The agent invokes nvapp_overlay_get_current_game_info with an empty argument object and reports running, gameName, processId, and fullscreen only when returned.",
      "assertions": [
        "The agent calls nvapp_overlay_get_current_game_info with {}",
        "The agent does not substitute nvapp_overlay_get_status because status does not return game identity",
        "The agent reports fullscreen only when returned",
        "When running is false, the agent does not invent a game name, process ID, or fullscreen state"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-status-009",
      "prompt": "Give me the current status of every NVIDIA Overlay feature you can read.",
      "expected_output": "The agent invokes nvapp_overlay_get_status with {} and reports only fields present in the response, distinguishing omitted fields from false.",
      "assertions": [
        "The agent calls nvapp_overlay_get_status with {}",
        "The agent reports status for present capture, statistics, audio, notification, and filter fields",
        "The agent does not interpret a missing field as false",
        "The agent does not invoke any mutation tool",
        "The agent does not treat readable Desktop Capture or excluded filter state as permission to change them"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-compound-010",
      "prompt": "Tell me what game is running, show the stats overlay, and start recording it.",
      "expected_output": "The agent makes three calls in request order: nvapp_overlay_get_current_game_info with {}, nvapp_overlay_configure_stats with enable true, and nvapp_overlay_capture with action toggle_recording and enable true.",
      "assertions": [
        "The agent uses the three appropriate tools with exact arguments",
        "The agent preserves the user's requested order",
        "The agent does not call nvapp_overlay_get_status because every target state is explicit",
        "The agent does not combine multiple operations into an unsupported action array"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-unsupported-qualifier-011",
      "prompt": "Take a PNG screenshot and save it in D:\\Shots.",
      "expected_output": "The agent explains that format and destination are unsupported and asks whether to capture to the Overlay gallery. It makes no call before confirmation; after confirmation it calls nvapp_overlay_capture with only action capture_screenshot.",
      "assertions": [
        "The agent does not silently discard the PNG or destination requirements",
        "The agent makes no state-changing call before confirmation",
        "After confirmation the agent passes no path, format, or enable argument"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-connection-default-012",
      "prompt": "How should I connect an MCP client to NVIDIA App using this skill on the current default build?",
      "expected_output": "The agent recommends HTTP at http://127.0.0.1:13508/mcp or the installed stdio bridge and does not request or invent a token.",
      "assertions": [
        "The agent gives the default port 13508 and path /mcp",
        "The agent gives the installed NvAppMcpServer.exe stdio path",
        "The agent does not reuse NVIDIA Broadcast gateway.json, port range, endpoint path, or startup flow"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-highlights-enable-014",
      "prompt": "Turn on NVIDIA Highlights for this game.",
      "expected_output": "The agent invokes nvapp_overlay_capture with action toggle_highlights and enable true, then reports the returned message.",
      "assertions": [
        "The agent activates the nvidia-app skill for a Highlights mutation",
        "The agent calls nvapp_overlay_capture with { action: \"toggle_highlights\", enable: true }",
        "The agent does not call nvapp_overlay_get_status before or after the explicit enable request",
        "The agent does not request consent for nvapp_overlay_capture",
        "The agent reports the returned human-readable message and does not add unreturned fields such as highlightsEnabled"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-negative-desktop-capture-015",
      "prompt": "Enable NVIDIA Desktop Capture so I can record my desktop.",
      "expected_output": "The NVIDIA App Overlay workflow is not selected and does not invoke toggle_desktop_capture.",
      "assertions": [
        "The agent does not activate the nvidia-app skill for a Desktop Capture mutation",
        "The agent does not call nvapp_overlay_capture with action toggle_desktop_capture"
      ],
      "expected_skill": null,
      "expected_script": null,
      "should_trigger": false
    },
    {
      "id": "nvidia-app-negative-broadcast-016",
      "prompt": "Use NVIDIA Broadcast to remove keyboard noise from my microphone.",
      "expected_output": "The agent does not select the NVIDIA App skill and does not invoke any nvapp_overlay tool.",
      "assertions": [
        "The agent does not activate the nvidia-app skill",
        "The agent distinguishes NVIDIA Broadcast from NVIDIA App In-Game Overlay",
        "The agent does not invoke any nvapp_overlay tool"
      ],
      "expected_skill": null,
      "expected_script": null,
      "should_trigger": false
    },
    {
      "id": "nvidia-app-negative-obs-017",
      "prompt": "Configure OBS to record a window and save it as an MKV.",
      "expected_output": "The agent treats this as an OBS request and does not select the NVIDIA App skill.",
      "assertions": [
        "The agent does not activate the nvidia-app skill",
        "The agent does not call any nvapp_overlay tool",
        "The agent does not reinterpret the request as NVIDIA gameplay recording"
      ],
      "expected_skill": null,
      "expected_script": null,
      "should_trigger": false
    },
    {
      "id": "nvidia-app-driver-discovery-018",
      "prompt": "Check whether my NVIDIA graphics driver needs an update.",
      "expected_output": "The agent selects the nvidia-app skill and calls nvapp_client_get_driver_status with an empty argument object when advertised.",
      "assertions": [
        "The agent activates the nvidia-app skill",
        "The agent confirms nvapp_client_get_driver_status is advertised",
        "The agent calls nvapp_client_get_driver_status with {}",
        "The agent reports installed and recommended driver update fields literally",
        "The agent does not invoke any nvapp_overlay tool"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-game-optimization-discovery-019",
      "prompt": "Optimize the graphics settings for every game in my NVIDIA library.",
      "expected_output": "The agent selects the nvidia-app skill and inspects the live tool catalog and schemas before determining whether bulk game optimization is supported and what user input or confirmation is required.",
      "assertions": [
        "The agent activates the nvidia-app skill",
        "The agent does not infer that one advertised per-game tool supports an unadvertised bulk operation",
        "The agent follows the selected live schema and asks for required input that cannot be inferred safely",
        "The agent does not invoke any nvapp_overlay tool"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-highlights-disable-020",
      "prompt": "Turn off NVIDIA Highlights for this game.",
      "expected_output": "The agent invokes nvapp_overlay_capture with action toggle_highlights and enable false, then reports the returned message.",
      "assertions": [
        "The agent activates the nvidia-app skill for a Highlights mutation",
        "The agent calls nvapp_overlay_capture with { action: \"toggle_highlights\", enable: false }",
        "The agent does not call nvapp_overlay_get_status before or after the explicit disable request",
        "The agent reports the returned human-readable message and does not add unreturned fields such as highlightsEnabled"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-rtx-dvc-enable-021",
      "prompt": "Enable NVIDIA RTX Dynamic Vibrance.",
      "expected_output": "The agent invokes nvapp_overlay_configure_filters with filter rtx_dvc and enable true, then reports the returned message.",
      "assertions": [
        "The agent calls nvapp_overlay_configure_filters with exactly { filter: \"rtx_dvc\", enable: true }",
        "The agent does not call nvapp_overlay_get_status because the target state is explicit",
        "The agent does not use another filter value or configure RTX HDR, sharpening, or Freestyle",
        "The agent does not issue a follow-up verification read"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-rtx-dvc-toggle-022",
      "prompt": "Toggle RTX Dynamic Vibrance.",
      "expected_output": "The agent calls nvapp_overlay_get_status once. If rtxDvc is present, it invokes nvapp_overlay_configure_filters with filter rtx_dvc and enable set to the opposite Boolean; if the field is absent, it asks for the target state and makes no mutation call.",
      "assertions": [
        "The agent calls nvapp_overlay_get_status with {} before resolving the true toggle",
        "The agent uses only rtxDvc and does not infer state from rtxHdr, sharpening, or freestyle",
        "The agent passes filter rtx_dvc and the opposite Boolean when rtxDvc is present",
        "The agent asks instead of guessing when rtxDvc is missing",
        "The agent does not issue a follow-up verification read"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-instant-replay-disable-023",
      "prompt": "Turn off NVIDIA Instant Replay.",
      "expected_output": "The agent invokes nvapp_overlay_capture with action toggle_instant_replay and enable false.",
      "assertions": [
        "The agent calls nvapp_overlay_capture with { action: \"toggle_instant_replay\", enable: false }",
        "The agent does not call nvapp_overlay_get_status first because the target state is explicit",
        "The agent reports the returned mutation message without a redundant verification call"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-applications-list-024",
      "prompt": "List the applications NVIDIA App knows about and show whether each supports optimization.",
      "expected_output": "The agent calls nvapp_client_get_applications with {} and reports only returned application and optimization fields.",
      "assertions": [
        "The agent calls nvapp_client_get_applications with {}",
        "The agent reports exact game identifiers and opsSupported",
        "The agent distinguishes omitted optimization profiles from unsupported optimization",
        "The agent does not invoke a mutation"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-launch-025",
      "prompt": "Launch Cyberpunk 2077 from my NVIDIA App library.",
      "expected_output": "The agent resolves the exact catalog game and calls nvapp_client_launch_application with that exact value.",
      "assertions": [
        "The agent uses nvapp_client_get_applications to resolve Cyberpunk 2077 unless a fresh exact game value is already established",
        "The agent calls nvapp_client_launch_application with { game: \"Cyberpunk 2077\" } only after an exact match",
        "The agent does not pass a path, executable, command line, or guessed display name",
        "The agent reports the server mutation response literally"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-driver-release-notes-026",
      "prompt": "Show the release notes for my installed NVIDIA driver.",
      "expected_output": "The agent calls nvapp_client_get_driver_release_notes with driver INSTALLED and reports its version and available highlights.",
      "assertions": [
        "The agent calls nvapp_client_get_driver_release_notes with { driver: \"INSTALLED\" }",
        "The agent reports driver and version",
        "The agent accepts an empty highlights array as a valid result",
        "The agent does not invent release-note items"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-game-optimization-027",
      "prompt": "Apply the Recommended optimization preset to Cyberpunk 2077 for AC power.",
      "expected_output": "The agent validates the exact game, optimization support, and AC preset availability, then calls nvapp_client_set_game_optimization with exact arguments if advertised.",
      "assertions": [
        "The agent resolves Cyberpunk 2077 with nvapp_client_get_applications",
        "The agent checks opsSupported and the AC availablePresets",
        "The agent calls nvapp_client_set_game_optimization with { game: \"Cyberpunk 2077\", preset: \"Recommended\", powerSource: \"AC\" }",
        "The agent reports the tool as unavailable when it is absent from tools/list"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-laptop-global-read-028",
      "prompt": "Show my global NVIDIA Battery Boost and Whisper Mode settings.",
      "expected_output": "The agent calls nvapp_client_get_laptop_features with {} and reports support and only returned global values.",
      "assertions": [
        "The agent calls nvapp_client_get_laptop_features with {}",
        "The agent reports supported for both features",
        "The agent does not invent enabled, frameRate, fanVolume, or useGlobal when omitted",
        "The agent does not invoke a mutation"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-laptop-global-set-029",
      "prompt": "Enable global NVIDIA Battery Boost.",
      "expected_output": "The agent reads support and calls nvapp_client_set_laptop_feature with exactly one global batteryBoost object if supported.",
      "assertions": [
        "The agent reads global laptop features first",
        "The agent calls nvapp_client_set_laptop_feature with { batteryBoost: { enabled: true } } only when supported",
        "The agent omits game and useGlobal",
        "The agent does not include whisperMode"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-game-optimization-default-ac-030",
      "prompt": "Apply the Recommended optimization preset to Cyberpunk 2077.",
      "expected_output": "The agent validates the exact game and optimization support, then calls nvapp_client_set_game_optimization without inventing a power source; NVIDIA App defaults the request to AC.",
      "assertions": [
        "The agent resolves Cyberpunk 2077 with nvapp_client_get_applications",
        "The agent checks opsSupported and Recommended preset availability",
        "The agent calls nvapp_client_set_game_optimization with { game: \"Cyberpunk 2077\", preset: \"Recommended\" }",
        "The agent does not add powerSource unless the user requests AC or Battery"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-game-optimization-battery-031",
      "prompt": "Apply the Recommended optimization preset to Cyberpunk 2077 while I am running on battery power.",
      "expected_output": "The agent validates the exact game, optimization support, and Battery preset availability, then calls nvapp_client_set_game_optimization with Battery as the power source.",
      "assertions": [
        "The agent resolves Cyberpunk 2077 with nvapp_client_get_applications",
        "The agent checks opsSupported and the Battery availablePresets",
        "The agent calls nvapp_client_set_game_optimization with { game: \"Cyberpunk 2077\", preset: \"Recommended\", powerSource: \"Battery\" }",
        "The agent uses Battery as the powerSource value"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-game-optimization-resolution-prerequisite-032",
      "prompt": "Optimize Cyberpunk 2077 for Quality. Its AC profile reports unavailableReason: Presets cannot be applied until the desktop resolution is changed to 2560x1440.",
      "expected_output": "The agent does not call the optimization setter, reports the returned unavailableReason including desktop resolution 2560x1440, and does not change the display resolution implicitly.",
      "assertions": [
        "The agent interprets unavailableReason as a blocking prerequisite",
        "The agent reports the returned reason including 2560x1440",
        "The agent does not call nvapp_client_set_game_optimization",
        "The agent does not change the desktop resolution implicitly",
        "The agent does not describe the game as lacking OPS support"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    },
    {
      "id": "nvidia-app-game-optimization-configuration-prerequisite-033",
      "prompt": "Revert Cyberpunk 2077 optimization. Its AC profile reports unavailableReason: Presets cannot be applied because the current game configuration is unavailable. Start and close the game or app, or edit its settings, then try again.",
      "expected_output": "The agent does not call the optimization setter and tells the user to start and then close the game or app, or edit its settings, before refreshing application details and retrying.",
      "assertions": [
        "The agent interprets unavailableReason as a blocking prerequisite",
        "The agent does not call nvapp_client_set_game_optimization even for Revert",
        "The agent gives the start-and-close or edit-settings recovery guidance",
        "The agent recommends refreshing nvapp_client_get_applications before retrying",
        "The agent does not report a successful Revert"
      ],
      "expected_skill": "nvidia-app",
      "expected_script": null,
      "should_trigger": true
    }
  ]
}

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: Needs an MCP server

Security

What our scanner noticed· Medium risk

  • Large base64-encoded blobs

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
NVIDIA CORPORATION
Publisher
NVIDIA (Official)
Source
NVIDIA/skills · skills/nvidia-app · 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 nvidia-app.zip