G Assist MCP Skill

NVIDIAOfficialCreated by schopparapuDistributed by NVIDIA

Skill
Tool integration
Software development
CC-BY-4.0
Medium risk

From the author

Use this skill to check or change this machine's NVIDIA display and GPU settings, such as resolution, refresh rate, V-Sync, G-SYNC, brightness, color, and GPU performance.

— the description by schopparapu

AutoGineer summary

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

G-Assist provides an interface to manage NVIDIA display and GPU hardware settings using MCP tools. It allows users to query current states or modify configurations such as resolution, refresh rate, V-Sync, G-SYNC, and various monitor color or brightness parameters. The skill operates by mapping natural language requests to specific, hardware-gated tools available in the current session, ensuring that only supported adjustments are attempted.

What it does

Queries current status of NVIDIA display and GPU features.
Adjusts display resolution and refresh rate settings.
Configures monitor brightness, contrast, gamma, and color temperature.
Toggles G-SYNC, V-Sync, and G-SYNC Pulsar modes.
Manages GPU performance settings including frame-rate limits and power modes.
Generates plots for GPU and CPU metrics over time.

When to use it

When you need to check or modify NVIDIA display or GPU settings.
To resolve display issues like screen tearing, stutter, or incorrect refresh rates.
To adjust monitor image quality, such as brightness, color balance, or presets.
When you want to monitor GPU and CPU performance metrics.

Advantages

Provides direct control over hardware settings via natural language.
Integrates seamlessly with MCP-capable hosts.
Supports a wide range of display and GPU configuration options.
Includes built-in status verification for hardware features.

Usage examples

“Is G-SYNC currently enabled on my display?”: The agent calls the gassist_query_feature_status tool to report the current G-SYNC status.
“Set my refresh rate to 144 Hz.”: The agent verifies the availability of the refresh rate tool and calls gassist_set_display_refreshrate with the specified value.
“Turn off V-Sync.”: The agent calls gassist_set_display_vsync with the enable argument set to 0.
“Show me a graph of my GPU usage for the last 5 minutes.”: The agent uses the gassist_graphdata tool to retrieve and display the requested performance metrics.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/nvidia/g-assist-mcp-skill/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip g-assist-mcp-skill.zip -d .agents/skills

Documentation by schopparapu

G-Assist

G-Assist exposes NVIDIA display and GPU controls as callable tools. Use them whenever the user wants to view or change NVIDIA display or GPU settings on this machine. The available tools depend on the machine and hardware, so always rely on the G-Assist tools actually available in your session and only use tools that are present.

When to use this skill

Use this skill whenever the user wants to know or change how their NVIDIA display or GPU is behaving, or describes a symptom like screen tearing, stutter, a wrong or locked refresh rate, a dim monitor, or washed-out color. Prefer a read-only status check before changing anything. Do not use it to edit images, files, documents, or app windows. It acts only on the real display and GPU hardware, and the available tools depend on the machine, so confirm them at runtime instead of assuming.

It covers refresh rate and resolution; monitor brightness and color (temperature, gamma, contrast, RGB gain, and ambient-light adaptive brightness/color); monitor volume and image presets; restoring display defaults; G-SYNC, G-SYNC Pulsar and V-Sync; and GPU performance such as a frame-rate limit, a max performance-per-watt mode, and plotting GPU/CPU metrics.

Purpose

G-Assist maps a natural-language request to a single display or GPU control tool: a status query to read current state, or a dedicated tool to change one setting per turn.

Prerequisites

An NVIDIA driver installation that provides G-Assist on this machine (the gassist MCP server at the path in Setup).
An MCP-capable host configured with the gassist server (see Setup).
No API keys are required.

Setup

The G-Assist tools come from a stdio MCP server that the host launches. The executable ships at:

C:\ProgramData\NVIDIA Corporation\nvtopps\rise\rise_mcp.exe

