Skip to main content
Glama

Overdare MCP

An MCP server that lets AI agents (Claude Code / Claude Desktop) drive OVERDARE Studio — browse the DataModel, create and edit instances, write Luau scripts, and start playtests.

How it works

OVERDARE Studio already hosts a local JSON-RPC server (the same one its built-in "diligent" agent uses). This MCP server is a thin bridge to it — much like unity-mcp's connector, except Studio hosts the local server itself, so there's no plugin to install.

Claude  ──stdio──▶  overdare-mcp  ──raw TCP──▶  Studio RPC        (127.0.0.1:13377)
                                  ──HTTP────▶  UE Remote Control (127.0.0.1:30010)
                                                  └─ OVERDARE Studio (must be running)

Port 13377 is not HTTP. It is newline-delimited JSON-RPC 2.0 straight over a TCP socket, one connection per call — speaking HTTP at it yields a protocol violation instead of a response. Remote Control on 30010 is HTTP, and is a separate surface (the overdare_rc_* tools) that reaches the Unreal editor underneath rather than the OVERDARE DataModel.

Studio must be open with a project for tools to work. If Studio isn't running, tools return a clear "cannot reach Studio" error instead of hanging.

Related MCP server: onyx MCP

Setup

git clone https://github.com/ShootTheMoon/overdare-mcp
cd overdare-mcp
npm install
npm run build

Verify the connection (open OVERDARE Studio first):

npm run probe                                   # smoke test + level.browse
npm run probe -- instance.read '{"path":"Workspace.Baseplate"}'   # inspect any method

Register with Claude Code

Add to .mcp.json in your project (an example is included in this repo):

{
  "mcpServers": {
    "overdare": {
      "command": "node",
      "args": ["/ABSOLUTE/PATH/TO/overdare-mcp/dist/index.js"]
    }
  }
}

For Claude Desktop, add the same block under mcpServers in claude_desktop_config.json.

Configuration (env vars)

Var

Default

Purpose

STUDIO_HOST

localhost

Studio RPC host (STUDIO_RPC_HOST also accepted)

STUDIO_PORT

13377

Studio RPC port (STUDIO_RPC_PORT also accepted)

STUDIO_RPC_TIMEOUT_MS

10000

Per-call timeout

OVERDARE_PROJECT_DIR

auto-detected

Fallback project directory for the file-backed tools

OVERDARE_BLENDER

auto-detected

Blender executable used by overdare_mesh_prepare

Tools

Three backends sit behind these, and the difference matters when something fails. RPC talks to Studio live over 13377. File edits the saved .ovdrjm and asks Studio to reload, which is how the tools whose RPC method does not exist are implemented — stop any playtest before using those. Each such edit first copies the level into .ovdr-backups/ beside it, keeping the last ten, and reports the path it wrote. RC is Unreal Remote Control on 30010.

Reading

Tool

Via

Purpose

overdare_browse

RPC level.browse

Browse the DataModel tree. Start here — everything else targets guid

overdare_find

File

Search by name substring and/or class; far more practical than browsing a large project

overdare_read_instance

File

Read one instance's properties as saved

overdare_script_read

File

Read a script's Luau source

overdare_validate_lua

luau-lsp

Type-check scripts against the OVERDARE type definitions

overdare_status

—

Report what is reachable and configured

overdare_validate_lua runs the luau-lsp and overdare-types.d.lua that ship beside Studio's bundled agent, so it knows the real API surface — it will tell you that Key 'Bold' not found in external type 'TextLabel', which is exactly the kind of break an engine update causes and that otherwise only shows up as a runtime warning in Sandbox.log. It takes scripts already in the project (by GUID or dotted path, as overdare_find reports them) or files on disk.

Its blind spot is worth knowing: a local from Instance.new("TextLabel") is not narrowed to TextLabel, so property errors on that local go unreported. Annotate the local, or check the value at runtime with overdare_observe.

Editing

Tool

Via

Purpose

overdare_create_part

File

Create a Part

overdare_create_instance

File

Create one instance of any class

overdare_create_instances

File

Bulk-create under one parent in a single reload

overdare_update_instance

File

Change properties and/or rename

overdare_move_instance

File

Reparent

overdare_duplicate_instance

File

Copy a subtree with fresh GUIDs

overdare_delete_instance

File

Delete by GUID

overdare_instance_create

RPC instance.create

Create live, under one parent, no reload

overdare_instance_update

RPC instance.update

Change properties live, no reload

overdare_instance_delete

RPC instance.delete

Delete live, without a reload

overdare_script_add

File

Create a Script / LocalScript / ModuleScript

overdare_script_edit

File

Replace a script's source, or toggle Enabled

