scenario-roblox-expert

name: scenario-roblox-expertdescription: "Use when an agent builds, fixes or tests anything in Roblox Studio: \"make a Roblox game\", \"Roblox Studio\", a Luau script, \"my Roblox game lags\", agent control of Studio, the Studio MCP server (execute_luau, start_stop_play, screen_capture), Rojo or Script Sync projects, offline Luau checks, playtests driven by code; when the MCP server lists no Studio, a playtest hangs, or 2019 to 2023 Roblox code breaks; or when a Roblox brief (UI, data, networking, combat, monetization, assets, performance) must go to the right scenario-roblox-* specialist."license: MIT

Roblox expert (technical director and agent protocol)

Target: Roblox Studio (October 2026 build) on macOS, driven through the scenario-roblox-expert toolkit.

Expert Roblox work is a loop run against evidence: set the budget, build one stage, measure it, look at it, fix it, advance. An agent without a mouse gets there through Studio's built-in MCP server, offline checks and text files, passing only on a parsed result and never on one signal alone. This skill is that protocol, the shared toolkit every scenario-roblox-* skill calls (scripts/), and the map of the team. If a sibling skill named here is missing from your available skills, load it with skill_get (Scenario MCP) or ask the user to install it (https://github.com/scenario-labs/skills#install); unattended, proceed from tool schemas and flag the gap.

Status (2026-10-18): the toolkit ran live in Studio 0.743, 36 live tests and 16 offline tests, all pass (references/procedures.md). run_headless is live run pending: it needs a machine with no interactive Studio.

Stance (the expert delta)

1. Pass on a parsed result, never on tool text. execute_luau returns only the first return value, and prints go to the Output log (observed). rbx_run.run returns ok, result, error, output with your chunk's line numbers. "Audit the results" of anything an agent made over the MCP (Roblox IAS Q&A, KnFJl6z5UN0 [00:21:23]).
2. One place per agent, opened once, never closed by an agent. Never run code in a window you did not open; the server asks you to confirm with the user before modifying their game. A SIGTERM to a place hung its window and hid every Studio from the server (observed). Closing places belongs to the orchestrator, with the user's agreement.
3. Frame time against a budget, on the target. Consistent frame time beats average FPS (Andrew, XLCZfGEm9tU [00:02:12]). Triage: works, real device, frame rate, Stats, then MicroProfiler (McNeill, rwLEnBtXr30 [00:29:19]). Studio memory "is incorrect" (McNeill, cWDNVvOh4o0 [00:28:25]): it read 3,800 MB in a small playtest here.
4. Look AND check. Every visual change gets captures from fixed cameras, image_checks, a before and after compare, and a contact sheet you open. Feel cannot be automated (RDC 2026, vumAuOqSmNA [00:29:36]); AI "doesn't automatically have taste" (SmartyRBX, da-wHJpNhBo [00:07:35]).
5. Small steps, red before green. One feature per prompt (SmartyRBX, 0ENeVVC9QT0 [00:10:26]). Follow a working answer with a security review, and test death and respawn (SimTek, -0H6JRtrA2Y [00:03:53, 00:06:42]). Write the Spec test first and watch it fail.
6. Text files, Git, and a gate before Studio. A CI gate on type and lint errors catches "90 percent of what breaks a game" (CJ_Oyer, gapG2tH-etI [00:12:50]); Git is the safety net (Roblox Learn, v8r1d80DxOY [00:00:45]). Gate with rbx_check (luau-lsp with Roblox definitions), not bare luau-analyze.
7. Know what persists. An Edit change lives in the open session until someone saves, and no MCP tool saves; Server writes vanish when play stops (L24, L25). A Rojo reconnect deletes Studio-only instances without $ignoreUnknownInstances (Distracted Games, Zhl_NAPMztY [00:44:28]).
8. Be honest about GUI-only tools. The Animation Editor, terrain brushes, Avatar Setup, the Accessory Fitting Tool, Creator Hub dashboards and publishing are GUI steps. Give the substitute (Terrain:WriteVoxels, KeyframeSequenceProvider:RegisterKeyframeSequence, AvatarCreationService:ValidateUGCAccessoryAsync) or the GUI path (references/gui-paths.md). Never publish, upload or spend Robux without the user's go.

Channels

Concurrency: at most RBX_MAX (default 3) agents hold a place through rbx_env.place_slot(). Each place is its own Studio process of about 2.9 GB, and every window renders all the time. open_place waits while RBX_MAX_PLACES (default 4) place windows are open machine-wide, GPU use or GPU memory is above 85%, or RAM is above 75%. Close a place as soon as its run ends. Several StudioMCP proxies share one port, so Studio.call retries for 45 s while the host proxy changes.

