Skip to main content
Glama

Tufan-Blox-Bridge: Roblox Studio MCP Server and Plugin

npm version license: MIT GitHub release

A free Roblox Studio MCP server and plugin that works as an add-on to Roblox's built-in Studio MCP. Connect Claude Code, Cursor or any MCP client to Roblox Studio and let your AI build, audit and version your game: 87 tools for Luau scripts, instances and properties, plus two-way file sync, git history, snapshots, a backdoor scanner, Luau linting and AI 3D-asset generation.

Keep the built-in server for play tests and screenshots. Add Tufan for everything around them.

Made by Tufan Studio, a game and web studio that builds Roblox, FiveM and AI developer tools.

Website and overview · npm · Latest release

Guides: Setup for Claude Code, Codex, Cursor, Antigravity, Gemini CLI and VS Code · Roblox Studio MCP not working? · Best Roblox Studio MCP servers compared

Roblox Studio with the Tufan-Blox-Bridge MCP plugin panel open beside a place


Quick install: connect Claude Code or Cursor to Roblox Studio

You need Node.js 18 or newer.

Easiest: paste this into your AI agent

Open Claude Code, Cursor or another AI agent in your Roblox project folder and paste:

Set up Tufan-Blox-Bridge, a Roblox Studio MCP server and plugin, for this project.

1. Run `npx -y tufan-blox-bridge@latest setup` in this folder. It installs the server and the Studio plugin, and registers with Claude Code or Cursor.
2. If it says nothing was registered, add the config it prints to your MCP settings, keeping any servers already there.
3. Don't ask me for API keys. They're optional.
4. Tell me what it did and the next steps it printed.

Or run one command

npx -y tufan-blox-bridge@latest setup

Then restart Roblox Studio and your AI client, and open the Tufan Studio toolbar button. A green pill means it's connected.

Or set it up by hand

1 — One-line installer (run from your Roblox project folder). It checks Node ≥ 18, installs the MCP server globally (npm i -g tufan-blox-bridge), drops the Studio plugin into your Plugins folder (tufan-blox-bridge install-plugin), and auto-registers with Claude Code when the claude CLI is on PATH:

# Windows (PowerShell)
iwr https://raw.githubusercontent.com/drgost1/Tufan-Blox-Bridge/main/install.ps1 | iex
# macOS / Linux
curl -fsSL https://raw.githubusercontent.com/drgost1/Tufan-Blox-Bridge/main/install.sh | bash

2 — Point your AI client at the server (skip if the installer registered it; use forward slashes in the path):

claude mcp add tufan --env TUFAN_PROJECT=C:/path/to/your/project -- tufan-blox-bridge

For Cursor / Claude Desktop / any MCP client:

{
  "mcpServers": {
    "tufan": {
      "command": "tufan-blox-bridge",
      "env": { "TUFAN_PROJECT": "C:/path/to/your/project" }
    }
  }
}

Optional env: TUFAN_OPENCLOUD_KEY (Open Cloud: datastore, cloud_luau, get_server_logs, get_server_history), TUFAN_MESHY_KEY (AI 3D generation).

3 — Restart Studio and your AI client. A Tufan Studio toolbar button appears — open its widget; the pill turns green when connected.

That's it. Your AI can now drive Studio, your scripts mirror to disk, and scan_backdoors is ready.

tufan times out / won't connect? Run claude mcp get tufan and confirm the command is tufan-blox-bridge (global install) or npx -y tufan-blox-bridge. If an argument got dropped, claude mcp remove tufan, then re-run the add. The installer auto-verifies this.

Other install methods

  • No install: npx -y tufan-blox-bridge or bunx tufan-blox-bridge.

  • Global: npm i -g tufan-blox-bridge → command tufan-blox-bridge.

  • Plugin: tufan-blox-bridge install-plugin (copies the bundled .rbxm into your Plugins folder), or manually download TufanBloxBridge.rbxm from Releases (or pwsh scripts/build-plugin.ps1 -Install).


Related MCP server: Melo

Why add Tufan when Roblox Studio already has an MCP server?

Roblox's built-in Studio MCP is excellent at running and seeing your game. Tufan is the add-on for building it safely, keeping it versioned and keeping it clean. Install both: they cover different jobs, and Tufan tells your AI which one to use.

You want to...

Built-in Studio MCP

Tufan add-on

Play test with a real character, keyboard and mouse

✅ Use this

➖ Left to the built-in

Take a screenshot of the viewport

✅ Use this

➖ Left to the built-in

Debug inside a running game

✅ Use this

➖ Warns the AI and points it there

Generate meshes, materials and scenes with Roblox AI

✅ Use this

➖ Has its own Meshy + Blender route

Checkpoint a subtree and restore it after a bad AI edit

➖

✅ snapshot / restore

Keep scripts on disk with two-way sync

➖

✅ Automatic mirror

Get back a GUI or model that a delete or Ctrl+Z wiped

➖

✅ .rbxm mirror with history, restore_from_mirror

Commit, diff and recover deleted scripts with git

➖

✅ 12 git_* tools

Scan free models for backdoors

➖

✅ scan_backdoors

Lint, type-check and format Luau

➖

✅ Selene, luau-lsp, StyLua

Scan a place for performance and responsive UI problems

MicroProfiler analysis

✅ scan_perf, scan_responsive, project_health

Build many objects in one call

By writing Luau yourself

✅ Ready-made batch, create_tree, mass_edit

Read and edit live DataStores

➖

✅ datastore (Open Cloud)

Upload local files

Images

✅ import_file: models, audio, images (Open Cloud)

Keep notes on your project between AI sessions

Skills

✅ project_context, per place

Let an AI explore with zero risk of changes

➖

✅ TUFAN_READONLY=1

Six reasons to install it as an add-on

  1. AI edits become reversible. Snapshots, git history and git_recover give you a way back that outlives Studio's undo stack.

  2. It's quick on every call. In our benchmark, running the same Luau took 17 ms through Tufan and 67 ms through the built-in server (median of 25 calls, measured November 2026 on one Windows PC; your numbers will vary). Roblox allows a plugin about 500 HTTP requests a minute, roughly 240 Tufan calls, so big jobs should use batch; past that, calls wait rather than fail.

  3. Free models stop being a blind risk. scan_backdoors checks scripts, attributes and values for hidden require payloads, obfuscation and webhooks.

  4. Your code lives where your tools do. Scripts mirror to disk, so VS Code, Selene, luau-lsp and git all work on real files.

  5. Big builds stay manageable. Thousands of changes go through in a single call, without your AI writing and debugging a Luau script for each job.

  6. The two servers cooperate. Tufan tells your AI at connect to use the built-in server for screenshots, play tests and live debugging, and it flags any result that used the edit copy while a Play session is running.

Comparison based on each server's published tool list as of November 2026. Roblox updates its server often, so check its tool list for changes.

How the Roblox Studio plugin and MCP server fit together

Two parts over a local HTTP bridge (127.0.0.1:58741):

  • MCP server (npx -y tufan-blox-bridge) — what your AI client connects to. Exposes the 87 tools.

  • Studio plugin (TufanBloxBridge.rbxm) — the in-Studio agent that executes commands and mirrors your scripts.

The AI calls a tool → the server queues a command → the plugin's long-poll picks it up → executes in Studio → returns the result. The server also handles file sync and git on your machine.

