Skip to main content
Glama

playtest

Starts a Roblox Studio test session, runs optional server/client Luau assertions, collects both outputs, and stops to verify runtime behavior after changes.

Instructions

One-shot verification: starts a playtest, optionally waits for player/character spawn, runs optional server and/or client Luau assertions, waits, collects errors/warnings/prints from BOTH Server and Client Output, then stops. Use after changes to verify runtime behaviour.

Tool call template

This tool declares no required parameters. Add optional parameters from the input schema as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {},
    "name": "playtest"
  }
}

Input Schema

NameRequiredDescriptionDefault
codeNoOptional Luau to run in `context` (default server) once the game is running.
studioNoOptional. Target Studio (name substring, place id or id). Only needed when several Studios are open and none was selected.
contextNoWhere to run `code`. Default server.
duration_sNoHow long to let the game run in total. Default 5, max 120.
stop_afterNoStop the playtest at the end. Default true.
client_codeNoOptional Luau to run on the Client datamodel.
server_codeNoOptional Luau to run on the Server datamodel.
wait_for_playerNoWait up to 15s for the local Player and Character to spawn before running code. Default false.

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.2.0

TDQS

A4.4/5.0
Behavior4/5

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

With no annotations supplied, the description carries the full burden and does well: it discloses the entire lifecycle (start → wait → assert → collect → stop) and that output is gathered from BOTH Server and Client Output, which is the key result shape. It omits what happens to the user's Studio session (foreground takeover, unsaved state) and that stop_after=false leaves a running session behind.

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

Conciseness5/5

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

One dense lifecycle sentence followed by a one-line usage rule; the sequence is ordered chronologically and front-loaded with the tool's identity. Every clause (wait, server and/or client, BOTH outputs, stops) carries distinct information.

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

Completeness4/5

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

For an 8-parameter, all-optional tool with no output schema, the description covers the operation sequence, the return signal (errors/warnings/prints from both outputs) and the stop behaviour, so an agent can call it correctly. It could still say what happens when no Studio is targeted or when the playtest fails to start.

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 baseline is 3, but the description adds real meaning the schema does not: it clarifies how `code`/`context` relate to `server_code`/`client_code` (optional assertions on either datamodel) and that `wait_for_player` gates the spawn wait before code executes. It does not explain duration_s vs the 15s spawn wait interplay, which is the one ambiguity left.

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?

The description names a specific verb chain and resource: start a playtest, wait for spawn, run server/client Luau, collect output, stop. The 'one-shot' framing and the explicit 'then stops' distinguish it from a persistent `play` and from a bare `luau_run` without either being named.

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

Usage Guidelines4/5

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

'Use after changes to verify runtime behaviour' gives a clear triggering condition. It stops short of a 5 because it never states when NOT to use it (e.g. for iterative debugging where a persistent `play` session is cheaper) nor names an alternative tool.

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