Model or dataset
tumourlove/monolith avatar
tumourlove/monolith

Monolith, the Unreal MCP plugin that hides 1,400 actions behind 26 tools

MCP plugin for Unreal Engine 5.7 & 5.8 — gives AI assistants full read/write access to Blueprints, Materials, Niagara, Animation, Mesh, AI, GAS, Logic Driver, ComboGraph, UI, Audio, plus Reflection Intelligence (decision / risk / C++ reflection / replication queries). 1,400+ actions across 25+ namespaces. Native C++, zero Python dependency.

372 stars95 forksC++MIT

At a glance

What is it?
Monolith is a native C++ Unreal Engine plugin that exposes Model Context Protocol access to almost every editor domain, from Blueprints and Niagara to Behavior Trees and replication graphs. Its central design argument is about context rather than coverage: one dispatch tool per namespace instead of one tool per action, an index of Unreal source symbols built offline, and per-call response shaping so a model can ask for less.
Who is it for?
Monolith is worth the setup cost if you drive Unreal through an AI assistant and have hit the wall where the tool catalogue is longer than the conversation. Its namespace dispatch pattern, its did_you_mean on bad action names, and its response shaping are all aimed at that specific problem.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 28 days ago.
What is it written in?
Mainly C++, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • tumourlove/monolith372 ★ · +60
Star history
Repository2026-09-222026-11-15
tumourlove/monolith312372

60 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The whole argument is what 1,400 tool names cost

The reason this plugin exists is stated in the first section of the README, and it is not about features.

Most MCP integrations for Unreal register every action as a separate tool. The objection is that this floods the assistant's context window with hundreds of tool names before you have asked a single question, and the useful actions get buried in the noise.

Monolith inverts that. Instead of a tool per action, each domain registers one tool of the form namespace_query(action, params), so a Blueprint edit is blueprint_query("create_blueprint", ...) and a material compile is material_query("compile", ...). Discovery is a separate call: monolith_discover() lists what exists, and it is terse by default, returning only a name and a one line description per action. The full parameter schema is one describe_query("action_schema", ...) call away, or detail=true on the dispatch itself.

There is a monolith_guide tool as well, described as self-onboarding, which exists so the assistant can work out what is available without the operator narrating it.

The claimed effect is that listing a namespace costs almost nothing, and that the assistant spends its budget on the problem rather than on memorising a catalogue.

The counts are approximate and the two of them disagree

The repository description and the README quote different numbers for the same thing.

The description says 1,400+ actions across 25+ namespaces. The README says about 1,400+ actions across 26 in-tree namespaces, and adds a parenthetical that the exact counts are intentionally approximate and that you should query monolith_discover() for the live figure.

The parenthetical is the honest answer and it is a defensible one. Action counts move with every release, and a number in a README that nobody updates is worse than no number. Making the tool itself the source of truth is the right call.

What the discrepancy does leave is a small ambiguity for anyone deciding whether to install. Twenty-five or twenty-six namespaces is the difference between the feature list in the description being complete and one namespace being unlisted, and nothing in the visible text says which one.

The plugin targets Unreal Engine 5.7 and 5.8 only. That is stated plainly, and it matters more than the namespace count for anyone still on 5.5 or 5.6.

A parser fix tripled the engine index to about 967K symbols

One change in version 0.19.0 did more for usefulness than any feature in the same release.

A parser fix taught the indexer about allman-brace plain classes and structs, and the engine source index went from roughly 300K symbols to roughly 967K. The README names the types that now actually return results: FCollisionShape, FScopeLock, FPaths, and about 40K other engine types.

That is worth pausing on. A source index that silently misses half the engine is not a smaller index, it is a broken one, because the model asks for a type, gets nothing back, and concludes the type does not exist. The failure mode looks like a wrong answer rather than a bug.

The same release added eight read-only lookups in the source namespace for exactly this class of question: get_include_path, get_signature, check_deprecations, verify_symbols, find_example_usage, suggest_build_cs_deps, lint_header, and generate_class_stub. Eight calls that each answer in one round trip what would otherwise cost the model a search through raw headers, and all eight are read-only, so a wrong guess costs nothing.

Engine source search is described as covering 1M+ symbols, fully offline, and project asset search runs on SQLite FTS5.

The reflection index is project-shaped, and engine built-ins stay out

The indexers have a scope, and the README states it plainly twice.

The cppreflect and network indexers scan your project plugins by default, so replicated classes and RPCs declared in plugins are in scope with no extra setup. Enabled marketplace plugins are behind a setting. Epic engine built-ins stay excluded.

That exclusion is the decision to understand. For replication analysis the interesting code is usually yours, so scanning the project and its plugins is the right default. It also means the answers are about your code, and a query that finds nothing is a finding rather than a coverage statement.

cppreflect is where the engine version shows up. It is described as Unreal 5.7 UHT reflection-edge queries cross-joined with the asset registry, so the reflection layer is built against one minor version's generated headers even though the plugin supports 5.7 and 5.8.

The reflect action is index maintenance, and the README is explicit that its force-rebuild is project only. Running it touches your project's tables and not the engine's, which is the boundary you want when something goes wrong.

