Skip to main content
Glama
okenjioxx

Roblox Executor MCP Server

by okenjioxx

Write a value into a live GC table slot (direct heap write, MUTATES STATE)

write-path-value
Destructive

Write live Roblox game state by resolving a Luau table expression and assigning container[key], returning old and new values for auditing.

Instructions

WRITES LIVE GAME STATE. Direct heap write into one slot of a Luau table: resolve a Luau expression to a TABLE container, then assign container[key] = , returning BOTH the OLD and NEW value so the change is auditable. This is the write counterpart to read-path-value and the natural action after a memscan locates a field — e.g. flip a config flag ('require(game.ReplicatedStorage.Config)', key='GodMode', value true), bump a cached stat ('getgenv().PlayerData', key='Coins', value=9999), or clear a slot (kind='nil'). The container expression is evaluated as return <containerExpr> and MUST resolve to a table (anything else returns a clean { error }). For non-primitive values (Vector3, Color3, Enum, an Instance, a table, …) use kind='raw' and pass a Luau expression. The read of the old value and the write are each pcall-guarded. WARNING: this mutates running client memory immediately; writing through a metatable-protected/readonly table may error (returned as { error }) and some game state replicates or is server-authoritative. Requires loadstring/load. Returns { Container, Key, OldValue, NewValue, ok } or { error }. Signature: { containerExpr: string, key: string, value: { kind: "string" | "number" | "boolean" | "nil" | "raw", value: string | number | boolean? }, threadContext: number? }. Phase: act; cost=medium; idempotency=contextual-write. Requires: active-client, explicit-mutation-approval. Produces: operation-receipt. Verify with: assert-state. Safety: MUTATING; writes live game/client state. On failure: inspect tool-schema for exact fields, defaults, constraints, and an invocation example.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
keyYesThe string key (field name) within the container table to write, e.g. 'Coins', 'GodMode', 'WalkSpeed'. Indexed as container[key]. (String keys only — for non-string keys, write via a raw containerExpr that already indexes to the parent.)
valueYestyped value consumed by this operation.
containerExprYesLuau expression resolving to the TABLE whose slot you want to write, e.g. 'getgenv().PlayerData', 'require(game.ReplicatedStorage.Config)', '_G.Settings', or any table reference found via a heap scan. Evaluated as `return <containerExpr>` and must resolve to a table.
threadContextNoOptional Roblox thread identity for this call; omit it to use the server default.

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv2.0.0-spies.2

TDQS

A4.8/5.0
Behavior5/5

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false, and the description goes well beyond them: pcall-guarded old-read and write, error-as-{error} on metatable-protected/readonly tables, server-authoritative replication caveats, and the loadstring/load requirement. It also discloses that both OLD and NEW values are returned for auditability, which is genuinely useful 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?

The critical constraint ('WRITES LIVE GAME STATE') is front-loaded and the prose is dense with usable detail, but the trailing block ('Signature: ... Phase: act; cost=medium; idempotency=contextual-write. Requires: ... Produces: ...') restates schema and metadata in prose, which pads the definition without adding selection value.

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?

Despite having no output schema, the description fully documents the return contract ({ Container, Key, OldValue, NewValue, ok } or { error }), the failure modes, and the verification path. Nothing an agent needs to invoke or interpret this mutating call 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 baseline is 3, but the description adds real meaning: containerExpr is evaluated as `return <containerExpr>` and MUST resolve to a table, and kind='raw' is the route for Vector3/Color3/Enum/Instance/table values. It stops short of documenting threadContext semantics beyond what the schema already says.

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 opens with a specific verb+resource+scope ('Direct heap write into one slot of a Luau table') and explicitly names its counterpart and predecessor ('the write counterpart to read-path-value and the natural action after a memscan locates a field'). An agent can distinguish it from read-path-value, set-instance-property, and set-attribute without opening any schema.

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?

It states when to use it (after a memscan locates a field), gives three concrete scenarios (flip a config flag, bump a cached stat, clear a slot with kind='nil'), and routes the agent explicitly: kind='raw' for non-primitive values, and verify with assert-state. Alternatives and the condition selecting them are spelled out rather than inferred.

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

Deploy Server

Other Tools