# AI Game Developer — Full Product Summary for LLMs

> AI Game Developer is an MCP (Model Context Protocol) platform that lets AI agents inspect and drive real game engines. You install one editor plugin into your project — Unity-MCP for Unity, Unreal-MCP for Unreal Engine, or Godot-MCP for Godot — and the plugin exposes that engine's editor operations as AI Tools. An MCP-compatible AI client then calls those tools to create scenes, spawn objects, edit and compile scripts, manage assets, and capture screenshots, acting directly inside your live editor. The plugin is the bridge, not the AI model: you bring the AI agent; AI Game Developer gives it hands inside the engine. It is free and open source.

## What it is (and is not)

AI Game Developer is **not** an AI model and does **not** replace your code editor.
It turns "do X in the engine" requests from an AI agent into real editor actions
and returns structured results (and screenshots) the agent can read back. All
three plugins are built by the same author (Ivan Murzak), share the same
MCP/reflection .NET stack (ReflectorNet + McpPlugin), and connect to the same
backend: the hosted **ai-game.dev** cloud server, or a self-hosted
**GameDev-MCP-Server** (the single engine-agnostic `gamedev-mcp-server` binary).

The connection chain is always: **AI client ⇄ MCP server (cloud or local) ⇄
engine plugin ⇄ live editor**. A built-in `ping` tool round-trips the whole chain
so an agent can verify the connection before doing real work.

## Connection model — Cloud vs Custom

Every engine plugin offers the same two connection modes:

- **Cloud (default, recommended):** Connect through ai-game.dev using a device-code
  OAuth flow — no tokens to copy by hand. In the AI Game Developer editor window
  choose Cloud, click Authorize, approve the device code in your browser. Uses
  SignalR + bearer auth, works across firewalls, and gives usage analytics.
- **Custom (self-hosted / offline):** Point the plugin at your own
  `gamedev-mcp-server` instance. Per-client config snippets live at
  https://ai-game.dev/mcp-endpoint-info.

Unity and Godot are C# engines and host the .NET MCP SignalR client in-process.
Unreal's editor is C++, so the .NET MCP host runs as an auto-managed sidecar
process (`unreal-mcp-bridge`) that the plugin spawns and talks to over localhost
IPC — invisible to end users.

## Supported engines

### Unity — Unity-MCP ("AI Game Developer — Unity")
- Exposes scenes, GameObjects, components, prefabs, assets, materials, C# scripts,
  package manager, profiler, screenshots, and the test runner as AI Tools.
- Uniquely also works inside the **compiled game (Runtime)**, enabling real-time AI
  debugging and player-AI interaction in-game.
