Unreal Capability Mesh

// PRODUCT WALKTHROUGH

Visual orientation backed by the product facts below.

Use the gallery as quick orientation, then inspect mechanics, actions, outputs, integrations, and boundaries.

Unreal Capability Mesh Overview slide — Overview **One control plane for capability routes, tools and diagnostics**
Real editor surface, project-local setup, governed execution.

// THE PAIN

Before the plugin enters the chat.

Every plugin integration has to choose between direct coupling and brittle glue code.

PAIN

A direct plugin pair often means duplicated assumptions, duplicated configuration paths, and duplicated failures when route behavior changes.

Unreal Capability Mesh introduces a manifest-first layer so providers expose stable capabilities, declared schemas, and route rules in project-local or plugin-local setup.

What that feels like

Plugins are coupled through hidden assumptions instead of explicit declarations.
Route contracts drift because integration details are spread across implementations.
Execution behavior is hard to inspect before side effects happen.

// WHAT YOU GET

After — in the editor, not in a slide deck.

Declare capabilities and routes in manifests, then execute constrained workflows with traceable diagnostics.

GAIN

Unreal Capability Mesh reads project-local and plugin-local setup, discovers providers, validates schemas and policies, and executes mesh routes through local diagnostics instead of hard-coded inter-plugin calls. Plugin-local manifests let an installed tool carry its route contract into another UE 5.4+ editor project.

Manifest-defined capability registry for providers, schemas, routes, transforms, and adapters.
Safe route planning with policy and side-effect constraints.
Local diagnostics, control panel access, editor job routes, MCP gateway access, and route dry-run workflows.
Portable provider-owned manifests for engine-installed tools and cross-project composition routes.

// HOW IT WORKS

The product architecture, inspected from the plugin surface.

These are the moving parts I would place on the page so buyers can understand what they are actually getting beyond the slide narrative.

01 / Declare

Manifests describe what plugins can do.

JSON setup files in project or enabled-plugin Config/UnrealCapabilityMesh folders define capabilities, schemas, routes, transforms, providers, and adapters.

02 / Plan

Routes are inspectable before execution.

The gateway can list capabilities, list routes, configure self-approval, and dry-run a route to show policy and side-effect expectations.

03 / Execute

The mesh invokes endpoints through a local route contract.

Editor subsystems can execute routes or invoke endpoints while diagnostics keep the setup-driven contract visible.

// FIT

Who actually reaches for this.

Teams running multiple TTD plugins that need interoperable routes and stable cross-plugin handoff.

Unreal Capability Mesh is published on Fab. It lets editor plugins discover capabilities, compose safe routes, expose editor job surfaces, and run compatible tool chains without direct compile-time coupling. Plugin-local manifests can travel in packaged engine plugins, and the optional TTER integration projects those routes while UCM retains planning, approval, dry-run, transform, and execution authority.

// SURFACE

Where it lives in Unreal.

Tools menu control panel, project/plugin manifest directories, capability discovery, route planning, execution, and diagnostics output.

// CAPABILITY MAP

Feature groups with the value of each part made explicit.

Grouped from plugin modules, public APIs, automation hooks, and documented workflow surfaces.

Manifest-first integration

The product replaces hidden pairwise glue with route declarations that remain visible whether the project or an installed provider owns them.

Reload setup from project-local and plugin-local manifest directories.
List available capabilities and routes.
Define schemas, transforms, adapters, and provider endpoints.
Keep project-owned integration behavior reviewable in project config.

Portable provider manifests

A provider can carry its own route contract into another UE 5.4+ editor environment.

Discover manifests from enabled project plugins and engine-installed plugins.
Keep provider routes next to the plugin that owns the endpoint.
Avoid copying provider declarations into every consuming project.
Let project-local setup override or extend only the routes the project owns.

Safe route execution

Operators can inspect what a route would do before the editor carries it out.

Dry-run routes before execution.
Configure self-approval behavior for trusted workflows.
Return diagnostics for policy and schema decisions.
Expose side-effect intent in the route layer.

Ecosystem backbone

UCM is the shared connective tissue across Tiny Tool plugins, including Composition evidence, approved execution, materialization, and verification routes.

Bundled routes cover IIS, LLM Store, UMCP, SCD, ASB, PRS, APM, PIO, and editor tools.
Editor job routes become visible without direct plugin dependencies.
MCP gateway behavior can call mesh routes.
Provider plugins keep domain logic while UCM owns interoperability.

Composition read path

APM and PIO publish owner-held routes for recursive inventory and deterministic draft compilation.

APM exposes recursive source and target inventories plus dependency-ranked mirror candidates.
PIO consumes the inventory evidence and compiles a canonical draft composition manifest.
Dry-run, approval, and owner-held mutation boundaries remain visible before any target change.
Automation evidence covers deterministic drafts, approval-gated execution, materialization, and findings-bearing verification; project acceptance remains operator-owned.

// OPERATOR TOOLS

Concrete actions, expected result, and mutation boundary.

This is the part that keeps product marketing honest: buyers can see which buttons, APIs, or MCP tools matter and what they change.

