Skip to main content
Glama
EL4CTEO

Roblox Studio MCP

Performance and memory

performance
Read-onlyIdempotent

Diagnose why a Roblox place runs heavy: read engine counters, profile scripts, measure memory, and audit broken asset references.

Instructions

Reads the engine's own counters, and can run the script profiler.

snapshot returns what the Developer Console shows: frame, physics and render times in milliseconds, instance and part counts, draw calls, network rates, and memory broken down by category. Use it to answer 'why is this place heavy' with numbers instead of guesses.

profile runs Studio's script profiler — the Script Performance window — for seconds and reports which scripts consumed CPU. It blocks for that long, so keep it short. It only sees code that actually runs, so start a playtest first; profiling an idle edit session returns nothing.

coverage reports which lines of which scripts actually executed — dead code, untested branches, whether a fix was even reached. Pass enable first, then play, then read the coverage back FROM THE PLAYTEST session, not the editor: instrumenting is per data model, and the playtest is a different one. enable is remembered for the place and re-applied by each new session as it loads. Pass an empty enable array to stop.

What it can and cannot see: instrumentation is fixed when a script is first compiled, so it measures modules required after that point — where most game logic lives — but never a script that starts with the place, which the data model compiles before any plugin exists. Those report 0 lines and are named as unmeasurable rather than counted as dead code.

scene breaks the place down by what it is actually made of: instances by category, triangles and draw calls FOR WHAT THE CAMERA CAN SEE, and the assets holding script, animation and audio memory — each named, so "2.4GB of memory" becomes "this animation is 138KB and these are the Animators using it". It also reports UNPARENTED INSTANCES, which is the closest thing here to a leak detector: objects still alive with nothing holding them in the tree, invisible to find and to tree because they are in neither.

The triangle and draw-call section is the one number here that depends on where the camera is pointing, and it moves enormously: the same place measured 332 triangles looking at empty sky and 29,060 looking at 1,800 parts, seconds apart. So it answers "how heavy is this view", not "how heavy is this place" — point the camera first with viewport op="focus", and compare two views only if both were framed the same way.

audit is a health check rather than a performance one: it finds every reference in the place that points at NOTHING. A Sound whose id was deleted or made private plays silence, a Decal shows nothing, an Animation does nothing — none of them errors, none warns, and the instance looks perfectly healthy because the id is still a string. The only other way to find them is to play the game and notice something missing. It also reports ids left blank, scripts left Disabled, and same-named siblings, which is what makes WaitForChild return the wrong one.

audit fetches the assets to test them, so Studio's Output window will show load errors for the dead ones. That is the engine confirming the finding, not a fault in the tool.

Frame and network figures are only meaningful while something is running. Instance counts and memory are useful in edit mode too.

Input Schema

NameRequiredDescriptionDefault
opNo'snapshot' reads counters now; 'profile' samples running scripts; 'coverage' reports which lines have executed; 'scene' breaks the place down by what it is made of; 'audit' finds broken asset references and other silent faults.snapshot
enableNocoverage only: scripts to start measuring. Remembered for this place and switched on by every session that loads afterwards, so a playtest instruments them before its scripts run. An empty array stops instrumenting.
playerNoclient only: player name; required with multiple players.
targetNoclient: read the actual player's playtest VM. Use the playtest server studioId.studio
secondsNoprofile only: how long to sample. The call blocks for this long.
sectionNoscene only: return just one section instead of all six.
studioIdNoTarget Studio; omit for the active one.
frequencyNoprofile only: samples per second. Higher is more precise and costlier.
includePluginsNoprofile only: include Studio plugins in the results. Off by default — an idle Studio is mostly plugin activity, which buries the place's own scripts.

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed2 schema fields changedv0.9.1
    • addedInput schema / properties / player
      Added value: +{
      +  "description": "client only: player name; required with multiple players.",
      +  "type": "string"
      +}
    • addedInput schema / properties / target
      Added value: +{
      +  "default": "studio",
      +  "description": "client: read the actual player's playtest VM. Use the playtest server studioId.",
      +  "enum": [
      +    "studio",
      +    "client"
      +  ],
      +  "type": "string"
      +}
  2. Changed2 schema fields changedv0.6.5
    • changedInput schema / properties / op / description
      Previous value: -"'snapshot' reads counters now; 'profile' samples running scripts; 'coverage' reports which lines have executed; 'scene' breaks the place down by what it is made of."New value: +"'snapshot' reads counters now; 'profile' samples running scripts; 'coverage' reports which lines have executed; 'scene' breaks the place down by what it is made of; 'audit' finds broken asset references and other silent faults."
    • changedInput schema / properties / op / enum
      Previous value: -[
      -  "snapshot",
      -  "profile",
      -  "coverage",
      -  "scene"
      -]New value: +[
      +  "snapshot",
      +  "profile",
      +  "coverage",
      +  "scene",
      +  "audit"
      +]
  3. First observedv0.1.8

TDQS

A4.8/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Far beyond the annotations: it discloses that profile blocks for `seconds`, that enable persists per-place and is re-applied by new sessions, that instrumentation misses place-start scripts (reported as unmeasurable, not dead), that scene triangles depend on camera aim (332 vs 29,060 tris in the same place), and that audit fetches assets so Output will show load errors. For a readOnly tool this is unusually rich context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with one paragraph per op and no filler sentences, but the prose is long and occasionally rhetorical ("why is this place heavy", the 332/29,060 aside), which pushes past tight conciseness. Still, every paragraph carries distinct guidance, so the size is largely earned.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema exists, so the description must carry the burden of describing returns — and it does so for all five ops, including units, section breakdowns, and the caveat that some scripts report 0 lines. Nothing needed to invoke it correctly is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the 3 baseline applies, but the description adds meaning on top: it frames enable as persistent/instrumentation-scoped and seconds as blocking. It reinforces rather than replaces the schema, which already documents all nine params.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

It names five concrete ops and states exactly what each returns: counters in milliseconds and counts (snapshot), CPU-consuming scripts (profile), executed lines (coverage), composition/assets/unparented instances (scene), dead asset references (audit). It also distinguishes itself from siblings by name (find, tree) and scope.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Each op carries an explicit when/when-not: profile requires a running playtest and returns nothing when idle; coverage requires enable→play→read from the playtest data model, not the editor; scene requires the camera framed first via viewport op="focus" before comparing views. Alternatives and prerequisites are spelled out.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.