Roblox Studio MCP Setup: Connect Claude or Cursor Safely

Quick Answer: Roblox Studio MCP is an open-source Model Context Protocol server that lets AI assistants like Claude Desktop and Cursor read your place's object tree, inspect properties, edit Lua scripts, and run playtests. Set it up through a JSON config entry and the Studio plugin, start in safe mode, and skip any "Core_Update_Pack" or .exe download. The legitimate setup doesn't need one.

The README for Roblox Studio MCP has a Quick Start section that tells you to download a zip from a telegra.ph link, extract it, run an executable called ProjectFiles.exe, and "inject the script." Stop there. That isn't how an MCP server gets installed, and it's the first thing you should check before anything else in this repo. The rest of the project is worth understanding, so let's separate what's useful from what's a red flag.

What the Server Actually Does

The Model Context Protocol is an open standard Anthropic released in November 2024. It defines how an AI client, such as Claude Desktop, Cursor, or Cline, discovers and calls external tools. An MCP server exposes those tools. Here, the server exposes Roblox Studio operations.

The architecture has three parts. Your AI client talks to the MCP server over stdio. The server talks to a plugin running inside Roblox Studio over a local WebSocket, which defaults to port 44755. The plugin then calls the Roblox Studio API on your behalf. The server never touches your place file directly.

The README lists nine tools. They don't carry equal risk, and that difference matters more than the feature list:

Tool	Category	Risk if the agent misfires
`get_object_tree`	Read	None to your place
`get_properties` / `get_instance`	Read	None to your place
`run_playtest` / `stop_playtest`	Runtime	Low; interrupts your session
`set_property`	Write	Changes live values, possibly with no obvious trail
`update_script` / `create_script`	Write	Overwrites source code
`delete_instance`	Destructive	Removes parts of your place

Most people start by asking Claude to describe their hierarchy. That's the right move. Treat anything in the write or destructive rows as something you review.

Why the Quick Start Is a Red Flag

Here's the part most guides would gloss over. The README says the server is "safe by design" with "no execution of untrusted code," then asks you to run an unsigned executable from a file-sharing link. Those two claims can't both be true for the setup it describes.

A real MCP server needs a runtime (Node.js in this case) and a config entry. It does not need a standalone .exe. Downloading an executable from an anonymous link and running it on the machine that holds your Roblox account, your source code, and your AI API keys is a common malware delivery pattern. Pausing here costs you five minutes. Skipping it could cost you your account.

So the lazy advice, "just follow the Quick Start," is wrong for this repo. The useful part of the README is the config snippet, and that's where you should start.

Install It the Way MCP Servers Are Meant to Be Installed

Before you run anything, do these checks:

Open the GitHub repository and confirm the owner, commit history, and open issues look like an active project.
Check the npm package named in the config (roblox-studio-mcp). Confirm it links back to this repo and has a publisher you recognize.
Look at the plugin source. If you can't find the plugin code in the repo, don't install a plugin file from anywhere else.

If those checks pass, add the entry to your client config. For Claude Desktop, that's claude_desktop_config.json. For Cursor, it's the MCP settings panel.

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

Two notes on that snippet. The -y flag tells npx to install without prompting, which means it pulls whatever version is latest at launch. For anything beyond a test machine, pin a specific version so an update can't change behavior under you. Also, the snippet doesn't need any file from a download link.

Once the config is in place, follow this sequence:

Install the Studio plugin from the repository source, or build it yourself from the code you reviewed.
Open your place in Roblox Studio. The server auto-discovers open sessions, so you don't need to paste an ID.
Restart your AI client so it loads the new MCP server.
Ask: "Show me the object tree of my Roblox place." If you get a hierarchy back, the connection works.

Start in Read-Only Mode and Verify It Yourself

Set RBX_MCP_SAFE_MODE=true in the server's environment before you let an agent touch anything. The README says this disables destructive actions such as delete_instance. It doesn't say whether set_property or update_script are blocked in safe mode. That gap is the most important thing to test.

Here's a simple check. Make a copy of your place, enable safe mode, and ask the agent to change a property and edit a script. If either change lands, you know safe mode doesn't cover writes, and you'll plan around that.

Before any agent gets write access, protect the place. Use Team Create or keep saved .rbxl copies you can roll back to. Plugin-driven writes don't always appear in the same undo history you'd expect when you edit by hand, so don't rely on Ctrl+Z as your only safety net. That's the failure mode that catches experienced developers, because they assume every change is undoable.

Source Control vs. Live Editing: Pick the Right Tool

MCP is good at live, interactive work: asking an agent to inspect a hierarchy, find a misconfigured Part, or try a playtest. It's a poor fit for being the source of truth for production code. For that, most Roblox teams use Rojo, a tool that syncs files on disk into Studio. Rojo keeps your Lua in Git, where diffs, reviews, and rollbacks already work.

A reasonable split looks like this: use MCP for exploration and quick experiments, and keep the authoritative code in a Rojo-managed repository. If an agent changes something in Studio that Rojo doesn't track, you'll see the drift on your next sync. That's your signal to move the change into source control, not to leave it orphaned in the place file.

Troubleshooting: Why It Won't Connect

Most connection failures come from one of four causes. Each one has a clear mechanism, so you can check them in order.

The plugin isn't loaded. Studio can't reach the server if the plugin isn't running in the open session. Confirm the plugin appears in Studio's Plugins tab.
Port 44755 is in use. Another process holds the default WebSocket port, so the server can't bind or the plugin connects to the wrong place. Set RBX_MCP_PORT to a free port and update both sides.
The request timed out. Large object trees take longer to serialize. Raise RBX_MCP_TIMEOUT (in milliseconds) before you assume the server is broken.
The client didn't restart. Claude Desktop and Cursor load MCP servers at startup. Editing the config file while the app is running changes nothing until you restart.

Set RBX_MCP_LOG_LEVEL=debug when you're stuck. It'll show whether the failure is at the client, the server, or the plugin.

Frequently Asked Questions

What is Roblox Studio MCP?

Roblox Studio MCP is an open-source Model Context Protocol server. It connects AI assistants such as Claude Desktop and Cursor to a running Roblox Studio session through a Studio plugin. The assistant can read the object tree, inspect and change properties, edit Lua scripts, and start or stop playtests.

How to connect Cursor to Roblox Studio?

Add the roblox-studio entry to Cursor's MCP settings using the npx -y roblox-studio-mcp command. Install the Studio plugin from the repository source, open your place in Studio, and restart Cursor. Ask the agent to show your object tree to confirm the connection.

Is Roblox Studio MCP safe to use?

The server's design is reasonable, but the Quick Start's instruction to run a downloaded .exe is a serious warning sign. Skip that step, verify the npm package and plugin source yourself, and start with RBX_MCP_SAFE_MODE=true on a copy of your place. Test whether writes are blocked before you trust safe mode.

Why does my Roblox Studio MCP connection keep failing?

The most common causes are a plugin that isn't loaded in Studio, a conflict on port 44755, a timeout on a large hierarchy, or a client that wasn't restarted after the config change. Check those four items first, then raise log level to debug to see where the request stops.

Use this tool the way you'd use any new teammate: give it read access first, check its work, and keep your real code under version control. Start by connecting it to a copy of your place and asking for the object tree. If the hierarchy comes back and nothing else changes, you've verified the setup, and you can decide what write access to grant next. Pass this along to anyone about to run an MCP server from a README they haven't read closely.

Keep reading