What Ships in Funplay Unity MCP 0.1.10: Tools, Prompts, and Resources

Funplay Unity MCP 0.1.10 ships 79 built-in tools that let AI assistants operate a live Unity Editor over a local HTTP endpoint. The server exposes scene creation, script generation, input simulation, runtime verification, performance profiling, and editor automation through two tool profiles: core and full.

What the Project Is

Funplay MCP for Unity is an MIT-licensed MCP server that runs inside the Unity Editor. Once active, any connected AI client can query and manipulate the project in real time — no export step, no separate build. It works with Claude Code, Cursor, VS Code Copilot, Windsurf, and Codex out of the box.

Why it matters: the 79 tools span the full edit-verify loop. An agent can create a GameObject, attach a script, enter Play Mode, simulate input, capture frame timings, and report results back without the developer touching the keyboard. That tight loop is the core value proposition.

Two Tool Profiles

The server offers two profiles so you can limit blast radius when pairing with less-trusted agents:

Core includes tools for reading the Hierarchy, listing components, inspecting properties, and querying project structure. Full adds scene mutation, asset creation, script generation, input simulation, and editor automation.

Installation and Startup

Requirements: Unity 2022.3 or later.

Window → Package Manager → Add from git URL:
https://github.com/FunplayAI/funplay-unity-mcp.git

After installation, open Funplay → MCP Server in the menu bar. The server starts on 127.0.0.1 port 8765 by default. No additional configuration is needed for local use.

Connecting from an AI Client

Here is a minimal configuration for Claude Code or any MCP-compatible client:

{
  "mcpServers": {
    "funplay-unity": {
      "url": "http://127.0.0.1:8765/mcp",
      "transport": "streamable-http"
    }
  }
}

Cursor and Windsurf follow the same pattern in their respective settings panels. VS Code Copilot consumes MCP servers through the same JSON block in .vscode/mcp.json.

Concrete Walkthrough: Agent-Driven Scene Setup

This example shows what an agent does when you ask it to scaffold a simple scene. Each step maps to one or more tool calls the server exposes.

Step 1 — Query existing scene state

The agent calls a core-profile tool to list root objects in the active scene. It receives back a JSON array of names and instance IDs. Nothing changes in the project.

Step 2 — Create GameObjects and attach components

Using full-profile tools, the agent creates two objects:

// The agent generates this script through a tool call,
// then attaches it to the "Player" GameObject.
using UnityEngine;

public class PlayerMovement : MonoBehaviour
{
    public float speed = 5f;

    void Update()
    {
        float h = Input.GetAxis("Horizontal");
        float v = Input.GetAxis("Vertical");
        transform.Translate(new Vector3(h, 0, v) * speed * Time.deltaTime);
    }
}

The agent creates the GameObject, generates the script file, adds the component, and sets the speed property — all through tool calls.

Step 3 — Enter Play Mode and simulate input

The agent triggers Play Mode, then uses input-simulation tools to fire virtual axis values. It reads back transform.position from the live object to confirm movement occurred.

Step 4 — Exit and clean up

The agent exits Play Mode, optionally deletes test objects, and reports results. The entire cycle ran without a human clicking the Editor.

Comparison Across the Funplay Ecosystem

Funplay ships MCP servers for three engines. Here is how they line up:

Godot MCP has the highest tool count at 105 tools, reflecting Godot's broader built-in API surface for editor scripting. Unity MCP sits in the middle at 79 tools. Cocos MCP offers 67 tools tailored to the Cocos Creator workflow.

A separate companion project, Funplay Skills, provides 12 skills — reusable prompt-and-tool compositions — that work across all three servers.

Gotchas and Limitations

Windows-only first-class support. The server works on macOS and Linux, but the team tests primarily on Windows. File-path quirks on other platforms are possible.

No headless mode. The server runs inside the Unity Editor, which requires a GPU and a display. You cannot run it in a CI container without a virtual framebuffer.

Profile switching is manual. Switching between core and full profiles requires a restart of the MCP Server from the Funplay menu. There is no hot-swap.

Editor freezes propagate. If an agent calls a tool that triggers a long compilation or an infinite loop in Play Mode, the Editor freezes along with the server. Set reasonable timeouts on the client side.

No authentication. The server binds to localhost only, but there is no API key or token system. If you expose port 8765 beyond localhost, anyone on that network can call every tool.

Tool stability varies. Core-profile tools are stable across Unity versions. Full-profile tools that depend on internal Editor APIs may break on new Unity releases. Pin your Unity version if you rely on specific full-profile calls.

When Not to Use It

Skip this server if you need headless CI integration, cross-machine access, or sandboxed execution with strong access controls. It is designed for single-developer, local workflows where the AI pair-programmer sits beside a running Editor.

Further Reading and Repositories

• Primary repository: funplay-unity-mcp
• Godot variant: funplay-godot-mcp
• Cocos variant: funplay-cocos-mcp
• Skills library: funplay-skills
• Long-form tutorials and guides: gamebooom.ai/en/blog/

Clone the Unity MCP repo, start the server, and point your AI client at localhost:8765 to begin working.