Prefer the RPC three when you are iterating: the file-backed tools rewrite the project and ask Studio to reload, so they need the playtest stopped, while these go to the running editor. Two things about them are worth knowing before you trust a result:

  • Properties go flat. Nesting them under a Properties key does not fail — the call succeeds, message says Properties is not a valid property of Frame, and every value is dropped. Same for a misspelled property name: a [WARNING] in message, not an error. Read message.

  • A class this build lacks is not an error either. The call succeeds and returns fewer GUIDs than you asked for. overdare_instance_create pairs them back up and reports guid: null per instance. UICorner, UIGradient, UIPadding, UISizeConstraint, UITextSizeConstraint, ViewportFrame, TextBox, CanvasGroup and VideoFrame are all absent; UIStroke, UIListLayout, UIGridLayout, UIAspectRatioConstraint, ProgressBar and ScrollingFrame are present.

Composite property values are tagged objects, and UDim2 spells its second axis with a lower-case y — an upper-case Y is silently dropped. Rather than write those by hand, pass the array short forms (Size: [0.5, 10, 0, 64], BackgroundColor3: [20, 180, 90], AnchorPoint: [0.5, 1]); see src/props.ts.

Project lifecycle

Tool

Via

Purpose

overdare_save

RPC level.save.file

Save the project to disk

overdare_apply

RPC level.apply

Reload pending level changes

overdare_publish

RPC level.publish

Publish to the Hub (owner only)

overdare_set_project

—

Re-detect or pin the project directory

Playtest and viewport

Tool

Via

Purpose

overdare_play / overdare_stop

RPC game.play / game.stop

Start / stop a playtest

overdare_screenshot

RPC game.screenshot

Capture the viewport and return the image. UI is included; locate projects instances into click coordinates

overdare_camera

RC

Aim the editor camera before a screenshot

overdare_viewport

RC

Read or change how the editor viewport renders

Runtime observation

Only meaningful while a playtest is running. A screenshot shows pixels and the saved project shows what was authored; neither shows what the running game currently holds, which is where UI bugs live — a label a script rewrote, a frame a layout pushed off screen, a button buried under a higher ZIndex.

Tool

Via

Purpose

overdare_pie_status

RPC game.pie.status

Is a playtest running, and which clients take input

overdare_ui_browse

RPC game.ui.browse

The live UI as flat elements: path, class, text, normalized rect, visibility

overdare_observe

RPC game.observe

Character, UI, and live instance state in one game-thread read

overdare_character_read

RPC game.character.read

CFrame, speed, facing, what it stands on

overdare_input_inject

RPC game.input.inject

Keys, pointer, look, scroll, waits — up to 64 events

Two things the underlying method does not tell you, which the tool handles:

  • pieSessionId and clientId are mandatory on the wire. Omitting either fails the batch with the same Invalid input event as a malformed event, so overdare_input_inject resolves both from game.pie.status when you leave them out.

  • action: "press" is documented but rejected by this build; only down/up are accepted. The tool expands press into a down/wait/up triple so the short form still works.

Pointer events only land on the part of the viewport that lies inside the Studio window. When the window hangs off screen the reachable region shrinks — sometimes to a sliver — and overdare_ui_browse reports it under viewport.reachable. The game still renders the whole frame, so a screenshot looks fine while a click at those coordinates goes nowhere.

Assets

Tool

Via

Purpose

overdare_assets

—

List the curated Asset Drawer catalog

overdare_asset_import

RPC

Import an Asset Drawer model by id

overdare_image_import

RPC

Import a local PNG/JPG into the asset manager

overdare_mesh_prepare

Blender

Make a 3D file import-ready (see below)

overdare_mesh_bulk_import

GUI

Drive many prepared meshes through the import dialog

overdare_engine_assets

RC

Query the engine asset registry

overdare_rc_search_assets

RC

Search the Unreal asset library

Unreal Remote Control (low level)

Tool

Purpose

overdare_rc_call

Call a UFunction on an Unreal object

overdare_rc_property

Read or write a property

overdare_rc_describe

Describe an object's properties and functions

overdare_rc_list_actors / overdare_actors

Enumerate live actors and their object paths

overdare_selection

Read or change the editor's actor selection

overdare_console

Run a console command or read a cvar

overdare_rc_batch

Several RC requests in one round-trip

overdare_rc_python

Run an Unreal Python command

overdare_rc_batch and overdare_rc_python do not work against a shipping Studio build: PUT /remote/batch has crashed Studio outright, and ExecutePythonCommand returns 400 because the Python plugin is not loaded. They are kept for builds that do support them.

Escape hatch

Tool

Purpose

overdare_rpc

Call any Studio RPC method with raw params

overdare_recipe

Read a build recipe adapted from the built-in agent's skills

Smart mesh import (overdare_mesh_prepare)

OVERDARE caps imported meshes at 30,000 triangles per mesh and recommends 512px textures (large 4K textures OOM the importer). overdare_mesh_prepare runs headless Blender to make any .fbx / .obj / .glb / .gltf / .blend import-ready:

  • decimates an over-budget mesh to fit the triangle limit,

  • downscales & re-embeds textures to the target size,

  • writes a self-contained <name>_overdare.fbx.