// ACTION

Reload setup

Why it matters: Refreshes manifest-defined capabilities and routes.
Operator result: The mesh reflects the current project configuration.
Change surface: Updates mesh discovery state.

// ACTION

List capabilities

Why it matters: Shows what the project says each provider can do.
Operator result: Operators can inspect integration inventory.
Change surface: Read-only.

// ACTION

Dry-run route

Why it matters: Plans a route without applying its side effects.
Operator result: Policy, schema, and adapter behavior can be reviewed.
Change surface: Read-only planning pass.

// ACTION

Execute route

Why it matters: Runs a declared route through the mesh gateway.
Operator result: Cross-plugin workflow happens through the manifest contract.
Change surface: Depends on the declared route side-effect policy.

// ACTION

Invoke endpoint

Why it matters: Calls a declared provider endpoint through the gateway contract.
Operator result: Toolchains can reach a plugin surface without direct compile-time coupling.
Change surface: Depends on endpoint declaration and provider implementation.

// ACTION

Configure self-approval

Why it matters: Sets whether trusted routes can proceed without a separate approval hop.
Operator result: Automation can be strict for risky routes and smoother for known-safe diagnostics.
Change surface: Updates mesh approval behavior.

// ACTION

List routes

Why it matters: Shows the current executable route inventory.
Operator result: Integrations become visible as project setup, not hidden code paths.
Change surface: Read-only route inventory.

// TYPICAL FLOW

From inspection to use without losing the product boundary.

01

Enable providers that ship their own manifests and add project-local setup only where the project owns the route.

02

Open the Unreal Capability Mesh control panel and reload discovery state.

03

Validate policies, run dry-runs, and execute only when diagnostics match expected side-effect behavior.

// PROOF AND BOUNDARIES

Signals that make the product specific, plus the limits worth saying out loud.

Each card turns implementation facts into buyer-facing proof without pretending the tool solves the wrong problem.

Setup Project-local and plugin-local JSON manifests

Engine floor UE 5.4+

Controls Reload, list, dry-run, execute, invoke endpoint

Policy Self-approval and side-effect constraints

Coverage Routes for AI, scene, governance, and bridge tools

Manifest content Capabilities, routes, schemas, transforms, adapters, providers

Bundled route scope IIS, LLM Store, UMCP, SCD, ASB, editor utilities, PRS, UII, APM, PIO

Gateway surface Dry-run and execution through a local MCP/editor gateway subsystem

Composition proof UE 5.4 automation covers draft, approved owner-routed execution, materialization, and findings-bearing verification; project acceptance remains operator-owned

Outputs

What the plugin leaves behind when the workflow is doing useful work.

Route diagnostics
Evidence for why a route is allowed, blocked, or adapted.
Capability inventory
A readable map of available plugin surfaces.
Execution result JSON
Structured response from route or endpoint invocation.
Route plan
Dry-run detail that shows schema, policy, adapter, and side-effect expectations.
Manifest-backed setup
Source-controllable configuration that explains the ecosystem wiring and can travel with its owning provider.

Inspection basis

The concrete code, API, and tool surfaces used to shape this product page.

Subsystem
CapabilityMeshMcpGatewaySubsystem exposes reload, list capabilities/routes, dry-run, execute route, invoke endpoint, and approval configuration.
Config folders
Project and enabled-plugin Config/UnrealCapabilityMesh manifests define routes and capabilities across Tiny Tool plugins.
Route inventory
The inspected manifests include AI, scene, governance, content-health, bridge, editor-job, integration-intelligence, and Composition surfaces.
Design boundary
UCM owns interoperability contracts; provider plugins keep their own domain behavior.
Proof boundary
UE 5.4 automation covers deterministic drafts, separately approved owner-routed execution, materialization, and findings-bearing verification; target-project acceptance remains an operator decision.

Integrations

Where the product connects without losing ownership of its own domain.

Unified MCP Server
MCP clients can reach mesh-declared routes through a shared gateway path.
All Tiny Tool plugins
The mesh reduces pairwise coupling across the ecosystem.
Editor job surfaces
Long-running product jobs can be listed and queried through common routes.
Bridge plugins
Bridges can publish constrained handoff routes without becoming giant dependency hubs.
Asset Plugin Maker
APM publishes cross-project inventory and approval-gated transfer routes while keeping asset-package authority.
Project Intelligence Orchestrator
PIO consumes Composition evidence, compiles deterministic drafts, and coordinates separately approved execution and verification while route owners retain authority.
CI and local automation
Declared routes can be used as repeatable, inspectable automation contracts.

Safety model

The boundaries that make the tool understandable before automation enters.

Dry-run first
Route planning is a visible operation before execution.
Declared side effects
Mutation expectations live in setup rather than only in implementation code.
Manifest ownership
Project teams can audit project-owned routes while provider-owned declarations remain versioned with the plugin that implements them.
Approval mode
Self-approval can be configured instead of being assumed globally.
Schema visibility
Input/output expectations sit in route setup, making drift easier to catch.
Composition gates
Inventory and draft compilation do not imply human approval, execution, or target-project acceptance; each later route retains its declared approval and owner authority.