Establish first

Ask once, then run:

• target devices and the lowest one (default: phone, 60 fps, 16.67 ms);
• players per server and genre;
• Rojo, Script Sync or Studio-only;
• whether Server Authority or streaming is wanted (StreamingEnabled is on in new places);
• which place is the agent's own, and the deliverable.

Then rbx_env.doctor() and an Audit.all(game) of the starting place. Write the budget, sync tool, data model plan and owners into the plan.

The expert loop

1. Brief in numbers. Budgets per device, players, memory, art style. GATE: every later check has a number.
2. Place. new_place then open_place inside place_slot, once. GATE: open_places() lists it; Audit tally has no error.
   • new_place overwrites <dir>/default.project.json: dir is a new folder of your own, never the user's project.
   • Existing game: ask the user to save first, since edits in their open window are not on disk. Merge a copy of the saved place with the code build (scenario-roblox-tooling P15, merge_place, any repository) and open the merge, never the user's file.
   • Edit a worktree or copy of their sources: their rojo serve syncs src/ into their window.
3. Baseline. Audit, Spec tests that fail first, captures from fixed cameras, Stats.frames in a playtest. GATE: numbers recorded, sheet opened.
4. Build one stage with idempotent chunks or files; route domain work to its owner (below). Adding instances to the open place: procedures.md P2.
5. Measure. rbx_check 0 errors, Spec all green, Audit clean, Stats.frames on Server and Client within the frame gate: p95 at most 1.2 x the frame budget (20 ms at 60 fps) and worst at most 2 x (33.3 ms). Heartbeat steps jitter around the vsync interval, so a healthy 60 fps place reads p95 17.2 to 17.4 ms and a bare 16.67 ms gate fails it; a dropped frame reads about 33 ms.
6. Look AND check. Same cameras, image_checks ok, compare changed where it should, contact sheet opened, judged with the owner's critique.
7. Fix before advancing, one change at a time.
8. Deliver with evidence: Verified (what ran, result file, numbers, frames) and Assumed (not run). List what a human must still play for feel.

Toolkit (scripts/, the contract for every scenario-roblox-* skill)

import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1].parent / "scenario-roblox-expert" / "scripts"))

Full signatures, return shapes and tool arguments: references/procedures.md section 1. Domain code goes in each sibling's scripts/rbx_<domain>.py and scripts/agentkit/<domain>/. rbx_env.close_place is orchestrator-only and refuses by default.

Numbers

Quality gates

• Measurable: rbx_check 0 errors; Spec failed == 0 and total > 0, after one red run; Audit tally.error == 0 and deprecated APIs gone; Stats.frames p95 and worst within budget; console free of errors after a playtest; get_studio_state back in Edit.
• Visual: every capture passes image_checks; before and after from the same cameras; a contact sheet of at most 1,600 px opened and judged.

Common mistakes

Routing and handoffs

Split items have one owner, which names the second skill in its packet:

• streaming: settings to performance, per-model modes to environment;
• hit validation: the rule to networking, the casts to gameplay;
• ProcessReceipt: the contract to monetization, persistence to data;
• AI meshes: intake to assets, placement to environment, reuse budgets to performance;
• Server Authority: enabling to networking, BindToSimulation logic to gameplay;
• memory leaks: diagnosis to performance, cleanup code to luau.

Every handoff packet carries: place path and window, channel, the brief in numbers, toolkit calls, evidence paths (results JSON, Audit tally, Spec totals, Stats, contact sheet), Verified, Assumed, open issues, and a fence. The receiver reproduces one piece of evidence before building on it.

Scenario assets into Roblox

Check each asset before import (scenario-quality-gate) and after, in a capture judged by the receiver. Getting any file into a shipped game uploads it to Roblox, so it needs the user's go.

Traps

Read references/traps.md before the first job: the 2026 API renames and replacements, the Studio MCP tool facts (is_start, capture_id, datamodel_type "Client", lost replies), process hazards, Rojo and Script Sync traps, and live corrections to the version deltas.

References

• references/procedures.md: the toolkit API in full, chunk rules, and each procedure with its tests and results.
• references/traps.md: current-Roblox traps, MCP and file pipeline traps, live corrections.
• references/expert-notes.md: expert claims by source with timestamps.
• references/critique.md: the rubric for judging an agent's Roblox work and a handoff.
• references/gui-paths.md: Studio menus for the same tasks, and the GUI-only steps.
• references/sources.md: every source with credentials, URLs and best timestamps.