Roblox Studio AI features

  • 🛠 Full Studio control — 87 tools: scripts (line-level edits + atomic multi-hunk patch_script), instances (incl. whole-tree creation in one call), properties/attributes with full round-trip serialization (particle curves, gradients, fonts, springs), tags, tree inspection (describe = an instance's entire context in one call), Luau execution, output logs + a live error feed.

  • 🔄 Two-way file sync — open a place and its script tree mirrors to disk; edit a file → Studio updates, edit in Studio → the file updates.

  • 🌿 Opt-in per-place git — off by default (no .git, no headache). Turn it on in the widget and each place becomes its own repo with Commit / Push / Backup / Setup-GitHub buttons + auto-commit/push toggles. Your choice persists across restarts.

  • 🛡 Backdoor scanner — scan_backdoors finds require-of-Value, loadstring+HttpGet, exploit APIs, Discord webhooks, obfuscation, and hidden binary payloads; list_studio_plugins surfaces the remote-code-plugin vector.

  • ⏪ Snapshots — snapshot checkpoints any subtree before risky changes; restore brings it back exactly. A real undo that survives across the AI boundary.

  • 🛟 Instance mirror + history — GUIs, folders and models are saved to disk as .rbxm seconds after a change, with frozen copies whenever something is deleted or undone. restore_from_mirror brings back any instance by path, even one a Ctrl+Z wiped.

  • ⚡ Batch ops — batch runs dozens of mixed operations in one round-trip and one undo entry; 40 creates = 1 call, not 40.

  • 📱 Responsive UI engine — make_responsive converts a UI subtree Offset→Scale with a validated formula (skips draggables, dryRun previews); scan_responsive audits tree and scripts for resolution breakage and sub-44px tap targets.

  • 🩺 One-look audits — project_health (full place census in one traversal), scan_perf (ranked frame-killer fix list), find_duplicates (copy-pasted script clusters).

  • 🧹 Luau quality gate — format_scripts (StyLua), lint_scripts (Selene: unused vars, shadowing, deprecated APIs, footguns), typecheck (luau-lsp: type errors, undefined globals, bad require paths — before the code runs), and export_sourcemap (Rojo-style sourcemap so luau-lsp resolves requires + gives IntelliSense) run the standard toolchain over your synced script mirror — host-side, no Studio round-trip.

  • 🗄 Live save data — datastore reads and (gated) edits your PUBLISHED game's DataStores via Open Cloud — standard + ordered: list stores/keys, get/set/delete/increment. Read-first; writes need confirm and warn about the ProfileStore session-lock. No Studio runtime needed.

  • ☁️ Run code in production — cloud_luau executes server-side Luau against your published game via the Open Cloud Luau Execution API (ephemeral server, real server context, require works) and returns the script's return values + print logs — verify behavior against prod without joining. Gated as a write tool; DataStore/HttpService side effects are real.

  • 📈 Production server observability — get_server_logs reads per-server errors/warnings with full stack traces from your LIVE game (Open Cloud Server Management), and get_server_history lists 30 days of terminated/crashed/OOM servers with status, uptime and last-known memory/fps — then drill into any server's logs, even after it shut down.

  • 📥 Local file import — import_file uploads .rbxm/.fbx/.glb/audio/images from your disk to your own Roblox account (Open Cloud) and drops them straight into the place — Models insert, audio becomes a Sound, images a Decal. Your own uploads always pass the LoadAsset ownership wall.

  • 🧊 AI 3D-asset generation — generate_asset turns a text prompt (or image) into a game-ready prop in your open place: Meshy AI generates it, headless Blender lints + auto-fixes it against Roblox limits (≤20k tris, ≤1024px textures — Roblox silently mangles violations otherwise), Open Cloud uploads it, it inserts as a Model, and a post-insert finishing pass makes it actually game-ready: anchored, scaled to a stud height, semantic part names (no leaked "Cube"/"Cylinder"), flat material colors recovered (Roblox drops them on import), CollisionFidelity set, traceability attributes stamped, placed flush on the ground — one undo step. previewFirst: true shows you a rendered thumbnail of the geometry preview before the texture spend. Raw stages exposed too: meshy_generate/meshy_task (generation, remesh, credit balance) and blender_run/blender_process (headless Blender: lint, decimate, split-by-material, chunk oversized meshes, Cell-Fracture destructibles, convert, texture downscale, thumbnail render — or any custom bpy script). Credit-spend confirm gate built in.

  • 🔐 Your keys never leave your machine — TUFAN_MESHY_KEY / TUFAN_OPENCLOUD_KEY live only in your local MCP server env, are scrubbed from every error message, and are never written to any file, repo, or log by the bridge. Each user brings their own keys.

  • 🧭 Spatial awareness — the AI relates what it sees to coordinates: scene_state grounds a screenshot (every visible object's world and on-screen pixel coords via projection), pick raycasts a screen point → world hit + surface normal (identify / trace), place_on computes and applies a flush placement (bounding-box offset, optional align-to-surface + grid snap), objects_in_region queries an area.

  • 👥 Concurrent multi-session — run several Claude/Cursor sessions on the same Studio at once; one owns the plugin, the rest proxy through it, all commands serialized → no collisions.

  • 🧠 Per-project AI memory — project_context is a persistent markdown blob per place that the AI reads at session start (architecture, gotchas, false-bug traps) and updates as it learns — fewer tokens wasted re-discovering the project, fewer wrong conclusions.

  • 🔒 Read-only / safe mode — TUFAN_READONLY=1 hides the 37 write tools; mixed tools (script_source, tag, git_branch, git_remote) stay readable with writes blocked. Zero-risk AI exploration.

  • 🎚 Lean core toolset — TUFAN_TOOLSET=core exposes only the 28 everyday tools (the power suites stay one env-var away) for smaller tool menus and sharper AI focus.

  • 👁 Seeing the game — by design, not ours — screenshots come from the official Studio MCP's screen_capture, a real viewport render even when Studio is behind other windows. The server tells the AI this at connect, and flags any Tufan call that misses a running Play session. get_asset_thumbnail shows any catalog asset.

  • ▶️ Playtest — by design, not ours — starting, driving and probing a play session belongs to Roblox's official Studio MCP (real Play Solo with a character, keyboard/mouse input, character navigation). Tufan deliberately doesn't duplicate it: run the session there, and Tufan's get_output_log / get_recent_errors / official screen_capture still watch it live, with is_running telling you edit mode from a live sim.

  • 🗺 Multi-place — list_places, pull_place, and copy_script_across to move a module straight from one open place into another.

Roblox Studio MCP tools (87)

Group

Tools

Scripts

script_source · grep_scripts · edit_script_lines · patch_script · find_and_replace_in_scripts · find_duplicates

Instances

create_instance · delete_instance · clone_instance · move_instance · rename_instance · create_tree · history

Properties

get_properties · set_property · mass_edit · search_by_property · get_attributes · set_attribute · mass_set_attribute

Inspection

get_tree · get_descendants · search_objects · get_services · describe

Tags

tag · get_tagged

Selection

get_selection · set_selection

Luau / Batch

run_luau · batch

Logs

get_output_log · get_recent_errors · get_server_logs · get_server_history

Snapshots

snapshot · restore · list_snapshots · delete_snapshot

Instance mirror

mirror_history · restore_from_mirror

Responsive UI

make_responsive · scan_responsive

Audits

project_health · scan_perf

Code quality

format_scripts · lint_scripts · typecheck · export_sourcemap

Spatial

scene_state · pick · place_on · objects_in_region

Git

git_status · git_log · git_diff · git_show · git_commit · git_push · git_pull · git_restore · git_revert · git_recover · git_branch · git_remote

Assets

search_assets · get_asset_details · get_asset_thumbnail · search_materials · insert_asset · import_file

Asset pipeline

generate_asset · meshy_generate · meshy_task · blender_run · blender_process

Open Cloud

datastore · cloud_luau

Security

scan_backdoors · list_studio_plugins

HTTP

http_get

Multi-place

list_places · pull_place · copy_script_across

Meta

ping · is_running · project_context

In read-only mode (TUFAN_READONLY=1) the 37 write tools are hidden (including generate_asset, meshy_generate — spends money —, blender_run — native host execution — and cloud_luau — runs code in production) and the mixed read/write tools (script_source, tag, git_branch, git_remote, format_scripts) stay visible with their write paths blocked (datastore's write actions are also gated) — 50 inspection tools remain. With TUFAN_TOOLSET=core only the 28 everyday tools are exposed; both gates compose.

How it works

  • Auto-mirror on connect — opening a published place pulls its script tree to <project>/projects/<Experience>_<universeId>/<Place>_<placeId>/.

  • Two-way sync — file edits push to Studio; Studio edits write to disk. A loop-guard prevents echo, and a file only flows to Studio when its content really changed.

  • Instance mirror — every direct child of StarterGui, ReplicatedStorage, ServerStorage, StarterPack and Lighting is saved as <Service>/<Name>.rbxm next to the scripts (whole subtree, scripts included, via SerializationService). Changes are debounced (2 s) and batched into one request, and nothing is sent unless the bytes changed; StarterGui is watched per property, the rest by structure changes plus a 90 s sweep.

  • History — before a mirror file is deleted or overwritten, a copy goes to .history/<timestamp>/ (always when an instance is removed, when a unit loses descendants, and at most every 5 min for plain edits; scripts too). Copies older than 30 days are pruned on connect. mirror_history lists them; restore_from_mirror puts one instance back (whole unit or anything inside it), trying the live file first and then older copies.

  • Git (opt-in) — enable it in the widget; each place folder becomes its own repo. Off by default = plain files, no .git. A re-pull auto-snapshots first, so it never overwrites uncommitted work. git_recover brings back a deleted file from history.

  • HTTP limit — Roblox allows a plugin about 500 HTTP requests a minute, roughly 240 Tufan calls. Past that, calls wait for the budget to refill (up to about a minute) rather than fail, so use batch, create_tree or mass_edit for big jobs.

  • Concurrent sessions — the first server owns port 58741 + the plugin; others run as proxies that forward to it. The owner serializes every command through one plugin queue, so multiple sessions never collide. If the owner closes, a proxy promotes automatically.

  • Disconnect lock — when the plugin goes offline the mirror is set read-only (copy-only) until it reconnects.

Config (env)

Variable

Effect

TUFAN_PROJECT

Project root for sync/git (use forward slashes). Defaults to cwd.

TUFAN_READONLY=1

Safe/inspector mode — write tools hidden, script_source/tag readable but write-blocked.

TUFAN_TOOLSET=core

Lean mode — expose only the 28 everyday core tools (default full = all 87).

TUFAN_AUTOCOMMIT=1

Auto-commit each Studio→file edit (also toggle-able in the widget).

TUFAN_AUTOPUSH=1

Also push after each commit.

TUFAN_PROJECTS_DIR

Base dir override for auto-registered projects.

TUFAN_OPENCLOUD_KEY

Open Cloud API key for import_file / generate_asset (assets Read+Write scopes, create one here).

TUFAN_CREATOR_ID / TUFAN_GROUP_ID

Upload owner override for import_file / generate_asset (defaults to the logged-in Studio user).

TUFAN_MESHY_KEY

Meshy AI API key for meshy_generate / meshy_task / generate_asset (create one here — needs a paid Meshy plan).

TUFAN_MESHY_AUTOCONFIRM=1

Skip the per-call Meshy credit-spend confirmation gate.

TUFAN_BLENDER_PATH

Path to blender.exe for the Blender tools (default: auto-detect newest install, then PATH).

TUFAN_ASSET_DIR

Where generated assets download (default ~/.tufan-blox-bridge/assets/).


Potential capability (roadmap)

Where this can go — honest about what's built vs. next:

  • Playtest automation — intentionally out of scope. Tufan shipped plugin-side Run-mode control (playtest, playtest_probe, playtest_input) through v0.13; removed in v0.14. A plugin can only drive Run mode (server + physics, no player character) — Roblox's official Studio MCP drives real Play Solo with a character, keyboard/mouse and navigation, so duplicating a weaker version was net-negative. Run the session there; Tufan's log feed, screenshots and is_running still observe it.

  • Non-script instance mirroring — models/parts as files on disk (geometry currently stays in Studio by reference, a plugin-API limit).

  • More Power Tools — scan_deprecated (flag deprecated API usage across all scripts).

  • Asset pipeline, next steps — mesh generation (v0.11) + real-world finishing/preview (v0.12) shipped. Still ahead: inventory-insert for unowned assets, Meshy auto-rigging/animation passthrough, bulk procedural kits via Blender geometry nodes, Roblox-privileged material generation (pairs with the official MCP).

  • Shared off-machine backup — push every place mirror to a configured GitHub org with one click.

Issues + status tracked in ISSUES.md. Contributions welcome.

Repo

server/   TypeScript MCP server (published as npm `tufan-blox-bridge`)
plugin/   Luau Studio plugin (built to TufanBloxBridge.rbxm)
scripts/  build-plugin.ps1
docs/     launch notes, market comparison

Roblox MCP FAQ

What is Tufan-Blox-Bridge? A free, open-source Roblox Studio MCP server and Studio plugin. It lets AI coding tools such as Claude Code and Cursor edit scripts, build instances, audit and back up your game inside Roblox Studio.

Does it replace Roblox's built-in Studio MCP? No. It's an add-on. Keep the built-in server for play tests, screenshots and live debugging, and use Tufan for editing, safety, versioning and audits.

Does it work without the built-in server? Yes, for everything that happens in edit mode. You won't have screenshots or play testing, because Tufan leaves those to the built-in server.

Which AI clients does it work with? Any MCP client over stdio, including Claude Code, Claude Desktop and Cursor.

Do I need the Studio plugin as well as the npm package? Yes. The npm package is the MCP server your AI talks to, and the plugin carries out the commands inside Studio. The one-line installer sets up both.

Is it free? Yes, MIT licensed. Only the optional Meshy AI features need a paid Meshy plan, and you bring your own keys.

Is it safe to use on a real game? You choose how much it can do. Read-only mode hides every write tool, snapshots protect risky edits, and tools that touch your published game ask for a separate Open Cloud key. Your keys stay on your machine.

License

MIT © Tufan Studio.

Available Tools

87 tools
batchA
Destructive

Run MANY operations in ONE round-trip and ONE undo entry. The single biggest speed win for multi-step builds (a 40-instance UI = 1 call, not 40). Each op is { op, args } where args is exactly what that tool takes (omit place). Returns a per-op result list. Set stopOnError to halt at the first failure. Supported ops: create_instance, delete_instance, clone_instance, move_instance, rename_instance, mass_create, mass_duplicate, create_tree, set_property, mass_set_property, mass_edit, set_attribute, mass_set_attribute, add_tag, remove_tag, set_script_source, edit_script_lines, find_and_replace_in_scripts, set_selection, get_properties, get_children, get_script_source. (create_tree / mass_* already batch one kind; use batch to mix different ops.)

Inputs: ops (required), place, stopOnError.

blender_processA

Run a canned headless-Blender operation on a local 3D file (.glb/.gltf/.fbx/.obj/.blend in; .glb/.fbx out — input is never modified). Actions: inspect (Roblox-readiness lint: tri counts vs the 20k limit, materials-per-mesh, UV sets, texture sizes vs the 1024 cap), decimate (reduce to target tris, default 20000), split_by_material (one object per material — Roblox imports one MeshPart per material object), split_chunks (bisect oversized meshes into ≤target-tri pieces), fracture (Cell Fracture shards for destructibles — needs the Cell Fracture extension installed), set_origins (per-object geometry-median origins), convert (re-export, e.g. obj→glb for import_file), downscale_textures (cap textures at texLimit, default 1024), thumbnail (render a 512px PNG preview of the model — SEE an asset before uploading/spending; returned as an image). Needs Blender installed (free) — auto-detected or TUFAN_BLENDER_PATH.

Inputs: action (required), inputFile (required), shards, target, +3 more.

blender_runA
Destructive

POWER TOOL: run an arbitrary bpy (Python) script in headless Blender on this machine. The script gets helper globals from the Tufan preamble: ARGS (parsed k=v argv), IN/OUT (from inputFile/outputFile), emit(dict) → returns structured JSON to the caller, plus load_input()/import_any()/export_any()/mesh_objs()/tri_count()/inspect_report()/apply_all_modifiers()/select_only(). End with emit({...}) to return data. Python exceptions come back as clean tracebacks. Use blender_process for the common canned operations; this is for everything else (procedural geometry, custom cleanup, baking, batch edits). Executes native code locally — hidden in read-only mode. Needs Blender installed (auto-detected or TUFAN_BLENDER_PATH).

Inputs: script (required), inputFile, outputFile, factoryStartup, +1 more.

clone_instanceA

Copy an instance with all its descendants and return the copy's path. Recorded as one Studio undo step. Instances with Archivable=false cannot be cloned. For many copies at once use batch with several clone operations.

Inputs: path (required), place, parentPath.

cloud_luauA
Destructive

Run server-side Luau against your PUBLISHED game via the Open Cloud Luau Execution API — a fresh ephemeral server loads the latest published place version, runs your script in SERVER context (require/ModuleScripts work; existing scripts do NOT auto-run; no physics), and returns the script's return values + print logs. The closest thing to 'verify in production' without joining the game. ⚠ NOT a side-effect sandbox: DataStoreService and HttpService ARE available and PERSIST (a script could even AssetService:SavePlaceAsync) — runtime/in-memory state is throwaway, but cloud writes are real. Long scripts: if still running when the wait elapses, re-call with resume = the returned task path. Needs an Open Cloud key with the luau-execution scope (TUFAN_OPENCLOUD_KEY) + a published universe. For Studio EDIT-mode code use run_luau instead; for code inside a live Studio play session use Roblox's official Studio MCP (execute_luau).

Inputs: place, resume, script, versionId, +2 more.

copy_script_acrossA
Destructive

Copy one script's Source from one connected place into another, for example to share a module between two games. Both places must be open in Studio. The destination script is overwritten if it exists, or created with any missing folders if it doesn't. Use list_places to get the place names or ids.

Inputs: toPlace (required), fromPlace (required), sourcePath (required), destPath.

create_instanceA

Create one new instance in the edit copy and return its path. Recorded as one Studio undo step. A property that fails to set is skipped without an error, so read it back with get_properties when it matters. For several instances use create_tree (a nested hierarchy) or batch (mixed operations), which run in one call.

Inputs: className (required), parentPath (required), name, place, +1 more.

create_treeA

Build a whole nested hierarchy from one spec in a single call and one Studio undo step, and return the root path and instance count. Best for UIs and models (a panel and all its children at once). Properties that fail to set are skipped silently. For one instance use create_instance; for mixed creates, edits and deletes use batch.

Inputs: tree (required), parentPath (required), place.

datastoreA
Destructive

Inspect/edit a PUBLISHED game's saved data via the Open Cloud DataStore API (server-side HTTP, no Studio runtime). READ actions: list_datastores, list_keys, get, list_ordered, get_ordered. WRITE actions (gated — need confirm:true and are blocked in read-only mode): set, delete, increment. ⚠ SESSION-LOCK WARNING: a live game server owns the keys of ONLINE players (ProfileStore session lock); the REST write path ignores that lock, so writing such a key either gets overwritten by the server's autosave or corrupts the live session. Only write keys for OFFLINE players. ⚠ SHARED BUDGET: since 2026-07-29 Open Cloud DataStore calls count against the SAME unified per-experience request budget as the live game's in-game DataStore calls (base 300 + CCU × multiplier per request type/minute) — heavy MCP-driven reads/writes can starve a running game; watch the quota: line when the API returns rate-limit headers. Needs an Open Cloud key with universe-datastores scopes (TUFAN_OPENCLOUD_KEY) and a published universe (auto-detected from game.GameId, or TUFAN_UNIVERSE_ID).

Inputs: action (required), limit, order, place, +14 more.

delete_instanceA
DestructiveIdempotent

Destroy an instance and all of its descendants in the edit copy. Recorded as one Studio undo step, so history undo brings it back while the undo stack lasts. For a checkpoint that outlives the undo stack, take a snapshot first. Fails if the path does not resolve.

Inputs: path (required), place.

delete_snapshotA
DestructiveIdempotent

Permanently delete one saved snapshot from ServerStorage._TufanSnapshots to free space or tidy up. Only the checkpoint is removed; the live instance it was taken from is not touched. The deletion is not recorded as a Studio undo step, so treat it as final. Fails if no snapshot has that name; use list_snapshots to check names first.

Inputs: name (required), place.

describeA
Read-only

Full context of one instance in a SINGLE call: identity, key properties, attributes, tags, a class-bucketed child summary, attached scripts (with line counts), and world bounds. Replaces the 5-6 round-trips (get_properties + get_children + get_attributes + get_tags + script grep) it used to take to understand a node. Read-only. For a whole area use get_tree; for property values describe doesn't show, use get_properties with names.

Inputs: path (required), place.

edit_script_linesA
Destructive

Replace a range of lines in one script with new text, without resending the whole Source; returns the new line count. Overwrites those lines. Line numbers shift after each edit, so re-read with script_source or grep_scripts before a second edit. When you can quote the text to change, patch_script is safer because it doesn't depend on line numbers.

Inputs: path (required), endLine (required), newText (required), startLine (required), +1 more.

export_sourcemapA
Idempotent

Generate a Rojo-style sourcemap.json from a place's synced script mirror — the file luau-lsp needs to resolve require paths and give IntelliSense/type info in VS Code (and the foundation the typecheck tool will build on). Pure filesystem walk of the on-disk mirror: no Studio round-trip, no mutation. Writes to /sourcemap.json by default. Point luau-lsp at it via the luau-lsp.sourcemap.sourcemapFile setting. (Reflects scripts + folders in the mirror; non-script instances aren't on disk so aren't represented — that's all luau-lsp needs for requires.)

Inputs: place, output.

find_and_replace_in_scriptsA
Destructive

Replace a piece of plain text in every script of the place at once, for renames across the codebase. Overwrites every match in every script. Run with dryRun true first to see which scripts and how many matches would change. For changes inside one script use patch_script.

Inputs: find (required), replace (required), place, dryRun.

find_duplicatesA
Read-only

Find groups of scripts whose Source is exactly identical, biggest group first: copy-pasted code to move into one shared ModuleScript. Read-only. Only exact copies match; near-duplicates with small edits are not reported. To search for a specific snippet use grep_scripts.

Inputs: place, minLines.

format_scriptsA
DestructiveIdempotent

Format Luau on disk with StyLua (the standard Roblox formatter) over a place's synced script mirror. Default formats in place; check:true reports what's NOT formatted WITHOUT writing (a --check diff) — use it as a pre-commit gate so git diffs and snapshots stay clean. Respects a .stylua.toml in the project. Scope with paths (relative to the mirror root) or format the whole mirror. Needs StyLua installed (auto-detected or TUFAN_STYLUA_PATH).

Inputs: check, paths, place, timeoutSeconds.

generate_assetA

FULL PIPELINE: turn a text prompt (or an image) into a game-ready asset in the open place — Meshy AI generates the textured mesh, headless Blender lints it against Roblox limits and auto-fixes (decimates >20k tris, downscales >1024px textures; autoFix:false to skip), then the GLB uploads to the user's Roblox account via Open Cloud and inserts as a Model. SPENDS MESHY CREDITS (~30 ≈ $0.60 per asset) — first call returns a cost estimate and asks for confirm:true unless TUFAN_MESHY_AUTOCONFIRM=1. Generation takes minutes; on budget exhaustion you get a meshyTaskId to resume with (no re-spend). Position the inserted model afterwards with place_on. Needs TUFAN_MESHY_KEY + TUFAN_OPENCLOUD_KEY (Blender optional but recommended). For an EXISTING marketplace asset by id use insert_asset instead; for a local file you already have use import_file instead; to generate WITHOUT auto-inserting into the place (just the raw model), use meshy_generate instead.

Inputs: name, place, anchor, insert, +15 more.

get_asset_detailsA
Read-only

Fetch public marketplace details for one asset id as JSON: name, creator, asset type, description, created and updated dates, and whether it is for sale. Read-only; uses Roblox's public economy API. It does not say whether a model contains scripts, so run scan_backdoors after inserting one. To see the asset, use get_asset_thumbnail.

Inputs: assetId (required).

get_asset_thumbnailA
Read-only

Return an asset's thumbnail as a PNG image, so you can see what it looks like before inserting it. Read-only; uses Roblox's public thumbnail API and works for any public asset, owned or not. For text details use get_asset_details. This shows catalog art only; to see the open place use the official Studio MCP's screen_capture.

Inputs: assetId (required), size.

get_attributesA
Read-only

Read every attribute set on one instance as a JSON object of name to value. Read-only; returns {} when there are none. For attributes together with properties, tags and children use describe.

Inputs: path (required), place.

get_descendantsA
Read-only

List every descendant of an instance, one line each with its class and full path, down to a depth limit. Read-only. Gives exact paths you can pass to other tools, but nothing is folded, so it gets long on big models: prefer get_tree to map a large area, and describe for one instance in detail.

Inputs: path (required), place, maxDepth.

get_output_logA
Read-only

Read recent lines from Studio's Output window, prints included, newest last. Read-only. The plugin keeps the last 1,500 messages, play test output included. Use it to see what a script printed; for errors only, with script and line parsed, get_recent_errors is faster.

Inputs: place, severity, maxEntries.

get_propertiesA
Read-only

Read property values of one instance as JSON. Read-only. Without names it returns Name, ClassName, all attributes and a common set (Position, Size, CFrame, Color, Material, Transparency, Anchored, Text, Visible, Enabled, Value, Source and more) that applies to the class; Roblox has no API to list every property, so pass names for anything else. For identity, children, tags and attributes in one call use describe; for attributes only use get_attributes.

Inputs: path (required), names, place.

get_recent_errorsA
Read-only

Read the errors and warnings Studio has produced, including during a play test, with script and line parsed out. Read-only. It reads the feed the plugin already pushed, so it answers instantly even while Studio is busy. Pass the cursor from the previous reply as since to get only new events. For all Output text (prints and info) use get_output_log; for your published game's live servers use get_server_logs.

Inputs: place, since, severity.

get_selectionA
Read-only

Return what the user has selected in Studio right now, one line per instance with class and path. Read-only. Use it when the user says "this" or "the selected part" instead of guessing a path.

Inputs: place.

get_server_historyA
Read-only

Server History for your PUBLISHED game via the Open Cloud Server Management API (BETA) — a rolling 30-day list of active AND terminated servers (shut down / restarted / crashed / out_of_memory / moderated) with status, uptime, termination time, last-known memory/fps/occupancy. Default view is terminated servers only; pass status:active for live servers or status:all for everything. This is the same ListGameServers endpoint Creator Hub's Server Management page uses. Needs TUFAN_OPENCLOUD_KEY with the universe read scope. Siblings: get_output_log = edit-mode Studio Output; get_recent_errors = live Studio session feed; this = PRODUCTION servers. Follow up with get_server_logs serverId: to read a server's errors/stack traces (logs remain available after termination).

Inputs: limit, place, cursor, filter, +3 more.

get_server_logsA
Read-only

Recent PRODUCTION game-server logs (errors/warnings with full stack traces) via the Open Cloud Server Management API (Game Server Logs, BETA) — per-server visibility into your LIVE game, the same data as Creator Hub → Server Management → Logs tab. Logs take ~3 min to appear after they're emitted. Pass serverId (a jobId, same as game.JobId) to read one server's logs; omit it to list the currently running servers so you can pick one (re-call with serverId). Server-emitted duplicates are aggregated into skippedCount. Needs TUFAN_OPENCLOUD_KEY with the universe read scope. Siblings: get_output_log = edit-mode Studio Output; get_recent_errors = live Studio session feed; this = PRODUCTION servers. Pair with get_server_history to find terminated/crashed servers (logs stay readable after shutdown).

Inputs: limit, place, cursor, filter, +3 more.

get_servicesA
Read-only

List the top-level services of the open place (Workspace, ReplicatedStorage, StarterGui and so on). Read-only. Use it to orient in an unfamiliar place, then get_tree on the service you care about.

Inputs: place.

get_taggedA
Read-only

List the paths of every instance in the place that carries a CollectionService tag. Read-only. Use it to check what a tag-driven script will act on. For one instance's tags use tag with action get.

Inputs: tag (required), place, className.

get_treeA
Read-only

Map the hierarchy under an instance with as few tokens as possible: runs of same-class siblings fold into one "ClassName ×N" line, so a 4,000-part model costs about one line. Read-only. Start here to understand a place or a large model. For exact paths of every descendant use get_descendants; for one instance's properties, tags and children use describe.

Inputs: path (required), place, maxDepth, className, +1 more.

git_branchA

List the local branches of a place's mirror repo (current one marked *), or create a new branch from the current commit and switch to it. Listing is read-only; creating is blocked in read-only mode. Uncommitted changes carry over to the new branch.

Inputs: name, place.

git_commitA

Stage and commit changes in a place's mirror repo, creating a restore point for scripts and saved instances. Only adds history; nothing is overwritten. Commits every change unless paths is given. Commit before risky edits so git_restore, git_revert and git_recover have something to go back to; git_push then copies it off this machine.

Inputs: message (required), paths, place.

git_diffA
Read-only

Show a unified diff in a place's mirror repo. Read-only. With no refs it shows uncommitted changes; with from it compares that commit to the working files; with from and to it compares two commits. For a commit's summary use git_show; for which files changed use git_status.

Inputs: to, from, path, place.

git_logA
Read-only

List recent commits in a place's mirror repo, newest first: short hash, date and message. Read-only; says so when there are no commits yet. Use it to find the ref for git_show, git_diff, git_restore or git_revert.

Inputs: count, place.

git_pullA
Destructive

Fetch the remote's commits and merge them into the mirror, for example to restore a place's files on a new machine. Merged changes overwrite files in the mirror, and the file sync carries them into Studio. Commit or check git_status first; a conflict stops the merge.

Inputs: place.

git_pushA

Push the current branch's commits to its remote, as an off-machine backup of the place's scripts and saved instances. Sends data to the remote (for example GitHub) using your local git credentials. Needs a remote with an upstream branch: add one with git_remote first. Commit with git_commit before pushing.

Inputs: place.

git_recoverA

Bring back a deleted file: searches all history for the last commit where the file still had content and writes it back into the mirror. Use it when a script is gone and you don't know which commit had it; if you know the commit, git_restore with source does the same. Says so if the file was never committed.

Inputs: path (required), place.

git_remoteA

List the git remotes of a place's mirror repo, or add one. Adding a remote such as a private GitHub repo lets git_push keep a copy off this machine. Adding is blocked in read-only mode and fails if the name already exists.

Inputs: url, name, place, action.

git_restoreA
DestructiveIdempotent

Overwrite one file in the mirror with its committed version: HEAD by default, or an older commit given as source. Uncommitted edits to that file are lost and cannot be recovered, so check git_diff first. The file sync then carries the restored script into Studio. For a file that was deleted use git_recover; for instances checkpointed in the place use restore.

Inputs: path (required), place, source.

git_revertA
Destructive

Undo one earlier commit by adding a new commit with the opposite changes; history is kept, and the files in the mirror change accordingly. Use it to roll back a bad change that is already committed. Fails on a merge conflict. To undo uncommitted edits to one file, use git_restore instead.

Inputs: ref (required), place.

git_showA
Read-only

Show one commit's author, date, message and changed-file summary, or, with path, the full content of one file as it was in that commit. Read-only. Use it to inspect an old version before restoring it with git_restore. For line-by-line changes use git_diff.

Inputs: ref (required), path, place.

git_statusA
Read-only

Show the git status of a place's mirror repo: current branch, commits ahead or behind the remote, and each changed file. Read-only. Run it before git_commit to see what will be committed, or before git_pull to make sure nothing is uncommitted. For line-level changes use git_diff.

Inputs: place.

grep_scriptsA
Read-only

Search the Source of every script in the place and return matching lines as path:line: text. Read-only; stops at 500 matches. Use it to find where something is defined or used before editing. To find instances by name use search_objects; to replace text everywhere use find_and_replace_in_scripts.

Inputs: pattern (required), place, ignoreCase.

historyA
Destructive

Step Studio's own undo history back or forward one entry, exactly like Ctrl+Z or Ctrl+Y. It affects the latest change by anyone, including the user, not only Tufan's. Each Tufan write (and each batch, create_tree or mass_edit) is one entry. For anything older than the undo stack, use restore (snapshots) or restore_from_mirror.

Inputs: direction (required), place.

http_getA
Read-only

Fetch a URL (GET) and return the response body as text. For grabbing docs, JSON APIs, or reference data while working. Body is capped at ~100 KB; 15s timeout.

Inputs: url (required), headers.

import_fileA

Import a LOCAL file into Roblox: uploads it to the user's own account via the Open Cloud Assets API (needs TUFAN_OPENCLOUD_KEY), then inserts it into the open place. Supports .rbxm/.rbxmx/.fbx/.gltf/.glb (Model), .mp3/.ogg/.wav/.flac (Audio → Sound instance; wav/flac acceptance may vary), .png/.jpg/.bmp/.tga (Decal instance). NOT .obj — convert to .fbx/.glb first. Max 20 MB. Audio uploads are quota-limited (10/month, 100/month if ID-verified) and queue for moderation — they often outlive waitSeconds; when that happens the call returns an operationId, and re-calling with { operationId } resumes WITHOUT re-uploading or burning quota. Models typically finish in seconds. For an EXISTING marketplace asset by id, use insert_asset instead; to AI-generate a new mesh from a prompt/image, use generate_asset instead.

Inputs: name, place, anchor, insert, +10 more.

insert_assetA

Insert a marketplace asset into the edit copy by id and return its path. Recorded as one Studio undo step. Roblox only lets Studio load assets the signed-in user owns, or Roblox-made ones, so most third-party free models fail until the user adds them to their inventory in the Toolbox. Run scan_backdoors after inserting a free model. For a file on this computer use import_file; to generate a new model with AI use generate_asset.

Inputs: assetId (required), place, parentPath.

is_runningA
Read-only

Whether a simulation is running in the target Studio: a Play session, Run mode, or plain edit mode. Read-only state check — use it to confirm you're in edit mode before mutating. To START/STOP a play session or send input, use Roblox's official Studio MCP.

Inputs: place.

lint_scriptsA
Read-only

Lint Luau with Selene (the standard Roblox linter) over a place's synced script mirror — catches footguns, unused variables, shadowing, undefined globals, and deprecated APIs (file:line). Read-only: reports findings, changes nothing. Scope with paths or lint the whole mirror. Needs Selene installed (auto-detected or TUFAN_SELENE_PATH) and a selene.toml with std="roblox" in the project (else Roblox globals report as undefined).

Inputs: paths, place, timeoutSeconds.

list_placesA
Read-only

List the Roblox Studio places connected to the bridge right now, with placeId, name, gameId and project folder. Read-only. Call it first when several places are open, then pass a placeId or name as the place argument of other tools; with one place open, tools target it automatically. To check a single connection, ping is enough.

Inputs: no named parameters.

list_snapshotsA
Read-only

List the snapshots saved in this place: name, class, descendant count and the path each one restores to. Read-only. Call it before restore or delete_snapshot to get the exact name; returns "(no snapshots)" when there are none.

Inputs: place.

list_studio_pluginsA
Read-only

List Studio plugins installed locally on this machine (local .rbxm plugins + marketplace InstalledPlugins). Use this to spot the blind spot scan_backdoors can't reach: a third-party plugin running remote code. Server-side; no Studio call.

Inputs: no named parameters.

make_responsiveA
Destructive

Make a UI subtree resolution-proof. Converts Offset→Scale across ALL the properties that break responsiveness — Position, Size, CanvasSize, CellSize, CellPadding, UIPadding, UICorner CornerRadius (validated formula: ÷ parent AbsoluteSize per axis; CornerRadius ÷ min-axis). Skips runtime-driven elements (tagged Draggable/Resizable, or in exclude) so it never shatters draggable/resizable panels. ALWAYS dryRun first to preview. modes: scale (default, Offset→Scale) · offset (reverse) · fit (root fills parent: Size {1,1} + Pos 0 + Anchor 0) · uiscale (keep Offset, add a UIScale + a real viewport-fit driver). Flags: aspectRatio (add UIAspectRatioConstraint at current aspect, skips layout-managed kids), minSize (UISizeConstraint 44×44 on buttons).

Inputs: path (required), mode, place, dryRun, +4 more.

mass_editA
DestructiveIdempotent

Apply many property changes, across any number of instances, in one call recorded as one Studio undo step. Each edit is tried on its own: failures (unresolved path, bad property or value) are listed with their index and reason, and the rest still apply. Prefer it over repeated set_property calls, since Roblox limits the plugin to about 500 requests a minute. For attributes use mass_set_attribute.

Inputs: edits (required), place.

mass_set_attributeA
DestructiveIdempotent

Set many attributes, across any number of instances, in one call recorded as one Studio undo step. Each edit is tried on its own; failures are listed with their index and reason while the rest still apply. The attribute version of mass_edit; for one attribute set_attribute is enough.

Inputs: edits (required), place.

meshy_generateA

Generate a 3D model with Meshy AI from a text prompt (two-stage: geometry preview → texture refine, auto-chained) or a single image (imageUrl or local imagePath). Downloads the resulting GLB + PBR maps to the local work dir (~/.tufan-blox-bridge/assets//) and reports the paths — pair with blender_process (lint/fix) and import_file (upload+insert), or use generate_asset for the whole pipeline in one call. SPENDS MESHY CREDITS (~30 ≈ $0.60 per textured asset): the first call returns a cost estimate and asks for confirm:true unless TUFAN_MESHY_AUTOCONFIRM=1. Generation takes minutes; if waitSeconds runs out you get a taskId to resume with (no re-spend). Needs TUFAN_MESHY_KEY (paid Meshy plan).

Inputs: prompt, taskId, confirm, imageUrl, +5 more.

meshy_taskA

Inspect or act on an existing Meshy task by id: status (poll progress), download (re-fetch fresh signed URLs and save the GLB + PBR maps locally), remesh (retopologize an existing task's model to targetPolycount — 5 credits, textures preserved; use to bring a >20k-tri result under Roblox's limit without regenerating), balance (remaining account credits — no taskId needed). Needs TUFAN_MESHY_KEY.

Inputs: action, taskId, waitSeconds, targetPolycount.

mirror_historyA
Read-only

What the on-disk mirror can bring back. The plugin saves every direct child of StarterGui, ReplicatedStorage, ServerStorage, StarterPack and Lighting as a .rbxm next to the script files (seconds after a change), and keeps a frozen copy in .history whenever one is removed, loses descendants (a delete or Ctrl+Z) or is overwritten after a quiet spell; scripts get the same. Lists the live mirror files and the history copies whose path matches path (a unit or anything inside it). Read-only. Restore one with restore_from_mirror; for snapshots taken inside the place use list_snapshots, and for committed script history use git_log.

Inputs: path, limit, place.

move_instanceA
DestructiveIdempotent

Move an instance (with its descendants) under a different parent and return its new path. Recorded as one Studio undo step. To change only the name use rename_instance; to keep the original and place a copy, use clone_instance.

Inputs: path (required), newParentPath (required), place.

objects_in_regionA
Read-only

List parts whose bounds overlap a region: a box (center+size), a sphere (center+radius), or 'around' an instance (its bounding box, optionally padded). Spatial query for "what's near X / inside this area". Returns part paths + world pos + size. Read-only. Give center with size (box) or radius (sphere), or around instead. To find what is under a screen point use pick; to find by name use search_objects.

Inputs: pad, size, place, around, +5 more.

patch_scriptA
Destructive

Apply several literal find-and-replace hunks to one script in a single call, in order, without resending the file. All or nothing: if a required hunk's text is missing, it errors and writes nothing, so a stale patch can't half-apply. Use dryRun to check first. The safest way to edit code you can quote; for a line range use edit_script_lines, and for the same change in many scripts use find_and_replace_in_scripts.

Inputs: path (required), hunks (required), place, dryRun.

pickA
Read-only

Raycast from a screen point into the scene and report what's under it: the hit instance (+ nearest Model ancestor), world position, surface normal, distance, and the part's CFrame/size/orientation. Give x,y in pixels OR nx,ny in 0..1 OR nothing for the viewport center. Powers "what is that?" and tracing (sample points along a screen path). Read-only.

Inputs: x, y, nx, ny, +4 more.

pingA
Read-only

Check that a Studio place is connected and answering, and return its name, PlaceId and session id. Read-only. Use it to confirm the plugin is connected before other calls, or to diagnose timeouts; list_places shows every connected place at once.

Inputs: place.

place_onA
DestructiveIdempotent

Compute and apply an accurate placement: raycast to a surface (a screen point, a target instance's TOP via onTarget, or straight down via ground), then sit the object FLUSH on it — offset by the object's bounding box so it doesn't clip or float. Optional alignToNormal (rotate to the surface) and snap (grid studs). Use dryRun to get the computed CFrame without moving. Moves a Part (CFrame) or a Model (PivotTo, bbox-center flush). Write tool.

Inputs: path (required), x, y, nx, +10 more.

project_contextA
DestructiveIdempotent

Persistent per-project AI context (markdown) stored on the MCP server at ~/.tufan-blox-bridge/context/.md — survives sessions and is shared by every AI session that touches this place. CALL get AT SESSION START, BEFORE exploring the place: it carries hard-won facts (architecture, conventions, gotchas, false-bug-report traps) that save tokens and prevent wrong conclusions. set overwrites the blob; append adds a dated entry — update it whenever you learn something durable about the place (a confirmed bug's root cause, a naming convention, a do-not-touch area). get works in read-only mode; set/append are write-gated. An explicit numeric PlaceId works even with no Studio connected (storage is local).

Inputs: action (required), place, content.

project_healthA
Read-only

One-look census of the game (installed plugins and Studio UI excluded): instance / script / part counts, total Luau size, particle + light counts, a per-service descendant breakdown, tag count, and StreamingEnabled. The fast 'what is this game?' overview before diving in. Read-only. For performance problems use scan_perf; for security use scan_backdoors; to explore the hierarchy use get_tree.

Inputs: place.

pull_placeA
DestructiveIdempotent

Re-read every script in a connected place and rewrite its mirror folder on disk (/projects/_) to match Studio. It runs automatically on connect, so use it only when the files look out of date. Mirror files are overwritten; when git is on, uncommitted mirror changes are committed first so they can be recovered. Unpublished places (PlaceId 0) have no mirror.

Inputs: place.

rename_instanceA
DestructiveIdempotent

Change an instance's Name and return its new path. Recorded as one Studio undo step. Scripts that find the instance by its old name will stop finding it, so search with grep_scripts first when renaming something code refers to.

Inputs: path (required), newName (required), place.

restoreA
DestructiveIdempotent

Put a snapshot checkpoint back: destroys the child with the original name under the original parent, then clones the checkpoint into its place. Recorded as one Studio undo step, and the snapshot is kept so you can restore it again. Use list_snapshots to find names. For script files tracked in git use git_restore or git_recover; for instances saved by the disk mirror use restore_from_mirror.

Inputs: name (required), place, parentPath.

restore_from_mirrorA
DestructiveIdempotent

Bring one instance back into the edit copy from the on-disk mirror or its .history, by Studio path (e.g. StarterGui.MineGui, StarterGui.FarmGui.Toasts, ReplicatedStorage.Mining.SomeModule). Works for anything inside a mirrored unit and for scripts. Without version it tries the live mirror file first, then history copies newest first, and uses the first one that still holds the path. One undo entry. Refuses to overwrite an existing same-named instance unless replace=true. Use mirror_history to pick a version.

Inputs: path (required), place, replace, version, +1 more.

run_luauA
Destructive

Execute Luau in the Studio plugin context (EDIT mode — runs against the edit DataModel, not a running playtest's server/client). Captures the return value and printed output. Full plugin API access. For code that must run INSIDE a live play session, use Roblox's official Studio MCP (execute_luau); for code that must run against the PUBLISHED game on Roblox's servers, use cloud_luau instead.

Inputs: code (required), place, timeoutBudget.

scan_backdoorsA
Read-only

Tufan Power Tool: deep-scan a place for backdoors / exploits / obfuscation. Checks script source (require-of-Value, require-by-asset-id, loadstring, HttpGet, getfenv, exploit APIs, Discord webhooks, anti-debug, high-entropy blobs) AND the spots a script-only scanner misses — instance attributes and StringValues hiding encoded payloads. Findings sorted high→low severity. NOTE: this scans the PLACE tree; it cannot read installed Studio plugins' own source (a Roblox limit) — use list_studio_plugins to see what plugins are installed (the remote-code-plugin vector).

Inputs: place, rootPath, severity.

scan_perfA
Read-only

Audit the place for runtime frame-killers in one pass (part/physics load, StreamingEnabled, CSG unions, precise meshes, shadow lights, particles, and scripts with un-yielded while true do loops). Returns a ranked fix list. Read-only. For a general census of the place use project_health; for UI that breaks on other screens use scan_responsive.

Inputs: place.

scan_responsiveA
Read-only

Audit a UI subtree for what breaks on other resolutions — across the tree AND the scripts. Flags Offset-locked Position/Size/CanvasSize/CellSize/CellPadding/Padding/CornerRadius, sub-44 tap targets, and runtime pixel-positioning in code. Recognizes intentional draggable/resizable elements (tagged) and instead checks their drag logic (clamps to viewport?). Read-only. Run it before make_responsive to see what needs fixing, and again after to confirm.

Inputs: path (required), place.

scene_stateA
Read-only

Spatial snapshot of the scene as the editor camera sees it: camera intrinsics (CFrame, FOV, viewport) + a curated list of visible objects, each with world position/orientation/size AND its on-screen pixel (x,y,depth,onScreen) via WorldToScreenPoint. This is what grounds a screenshot — it lets you say "object X is at screen (px,py) = world (x,y,z)". A Model counts as one object (bounding box); closest objects first. Pair with the official Roblox_Studio MCP's screen_capture. Read-only.

Inputs: place, maxDepth, rootPath, maxObjects, +3 more.

script_sourceA
DestructiveIdempotent

Read a script's full Source, or replace all of it. Reading is read-only; writing overwrites the whole script (open editor tabs update too) and is blocked in read-only mode. For small changes prefer patch_script (anchored find/replace) or edit_script_lines (a line range), which don't resend the file. To search across scripts use grep_scripts.

Inputs: path (required), place, source.

search_assetsA
Read-only

Search the Roblox Creator Store (Studio's Toolbox) by keyword and list matching asset ids with name and creator. Read-only; calls Roblox's public web APIs and needs no Studio. Follow up with get_asset_details or get_asset_thumbnail, then insert_asset. Roblox no longer reports whether a model contains scripts, so run scan_backdoors after inserting a free model. To find instances already in the place use search_objects.

Inputs: keyword (required), limit, assetType.

search_by_propertyA
Read-only

Find every instance under a root whose property equals a given value, and list their paths. Read-only. Use it for questions like "which parts are still Anchored=false" or "which labels use Font Arial". To find by name or class use search_objects; to search the Roblox marketplace use search_assets.

Inputs: name (required), value (required), place, rootPath.

search_materialsA
Read-only

List the custom MaterialVariants defined in this place's MaterialService, with each one's base material. Read-only. Use it to find a material name to set on parts with set_property or mass_edit. For marketplace assets use search_assets; for other instances use search_objects.

Inputs: name, place.

search_objectsA
Read-only

Find instances by name, class or both under a root and list their paths. Read-only; stops at 200 results and says so, so narrow the search when that happens. Use matchMode exact or wholeWord to cut the noise of substring matches. To match a property value (every part with Material=Wood) use search_by_property; to search the Roblox marketplace use search_assets.

Inputs: name, place, rootPath, className, +2 more.

set_attributeA
DestructiveIdempotent

Create or overwrite one attribute on one instance, recorded as one Studio undo step. For several attributes use mass_set_attribute; for built-in properties use set_property.

Inputs: name (required), path (required), value (required), place.

set_propertyA
DestructiveIdempotent

Set one property on one instance in the edit copy, recorded as one Studio undo step. Fails with the Roblox error if the property is read-only or the value has the wrong type. For more than one change use mass_edit (one call, one undo step); for attributes use set_attribute.

Inputs: name (required), path (required), value (required), place.

set_selectionA
Idempotent

Replace the user's Studio selection with the given instances, to point them at something or prepare for a Studio command. Changes only the selection, never the instances. Paths that do not resolve are skipped; the reply says how many were selected. An empty list clears the selection.

Inputs: paths (required), place.

snapshotA
Destructive

Checkpoint an instance and everything under it before a risky edit, so restore can put it back exactly. Stores a live clone in ServerStorage._TufanSnapshots, which survives after Studio's undo stack has moved on and is saved with the place. Saving under an existing snapshot name replaces that snapshot. Archivable=false descendants are included. Use this for instances in the place; for script files on disk use git_commit, and for GUIs or models lost to a delete use restore_from_mirror.

Inputs: path (required), name, place.

tagA
DestructiveIdempotent

Read, add or remove CollectionService tags on one instance. get is read-only; add and remove change the instance and are blocked in read-only mode. Tags are how scripts find groups of objects (CollectionService:GetTagged). To list every instance with a tag, use get_tagged.

Inputs: path (required), action (required), tag, place.

typecheckA
Read-only

Type-check Luau with luau-lsp (the Luau analyzer) over a place's synced script mirror — catches type errors, undefined globals, and bad require paths BEFORE the code runs. Read-only: reports findings, changes nothing. Resolves requires via a sourcemap (uses sourcemap.json if present, else synthesizes one) and Roblox globals via type defs (TUFAN_LUAU_DEFS, a project globalTypes.d.luau, or an auto-cached download). Scope with paths or check the whole mirror. Needs luau-lsp installed (auto-detected or TUFAN_LUAU_LSP_PATH).

Inputs: paths, place, timeoutSeconds.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 87 tools

    Disambiguation4/5

    Descriptions do heavy lifting with explicit 'use X instead' cross-references, cleanly splitting near-neighbours like get_properties vs describe vs get_attributes, and search_objects vs search_by_property vs search_assets. The main risk is the four parallel undo/restore mechanisms (history, snapshot/restore, restore_from_mirror, git_restore) and the several script-writing tools (script_source, patch_script, edit_script_lines, find_and_replace_in_scripts), which an agent can still misselect despite the guidance.

    Naming Consistency3/5

    The bulk is snake_case verb_noun (get_tree, set_property, create_instance, git_commit, scan_perf), with pleasant domain prefixes (git_*, meshy_*, blender_*). But a sizeable minority are bare nouns or ambiguous names — snapshot, restore, describe, pick, place_on, tag, batch, history, typecheck, datastore, is_running — and `tag` uses an action parameter while sibling tools split actions into separate verbs, so conventions are mixed though still readable.

    Tool Count2/5

    87 tools vastly exceeds a workable selection surface; each domain (Studio edits, git, disk mirror, Blender, Meshy, Open Cloud) justifies its members, but the aggregate forces the agent to scan a huge catalogue before acting. Consolidation into families (e.g. one indexed action-based tool per domain like `datastore` and `tag` already do) would cut this dramatically.

    Completeness4/5

    Coverage is unusually deep: full CRUD plus batch, hierarchy mapping, script edit/lint/typecheck/format, three-tier recovery (undo stack, snapshots, disk mirror, git), asset search/generation/import, and production logs/datastores. Minor gaps remain — no place publishing/packaging, no plugin installation, and live play-session control is deliberately deferred to Roblox's official Studio MCP — but no workflow is truly blocked.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      An agentic MCP server for Roblox Studio that provides over 45 tools for script diffing, playtest automation, and bulk instance manipulation. It enables AI agents to manage full development cycles within Roblox, including transaction-safe batch operations and real-time script reviews.
      1
      MIT
    • A
      license
      Not graded
      quality
      Not graded
      maintenance
      A comprehensive MCP server providing 41 tools for complete Roblox Studio control, enabling safe script editing with syntax checking, instance manipulation, and backup features directly from Claude Code or any MCP-compatible AI assistant.
      1
      MIT