Every action accepts _fields, _omit, and _compact_json

The token-saving machinery is per call rather than per session, and it applies everywhere.

Three parameters work on every action in the plugin. _fields selects what comes back. _omit removes keys. _compact_json changes the encoding. Nothing needs to be opted into per namespace.

The stated purpose is that the assistant spends less context recovering from typos and trial and error, which is the same goal as the dispatch pattern in the first place. One design narrows the tool list, the other narrows the response, and the README treats them as a single idea.

Two related pieces come from the same release. Params are schema-tagged with kinds, and asset paths get an automatic rewrite from backslashes to forward slashes. MCP tools/list annotations carry read-only, destructive, and idempotent hints.

Those annotations are the part most worth reading twice. They are hints to the model, not enforcement in the engine, so a model that ignores them can still destroy a graph. What they buy you is the ability to ask an assistant which of the 1,400 actions are safe to retry.

A bad action name gets a suggestion instead of an error

The dispatch layer is written to survive a model that guesses wrong.

When an action name does not resolve, the failure path returns did_you_mean, a fuzzy match suggestion, rather than a bare error. Combined with the terse default for discovery and the deferred schema, the intended loop is: list a namespace cheaply, call an action with a guessed name, get corrected, try again.

That loop is cheap only because of the other defaults. A full action listing with parameter schemas for 1,400 actions would be unusable as a retry path, which is why the full schema sits behind a separate call and why detail=true is opt-in per dispatch.

The error surface also grew a pagination story in the same release. source_query takes a cursor rather than returning every match at once, so a broad source search becomes a sequence of bounded pages instead of one enormous response.

The README frames all of this under a heading about LLM ergonomics rather than under features, which is a fair signal about where the effort went.

The release titles are a record of what went wrong

Three recent release names read like post-mortems, which is unusual and probably a good sign.

Version 0.21.3 is titled PR queue closeout. Version 0.22.0 is titled Correctness release. Version 0.23.0 covers input and localization namespaces, and adds that a lot of silent failures were made loud.

Making silent failures loud is the one to sit with, because it is a description of a class of bug specific to tool servers. An action that does nothing, or that quietly writes nothing, returns success. The model then reports a change that did not happen, and the next turn builds on it.

The 0.19.0 notes show the same instinct in two concrete first-launch fixes. MonolithMesh now delay-loads GeometryScripting, and the deep indexer no longer asserts on UserDefinedStruct fields with unresolved types, which was issue 70.

An assert in an indexer on a specific asset type is the kind of defect that only appears in one project, which is why it took an issue report. The 0.19.0 release also shrank the tools/list manifest by about 40 percent by dropping duplicated action lists from the dispatcher descriptions, which is the context argument being applied to the plugin's own surface.

The root has a CHANGELOG.md, an ATTRIBUTION.md, SECURITY.md, and CONTRIBUTING.md alongside Source/, Config/, MCP/, Skills/, Templates/, Tools/, and a wiki directory, so the reference material is versioned with the code rather than only on the GitHub wiki.

Editorial conclusion

Monolith is worth the setup cost if you drive Unreal through an AI assistant and have hit the wall where the tool catalogue is longer than the conversation. Its namespace dispatch pattern, its did_you_mean on bad action names, and its response shaping are all aimed at that specific problem. Check four things first. That your engine is 5.7 or 5.8, since cppreflect is described against 5.7 reflection data. That you understand what the index covers: your project and its plugins, not Epic's built-ins. That you are willing to read the wiki rather than a docs site, since the wiki is the documented home. And that the destructive and idempotent annotations mean something to the assistant you use, since they are hints rather than enforcement.

Frequently asked questions

How does monolith hide 1,400 Unreal actions from the model?

Each domain registers a single namespace_query(action, params) tool rather than one tool per action, so a Blueprint edit is blueprint_query("create_blueprint", ...) and a material compile is material_query("compile", ...). monolith_discover() lists what exists and returns only a name and a one line description per action by default.

Which Unreal Engine versions does monolith support?

Unreal Engine 5.7 and 5.8. The cppreflect layer is described as Unreal 5.7 UHT reflection-edge queries cross-joined with the asset registry. The plugin is native C++ with no Python dependency.

What does the monolith reflection index actually cover?

The cppreflect and network indexers scan your project plugins by default, enabled marketplace plugins are gated behind a setting, and Epic engine built-ins stay excluded. The reflect action performs a project-only force-rebuild of the reflection tables.

Where is the monolith documentation, and is there a release feed?

The repository homepage is the GitHub wiki rather than a separate documentation site, and there is also a wiki directory in the tree. Recent tags are v0.21.3 for a PR queue closeout, v0.22.0 as a correctness release, and v0.23.0 covering input and localization namespaces.

Official sources

  1. License: MIT
  2. Project website
  3. README
  4. Releases
  5. tumourlove/monolith on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/tumourlove-monolith.svg)](https://hysenlabs.com/projects/tumourlove-monolith)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/tumourlove-monolith.svg)](https://hysenlabs.com/projects/tumourlove-monolith)

Was this useful?