The final Import into Studio (Home ▸ Import) is still a manual GUI step. Requires Blender installed — Steam installs are auto-detected; set OVERDARE_BLENDER to override the path.

Switching projects (overdare_set_project)

The .ovdrjm file-edit tools now auto-follow whichever project is open in Studio (recovered from its screenshot path). After switching projects in Studio, call overdare_set_project with no args to re-detect, or pass a dir to pin a specific project directory. OVERDARE_PROJECT_DIR remains a fallback.

Which RPC methods actually exist

Method names were originally read out of the Studio runtime, and several of them turned out not to be dispatchable. Probed against a live Studio (2026-09-07):

Present. level.browse · level.apply · level.save.file · level.publish · instance.create · instance.update · instance.read · instance.move · instance.delete · game.play · game.stop · game.screenshot · game.observe · game.ui.browse · game.pie.status · game.character.read · game.input.inject · viewport.camera.read · viewport.camera.set · hub.token.read

Absent — these return -32601, so anything routed to them fails: every script.* method, instance.upsert, procedural.run, the asset-import methods, and validatelua. They belong to the bundled agent, not to the RPC surface. The script and instance tools here go through the project file instead, which is why they carry the "stop the playtest first" caveat.

There is no discovery method — rpc.discover and system.listMethods are both absent. To check whether a method exists, call it with empty params and read the error: -32601 means no such method, anything else means it is there. npm run probe -- <method> '<json>' does this, and overdare_rpc is the fallback for a method with no dedicated tool.

Reading results back without being misled

Every trap below returns a plausible answer rather than an error, so it costs a while to notice. All measured against a live Studio while building the UI motion work in onlyoneshot (2026-09-07/08).

A screenshot without UI looks like a correct screenshot. game.screenshot renders the world alone by default, despite documenting the opposite. overdare_screenshot now sends includeGui: true for you, but a raw overdare_rpc game.screenshot still needs it spelled out.

Screenshots are refused while two playtest clients are running — the error is game.screenshot is ambiguous. Start one client when you intend to look at the screen, or read state with overdare_observe instead.

game.ui.browse rects are in render-viewport pixels, not UI pixels. The two differ by the display scale: a 2266-wide render against a 1511-wide UI space is 1.5x, so a 700px-wide label reports 1050. Compare normalized values against each other, or divide before checking against a layout number — otherwise correctly placed elements read as 14px out of position.

AbsoluteSize is the wrong thing to verify a tween with. It is zero while the owning ScreenGui is disabled, and it trails the property by a frame. Read the property the tween actually drives — Size.X.Scale, BackgroundTransparency — which is also live when the GUI is hidden.

task.wait overshoots badly while the level is still loading. Sampling a 0.5s tween with task.wait(0.25) can land after it finished, which reads as "tweens snap instantly" — they do not. Count frames in a RenderStepped connection and log (elapsed, value) pairs instead. This produced a wrong conclusion twice before the frame-counting check settled it.

level.apply can exceed the 10s default timeout. The edit lands; only the RPC gives up. Raise STUDIO_RPC_TIMEOUT_MS or re-read the tree to confirm, rather than retrying an edit that already succeeded.

Drawing with Rotation

GuiObject.Rotation works, which matters because stacking small squares to fake a diagonal is the most expensive habit in a UI script — instance count is the only lever that has ever moved this project's framerate.

Screen y points down, so rotating a vertical bar (0,1) by t yields (-sin t, cos t). To aim it along (dx, dy) the angle is math.deg(math.atan2(-dx, dy)) — drop the minus and you get a mirrored zigzag.

Building a curve from segments, tilt each piece along the chord between two adjacent sample points, not along the tangent at one point. The chord gives the length and the angle together, so the joints close; tangents leave gaps.

Replacing stacked pieces with one solid bar also exposes overlaps that the gaps used to hide — expect to re-tune positions, not just counts.

Mesh pipeline scripts

scripts/ holds the Blender and Node helpers used to move large maps into Studio. OVERDARE caps a FBX at 30k triangles and 200 meshes, so big assets are split first.

Script

Purpose

split_absolute.py

Cut one asset into <=30k-tri pieces with world coordinates baked into the vertices, so every piece places at the same origin

split_all_absolute.sh

Run split_absolute.py once per asset, one Blender process each

merge_detail.py

Merge thin ornamental faces (friezes, glyphs) into one mesh so decimation can't leave floating slabs

place_asset_abs.mjs

Build placement items for a split asset from UGCLocalAssetTable.json

split_asset.py · place_split_asset.mjs

Earlier recentred-split workflow (per-piece offsets)

Tool Schema Changelog

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

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      An MCP server that enables AI agents to act as dynamic dungeon masters for text-based RPGs with dynamically generated rule systems and comprehensive game state management.
      15
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      A Discord MCP server that gives AI agents full control of a Discord bot — messages, channels, roles, threads, forums, events, webhooks, reactions, moderation, image generation, and real-time voice.
      7
      MIT