That path contains a space (NVIDIA Corporation), and some hosts (for example Cursor) start MCP servers through cmd.exe, which fails to spawn a command whose path contains a space. Register the space-free 8.3 short path instead; it resolves to the same executable and works everywhere:

C:\PROGRA~3\NVIDIA~1\nvtopps\rise\rise_mcp.exe

Register it with your host under a server name (this skill uses gassist). Most hosts use an mcpServers map like this:

{
  "mcpServers": {
    "gassist": {
      "command": "C:\\PROGRA~3\\NVIDIA~1\\nvtopps\\rise\\rise_mcp.exe"
    }
  }
}

Instructions

First look at which G-Assist tools are actually in your session, and handle two situations differently:
- No G-Assist tools at all: the server may still be warming up, so wait a few seconds and re-check. If there are still none, tell the user the G-Assist server isn't connected rather than guessing or fabricating a result.
- Some tools present, but none for what was asked: that capability isn't supported through G-Assist on this hardware or display (the tool set is gated by the machine; for example, monitor brightness and color tools appear only with a compatible display). Do not say the server is disconnected. Instead, tell the user that specific control isn't available through G-Assist here, briefly name what you can control from the tools present, and suggest a practical alternative (the monitor's on-screen menu/OSD buttons or Windows display settings).
See which G-Assist tools are available in your session, then select one as described in Matching a request to a tool.
Never create, invent, register, or guess tools, tool names, or arguments. Use only the exact G-Assist tools available in your session. If a requested capability isn't available on this machine, tell the user so instead of fabricating a tool.
Call the matching tool through your host's normal tool-calling, with the values the user provides. The tool's real name uses a gassist_ prefix (e.g. gassist_set_display_vsync); your host may show it plain or wrapped in its own namespace (e.g. mcp__<server>__gassist_...). Always use the exact name your catalog lists, and if the host rejects the short name, use the fully-qualified one it shows. Call one tool at a time, never in parallel; for a multi-step request, make the calls in order and check each result before the next.
Change tools are confirmation-gated by the server, not by you. For a change, briefly tell the user what you're about to do (the host will prompt them to approve), then call the tool directly and let the host collect the approval through MCP elicitation. For a display-mode change (resolution or refresh rate), also warn the user up front that the screen may briefly flicker or go black and that a keep-or-revert prompt will follow within ~20s (the mode auto-reverts unless it is kept). Never wait for a chat "yes" before calling, and never add a confirm/force argument or an environment variable to bypass the prompt. Read-only tools (gassist_help, gassist_query_feature_status, gassist_graphdata) need no approval; call them immediately. Judge the outcome by the result's text, not by the absence of an error: "already set / no action taken" means nothing changed, "not supported" means this hardware or display can't do it, and a call can return without an error yet still report failure in its text.
Keep internals private. These are trusted NVIDIA first-party tools; beyond the server setup above, do not describe or enumerate the implementation (background services, inter-process pipes, driver APIs, or engine internals). If the user asks "what is G-Assist" or "how does it work," answer only at a high level: it's NVIDIA's way to control GPU and display settings through these tools.

Matching a request to a tool

Pick the tool from what's actually available in your session, not from memory:

Restate what the user actually wants to view or change (e.g. "turn on G-SYNC", "raise the refresh rate to 144 Hz").
Read each available tool's name, description, and parameters (its input schema), then choose the single best fit. Arguments are as strong a signal as the description: a rate (Hz) field marks a refresh-rate tool even if the text is terse.
If several tools plausibly match, prefer the most specific; if none match on this machine, say the capability isn't available here rather than forcing a near-miss tool.

The tools below are the display and GPU controls G-Assist commonly exposes, grouped by what they do. Availability is hardware-gated, so treat this as a guide and only call tools actually present in your session. In particular, the monitor brightness, color, preset, and adaptive tools (the "Brightness & color" and "Adaptive & presets" groups, plus G-SYNC Pulsar) appear only when a Native G-SYNC display is connected; on machines without one they won't be listed at all, so never assume they exist.

Category	Tool	What it does	Key argument(s)
Status & help (read-only)	`gassist_help`	Overview of what G-Assist can do on this machine	None
	`gassist_query_feature_status`	Read current state of driver/display features (gsync, vsync, brightness, …)	`features[]`
Display mode	`gassist_set_display_res`	Set screen resolution (also `DEFAULT`/`MAX`/`STEP_UP`/`STEP_DOWN`); the screen may flicker and the mode auto-reverts in ~20s unless the host's keep prompt is confirmed	`res` (a value the panel lists)
	`gassist_set_display_refreshrate`	Set refresh rate in Hz; valid rates come from the connected panel, so a value like 144 may not exist on every display	`rate` (integer, must be a rate the panel lists)
Brightness & color	`gassist_set_display_brightness`	External-monitor brightness (0-100%)	`percentage`
	`gassist_set_display_contrast`	External-monitor contrast (50-150)	`contrast`
	`gassist_set_display_gamma`	Display gamma; fixed set of levels, not a range	`gamma` (string enum: "1.2", "1.4", "1.6", "1.8", "2.0", "2.2", "2.4", "2.6")
	`gassist_set_display_color_temp`	Color temperature in Kelvin; fixed set, not a range	`kelvin` (integer enum: 4000, 5000, 6500, 7500, 8200, 9300, 10000)
	`gassist_set_display_color_balance`	Color saturation (global % or 6-axis)	`percentage` or `red/yellow/green/cyan/blue/magenta`
	`gassist_set_display_rgb_gain`	RGB gain (global % or per-channel)	`percentage` or `red/green/blue`
	`gassist_set_display_volume`	Monitor/system volume (0-100%)	`percentage`
Adaptive & presets	`gassist_set_adaptive_brightness`	Auto-adjust brightness to room light (overrides manual)	`enable_brightness` (bool)
	`gassist_set_adaptive_color`	Auto-adjust color temperature to room light (overrides manual)	`enable_color` (bool)
	`gassist_set_monitor_preset`	Switch image preset `DEFAULT`/`ESPORTS` (native G-SYNC)	`preset`
	`gassist_restore_display_default_settings`	Reset chosen display settings to defaults	`settings[]` string enum, these are the only valid keys: COLOR, BRIGHTNESS, CONTRAST, GAMMA, PRESET (1-5 items, unique). There is no restore key for RGB gain, color balance, volume, or color temperature
Sync & latency	`gassist_set_display_vsync`	Enable/disable V-Sync	`enable` "0"/"1"
	`gassist_set_display_gsync`	Enable/disable G-SYNC	`enable` "0"/"1"
	`gassist_set_gsync_pulsar`	Enable/disable G-SYNC Pulsar (reduce motion blur; needs 240/360 Hz)	`enabled` (bool)
GPU performance	`gassist_frl`	Frame-rate limiter (FPS; 0 = unlimited)	`fps`
	`gassist_maxppw`	Max performance-per-watt mode with a target FPS cap	`enable` "0"/"1", `fps` one of "0"/"30"/"60"/"120"/"144" (strings)
	`gassist_graphdata`	Plot GPU/CPU metrics over time	`metrics[]`, `time` "1"-"59" (string, e.g. "2" not 2), `unit` "secs" or "mins"

Read first, change second. For "is X on / what is X / check X" phrasings, call a read-only query tool directly. Use a change tool only when the user explicitly asks to change something.
Confirmation is the server's job. State the change, then call the tool directly; don't wait for a chat "yes" or add a confirm/force argument. (Full rule, including the display-mode keep-or-revert warning, is in Instructions step 5.)
One call at a time, never in parallel. A compound request ("set the refresh rate and turn on G-SYNC") is fine: make the separate calls in a sensible order and check each result before the next; just don't issue them simultaneously. Do only what the user asked. For "set up for competitive shooters", that is: (1) gassist_query_feature_status to read the current state, (2) gassist_set_display_vsync with enable "0" to turn V-Sync off, (3) gassist_set_display_refreshrate to the panel's max, checking each result before the next (three calls or fewer); don't also change G-SYNC, Pulsar, or presets unless the user asked.

Inputs

Tool arguments come only from what the user explicitly provides for the current request, matched to the selected tool's parameters (its input schema):

Required values: every field the tool's parameters list as required must be supplied. If a required argument is missing, ask the user for it rather than guessing a value.
Optional values: include only when the user specifies them; otherwise omit them and let the tool apply its defaults.

Do not infer, reuse, or carry over values across requests.

Examples

Field names and values come from the chosen tool's own parameters; confirm them against the live tool, since shapes vary (some take a percentage, some a "0"/"1" string).

"Is G-SYNC on?": read-only status check, safe to call directly: gassist_query_feature_status with features: ["gsync"].
"Set my refresh rate to 144 Hz" is a change: tell the user you'll change it (the host will confirm), then call gassist_set_display_refreshrate directly with a rate the panel actually lists. Valid rates come from the connected display, so 144 may not exist; if it isn't available, say so and offer the highest rate the panel supports.
"Make my screen brighter": if a brightness tool is present, pick by intent: gassist_set_display_brightness with a percentage (or, to follow room lighting, the different gassist_set_adaptive_brightness). If no brightness tool is present but others are, don't say the server is down; reply along the lines of: "I don't have a brightness tool in the G-Assist connector on this display; I can control things like resolution, refresh rate, V-Sync, the frame-rate limit, and GPU/CPU metrics. To change brightness, use your monitor's OSD buttons or Windows display settings."

You only choose the tool name and its arguments (which map 1:1 to the tool's inputSchema); your host formats and sends the underlying MCP call for you.

Troubleshooting

Every tool call returns a result message; validate it and handle errors before reporting success. On any error, relay the tool's message to the user and do not blindly retry; use the table below to decide the next step.

Symptom	Cause	Fix
G-Assist tools missing from your session	Server not connected or still warming up	Wait a few seconds and re-check your available tools; if still missing, tell the user the G-Assist server isn't connected.
Tool call reports "not supported"	This hardware or display can't do it	Report it to the user; do not retry the same change with another tool.
A requested resolution or refresh rate is rejected (not in the panel's list)	The value isn't one the connected display supports	Tell the user it isn't available and offer the highest or closest value the panel does support; don't retry the same value.
A change returns without an error, but the result text says it didn't happen	A failed change can still come back with `isError: false`	Judge success by the result's text, not the error flag; report the failure and don't claim success.
Tool call reports "already set / no action taken"	Value already applied	Treat as success; nothing to change.
A display-mode change flickers and a second prompt appears	Expected keep-or-revert: the mode auto-reverts in ~20s unless kept	Treat the second prompt as the keep-or-revert question, not an error; don't call the tool again; report whether it was kept or reverted.
The tool for what the user asked isn't in your session, but other G-Assist tools are	Gated off for this hardware/display	Don't say the server is disconnected: say that specific control isn't available through G-Assist here, name what you can control, and point to the monitor OSD or Windows display settings; never invent a tool.
Short tool name rejected (e.g. "not a deferrable tool") or a batched call refused	Host-specific tool naming/batching	Use the fully-qualified name the host lists (often `mcp__<server>__<tool>`) and call one tool at a time (never in parallel).

Limitations

Only the G-Assist tools available in your session on the current machine can be used; the set varies by hardware and display (some display/color tools require a native G-SYNC display).
Tools act on real hardware; follow the change-confirmation and one-call-at-a-time rules in Instructions.
This skill does not install or launch the server; the host launches it (see Setup). Never run the executable yourself.

Files

ATTRIBUTION.mdAdded by AutoGineer946 B
BENCHMARK.md9.2 KiB
LICENSELicence file added by AutoGineer18.3 KiB
SKILL.md15.6 KiB
evals/EVAL.md4.7 KiB
evals/evals-hardware.json22.1 KiB
evals/evals.json12.0 KiB
skill-card.md3.9 KiB
skill.oms.sig4.9 KiB

evals/evals-hardware.json

{
  "skill_name": "g-assist-mcp-skill",
  "evals": [
    {
      "id": "g-assist-mcp-skill-hw-001",
      "prompt": "Is V-Sync currently on?",
      "expected_output": "The current V-Sync state, read back from the machine. The agent should answer with a read-only query and change nothing.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Listed the available tools before calling one",
        "Called gassist_query_feature_status with the vsync feature",
        "Reported the state without changing it",
        "Did not call gassist_set_display_vsync"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-002",
      "prompt": "Turn off V-Sync.",
      "expected_output": "gassist_set_display_vsync is destructive and confirmation-gated, so the host asks the user to approve and the change is applied only on approval. The agent should relay the outcome from the result text.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Called gassist_set_display_vsync with enable \"0\" (a string, not a boolean)",
        "Let the host collect the user's confirmation rather than supplying one",
        "Did not include a confirm argument in the tool call",
        "Reported the outcome based on the text of the result"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-003",
      "prompt": "Change my display resolution to 1920x1080.",
      "expected_output": "The resolution change is confirmed once before it is applied and once after, because it auto-reverts in about 20 seconds unless kept. Both prompts are expected and the tool is called once.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Took the resolution value from the live tool schema rather than a remembered list",
        "Called gassist_set_display_res exactly once",
        "Warned the user the screen may flicker and a second keep-or-revert prompt will follow",
        "Treated the second prompt as the expected keep-or-revert question, not an error",
        "Did not call the tool again to finish or retry the change",
        "Reported accurately whether the new mode was kept or reverted"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-004",
      "prompt": "Set my refresh rate to 500 Hz.",
      "expected_output": "No consumer panel supports 500 Hz, so either the value is absent from the live enum or the call comes back with prose saying it could not be done. Either way the agent must report failure, not success.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Checked the live refresh rate enum for the requested value",
        "Read the text of the result rather than relying on the isError flag",
        "Reported that the refresh rate was not changed",
        "Offered the highest rate the panel actually supports",
        "Did not report success because the call returned without an error"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-005",
      "prompt": "Set this PC up for competitive shooters.",
      "expected_output": "A short sequence: read the current V-Sync and G-SYNC state, turn V-Sync off, and raise the refresh rate to the panel's maximum. The agent should explain the gated changes before triggering the prompts.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Read current state with gassist_query_feature_status before changing anything",
        "Used three or fewer tool calls",
        "Told the user which changes need confirmation before triggering the prompts",
        "Took the refresh rate value from the live enum",
        "Summarised what is now true based on the result text"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-006",
      "prompt": "What has my GPU temperature and utilisation been doing over the last two minutes?",
      "expected_output": "A read-only metrics plot over the requested window. The agent should request GPU temperature and GPU utilisation for two minutes.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Called gassist_graphdata with GPU_TEMP and GPU_UTIL",
        "Set time to 2 and unit to mins",
        "Changed no settings"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-007",
      "prompt": "Set my external monitor's colour temperature to 6500K.",
      "expected_output": "gassist_set_display_color_temp accepts a fixed Kelvin enum that includes 6500, and is available only when the display supports it. If the tool is present the agent should call it with kelvin 6500; if it is gated off on this display it should say so rather than invent a tool.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Checked that gassist_set_display_color_temp is present in the available tools",
        "Called it with kelvin 6500 taken from the tool's enum, or reported it is unavailable on this display",
        "Did not invent a tool name or a non-enum Kelvin value"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-008",
      "prompt": "Cap my frame rate at 120 FPS.",
      "expected_output": "A frame-rate limit set with the frame-rate limiter tool. The agent should select gassist_frl with fps 120 and must not change the refresh rate instead.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Listed the available tools before calling one",
        "Called gassist_frl with fps 120",
        "Did not change the refresh rate instead"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-009",
      "prompt": "Turn on G-SYNC.",
      "expected_output": "gassist_set_display_gsync enables G-SYNC and is confirmation-gated, so the host collects approval. The agent should call it with enable \"1\" (a string) and relay the outcome, without adding a confirm argument.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Called gassist_set_display_gsync with enable \"1\" (a string, not a boolean)",
        "Let the host collect the user's confirmation rather than supplying one",
        "Did not enable G-SYNC Pulsar or a different tool instead"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-010",
      "prompt": "Reduce the motion blur on my monitor.",
      "expected_output": "Motion blur is reduced by G-SYNC Pulsar, a separate tool from G-SYNC. The agent should select gassist_set_gsync_pulsar (enabled true) on a compatible monitor, or report it is unavailable if the display does not support it - not fall back to plain G-SYNC.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Selected the G-SYNC Pulsar tool (gassist_set_gsync_pulsar) rather than plain G-SYNC",
        "Called it to enable Pulsar, or reported it is unavailable on this display",
        "Did not silently substitute gassist_set_display_gsync"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-011",
      "prompt": "Make my monitor adjust its brightness to the room automatically.",
      "expected_output": "Automatic, ambient-light brightness is Adaptive Brightness - a different tool from a fixed brightness percentage. The agent should select gassist_set_adaptive_brightness to enable it, rather than gassist_set_display_brightness.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Selected gassist_set_adaptive_brightness rather than the fixed-percentage brightness tool",
        "Enabled adaptive brightness, or reported it is unavailable on this display",
        "Did not set a fixed brightness percentage instead"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-012",
      "prompt": "Make my GPU as power-efficient as possible but keep at least 60 FPS.",
      "expected_output": "This is the max performance-per-watt mode with a target FPS, not a plain frame-rate limit. The agent should select gassist_maxppw and enable it with the 60 FPS target taken from its enum, not gassist_frl.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Selected gassist_maxppw rather than the frame-rate limiter",
        "Enabled the mode with fps 60 taken from the tool's allowed values",
        "Did not use gassist_frl to cap the frame rate instead"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-013",
      "prompt": "Switch my monitor to esports mode.",
      "expected_output": "gassist_set_monitor_preset switches the monitor image preset between DEFAULT and ESPORTS on supported monitors. The agent should call it with preset ESPORTS, or report it is unavailable if the monitor does not support presets.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Called gassist_set_monitor_preset with preset ESPORTS",
        "Took the preset value from the tool's enum",
        "Reported unavailable rather than inventing a preset if the monitor lacks support"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-014",
      "prompt": "Set my monitor brightness to 40%.",
      "expected_output": "A fixed brightness level via gassist_set_display_brightness with percentage 40 (external monitors only; not laptop panels). The agent should call it once and report the result.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Called gassist_set_display_brightness with percentage 40",
        "Did not use adaptive brightness for a fixed value",
        "Reported the outcome, or that it is unsupported on a laptop panel"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-015",
      "prompt": "Reset my monitor's colours back to default.",
      "expected_output": "gassist_restore_display_default_settings resets the requested settings; it is a change, so confirmation is collected by the host. The agent should call it with COLOR in the settings list and let the host confirm, not add a confirm argument or reset unrelated settings.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Called gassist_restore_display_default_settings with COLOR in the settings list",
        "Let the host collect confirmation rather than supplying one",
        "Did not reset unrelated settings such as brightness or gamma"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-016",
      "prompt": "What can G-Assist do on this machine?",
      "expected_output": "A read-only overview from gassist_help describing the capabilities actually available on this machine. The agent should call the help tool and change nothing.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Called gassist_help",
        "Changed no settings",
        "Summarised the capabilities from the tool result rather than from memory"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-017",
      "prompt": "Set my monitor contrast to 75.",
      "expected_output": "gassist_set_display_contrast takes an integer in the 50-150 range (external monitors only, not laptop panels). The agent should call it with contrast 75 as an integer and report the result.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Called gassist_set_display_contrast with contrast 75 as an integer",
        "Did not treat contrast as a percentage or a fixed enum",
        "Reported the outcome, or that it is unsupported on a laptop panel"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-018",
      "prompt": "Set my display gamma to 2.2.",
      "expected_output": "gamma is a string enum and 2.2 is one of its allowed levels. The agent should call gassist_set_display_gamma with gamma \"2.2\" as a string, not the number 2.2.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Called gassist_set_display_gamma with gamma \"2.2\" as a string, not a float",
        "Took the value from the tool's enum",
        "Reported the outcome"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-019",
      "prompt": "Set my display gamma to 2.1.",
      "expected_output": "2.1 is not one of the allowed gamma levels (1.2, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4, 2.6). The agent should not force a non-enum value; it should offer the nearest allowed level (2.0 or 2.2) or ask the user to choose.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Recognised 2.1 is not one of the allowed gamma levels",
        "Did not call gassist_set_display_gamma with an out-of-enum value",
        "Offered a valid nearby level (2.0 or 2.2) or asked the user to choose",
        "Did not report success for an unsupported value"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-020",
      "prompt": "Set my colour temperature to 6000K.",
      "expected_output": "6000 is not in the Kelvin enum (4000, 5000, 6500, 7500, 8200, 9300, 10000). The agent should not send a non-enum value; it should offer the nearest allowed value (6500) or ask the user.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Recognised 6000 is not an allowed Kelvin value",
        "Did not call gassist_set_display_color_temp with a non-enum value",
        "Offered the nearest allowed value (e.g. 6500) or asked the user to choose",
        "Did not report success for an unsupported value"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-021",
      "prompt": "Increase my monitor's colour saturation to 80%.",
      "expected_output": "gassist_set_display_color_balance accepts either a global percentage or a full 6-axis set, mutually exclusive. A single overall value maps to the global percentage form (percentage 80).",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Called gassist_set_display_color_balance with percentage 80",
        "Used the global percentage form, not per-axis",
        "Did not mix the global percentage with per-axis arguments"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-022",
      "prompt": "Set my monitor saturation per channel to red 60, yellow 50, green 50, cyan 50, blue 70, magenta 50.",
      "expected_output": "This is the 6-axis form of gassist_set_display_color_balance, which requires all six channels (red, yellow, green, cyan, blue, magenta) together. The agent should send all six and not a global percentage.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Called gassist_set_display_color_balance with all six axes (red, yellow, green, cyan, blue, magenta)",
        "Used the per-axis form, not the global percentage",
        "Did not mix the global percentage with the per-axis arguments"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-023",
      "prompt": "Set my monitor's RGB gain to 90%.",
      "expected_output": "gassist_set_display_rgb_gain accepts either a global percentage or per-channel red/green/blue, mutually exclusive. An overall value maps to the global percentage (percentage 90).",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Called gassist_set_display_rgb_gain with percentage 90",
        "Used the global percentage form, not per-channel",
        "Did not mix global and per-channel arguments"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-024",
      "prompt": "Set my monitor's RGB gain to red 80, green 75, blue 70.",
      "expected_output": "This is the per-channel form of gassist_set_display_rgb_gain, which requires red, green, and blue together. The agent should send all three and not a global percentage.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Called gassist_set_display_rgb_gain with red 80, green 75, and blue 70",
        "Used the per-channel form with all three channels, not the global percentage",
        "Did not mix global and per-channel arguments"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-025",
      "prompt": "Set my monitor volume to 30%.",
      "expected_output": "gassist_set_display_volume sets monitor or system volume as an integer percentage (0-100). The agent should call it with percentage 30.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Called gassist_set_display_volume with percentage 30",
        "Reported the outcome"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-026",
      "prompt": "Make my monitor adjust its colour temperature to the room automatically.",
      "expected_output": "Automatic, ambient-light colour is Adaptive Color, a different tool from a fixed Kelvin value. The agent should select gassist_set_adaptive_color with enable_color true, not gassist_set_display_color_temp.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Selected gassist_set_adaptive_color rather than the fixed colour-temperature tool",
        "Enabled adaptive colour with enable_color true (a boolean), or reported it is unavailable on this display",
        "Did not set a fixed Kelvin value instead"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-027",
      "prompt": "Reset my monitor's RGB gain and colour balance back to default.",
      "expected_output": "gassist_restore_display_default_settings only supports the keys COLOR, BRIGHTNESS, CONTRAST, GAMMA, and PRESET. There are no restore keys for RGB gain or colour balance, so the agent should say those specific resets are not available rather than invent keys.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Recognised RGB gain and colour balance are not valid restore keys",
        "Did not invent settings keys or exceed the five allowed values",
        "Told the user those specific resets are not available (only COLOR, BRIGHTNESS, CONTRAST, GAMMA, PRESET)",
        "Did not call the tool with unsupported keys"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-028",
      "prompt": "Remove my frame rate cap.",
      "expected_output": "gassist_frl uses fps 0 to mean unlimited. The agent should call gassist_frl with fps 0 to remove the cap, not disable it via another tool.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Called gassist_frl with fps 0 to remove the cap",
        "Did not use a different tool to remove the limit",
        "Reported the outcome"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-029",
      "prompt": "Turn off the power-efficiency mode.",
      "expected_output": "gassist_maxppw toggles max performance-per-watt mode; enable and fps are both required string values. To turn it off the agent should call gassist_maxppw with enable \"0\" and a valid fps string, not gassist_frl.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Called gassist_maxppw with enable \"0\" (a string, not a boolean)",
        "Supplied the required fps argument as one of the allowed strings (\"0\", \"30\", \"60\", \"120\", \"144\")",
        "Did not use gassist_frl instead",
        "Reported the outcome"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-030",
      "prompt": "Show my CPU utilisation for the last 30 seconds.",
      "expected_output": "A read-only metrics plot via gassist_graphdata. The agent should request the CPU_UTIL metric with time \"30\" (a string) and unit secs, and change nothing.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Called gassist_graphdata with the CPU_UTIL metric",
        "Set time to \"30\" as a string and unit to secs",
        "Changed no settings"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    },
    {
      "id": "g-assist-mcp-skill-hw-031",
      "prompt": "Reset my display resolution back to the default.",
      "expected_output": "gassist_set_display_res accepts the special value DEFAULT to restore the default resolution. It is a display-mode change, so the same flicker and keep-or-revert behaviour applies.",
      "assertions": [
        "Read g-assist-mcp-skill/SKILL.md",
        "Called gassist_set_display_res with the DEFAULT value",
        "Called gassist_set_display_res exactly once",
        "Warned the user the screen may flicker and a keep-or-revert prompt will follow",
        "Did not call the tool again to keep, revert, or retry the mode change",
        "Did not compute or guess a numeric resolution",
        "Reported whether the mode was kept or reverted"
      ],
      "expected_skill": "g-assist-mcp-skill",
      "expected_script": null
    }
  ]
}

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, Needs an API key

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

schopparapu

Publisher

NVIDIA (Official)

Distributed by

NVIDIA

Source

NVIDIA/skills · skills/g-assist-mcp-skill · commit fce3cca

Licence

Creative Commons Attribution 4.0 International (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE-CC-BY-4.0)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-08

AutoGineer is not affiliated with or endorsed by schopparapu or NVIDIA.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download g-assist-mcp-skill.zip