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

Agent skill

Scenario Unreal Expert

by scenario-labs in scenario-labs/skills

A skill your agent uses when an agent drives Unreal Engine 5.8 on a Mac for any task: Editor Python (the unreal module), headless UnrealEditor-Cmd -run=pythonscript jobs, Epic's Unreal MCP server…

MITAuto-check passedGame Development

Install Scenario Unreal Expert

skills CLI
$ npx skills add scenario-labs/skills --skill scenario-unreal-expert -a claude-code

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

GitHub CLI
$ gh skill install scenario-labs/skills scenario-unreal-expert --agent claude-code

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

Manual copy
$ git clone --depth 1 https://github.com/scenario-labs/skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/game-engines/unreal/scenario-unreal-expert .claude/skills/scenario-unreal-expert && rm -rf skills-src

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

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

Facts

Skill name
scenario-unreal-expert
GitHub stars
946
Token cost
~6.4k tokens
SKILL.md length
2,052 words
Files
11 (incl. scripts, references)
Skills in repo
146
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when an agent drives Unreal Engine 5.8 on a Mac for any task: Editor Python (the unreal module), headless UnrealEditor-Cmd -run=pythonscript jobs, Epic's Unreal MCP server…

  • Works in 6 steps: Execution channels → The expert loop → Persona pipelines → …
  • An agent drives Unreal Engine 5.8 on a Mac for any task: Editor Python (the unreal module)
  • SKILL.md covers 1. Execution channels, 2. The expert loop, 3. Persona pipelines and 4. Shared toolkit (scripts/,…, plus 3 more sections
  • Runs Python scripts from its folder; calls npx

What it does

Scenario Unreal Expert is an agent skill from scenario-labs/skills. Use when an agent drives Unreal Engine 5.8 on a Mac for any task: Editor Python (the unreal module), headless UnrealEditor-Cmd -run=pythonscript jobs, Epic's Unreal MCP server, the Remote Control API, console commands and cvars; when a script breaks on 5.8 (EditorLevelLibrary, Remote Control calls refused, Substrate materials black, MRQ presets); when a level, material, shot or build must be judged by numbers and a screenshot before it is called done; or when a brief must go to the right scenario-unreal-…

Its SKILL.md is about 6.4k tokens, which your agent loads only when the skill is triggered. The skill folder holds 12 other files, including scripts and reference files (for example `references/python-reliability.md`, `references/sources.md` and `references/toolkit-map.md`).

It sits in Game Development, covering Game development. It works with Python, Model Context Protocol and Unreal Engine. The repository describes itself as: Get production-ready images, video, audio, and 3D from any AI agent: skills that pick the right model, price before spending, and keep characters and brands consistent through… The licence is MIT.

When your agent uses it

  • An agent drives Unreal Engine 5.8 on a Mac for any task: Editor Python (the unreal module)
  • Headless UnrealEditor-Cmd -run=pythonscript jobs
  • Epics Unreal MCP server
  • The Remote Control API

Example prompts

  • “/scenario-unreal-expert”

Requirements

  • Python 3
  • Node.js

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Execution channels
  2. The expert loop
  3. Persona pipelines
  4. Shared toolkit (scripts/, in-engine parts not yet run in Unreal)
  5. Top 5.8 traps (full list: references/ue-5.8-traps.md)
  6. macOS specifics

What it can do on your machine

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

  • Tool permissions

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

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 6 files in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • npx

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

  • Network

    No URLs in SKILL.md. Its commands use npx, which can reach the network depending on how they are called.

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

  • Credentials

    Names no API keys, tokens, secrets or passwords.

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

Context cost

Scenario Unreal Expert loads about 6.4k tokens when it runs, and up to ~30k if it reads all its reference files. Until then it costs about 136 tokens; SKILL.md has 2,052 words of instructions outside code blocks.

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

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

Safety

Auto-check passed

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

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

SKILL.md

The full file from scenario-labs/skills at commit f6f8ab7, republished under its MIT licence (© scenario-labs). 2,052 words, ~6,364 tokens.

Download SKILL.mdSave it as .claude/skills/scenario-unreal-expert/SKILL.md (or your agent's skills folder). This skill also uses 10 other files; get the full folder from GitHub.
name
scenario-unreal-expert
description
Use when an agent drives Unreal Engine 5.8 on a Mac for any task: Editor Python (the unreal module), headless UnrealEditor-Cmd -run=pythonscript jobs, Epic's Unreal MCP server, the Remote Control API, console commands and cvars; when a script breaks on 5.8 (EditorLevelLibrary, Remote Control calls refused, Substrate materials black, MRQ presets); when a level, material, shot or build must be judged by numbers and a screenshot before it is called done; or when a brief must go to the right scenario-unreal-* specialist.
license
MIT

Unreal expert (technical director and agent protocol)

Expert Unreal work is a loop run against numbers: set the budget, build one stage, measure it, look at it, fix it, then advance. An agent without a mouse gets there by choosing the right channel for each action, working like the Details panel (one transaction, explicit saves), and never trusting its own eyes alone. This skill is the protocol, the shared toolkit in scripts/, and the map to the team. Target: UE 5.8 on macOS Apple Silicon. If a sibling skill named here is missing from your available skills, ask the user to install it (npx skills add scenario-labs/skills --skill <name>); unattended, proceed from tool schemas and flag the gap.

Status (2026-09-24): UE 5.8 is not installed. Every in-engine call in scripts/ and references/ is not yet run in Unreal. The pure-Python parts ran offline and pass (eight test files, 314 checks on Python 3.14, 311 on 3.9). First action once the engine is installed: tests/code/unreal-expert/run_all.sh --live with UE_TEST_PROJECT set to a scratch project, then references/ue-5.8-traps.md section 7.

1. Execution channels

ChannelUse forRules
Epic Unreal MCP (plugin ModelContextProtocol, Experimental), your MCP client via .mcp.jsonstructured edits covered by shipped toolsets (actors, scene, material instances, Sequencer, PCG, UMG, animation), in the open editorEnable Unreal MCP and All Toolsets; if "connected but can do nothing", add Editor Toolset, which Epic's webinar says the docs omit (Sam Deiter, k0tgmrBuIJc [00:18:13]). Start with -ModelContextProtocolStartServer -ModelContextProtocolPort=8000 or ModelContextProtocol.StartServer; ModelContextProtocol.GenerateClientConfig ClaudeCode writes .mcp.json; editor first, agent second. Calls run serially on the game thread: never overlap them. describe_toolset only for the toolset you need now: Niagara's is "almost a quarter of a million" (k0tgmrBuIJc [00:46:04]). Loopback, no auth.
Editor Python in the running editor (ue_remote.PythonRemote, or a custom Python toolset on the MCP server)loops, audits, anything toolsets lack, screenshotsEnable Python Remote Execution (Project Settings > Plugins > Python). Full unreal API; the editor ticks between calls. One call = one named transaction that reports what it did.
Headless commandlet (ue_run.run_python, UnrealEditor-Cmd <uproject> -run=pythonscript)audits, imports, batch edits, validation, CI, when no editor has the project openNo level loaded (map= loads one), fewer modules, no rendering. The boot waits for the Asset Registry (get_asset_registry().wait_for_completion(), 5.8 batch example); a job passes only on its boot's job-id UE_RESULT line, never on the exit code. A commandlet that saves must not touch a project an open editor has loaded: the editor holds a write lock (Jamie Dale, 0guOMTiwmhk [01:17:18]).
Full editor, one shot (mode="editor": -ExecutePythonScript; mode="latent": ticking boot that quits after)jobs needing full modules; latent: screenshots and renders without a running editor-ExecutePythonScript shuts down right after the script, so nothing ticks; ue_run adds -ScriptErrorsAreFatal (5.5) so a failing script fails the process. Latent jobs are generators: yield = one tick.
Remote Control API (ue_remote.RemoteControl, 127.0.0.1:30010)batched property writes on known objects, live presets, -game buildsOff until WebControl.StartServer. 5.8 disables remote UFUNCTION calls by default with an allow list (5.8 release notes). C++ names, WRITE_TRANSACTION_ACCESS for undo, public EditAnywhere properties only.
Console and cvarsstats, view modes, quality switches, HighResShotFrom Python unreal.SystemLibrary.execute_console_command(world, cmd) [verify]; at launch -DPCVars= (before init, overrides read-only cvars; Profiling with Purpose, C-AjCqjKRSs [00:14:13]), not -ExecCmds. Restore what you change.
Commandlets and UAT (ue_run.run_commandlet, run_uat)DataValidation, ResavePackages -fixupredirects, WorldPartitionBuilderCommandlet, BuildCookRunHeadless; parse the log (ue_run.scan_log).

Capability matrix (from the 5.8 docs and talks; tests/code/unreal-expert/jobs/job_00_probe.py confirms or corrects each row):

ActionMCPPython, running editorHeadless commandletRemote Control
read and edit actors, assets, propertiestoolsetsyesyes (load the level first)public EditAnywhere properties
material instances and parametersMaterialInstanceToolsyesyesproperties only
material graphstoolset (large schema)MaterialEditingLibrary, partial: some pins unexposed (Matt Oztalay, m6mJ9r7ytks [00:13:39])sameno
Blueprint graphs, AnimGraph [verify]Blueprint toolset [verify scope]5.8 BlueprintGraphEditor [verify scope]sameno
Niagara emitters and modulestoolset, huge schemano emitter or module editingnouser parameters
PCG graphsPCG toolset, primitives, fire-and-forget callsgraph API [verify]yesno
screenshots, MRG stills, PIEvia Python toolsetyesno (use mode="latent" or -game render CLI)no
landscape sculpt, foliage paint, Fracture Modenononono
cook, package, validatenonot the cook (in-editor cook removed in 5.9)yes, UATno

Graph editors and viewport tools, substitutes: Blueprints: logic in C++ (code project, Xcode) with data-only Blueprints; template Blueprints duplicated and their defaults set; never 150 Delay nodes or unjustified Event Tick (k0tgmrBuIJc [00:56:45], [00:57:19]). Materials: instances of approved masters; node graphs, never a whole-HLSL Custom node unless required (k0tgmrBuIJc [00:39:27]). Niagara: duplicate template systems, set user parameters. PCG: compose Epic's primitives and example graphs (lDf_y-YPELo [00:05:20]). Control Rig: its "Copy Python Script". Sculpting, painting, fracturing: heightmap import, PCG, Dataflow graphs, or a human step, said plainly.

Write locks and source control: ue_run lists UnrealEditor processes holding the project (ps); pass lock_check="refuse" for jobs that save. 5.8's PythonScript commandlet enables source control before the script, so saves can check out [verify with Perforce]; ResavePackages needs -autocheckout (redirectors doc). Stop when a file you must edit is not checked out (Bardoux, MjjkWH0eT3U [00:55:27]). OFPA changelists are submitted from inside the editor: partial submits leave dangling references (World Partition doc). Content a builder regenerates, such as PCG partition actors, stays out of changelists (TbNZ4GKaTow [00:26:23]).

2. The expert loop

Name the engine call behind every toolkit call, in plans as in reports: a reader without scripts/ must be able to check each step. Write ue_review.screenshot(p, 1920, 1080) (AutomationLibrary.take_high_res_screenshot, fallback HighResShot 1920x1080), cvars and console commands literally, and close with Verified (what ran, with the number, log line or frame that proves it) and Assumed (not run in Unreal, [verify] names, defaults taken). Mapping and template: references/toolkit-map.md.

  1. Brief in numbers. Platform and device class; frame budget in ms per thread and GPU (16.67 at 60 fps, 33.3 at 30; Ari Arnbjörnsson, GuIav71867E [00:03:53]); output resolution and upscaler; scale (world size, actors, NPCs); gameplay or cinematic; references. When silent, take the domain skill's default and write it down.
  2. Preflight. ue_env.preflight() (chip, macOS, Xcode), ue_env.find_project() (plugins, path spaces), and the project settings that change the plan: r.Substrate, Lumen, VSM, Nanite, hardware ray tracing (ue_env.read_ini_value, or the probe). Upgraded projects keep old renderer settings [added].
  3. Build one stage with small idempotent scripts: get-or-create by path, mark what you create, one transaction per logical operation, explicit saves.
  4. Measure. ue_audit.verdict for content; stat unit to classify (Frame, Game, Draw, GPU, RHIT), then Insights (lean capture for "are we on budget", rich with -statnamedevents for "why", about 20% overhead, C-AjCqjKRSs [00:11:27]); ue_stat.budget_check on CSV profiler or TraceQuery JSONL. Profile a cooked Development or Test build on target hardware; this Mac is a proxy for a console. Measure before any rewrite (VMZftEVDuCE [00:16:33]); when Insights cannot explain a hitch, add a sampling profiler (C-AjCqjKRSs [00:17:30]).
  5. Look AND check. Screenshots from fixed camera bookmarks or an MRG still, opened with the image reader, plus ue_review.image_checks: Epic's lighting agent approved an all-white frame (lDf_y-YPELo [00:17:29]). review_images gives flags and a contact sheet in one call. Judge with the domain skill's references/critique.md. After a render, look for 5.8's on-screen exposure-range warning; an MRG frame that differs from the viewport: suspect Game Overrides first (fVg5ihB8Wdc [00:03:33]).
  6. Fix before advancing, one change at a time, with ue_review.compare for before and after parity from the same views.
  7. Deliver with evidence in that format: saved assets and levels, audit and stat JSON, the frames you looked at with their checks, the Verified and Assumed lists.

Never report a level, material, shot or build as done without numbers and a frame you looked at.

Show full SKILL.md (793 more words)Show less

3. Persona pipelines

BriefChainDeliverable
Open world or levelscenario-unreal-world-building, scenario-unreal-materials (landscape, RVT), scenario-unreal-lighting-rendering, scenario-unreal-performancestreamed level, HLODs, budget report
Material kitscenario-unreal-materials, then scenario-unreal-lighting-rendering (test bench), scenario-unreal-performance (shader cost)masters, instances, permutation audit
Lit interior or hero stillscenario-unreal-lighting-rendering (scenario-unreal-materials for emissives), scenario-unreal-cinematics for MRG outputgameplay lighting at budget, EXR still
Gameplay prototypescenario-unreal-gameplay, scenario-unreal-animation, scenario-unreal-vfx for abilities, scenario-unreal-performanceplayable map, automation tests
Character from Mayascenario-unreal-pipeline-automation (import), scenario-unreal-animation, scenario-unreal-gameplayretargeted, locomotion-ready character
Trailerscenario-unreal-cinematics (scenario-unreal-animation, scenario-unreal-lighting-rendering)Sequencer shots, reviewed renders
VFX or destructionscenario-unreal-vfx, scenario-unreal-performancesystems within budget
Batch import and buildscenario-unreal-pipeline-automation, scenario-unreal-performance (packaging)report, validated package
Frame-rate rescuescenario-unreal-performance, routing fixes to ownersproof capture, parity frames

Handoff contract: saved assets in a named folder, the ue_audit.verdict for the receiver's profile with no error, stat or trace numbers when performance matters, the frames the sender looked at with their image_checks, each toolkit call with its engine call, and the Verified and Assumed lists. Units are centimeters, Z-up [added]. Sister teams: scenario-maya-expert (1 unit = 1 cm, Y-up in Maya), scenario-zbrush-expert, scenario-blender-expert; scenario-3d for generated meshes to finish.

4. Shared toolkit (scripts/, in-engine parts not yet run in Unreal)

Import: import sys; sys.path.insert(0, "<this skill>/scripts"). PythonRemote.call adds that folder in the editor for one call.

  • ue_env.py: find_engine(version=None) (editor, editor_cmd, uat, version; UE_ROOT override), find_project(path), preflight(), plan_plugins / enable_plugins (timestamped backup), read_ini_value, xcode_status.
  • ue_run.py: run_python(uproject, script, args=None, map=None, timeout=1800, mode="commandlet"|"editor"|"latent", strict=False, lock_check="warn") returns the UE_RESULT envelope plus log scan and warnings; job side result(obj), args(), in_commandlet(), to_jsonable(), wait_for_registry(); run_commandlet(uproject, name, args), run_uat, build_buildcookrun, launch_editor(mcp_port=), stop_editor, editor_processes, scan_log, parse_ue_result.
  • ue_remote.py: RemoteControl(host, port).info/describe/get_property/set_property/call/batch/search_assets/console, errors carry fix hints; PythonRemote().open/exec/call/close; McpHttp().health() (reachability, tool search); loopback_only(port), pie_path, cdo_path, python_cdo_path.
  • ue_review.py: in editor set_camera, screenshot, wait_screenshot, screenshot_views, camera_views_from_actors, render_still (MRG or MRQ preset, own queue), wait_render; offline image_checks (histogram, clipped, crushed, EV-like, center vs surround, all_white, all_black, uniform, alpha), image_verdict, compare, contact_sheet, review_images, wait_for_file, build_render_command.
  • ue_audit.py: in editor audit_assets(paths, rules, profile), collect_facts; anywhere evaluate, build_report, verdict(report, "game"|"cinematic"|"mobile"|"prototype"); Epic prefixes, texture size and compression, Nanite, collision, LODs, slots, instance parents, Custom HLSL, After-DOF translucency, redirectors.
  • ue_stat.py: parse_stat_unit, parse_csv_profile + csv_frames, parse_jsonl + sniff_schema + trace_frames + timer_totals, budget_check(frames, target_ms), bound_by, summarize.

Domain skills add scripts/ue_<domain>.py; they never copy these. The engine call behind each function: references/toolkit-map.md.

5. Top 5.8 traps (full list: references/ue-5.8-traps.md)

  • EditorLevelLibrary and EditorAssetLibrary are the old API: EditorActorSubsystem, LevelEditorSubsystem, UnrealEditorSubsystem, EditorAssetSubsystem via unreal.get_editor_subsystem. Epic's own 5.8 samples still use the old names. load_level discards unsaved changes; delete_asset force-deletes and may clear undo; destination_name is ignored under Interchange.
  • Substrate defaults depend on project age: on for projects created in 5.7+, legacy for upgraded ones until opted in; Substrate materials render black with it off; no Metallic pin; Mac listed with known issues. Read r.Substrate before authoring.
  • Mac feature support: Apple Silicon only; Nanite and VSM Beta on M2+; Lumen HWRT and MegaLights Experimental on M2+; path tracing via Metal, macOS 26.4+. Xcode: Epic lists 26.0 minimum, 26.1.1 recommended, 26.4 incompatible; this Mac has 26.6, unlisted: verify a C++ build.
  • MRG renames: Movie Render Graph Production Ready, new features graph-only, MRQ presets legacy, queue default "Basic"; MoviePipelinePrimaryConfig (not Master); set_graph_preset() for graph jobs; end frames exclusive; H.264 node Windows only.
  • Remote Control defaults: server off until started, remote UFUNCTION calls refused by default in 5.8, 127.0.0.1 only; opening DefaultBindAddress to the LAN likely exposes the unauthenticated MCP server too [added inference].

6. macOS specifics

  • Launcher installs land in /Users/Shared/Epic Games/UE_5.8/; the editor is Engine/Binaries/Mac/UnrealEditor.app/Contents/MacOS/UnrealEditor; the -Cmd location is [verify] and find_engine falls back to the editor with -run=; UAT is RunUAT.sh; cook platform Mac.
  • Keep the Unreal project in a path without spaces (Allar style guide) [verify impact]; the toolkit stages jobs in a space-free folder anyway.
  • Metal only: DX11, DX12 and Vulkan tips do not apply; RenderDoc does not support Metal, use Xcode's Metal debugger [added]; Metal System Trace shows shader compiles and thermal throttling that invalidate captures (ufPtQEtk-RQ [00:14:06], [00:18:17]). Insights memory callstacks are not listed for Mac. Outside Insights, the Mac sampling profiler is Instruments Time Profiler [added].
  • Docs show Ctrl shortcuts and Windows paths: translate to Cmd [verify] and POSIX paths. A MacBook has no numpad: rebind the Gameplay Debugger's numpad category keys (tranek GAS guide 6.2, in the version deltas).
  • Never kill an editor you did not launch; save before stopping one you did.

References

  • references/ue-5.8-traps.md: every 5.8 change that breaks remembered code or old tutorials, with sources, and the first-run checklist. Load before writing code from memory.
  • references/toolkit-map.md: the engine call, command or cvar behind every toolkit function, and the report format (engine call per step, Verified and Assumed).
  • references/python-reliability.md: unreal module idioms and procedures (subsystems, paths, transactions, saving, get-or-create, marking what you create, the write lock and source control, latent work, imports, raw screenshot loop).
  • references/sources.md: every source, with credentials, URLs and best timestamps.

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

Files

SKILL.md and 10 other files (scripts, references) in skills/game-engines/unreal/scenario-unreal-expert of scenario-labs/skills.

  • SKILL.md
  • references/python-reliability.md
  • references/sources.md
  • references/toolkit-map.md
  • references/ue-5.8-traps.md
  • scripts/ue_audit.py
  • scripts/ue_env.py
  • scripts/ue_remote.py
  • scripts/ue_review.py
  • scripts/ue_run.py
  • scripts/ue_stat.py

Open the folder on GitHubat commit f6f8ab7

Compare with similar skills

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

Scenario Unreal Expert compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Scenario Unreal Expert this skillscenario-labs/skills946—~6.4kAutomated safety check: PassMIT
Unreal Enhanced Input Setupkevinpbuckley/VibeUE730—~2.4kAutomated safety check: PassMIT
Vibeuekevinpbuckley/VibeUE730—~5.2kAutomated safety check: PassMIT
Unreal Asset Import and Exportkevinpbuckley/VibeUE730—~6.5kAutomated safety check: PassMIT
Unreal BridgeTornLux/UnrealBridge306—~8.4kAutomated safety check: NotesMIT
Unreal Blueprint Authoringflopperam/unreal-engine-mcp1.1k—~1.6kAutomated safety check: PassNone

Similar skills

  • Unreal Enhanced Input Setup

    kevinpbuckley/VibeUE

    Creates and wires Unreal Engine Enhanced Input assets through VibeUE's InputService: Input Actions, Mapping Contexts, key bindings, triggers and modifiers.

    730 GitHub stars~2.4k tokensUpdated 3 days ago
    Game DevelopmentAuto-check passed

  • Vibeue

    kevinpbuckley/VibeUE

    Unreal Engine 5 development using the VibeUE Python API. An agent skill from kevinpbuckley/VibeUE.

    730 GitHub stars~5.2k tokensUpdated 3 days ago
    Game DevelopmentAuto-check passed

  • Unreal Asset Import and Export

    kevinpbuckley/VibeUE

    Imports files into Unreal Engine, exports textures, reads the Content Browser selection and checks open assets via VibeUE, plus mesh reimport material fixes.

    730 GitHub stars~6.5k tokensUpdated 3 days ago
    Game DevelopmentAuto-check passed

  • Unreal Bridge

    TornLux/UnrealBridge

    Execute Python scripts inside a running Unreal Engine 5.3+ editor via TCP bridge.

    306 GitHub stars~8.4k tokensUpdated 10 days ago
    Game DevelopmentAuto-check: notes

  • Unreal Blueprint Authoring

    flopperam/unreal-engine-mcp

    Walks an agent through creating and editing Unreal Engine Blueprints with the Flopperam MCP's bp_* tools, from inspection to commit and verification.

    1.1k GitHub stars~1.6k tokensUpdated 3 mo ago
    Game DevelopmentAuto-check passed

  • UMG Material MCP

    winyunq/UnrealMotionGraphicsMCP

    Creates, edits and compiles Unreal Engine 5.8 material assets as one HLSL Custom node through the UMG MCP bridge, instead of editing .uasset files directly.

    210 GitHub stars~913 tokensUpdated 2 mo ago
    Game DevelopmentAuto-check passed

More from scenario-labs/skills

All 146 skills in this repo

  • Scenario Blender Grease Pencil

    scenario-labs/skills

    A skill your agent uses when drawing or animating with Grease Pencil in Blender 5.x from Python: 2D or 2.5D illustration, frame-by-frame animation, a cutout or part-based 2D character, strokes with…

    946 GitHub stars~4.5k tokensUpdated yesterday
    Auto-check passed

  • Scenario Blender Hair

    scenario-labs/skills

    A skill your agent uses when grooming hair or fur in Blender with hair curves, such as a character hairstyle, animal fur, procedural fur in geometry nodes, or hair cards and mesh hair for games.

    946 GitHub stars~4.7k tokensUpdated yesterday
    Auto-check passed

  • Scenario Blender Lighting Rendering

    scenario-labs/skills

    A skill your agent uses when lighting, rendering or compositing in Blender: light a character, product or hero shot, interior at dusk or night, three-point or motivated lighting, sun and sky, HDRI…

    946 GitHub stars~5k tokensUpdated yesterday
    Auto-check passed

  • Scenario Chatgpt Pet Create

    scenario-labs/skills

    A skill your agent uses when creating a ChatGPT pet or Codex pet with Scenario: hatching an animated companion from a text idea, a character, mascot or brand cue, or reference photos and art; making…

    946 GitHub stars~3.6k tokensUpdated yesterday
    Auto-check passed

  • Scenario Godot Animation

    scenario-labs/skills

    A skill your agent uses when animating characters or scenes in Godot 4.7: AnimationPlayer clips and RESET, AnimationTree state machines and blend spaces built in code, Mixamo or glTF import, loop…

    946 GitHub stars~4.7k tokensUpdated yesterday
    Auto-check passed

  • Scenario Godot Audio

    scenario-labs/skills

    A skill your agent uses when adding or fixing sound in Godot 4.7: audio buses and effects, volume sliders, 'too many sounds', combat audio with hundreds of enemies, sounds clipping or distorting, 3D…

    946 GitHub stars~4.7k tokensUpdated yesterday
    Auto-check passed

Works with

Categories

Questions about Scenario Unreal Expert

What does Scenario Unreal Expert do?

A skill your agent uses when an agent drives Unreal Engine 5.8 on a Mac for any task: Editor Python (the unreal module), headless UnrealEditor-Cmd -run=pythonscript jobs, Epic's Unreal MCP server…. Scenario Unreal Expert is an agent skill from scenario-labs/skills.

When should I use Scenario Unreal Expert?

Scenario Unreal Expert fits situations like: an agent drives Unreal Engine 5.8 on a Mac for any task: Editor Python (the unreal module); headless UnrealEditor-Cmd -run=pythonscript jobs; epics Unreal MCP server; the Remote Control API.

How do I install Scenario Unreal Expert in Claude Code?

Run `npx skills add scenario-labs/skills --skill scenario-unreal-expert -a claude-code`. Or copy the skill folder (skills/game-engines/unreal/scenario-unreal-expert in scenario-labs/skills) into .claude/skills/scenario-unreal-expert in your project. Claude Code loads it when a task matches its description.

How do I install Scenario Unreal Expert in Codex?

Run `npx skills add scenario-labs/skills --skill scenario-unreal-expert -a codex`. Or copy the skill folder (skills/game-engines/unreal/scenario-unreal-expert in scenario-labs/skills) into .agents/skills/scenario-unreal-expert in your project. Codex loads it when a task matches its description.

Can I use Scenario Unreal Expert in Cursor, Gemini CLI or GitHub Copilot?

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

What does Scenario Unreal Expert need to run?

Going by SKILL.md and its folder, Scenario Unreal Expert needs Python for the scripts in its folder and the command-line tools its instructions call (npx). Our summary lists: Python 3; Node.js.

Does Scenario Unreal Expert access the network?

SKILL.md contains no URLs. Its commands use npx, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Scenario Unreal Expert safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Scenario Unreal Expert use?

Scenario Unreal Expert is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Scenario Unreal Expert use?

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

What are the alternatives to Scenario Unreal Expert?

Skills that share tags, products or a category with Scenario Unreal Expert: Unreal Enhanced Input Setup (kevinpbuckley/VibeUE, 730 stars), Vibeue (kevinpbuckley/VibeUE, 730 stars), Unreal Asset Import and Export (kevinpbuckley/VibeUE, 730 stars) and Unreal Bridge (TornLux/UnrealBridge, 306 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Scenario Unreal Expert?

scenario-labs (a GitHub organization) maintains it in scenario-labs/skills, which has 946 GitHub stars. The repository holds 146 skills in this directory. The repository was last updated on October 10, 2026.

Source: scenario-labs/skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.