Run Luau in the Roblox client (Opiumware, thread identity 8) and get back return values, print/warn output, and errors with traceback.

• Just return values; tables, Instances, Vector3s etc. are serialized automatically. Don't JSONEncode.

• Each run has its own global scope. Use getgenv() to keep state between runs. _G is the executor's; the game's is getrenv()._G.

• Full executor API is available (getgc, hookmetamethod, decompile, firesignal, ...). To run a local file use the file parameter; the executor's own readfile/loadfile only see Opiumware's workspace folder.

• Heavy scans (getgc, GetDescendants on large trees) must yield (task.wait() every few thousand items) or they freeze the game.

• Long-running code (loops, listeners) should task.spawn and return right away. On timeout the run itself is cancelled, but threads it spawned keep running.

• Errors returned here are NOT in the console. Errors/prints after the run returns (spawned/deferred code) only show in logs: use logs sinceExecute=true.

• Separate execute calls made in parallel may run in any order.

• Large results are saved to a temp file whose path is returned.

Read the Roblox client console (print/warn/error from all scripts, including the game's own), newest last.

• Debug loop: after execute, call with sinceExecute=true to see everything logged since that run started (deferred errors, spawned loops), or new=true for everything since the previous logs call.

• Errors from code run via execute are tagged "mcp:"; from the Opiumware editor "Opiumware:". Filter with grep.

• Repeated consecutive lines are collapsed to (xN). Long messages are truncated; when anything is cut, the full results are saved to a temp file you can grep.

Capture remote traffic between the client and server: outgoing FireServer/InvokeServer (with InvokeServer return values and the calling script) and incoming OnClientEvent.

• start: begin a fresh capture (replaces the previous log). stop: stop recording and remove the hooks (the log is kept). read: view the log (works while running).

• Hooks only exist while capturing, so stop as soon as you have what you need.

• read without remote gives a per-remote summary (count, rate, latest args); with remote it lists individual calls with arguments, collapsing consecutive identical calls.

• Calls made by your own executed code are marked [by executor].

• Long results are truncated and the full log is saved to a temp file.

Capture the Roblox window as the player sees it (works even if other windows cover it). Use to verify visual scripts (ESP, UI, menus). Each image costs ~1K tokens, so use sparingly.

Read the game's client-side code (LocalScripts, ModuleScripts; server Scripts never reach the client). Decompiled sources are cached and saved as .luau files in a temp folder mirroring the game tree, so you can also grep/read them directly.

• list: script paths (optionally filtered).

• search: regex across all decompiled sources, returns path:line matches. The first search decompiles everything (a few seconds).

• read: one script's source with line numbers, 150 lines at a time (use startLine/endLine).

Check the connection: which Roblox instances (Opiumware ports) are live, what game/player each is in, and whether the decompiler is running. Call this first or when something isn't working.