This server is an MCP platform that lets AI assistants autonomously build, inspect, modify, test, and debug Roblox Studio projects through 76+ specialized tools.
Studio & DataModel access: Inspect trees, search instances, read/write properties, attributes, and scripts.
Scene & component construction: Compose prefabs (doors, coins, weapons, chests, NPCs), scaffold folders, and build/optimize worlds.
Game system workflows: Create, modify, and verify complete multi-file systems (server/client/module scripts + remotes).
Animation & rigging: Pose R15/R6 rigs, calibrate tool grips, and generate animations.
Terrain & 3D generation: Fill voxel terrain and use official AI mesh/material/procedural model generation.
Playtesting & simulation: Start/stop playtests, inject keyboard/mouse input, navigate characters, and capture screenshots.
Asset management: Search and insert Creator Store assets and upload/store images.
Diagnostics & repair: Analyze errors, find root causes, propose/apply fixes, audit project health, and repair common issues.
Architecture analysis: Map dependencies, remotes, services, and server-client communication.
Autonomous planning: Resolve capabilities, run multi-step scenarios, create games from natural-language specs, and audit completeness.
Integrates with the Roblox platform, providing tools to manage game assets, scripts, and the DataModel hierarchy through MCP.
Provides MCP integration with Roblox Studio, enabling AI-driven game creation including component-based building, Luau script management, asset handling, and playtesting via the official StudioMCP.exe.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Universal Roblox AI Studio Create a script for a click-to-collect coin system"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Universal Roblox AI Studio is a next-generation Model Context Protocol (MCP) runtime that transforms Roblox Studio into an AI-Native, autonomous, and bidirectional development platform for external AI coding assistants (Claude Desktop, Cursor, Antigravity, VS Code, etc.).
🧱 Hierarchy & Component-First Construction ("+ Sign" Paradigm)
🛡️ Restricted and Official MCP Routing Tree (Restricted Taxonomy)
Related MCP server: Melo
63+ First-Class Universal MCP Tools: DataModel hierarchy, Instance lifecycle, Luau script management, PBR materials, Voxel Terrain, Playtest simulation, 3D Generative AI, and Virtual Hardware input.
Official Roblox Studio MCP (StudioMCP.exe) Native Integration: Roblox's own official MCP client (%LOCALAPPDATA%\Roblox\Versions\...\StudioMCP.exe and mcp.bat) is auto-discovered, and restricted 3D/Asset/Playtest commands are routed directly to the official engine.
Component & Hierarchy-First Construction (VisualConstructionEngine): Instead of generating everything with massive scripts, it builds physical objects, constraints, lights, particles, and sounds layer by layer using the + (Insert Object) logic from Studio Explorer.
Advanced Animation & Hardware Calibration (AnimationAuthoringEngine): R15/R6 rig posing (Motor6D), joint safety, KeyframeSequence creation, and Tool.Grip calibration to ensure tools sit correctly in the character's hand.
Self-Healing Error Diagnostics (DiagnosticsEngine): Instantly analyzes Luau engine errors (C0 is read only, attempt to index nil, HttpDisabled, etc.) and provides ready-to-use fix code (suggestedFix) and recommendations to the AI assistant.
4-Tier Dynamic Capability Resolution (UniversalCapabilityEngine): A command is resolved via a direct tool, a workflow template, compiled primitives, or an autonomous planner.
Bidirectional Secure HTTP/HTTPS Bridge: Real-time event listening between the Studio plugin and the Node.js server (LogService, errors, selection changes) with ChangeHistoryService Undo/Redo (Ctrl+Z) safety.
Instead of a single static tool list, Universal Roblox MCP operates through 11 specialized providers (IProvider) and a Central Capability Router (CapabilityRouter):
┌────────────────────────────────────────────────────────┐
│ AI Client (Claude / Cursor) │
└──────────────────────────┬─────────────────────────────┘
│ MCP (JSON-RPC)
▼
┌────────────────────────────────────────────────────────┐
│ Universal Roblox Studio MCP Router │
│ (UniversalCapabilityEngine) │
└───────┬──────────────────┬───────────────────┬─────────┘
│ │ │
┌────────────────────┴───┐ ┌────────┴────────┐ ┌──────┴────────────────┐
│ 1. Embedded Plugin │ │ 2. Official MCP │ │ 3-11. Specialized │
│ (HTTP/HTTPS Bridge) │ │ (StudioMCP.exe) │ │ Domain Engines │
└────────────┬───────────┘ └────────┬────────┘ └──────┬────────────────┘
│ │ │
│ Polling RPC │ Stdio / WS │ Logic & Templates
▼ ▼ ▼
┌──────────────────────────────────────────────────────────────────────────────────┐
│ Roblox Studio Session │
│ • DataModel Tree • Luau ScriptEditor • Viewport Framebuffer • Simulation │
└──────────────────────────────────────────────────────────────────────────────────┘EmbeddedPluginProvider: Manages 36 core primitives by communicating with the native plugin inside Roblox Studio.
OfficialRobloxMCPProvider: Connects to Roblox's official StudioMCP.exe binary to execute restricted 3D, Asset, and Playtest commands.
ModelingProvider: Coordinates 3D meshes, PBR materials, and procedural part assemblies.
AnimationProvider: Manages animation clips, player controls, and rig poses.
LuauProvider: Provides Luau static analysis, syntax validation, and safe code execution.
WorkflowProvider: Applies composite game systems (Day/Night, Leaderstats, Island Generator, etc.) as templates.
AssetProvider: Fetches/inserts models, sounds, and visual assets from the Creator Store and Cloud inventory.
TestingProvider: Manages automated scenario tests, virtual keyboard/mouse inputs, and validation processes.
DiagnosticsProvider: Monitors Studio output, performs root cause analysis, and suggests safe repairs.
ObservationProvider: Manages viewport screen capture and visual inspection.
DesignProvider: Audits spatial aesthetics, color harmony, and design rules.
An experienced developer in Roblox Studio does not procedurally generate everything with a single massive Luau script. Instead, they use Component-Driven development. Our system builds objects in 5 stages following industry-standard layering:
[Katman 1: Mekansal İskelet] ───▶ Model / Folder / Frame / Parts / Meshes / PrimaryPart
↓
[Katman 2: Görsel & Duyusal] ───▶ PBR Materials / PointLight / Particles / Sounds / SurfaceGui
↓
[Katman 3: Etkileşim & Fizik] ───▶ ProximityPrompt / HingeConstraint / WeldConstraint / Attachments
↓
[Katman 4: Animasyon & Donanım]──▶ KeyframeSequence / Motor6D Poses / Tool Grip Calibration
↓
[Katman 5: Ayrık Mantık] ───▶ Sadece sinyalleri dinleyen hafif ve modüler Luau Controllercomponent_compose):interactive_door: Wooden frame (Frame), hinge (HingePart), door panel (DoorPanel), ProximityPrompt, opening sound (Sound), TweenService controller, and custom Attributes (IsOpen, OpenAngle).
collectible_coin: Spinning cylinder coin, metal material, golden PointLight, Sparkles, collection sound, and CollectionService tag.
equippable_weapon: Calibrated Tool.Grip, RightGripAttachment, Handle, swing sound, hit trail (Trail), and activation script.
interactive_chest: Fixed chest body, opening lid (ChestLid), HingeConstraint, ProximityPrompt, golden glow, and LootTable attributes.
streetlamp_fixture: Metal pole, glass lamp head, PointLight, SpotLight, Neon material, and Day/Night automatic light sensor.
teleporter_pad: Teleportation platform, particle beam (ParticleEmitter & Beam), teleport sound, and target coordinates.
dialogue_npc: Posed R15/R6 character, BillboardGui name tag, dialogue ProximityPrompt, and conversation tree.
For security reasons, the Roblox engine restricts certain APIs (RobloxSecurity, RobloxScriptSecurity, SensitiveInput, Capture) for third-party plugins. Our system automatically recognizes these restrictions via the RestrictedCapabilityRegistry and routes them directly to the official StudioMCP.exe proxy:
RESTRICTED / OFFICIAL-ONLY (12 Kategori)
├── 1. RobloxSecurity ──▶ official-roblox-mcp (execute_luau / search_game_tree)
├── 2. RobloxScriptSecurity ──▶ official-roblox-mcp (script_grep / execute_luau)
├── 3. Internal Studio APIs ──▶ official-roblox-mcp (get_studio_state, list_roblox_studios)
├── 4. Internal Engine APIs ──▶ official-roblox-mcp (generate_mesh / get_console_output)
├── 5. Internal Plugin APIs ──▶ official-roblox-mcp (internal plugin manager)
├── 6. Protected Debug APIs ──▶ official-roblox-mcp (get_console_output)
├── 7. Protected Studio Control APIs ──▶ official-roblox-mcp (start_stop_play [Play/Run/Stop])
├── 8. Missing Sandbox Capabilities ──▶ official-roblox-mcp (screen_capture, keyboard/mouse input)
├── 9. Restricted Asset APIs ──▶ official-roblox-mcp (generate_mesh, generate_material, search_asset)
├── 10. Restricted HTTP APIs ──▶ official-roblox-mcp (Cloud Auth HTTP)
├── 11. Internal Network APIs ──▶ official-roblox-mcp (Replication diagnostics)
└── 12. Provider-Specific Capabilities ──▶ official-roblox-mcp (subagent, execute_luau)AI models can get stuck on common Roblox API errors while running code. The DiagnosticsEngine catches these errors and produces directly working solutions for the AI:
Encountered Error | Root Cause | Automatic Diagnosis and Solution |
| The R15 joint ( | Automatically suggests checking |
| The dynamic object has not loaded yet. | Generates |
| The operation requires | Routes the request to the official MCP |
|
| Reports that HTTP permission must be enabled via Studio Game Settings. |
component_compose: Builds complete components (door, chest, coin, NPC, etc.) from ready-made templates.
component_template_list: Lists all available component templates and their hierarchy trees.
hierarchy_scaffold: Organizes the Studio project into folders following professional industry standards.
tool_grip_calibrate: Automatically calibrates the grip angles (Tool.Grip) of weapons and items in the character's hand.
rig_pose_and_animate: Safely poses R15/R6 character joints (Motor6D).
StudioMCP.exe Integrated)generate_mesh: Generates Roblox Cloud AI 3D meshes from natural language prompts.
generate_material: Generates PBR materials and textures from natural language prompts.
generate_procedural_model: Creates procedural part assemblies.
search_asset & insert_asset: Searches and inserts assets from the Creator Store and Cloud library.
screen_capture: Captures high-resolution screenshots from the Studio 3D Viewport.
start_stop_play: Physically starts the game (Play/Run) or returns to edit mode (Stop).
get_studio_state: Queries the Studio session, open document, and active simulation mode.
list_roblox_studios & set_active_studio: Lists running Studio windows and selects the active one.
character_navigation: Moves the character to 3D world coordinates during simulation.
user_keyboard_input & user_mouse_input: Injects hardware-level key presses and mouse clicks into the simulation.
script_read, multi_edit, script_search, script_grep: Local multi-file editing and search via the Studio Script Editor.
subagent & execute_luau: Runs Roblox's native sub-agent and Luau code execution engine.
studio_info, studio_get_tree, studio_search, studio_inspect: DataModel hierarchy scanning and deep property inspection.
instance_create, instance_delete, instance_clone, instance_reparent, instance_rename, instance_move: Object lifecycle and 3D positioning.
property_get, property_set, property_get_all: Property read/write with automatic Luau type conversion.
attribute_get, attribute_set, attribute_delete, attribute_get_all: Attribute management.
script_get_source, script_set_source, script_patch_source, script_search_code: Script source reading, line-based patching, and code search.
selection_get, selection_set, selection_add, selection_clear: Studio Explorer selection control.
output_get, output_get_errors, output_clear: Output log and error capture.
terrain_fill_block, terrain_fill_ball, terrain_clear: Voxel Terrain creation and clearing.
batch_execute: Atomic multi-command execution in a single operation (with Undo/Redo waypoint support).
Node.js: v18.0.0 or higher (v20+ / v24 recommended).
Roblox Studio: Installed on Windows or macOS.
git clone <repo-url>
cd "Roblox Studio MCP"
npm install
npm run buildYou can install the plugin using one of two methods:
Run npm run bundle:plugin and node scripts/build-rbxmx.js (or copy the compiled files):
Windows: Copy the plugin-build\RobloxUniversalMCP.rbxmx file to the %LOCALAPPDATA%\Roblox\Plugins\ directory.
macOS: Copy the plugin-build/RobloxUniversalMCP.rbxmx file to the ~/Library/Application Support/Roblox/Plugins/ directory.
Open any Place in Roblox Studio.
Paste the contents of the plugin-build/RobloxUniversalMCP.luau file into a Script.
Right-click the Script and select "Save as Local Plugin...".
Enable "Allow HTTP Requests" from Home > Game Settings > Security.
Three different universal methods are provided to run it consistently and portably on any computer:
Run npm link once in the project folder to register the system as a global command:
npm run build
npm linkNow you don't need to type any file path in Claude Desktop, Cursor, or any MCP client:
claude_desktop_config.json)Windows: %APPDATA%\Claude\claude_desktop_config.json
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
{
"mcpServers": {
"roblox-universal-studio": {
"command": "roblox-studio-mcp"
}
}
}${workspaceFolder})When you open the project in Cursor or VS Code, add it to the .cursor/mcp.json or .vscode/mcp.json file. No matter which computer it opens on, ${workspaceFolder} is detected automatically:
{
"mcpServers": {
"roblox-universal-studio": {
"command": "node",
"args": [
"${workspaceFolder}/dist/index.js"
]
}
}
}If you want to call the compiled dist/index.js file directly instead of the global CLI:
{
"mcpServers": {
"roblox-universal-studio": {
"command": "node",
"args": [
"<PROJE_KLASORUNUZ_TAM_YOLU>/dist/index.js"
]
}
}
}(Example Windows: C:\\Projects\\Roblox-Studio-MCP\\dist\\index.js | macOS: /Users/username/Projects/Roblox-Studio-MCP/dist/index.js)
When the plugin is loaded, a special DockWidget (DiagnosticsView) opens inside Roblox Studio:
Plugin Runtime: ONLINE / STANDALONE
MCP Bridge: CONNECTED (Green) / DISCONNECTED (Red)
Capabilities Discovered: 80+ Live Capabilities (All providers and subsystems)
Low-Level Tools: 57 Primitive Tools
High-Level Workflows: 19 Composite Workflows
Total Universal Tools: 76 Universal Tools
Active Mode: CHAT | OBSERVE | BUILD | PLAYTEST | AUTONOMOUS
To run the full test suite:
npm testTest output:
✔ Tool Registry contains all universal tools
✔ HTTP Bridge Status returns disconnected when no session is active
✔ HTTP Bridge Handshake registers studio session
✔ Executing a command dispatches over polling RPC and resolves with response
✔ 11 Providers are registered and operational in ProviderRegistry
✔ Universal Capability Engine resolves across 4-tier hierarchy
✔ MultiModeEngine handles operating mode transitions and permissions
✔ Live Dashboard endpoint returns comprehensive real-time telemetry
✔ Visual Construction Engine lists rich archetypes and templates
✔ Animation Authoring Engine calibrates tool grips and keyframe sequencesThis project is licensed under the MIT License. Enjoy the AI-native game development experience with Roblox Studio! 🎮⚡
[HIGH_LEVEL] Performs architectural analysis of server-client communication boundaries, security gaps, and shared state patterns.
Inputs: no named parameters.
[WORKFLOW] Plans a new game architecture or major feature, returning structured steps, affected services, and verification plans.
Inputs: goal (required).
Remove an attribute from an Instance.
Inputs: target (required), attributeName (required).
Get the value of a specific attribute on an Instance.
Inputs: target (required), attributeName (required).
Get all attributes of an Instance as a key-value dictionary.
Inputs: target (required).
Set or update an attribute on an Instance (supports string, number, boolean, Vector3, Color3, etc.).
Inputs: target (required), attributeName (required), value.
Execute a sequence of multiple Studio operations atomically within a single ChangeHistoryService recording (Undo/Redo transaction). If any operation fails, provides detailed breakdown of results and rollback status.
Inputs: operations (required), stopOnError, transactionName.
Comprehensive system audit: reports available, unavailable, official-only, plugin-only, unknown capabilities, and schema mismatches.
Inputs: no named parameters.
Scans all providers (Embedded Plugin, Official MCP, Studio services) and returns the live capability matrix with availability, security level, risk, and fallback.
Inputs: refresh.
Universal Capability Engine: Resolves any intent or missing tool through 4-tier hierarchy (Direct Tool -> External Provider -> Primitive Composition -> UNAVAILABLE).
Inputs: intent (required), context.
Official MCP Routing: Lists all capabilities restricted by Roblox 3rd-party HTTP/sandbox that are routed directly to Official Roblox Studio MCP (3D AI, Asset Insertion, Screen Capture, Playtest Input).
Inputs: no named parameters.
Completeness Engine: Compares requested requirements against implemented systems, detects missing features, and runs final validation.
Inputs: requestedFeatures (required).
Visual Construction: Composes a complete, structured Roblox game component (Interactive Door, Collectible Coin, Weapon Tool, Chest, NPC, Teleporter, Light Fixture) into Studio hierarchy with correct nested parts, materials, constraints, lights, sounds, proximity prompts, and decoupled behavior script without manual boilerplate.
Inputs: name (required), templateId (required), position, attributes, +2 more.
Visual Construction: Lists all available component construction templates with their hierarchy trees, default attributes, and required Roblox instances.
Inputs: no named parameters.
Generate a compact, token-efficient architectural summary of the entire Roblox project (services, folder layout, key scripts, remotes, tags, and structure). Ideal for an AI to quickly understand an unfamiliar codebase.
Inputs: maxDepth, includeScriptSummaries.
Inspect the communication and dependency architecture (RemoteEvents, RemoteFunctions, BindableEvents, shared ModuleScripts) across the project.
Inputs: no named parameters.
[HIGH_LEVEL] Analyzes Studio output logs, pinpoints error stack traces, identifies candidate script files and line numbers, and prepares diagnostic contexts.
Inputs: errorQuery.
[HIGH_LEVEL] Diagnoses a runtime error, reads the relevant script source around the offending line, and generates a verified fix proposal.
Inputs: errorLine (required), scriptPath (required), errorMessage (required).
Root-Cause Error Analyzer & Safe Repair: Analyzes Studio errors, correlates with code, generates verified patch with dry-run support.
Inputs: search (required), scriptPath (required), replacement (required), dryRun.
Official Roblox MCP: Executes Luau code in Roblox Studio environment and returns evaluation results.
Inputs: code (required), targetContext.
[WORKFLOW] High-level autonomous workflow: Plans, instantiates instances, writes server/client/module scripts, sets up remotes, and verifies complete feature integration.
Inputs: description (required), featureName (required), remotes, clientScript, +2 more.
[WORKFLOW] Comprehensive post-implementation verification: checks that all instances exist, scripts have valid syntax, remotes are bound, and no errors occurred.
Inputs: featureName (required).
[WORKFLOW] End-to-end composite workflow: Analyzes project -> Plans architecture -> Implements server/client modules -> Anchors geometry -> Verifies entire game state.
Inputs: spec (required), featureName (required).
Autonomous Game Creation Pipeline: Takes natural-language game specification, parses requirements, generates architecture/GDD/plans, creates all systems, models, UI, animations, and produces verified game.
Inputs: specification (required).
Official Roblox Generative AI: Generates seamless PBR texture and material from prompt using official Roblox AI material generator.
Inputs: prompt (required), targetPart, baseMaterial.
Official Roblox Generative AI: Generates a 3D mesh model from a natural-language text prompt using Roblox official AI mesh generator.
Inputs: prompt (required), scale, parent, anchored, +1 more.
Official Roblox Generative AI: Generates a procedural model assembly using official Roblox MCP generator.
Inputs: prompt (required), category, position.
Official Roblox Studio: Retrieves active Studio session information, current place ID, edit/play simulation status, and open documents.
Inputs: studio_id.
Spatial Organization: Automatically scaffolds clean, industry-standard professional project structure in Roblox Studio (Workspace.World, ReplicatedStorage.Shared, ReplicatedStorage.Assets, ServerStorage.Templates, ServerScriptService.Systems).
Inputs: no named parameters.
Official Roblox Asset API: Inserts an asset from the Roblox Creator Store directly into Studio by Asset ID.
Inputs: assetId (required), parent, position.
Clone an existing Instance (and all its descendants) and place it under a target parent.
Inputs: target (required), parent, newName, properties.
Create a new Instance of any valid Roblox ClassName under a specified parent with initial properties and attributes.
Inputs: parent (required), className (required), name, tags, +2 more.
Safely destroy/delete an Instance from the Roblox DataModel by its path or session UUID.
Inputs: target (required).
Move a 3D Instance (Part or Model) to a new Position, CFrame, or relative Vector offset.
Inputs: target (required), pivot, cframe, position.
Rename an Instance in the DataModel.
Inputs: target (required), newName (required).
Move an Instance to a new parent in the hierarchy.
Inputs: target (required), newParent (required).
Official Roblox Studio: Lists all running Roblox Studio processes and open places.
Inputs: no named parameters.
Multi-Mode Engine: Inspects current operating mode, permissions, and autonomous loop state.
Inputs: no named parameters.
Multi-Mode Engine: Switches active operating mode (CHAT, OBSERVE, PLAN, BUILD, PLAYTEST, VISUAL, DEBUG, OPTIMIZE, VERIFY, AUTONOMOUS).
Inputs: mode (required), reason.
Official Roblox Studio: Atomically applies multiple script edits across one or more Luau scripts.
Inputs: edits (required).
Clear the internal log buffer.
Inputs: no named parameters.
Get recent output logs captured from Roblox Studio (prints, warnings, errors).
Inputs: limit, query, filterType.
Get recent runtime errors and unhandled exceptions captured from Roblox Studio with full stack traces.
Inputs: limit.
Control playtest simulation mode in Roblox Studio (Start / Stop / Pause / Resume) routed via Official Roblox Studio MCP proxy.
Inputs: mode, action, is_start, studio_id.
Get current Roblox Studio simulation state and active place status via Official Roblox Studio MCP proxy.
Inputs: studio_id.
Automated Playtest Runner: Executes multi-step gameplay testing scenario with input simulation, console output analysis, and screenshot capture.
Inputs: name (required), steps (required).
[HIGH_LEVEL] Comprehensive project architecture analysis: maps all services, active scripts, remote events, orphan remotes, and dependency relationships.
Inputs: no named parameters.
[HIGH_LEVEL] Generates the full static dependency code graph (require chains, module relationships, and remote event calls) across all scripts.
Inputs: no named parameters.
[HIGH_LEVEL] Runs an automated audit across scripts, instances, physics, and remotes to detect memory leaks, unanchored parts, orphan remotes, and syntax issues.
Inputs: no named parameters.
[HIGH_LEVEL] Builds an indexed architectural map of all game folders, systems, shared modules, and server/client script roles.
Inputs: maxDepth.
[HIGH_LEVEL] Automatically repairs common place issues (anchors loose parts, cleans orphan instances, resolves broken references).
Inputs: fixPhysics, cleanOrphans.
Read the value of a specific property on an Instance. Returns normalized representation with data type info.
Inputs: target (required), property (required).
Read all common and accessible properties of an Instance.
Inputs: target (required).
Set the value of a property on an Instance. Supports automatic type coercion for Vector3, CFrame, Color3, BrickColor, UDim2, NumberRange, Enums, etc.
Inputs: target (required), property (required), value.
Animation & Posing: Safely transforms R15/R6 rig joints (Motor6D C0) to set static poses, weapon hold stances, or dialogue stances without breaking rig hierarchy or throwing read-only Motor6D errors.
Inputs: poses (required), targetRigPath (required), rigType.
[HIGH_LEVEL] Analyzes Workspace geometry, parts count, physics performance, and lighting configuration.
Inputs: no named parameters.
[HIGH_LEVEL] Scans Workspace to detect unanchored parts, physics issues, and loose instances, with automatic verified anchoring.
Inputs: fixUnanchored, organizeLooseParts.
[HIGH_LEVEL] Organizes loose BaseParts in Workspace into semantic folders (e.g. Map, Geometry, Props, Interactive).
Inputs: no named parameters.
Official Roblox Studio: Captures a clean native high-resolution screenshot of the Studio 3D viewport framebuffer.
Inputs: cameraFocus, cameraPosition.
Read the complete source code of any Script, LocalScript, or ModuleScript in the Roblox project.
Inputs: target (required).
Official Roblox Studio: Searches for symbols, function definitions, or patterns with line number snippets across all scripts.
Inputs: pattern (required), scope.
Apply an incremental patch or replacement to a script without rewriting the entire file. Supports exact target replacement, line range replacement, or regex replacement.
Inputs: search (required), target (required), replacement (required), isRegex, +1 more.
Official Roblox Studio: Reads Luau script source directly from Studio Script Editor buffer.
Inputs: scriptPath (required).
Official Roblox Studio: Performs fast regex or literal text search across all Luau scripts in the DataModel.
Inputs: query (required), isRegex, caseSensitive.
Perform a project-wide code search across all Scripts, LocalScripts, and ModuleScripts. Returns matching script paths, line numbers, and code snippets.
Inputs: query (required), scope, isRegex, maxResults, +1 more.
Overwrite the full source code of a Script, LocalScript, or ModuleScript.
Inputs: source (required), target (required).
Official Roblox Asset API: Searches Roblox Creator Store / Marketplace for models, audios, decals, plugins using official authenticated APIs.
Inputs: keyword (required), limit, assetType.
Add Instances to the current Roblox Studio selection without deselecting currently selected objects.
Inputs: targets (required).
Clear the active selection in Roblox Studio (deselect all).
Inputs: no named parameters.
Get the list of Instances currently selected by the developer in Roblox Studio.
Inputs: no named parameters.
Programmatically select specific Instances in Roblox Studio.
Inputs: targets (required).
Official Roblox Studio: Switches active MCP focus to a specific running Studio instance by ProcessId or PlaceId.
Inputs: studioId (required).
Official Roblox Studio: Starts or stops Studio playtest simulation.
Inputs: mode, action, is_start, studio_id.
Official Roblox Asset API: Stores an image asset in the Studio project.
Inputs: assetId (required), targetName.
Inspect the Roblox DataModel hierarchy tree starting from a given root instance (e.g. Workspace, ReplicatedStorage, ServerScriptService) with configurable depth and filtering.
Inputs: root, depth, maxItems, classNameFilter, +1 more.
Get information about the active Roblox Studio session, place ID, place name, mode (Edit/Run/Play), and plugin status.
Inputs: no named parameters.
Perform a comprehensive inspection of a single Instance, returning all its properties, attributes, tags, child summary, script presence, and stable session UUID.
Inputs: target (required), includeChildren, includeScriptSourceSnippet.
Search for Instances in the DataModel matching specific criteria such as name pattern, ClassName, tag (CollectionService), or attribute values.
Inputs: tag, limit, query, scope, +3 more.
Official Roblox MCP: Delegates a complex sub-task to Roblox native subagent engine.
Inputs: task (required), context.
Deep audit of the entire development platform: providers health, Studio connection, DataModel state, and knowledge graph statistics.
Inputs: no named parameters.
[HIGH_LEVEL] Creates a complete multi-file Roblox modular system (ServerScript, ModuleScript, Client LocalScript, and RemoteEvents) in a single atomic verified transaction.
Inputs: systemName (required), remotes, clientCode, moduleCode, +1 more.
[HIGH_LEVEL] Safely modifies an existing system by updating its scripts, attributes, and configuration with state read-back verification.
Inputs: systemName (required), clientPatch, modulePatch, serverPatch.
[HIGH_LEVEL] Safely removes a modular system and its associated folders and remotes in an atomic rollback-supported transaction.
Inputs: systemName (required).
Live Dashboard: Retrieves real-time metrics across all 11 providers, active Studio session, capability counts, and mutation audit log.
Inputs: no named parameters.
Clear all terrain or clear a specific region of terrain.
Inputs: region.
Fill a spherical region in Roblox voxel Terrain with a specified material.
Inputs: center (required), radius (required), material (required).
Fill a block-shaped region in Roblox voxel Terrain with a specified material (e.g. Grass, Water, Rock, Sand, Brick).
Inputs: size (required), cframe (required), material (required).
Animation & Gear: Calibrates Tool.Grip and RightGripAttachment for weapons and equippable tools to ensure correct in-hand orientation (Sword upright, Gun aim forward, Shield forearm, Lantern carry).
Inputs: toolPath (required), gripPreset (required), offset, anglesDeg.
Official Roblox Asset API: Uploads a local or base64 image to Roblox Cloud as a Decal/Texture asset.
Inputs: assetName (required), imagePath, base64Data.
Official Roblox Studio: Injects keyboard key press/release events into the active Studio playtest simulation.
Inputs: keys (required).
Official Roblox Studio: Injects virtual mouse move and click events into the active Studio viewport.
Inputs: x (required), y (required), click, button.
Official Roblox MCP: Waits for an asynchronous AI generation job to finish and returns the generated asset identifier.
Inputs: jobId (required), timeoutSeconds.
World Building Engine: Construct spatial layout, zones, spawn points, lighting, terrain, roads, and interaction anchors atomically.
Inputs: theme (required), zones, terrain, lighting.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 94 tools
Many tools have overlapping purposes, such as three script search tools (script_search, script_grep, script_search_code), multiple project/architecture analyzers (project_analyze, project_map, context_get_architecture, architecture_analyze, context_build), and several capability tools (capability_discover, capability_audit, capability_resolve). An agent would frequently misselect among these.
All names use snake_case and are descriptive, but verb placement is inconsistent: some are verb_noun (generate_mesh, list_roblox_studios, get_studio_state) while others are noun_verb (property_set, instance_create, scene_analyze). Vague names like multi_edit and subagent further reduce predictability.
94 tools is an extreme count for a single MCP server, far beyond the 3-15 well-scoped range. Many of these tools are redundant or overlapping, making the surface unnecessarily heavy for an agent to navigate.
The tool set is exceptionally comprehensive, covering instance/property/attribute CRUD, scripting, terrain, playtest, asset generation, project analysis, debugging, and high-level workflows. No major gaps are apparent for the stated universal Roblox Studio purpose.
Generate game-ready 3D models, textures, and audio from natural language, over MCP.
Build and run AI workflows, agents, data tables and 1000+ API integrations from any MCP client.
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
Make games with AI: one MCP server that connects your agent to Unity, Unreal and Godot editors.
