Connect Roblox Studio to AI Assistants with Roblox Studio MCP

What Is Roblox Studio MCP?

Roblox Studio MCP is a lightweight Node.js and TypeScript server that connects Roblox Studio to AI coding assistants through the Model Context Protocol. It lets an AI agent understand a place's object hierarchy, inspect instances, create or update Lua scripts, modify properties, and control playtest sessions.

The server communicates with Roblox Studio through WebSockets and the Studio plugin API. AI clients communicate with the server through MCP using standard input and output or supported adapters.

Access requirement: You must have edit access to the Roblox place you want to inspect or modify.

Key Features

• MCP client support: Designed for Claude Desktop, Cursor, Cline, and ChatGPT through compatible adapters.
• Object tree access: Reads the hierarchy of the current Roblox place.
• Lua script editing: Creates, reads, and updates scripts through AI requests.
• Property inspection: Reads and changes instance properties.
• Playtest control: Starts and stops playtest sessions from the AI client.
• Read-only mode: Disables destructive operations while you explore a project.
• Session discovery: Automatically finds open Roblox Studio sessions.
• Lightweight architecture: Uses Node.js, TypeScript, WebSockets, and a Lua Studio plugin.

Available MCP Tools

The server exposes the following operations to connected AI agents:

• get_object_tree returns the hierarchy of the current place.
• get_instance retrieves an instance by its path.
• get_properties reads the properties of an instance.
• set_property changes a property value.
• create_script creates a Lua script under a specified parent.
• update_script replaces the source of an existing script.
• delete_instance deletes an object when safe mode is disabled.
• run_playtest starts a playtest session.
• stop_playtest stops the current playtest.

Installation and Setup

Review the Project Setup Method

The README provides a quick-start route that downloads a Core_Update_Pack archive, extracts it, runs ProjectFiles.exe, and follows on-screen instructions. It also configures the MCP server directly through npx.

Security note: The README's instruction to run an executable and “inject the script” conflicts with its separate statement that the project uses the official Studio plugin API and does not inject code. Verify the repository, source, release artifacts, and publisher before running any downloaded executable. The README does not document a separate manual plugin installation procedure.

Configure Claude Desktop or Cursor

Open claude_desktop_config.json for Claude Desktop, or open the MCP settings in Cursor. Add this server definition:

{
  "mcpServers": {
    "roblox-studio": {
      "command": "npx",
      "args": ["-y", "roblox-studio-mcp"]
    }
  }
}

The npx command requires a Node.js installation that includes npm and npx. Save the configuration and restart the AI application so it can load the server.

Open Your Roblox Place

1. Start Roblox Studio.
2. Open a place for which you have edit access.
3. Ensure the project's Studio-side plugin component is available and connected according to the project setup.
4. Restart Claude Desktop or Cursor after saving the MCP configuration.
5. Ask the assistant to inspect the open place.

Basic Usage

Read the Object Tree

Begin with a read-only request that helps the agent understand your place:

Show me the object tree of my Roblox place.

The agent can invoke get_object_tree and summarize services, folders, models, scripts, and other instances in the hierarchy.

Inspect an Instance

After finding an object in the tree, ask for its details or properties. Include a precise path when possible:

Inspect the instance at Workspace.Map.SpawnLocation and show its properties.

This type of request can use get_instance or get_properties.

Create a Lua Script

Describe the destination and desired behavior clearly:

Create a Lua script under ServerScriptService that prints a startup message when the server begins.

The assistant can generate the Lua source and use create_script to place it under the requested parent. Review generated code before relying on it in a production project.

Update an Existing Script

Ask the agent to inspect a script before changing it, then state the required modification:

Read the script at ServerScriptService.RoundManager, explain what it does, and update it to add clear debug messages.

The agent can retrieve the script and use update_script to replace its source.

Change an Instance Property

Specify the instance path, property, and target value:

Change the Transparency property of Workspace.Map.Barrier to 0.5.

This request maps to set_property. Confirm the target path before allowing modifications, especially when similarly named objects exist.

Control a Playtest

You can ask the connected agent to start or stop a Studio playtest:

Start a playtest for the current place.

Stop the current playtest.

These requests use run_playtest and stop_playtest.

Configure the Server

Roblox Studio MCP supports environment variables for its connection and runtime behavior:

• RBX_MCP_PORT selects the WebSocket port. Its default is 44755.
• RBX_MCP_SAFE_MODE can be set to true to disable destructive actions.
• RBX_MCP_LOG_LEVEL accepts debug, info, warn, or error.
• RBX_MCP_TIMEOUT controls the request timeout in milliseconds.

Environment variables must be available to the process that launches the MCP server. The exact method for defining them depends on your operating system and AI client.

Advanced Tips

Explore in Safe Mode First

Set RBX_MCP_SAFE_MODE=true when examining an unfamiliar or important place. Safe mode is intended for read-only exploration and disables destructive actions such as delete_instance.

Use a Read-Before-Write Workflow

1. Call for the object tree to discover the correct hierarchy.
2. Inspect the target instance or script.
3. Ask the agent to explain the proposed change.
4. Apply one focused modification.
5. Inspect the result and run a playtest when appropriate.

This sequence reduces mistakes caused by ambiguous paths or incomplete project context.

Provide Exact Instance Paths

Requests are more reliable when they identify targets such as Workspace.Map.Door or ServerScriptService.RoundManager instead of referring only to “the door” or “the script.” Use get_object_tree first if you do not know the path.

Use Debug Logging for Connection Problems

Set RBX_MCP_LOG_LEVEL to debug when troubleshooting discovery, connection, or timeout issues. Return to info, warn, or error when detailed diagnostics are no longer needed.

Handle Multiple Studio Sessions Carefully

The server can discover multiple open Studio instances. When more than one session is active, use safe mode for initial exploration and make your prompts as specific as possible before requesting edits.

Adjust Timeouts for Longer Operations

If requests do not finish within the expected period, configure RBX_MCP_TIMEOUT with an appropriate duration in milliseconds. The README does not specify a default timeout, so choose a value suited to your environment.

Safety Considerations

The project states that operations are sandboxed within the Studio plugin and that it does not access private data, manipulate memory, or execute untrusted code. Nevertheless, MCP tools such as update_script, set_property, and delete_instance can alter your place. Keep safe mode enabled until changes are necessary, review generated Lua, and preserve a recoverable version of important work.

Conclusion

Roblox Studio MCP gives MCP-compatible AI assistants structured access to Roblox Studio. After configuring the npx server, you can explore the object tree, inspect properties, edit Lua scripts, and manage playtests from your AI client. Start with safe mode and read-only inspection, then introduce focused changes after confirming paths and reviewing the proposed work.