Not for

The cases where the product promise would be the wrong expectation.

Single-plugin projects with no interoperability needs.
Teams that prefer every integration to be hardcoded in C++ only.
Workflows where route policy and side-effect declarations would be ignored.
Presenting implementation automation or a draft as proof that a concrete target project was approved and accepted.

// PRODUCT MEDIA

Tutorial and platform embeds stay attached to product context.

YouTube, Discord, LinkedIn, and Fab widgets are reserved for product presentation, explanation, support context, or tutorials. No third-party widget loads automatically.

Tutorial video

YouTube

Product walkthroughs, setup explanations, and tutorial material.

Embed source pending. No third-party widget is loaded here.

Open platform

Primary support context

Discord

Discord-first product support, quick questions, setup discussion, and community context.

Embed source pending. No third-party widget is loaded here.

Open platform

Professional context

LinkedIn

Company background, provider identity, project credibility, and listing context.

Embed source pending. No third-party widget is loaded here.

Open platform

Marketplace context

Fab

Product listing context, license details, purchase route, and marketplace availability.

Embed source pending. No third-party widget is loaded here.

Open platform

// INFORMATION

All essential product signals in one place.

Status Available on Fab

Category Foundation Plugins

Unreal Engine 5.4; current descriptor/build line UE 5.8

Source state Core setup, discovery, planning, execution, orientation, and editor surfaces verified; plugin-local manifests demonstrated in packaged foreign-editor hosts; TTER projection and runtime/editor separation implemented and UE 5.4 verified.

Primary surface Tools menu control panel, project/plugin manifest directories, capability discovery, route planning, execution, and diagnostics output.

Marketplace Fab listing available

Direct sales None on this website

Support route Discord first; product context lives on this page

Listing context Fab for marketplace, LinkedIn for public provider identity

Fact surface 3 functions / 3 settings / 3 failure modes / 1 bridge

Boundary Setup-driven interoperability hub for declared capabilities, endpoints, schemas, rules, routes, transforms, adapters, diagnostics, and generic gateway access.

Primary workflow Reload setup, inspect discovered capabilities and routes, dry-run route plans, execute approved routes, and review local diagnostics and reports.

Proof state Core setup, discovery, planning, execution, orientation, and editor surfaces verified; plugin-local manifests demonstrated in packaged foreign-editor hosts; TTER projection and runtime/editor separation implemented and UE 5.4 verified.

// NOTES

Practical boundaries.

Unreal Capability Mesh is published on Fab as Unreal Capability Mesh - The Plug for your Tools.

The product page links directly to the Fab listing for license, account, checkout, and download context.

The Composition Plane implementation is UE 5.4-first.

Automation evidence covers deterministic drafts, approval-gated owner-routed execution, materialization, and findings-bearing verification; concrete project approval and acceptance remain operator-owned.

The base technical layer is foundation-oriented and does not replace provider-specific plugin functionality.

// LEGAL / PRIVACY

Static information page.

Purchases, downloads, marketplace accounts, and platform-specific license details are handled outside this website. Product or tutorial widgets are loaded only after activation, where configured.

Provider details are listed in the legal notice. The current site template does not set first-party cookies and does not load analytics scripts.

Legal Notice Privacy Policy

// RESOURCES

Open the channel that matches the next question.

Fab listing

Listing, license, purchase, account, and download context are handled by Fab.

Open

GitHub documentation

Manuals, quickstarts, settings references, troubleshooting, technical notes, and release material live in GitHub.

Open

Discord support (primary)

Start quick questions, setup help, support context, and product-fit discussion on Discord.

Open

Plugin support email

Formal plugin support requests can be sent to the dedicated support mailbox.

Open

LinkedIn company context

Company background, public provider identity, and listing context are available on LinkedIn; support still starts on Discord.

Open

// RELATED

Visual orientation backed by the product facts below.

Before the plugin enters the chat.

After — in the editor, not in a slide deck.

The product architecture, inspected from the plugin surface.

Manifests describe what plugins can do.

Routes are inspectable before execution.

The mesh invokes endpoints through a local route contract.

Who actually reaches for this.

Where it lives in Unreal.

Feature groups with the value of each part made explicit.

Manifest-first integration

Portable provider manifests

Safe route execution

Ecosystem backbone

Composition read path

Concrete actions, expected result, and mutation boundary.

Reload setup

List capabilities

Dry-run route

Execute route

Invoke endpoint

Configure self-approval

List routes

From inspection to use without losing the product boundary.

Signals that make the product specific, plus the limits worth saying out loud.

Outputs

Inspection basis

Integrations

Safety model

Not for

Tutorial and platform embeds stay attached to product context.

YouTube

Discord

LinkedIn

Fab

All essential product signals in one place.

Practical boundaries.

Static information page.

Open the channel that matches the next question.

Fab listing

GitHub documentation

Discord support (primary)

Plugin support email

LinkedIn company context

Nearby tools in the catalogue.

Internal Index Service

LLM Store

Unified MCP Server

Continue through the catalogue.