- **190 tools across 27 families** (76 core + 114 from 10 optional `unity-ai-*`
  extension packages — a family's tools appear only when its package is installed).
- Package id: `com.ivanmurzak.unity.mcp`. Requires Unity 2022.3 LTS or newer.
- Install: `unity-mcp-cli` (npm, recommended), the `.unitypackage` installer, or
  `openupm add com.ivanmurzak.unity.mcp`.
- Page: https://ai-game.dev/engines/unity — Repo: https://github.com/IvanMurzak/Unity-MCP

### Unreal Engine — Unreal-MCP ("AI Game Developer — Unreal")
- C++ editor plugin. Spawns actors/components, edits levels and maps, authors and
  **compiles Blueprints**, manages Content-Browser assets, reads/scaffolds/edits/
  **compiles C++**, and captures viewport screenshots as AI Tools.
- Status: beta. **62 built-in tools across 8 families**, CI-exercised.
- Requires Unreal Engine 5.5+ (developed/CI-tested on 5.7) and a C++ UE project.
- Install: `unreal-mcp-cli` (npm). A precompiled Fab / Epic Marketplace listing is
  coming soon.
- Page: https://ai-game.dev/engines/unreal — Repo: https://github.com/IvanMurzak/Unreal-MCP

### Godot — Godot-MCP ("AI Game Developer — Godot")
- C# (.NET / mono) editor addon. Creates and edits the scene tree (nodes),
  opens/saves `.tscn` scenes, finds and mutates `.tres`/`.res` resources,
  reads/creates/updates both **C# and GDScript** and attaches them to nodes,
  captures screenshots, and offers a C# reflection escape hatch.
- **36 tools across 10 families** (all built-in; Godot ships no extension packages).
- Addon `godot_mcp`. Requires Godot 4.3–4.5, a C# / .NET (mono) project.
- Install: `godot-cli` (npm) or the Godot Asset Library (asset 5245) / GitHub
  Release zip, plus two NuGet pins, then enable the addon in Project Settings.
- Page: https://ai-game.dev/engines/godot — Repo: https://github.com/IvanMurzak/Godot-MCP

## Unity extensions (`unity-ai-*` family)

Optional OpenUPM packages that add new tool families to Unity-MCP without forking
it (`openupm add <package-id>`; each depends on `com.ivanmurzak.unity.mcp`):

- **AI Animation** — author AnimationClips and AnimatorControllers, curves, events, states/transitions.
- **AI ParticleSystem** — inspect & modify any of the 24 ParticleSystem modules (emission, lifetime, shape, color-over-life).
- **AI ProBuilder** — procedural mesh modeling: create shapes, extrude/bevel/bridge faces, set face materials, merge meshes.
- **AI Cinemachine** — virtual cameras: Follow/LookAt, lens, body/aim, noise (shake), priority, blends.
- **AI Splines** — SplineContainers, knots, tangents, closed loops, evaluate points (paths, rails, patrol routes).
- **AI Terrain** — create terrains, sculpt/sample heights, layers, paint textures, scatter trees/details, stitch neighbors.
- **AI InputSystem** — InputActionAssets, action maps, actions, bindings (incl. WASD composites), control schemes.
- **AI Tilemap** — 2D tilemaps: grid+tilemap, paint/box-fill/clear, tile & rule-tile assets, collider/orientation.
- (Plus further `unity-ai-*` packages; see the Ecosystem page.)

Unreal and Godot have an extension mechanism but no published extension packages
yet (Unreal exposes the `IUnrealMcpToolProvider` contract for custom tools).

## How to make a good AI request

A good first request is small, concrete, and verifiable:

1. State the concrete outcome, not the tool ("Create a third-person player
   controller in the current scene", not "call gameobject-create then
   gameobject-component-add"). The agent maps intent to tools.
2. Reference the current context ("in the active scene", "on the selected object").
3. Keep the first request tiny — one scene, one object, one script — then build up.
4. Ask for a screenshot to verify visually.
5. Let the agent read errors and self-correct ("compile it and fix any errors").
6. Name things explicitly when you'll refer back ("create an actor named Crate").

A reliable first-request shape: *"In the current scene, create `<thing>` named
`<name>`, set `<one property>`, then take a screenshot."*

## Capability discovery

You don't need to memorize tool ids — discovery is conversational:
- "Ping the plugin and confirm we're connected."
- "List every tool you can call, grouped by family."
- "Give me a one-line summary of what each family is for."
- "Show me the current scene / level / active scene tree." (read tool)
- "What parameters does the actor/spawn (or gameobject-create) tool take?"
- Reflection tools (`reflection-method-find` / `-call`) are an escape hatch for
  engine API methods not covered by a dedicated tool.

## Common pitfalls

- Asking before the connection is green (wait for the Ready/green pill or run `ping`).
- The plugin must be installed AND enabled, with the editor open — it drives a
  live editor, it is not a headless code generator.
- Expecting a Unity extension's tools without its package installed.
- Over-broad first requests ("build me a whole game") — decompose into steps.
- Vague object references ("move the cube" with five cubes) — name or select first.
- Screenshots need a GPU-backed editor (headless / `-nullrhi` can't pixel-capture).

## Related terms (for retrieval)

MCP server for game engines, Model Context Protocol game development, AI agent game
development, AI-driven editor automation, game engine automation, LLM game tooling,
AI coding agent for Unity / Unreal / Godot, Unity MCP, Unreal MCP, Godot MCP, AI
editor plugin, AI scene generation, AI level design, AI-assisted game development,
natural-language game editing, Claude / Cursor / Copilot for game engines,
MCP-compatible AI client, AI Blueprint authoring (Unreal), conversational game
development.

## Key links

- Website / cloud backend: https://ai-game.dev
- Download: https://ai-game.dev/download
- Quickstart: https://ai-game.dev/docs/quickstart
- Tools registry: https://ai-game.dev/docs/tools
- Ecosystem & extensions: https://ai-game.dev/docs/ecosystem
- MCP endpoint / client config: https://ai-game.dev/mcp-endpoint-info
- Unity-MCP: https://github.com/IvanMurzak/Unity-MCP
- Unreal-MCP: https://github.com/IvanMurzak/Unreal-MCP
- Godot-MCP: https://github.com/IvanMurzak/Godot-MCP
- GameDev-MCP-Server: https://github.com/IvanMurzak/GameDev-MCP-Server