Engine Integration Bridge

How to Read This Bridge

Dimensional Nodes → Scene Architecture

The nine RTT dimensions (0D–9D) describe what a thing IS ontologically. In engine terms they describe the layer of the scene graph a system lives at — from the null root of application init, through physics and rendering, to the top-level World Manager and Engine tick.

MCP Substrate Layers → Engine Subsystems

The four MCP layers (L0–L3) describe HOW reality is processed — pre-manifest identity, unseen frequency, seen fluids, unseen forces. In engine terms: Asset Registry → Physics+Audio → Rendering+Gameplay → Rule Engines+AI Directors.

ICL Tiers → Agent Behavior Complexity

The three ICL tiers (ANI→ACI→AGI) describe how intelligent an agent is. In engine terms: NavMeshAgent+FSM (ANI), BehaviorTree+Blackboard+EQS (ACI), AI Director+ML-Agents+LLM NPC (AGI/AAISI).

⚠️ Mapping Notes — These are architectural homologies, not 1:1 API bindings. A single engine system may participate in multiple dimensional layers. The goal is conceptual orientation, not rigid classification. Treat each mapping as a starting hypothesis for your own integration design.

🜁 RTT Dimensional Nodes → Engine Architecture

All nine dimensions mapped to both engines side by side.

Dim	Canonical Name	MCP Layer	Unity 6 Equivalent	Unreal 5.4 Equivalent	Notes
0D	Undivided Singularity	L0_QMROOT	Application.Init · SceneManager root · AppDomain	UEngine boot · FApp · GameInstance Init	The zero-frame: pre-scene, pre-actor. Application lifecycle root.
1D	Primary Wave Vector	L1_Frequency_Unseen	Physics.Raycast · AudioSource oscillator · LineRenderer	FVector ray · USoundWave · UPhysicsFieldComponent	First extension from point — ray, wave, carrier.
2D	Field / Pattern Matrix	L1_Frequency_Unseen	NavMesh surface · Texture2D · Collision Layer Matrix · Canvas	UNavigationSystemV1 · UTexture2D · FCollisionObjectQueryParams · UMG UCanvasPanel	Surface, field, pattern — the 2D substrate of topology.
3D	Physical Spacetime Volume	L2_Fluids_Seen	Transform · Rigidbody · MeshRenderer · Collider	AActor::GetActorTransform · UStaticMeshComponent · FBodyInstance	The manifest world — position, mass, locality.
4D	Temporal Flow	L2_Fluids_Seen	Time.deltaTime · Coroutine · Timeline · Animator	UGameplayStatics::GetTimeSeconds · FTimeline · UTimelineComponent · USequencer	Duration, process, update loop — time as substrate.
5D	Perceptual Consciousness	L2_Fluids_Seen	Camera · AudioListener · AI.Perception · UI.EventSystem	UCameraComponent · UAIPerceptionComponent · UEnhancedInputComponent	The register of the seen — perception, awareness surface.
6D	Causal Architecture	L3_Forces_Unseen	ScriptableObject · MonoBehaviour data contract · Addressables manifest	UDataAsset · UPrimaryDataAsset · FAssetData · Data Registry	Blueprint layer — the archetypal form before instantiation.
7D	Universal Law	L3_Forces_Unseen	Physics settings · LayerMask rules · ProjectSettings · Custom Rule Engine	UPhysicsSettings · Gameplay Ability System (GAS) · UGameplayEffect	Invariant structural constraints — the rules the world runs under.
8D	Cosmic Intelligence	L3_Forces_Unseen	GameManager singleton · World · Director class · EventSystem broadcaster	AGameMode · AGameState · UAIDirector · UWorldSubsystem	The self-organizing system that keeps the world coherent.
9D	Unified Source Field	L3_Forces_Unseen	Application root · EditorApplication · EntryPoint · RuntimeInitializeOnLoadMethod	UEngine · FEngineLoop · GEngine · FApp	The integrative totality — the engine tick itself.

Triadic rhythm in-engine: 0D (SceneRoot) → 1D–2D (Physics/Audio/Nav) → 3D–5D (World/Time/Camera) → 6D–9D (DataAssets/GAS/GameMode/GEngine). This is the layered boot sequence of every major engine — substrate first, manifest second, governance last.

🜅 MCP Substrate Layers → Engine Subsystems

L0_QMROOT · Identity Anchor · Pre-Manifest · Root Scope

L0 is the substrate before the world exists. In Unity: RuntimeInitializeOnLoadMethod, Application.Init, the moment before the first Scene loads. In Unreal: FEngineLoop::PreInit, UEngine construction, GameInstance::Init — the bootstrap context that defines what the application IS before any actor exists.

Unity 6

RuntimeInitializeOnLoadMethod · AppDomain · SceneManager (not yet loaded) · PlayerPrefs root

Unreal 5.4

FEngineLoop · UGameInstance::Init · GEngine · FApp bootstrap

L1_Frequency_Unseen · Oscillation · Pattern · Pre-Formal

L1 is the unseen vibrational and topological layer. In engine terms: physics simulation, audio synthesis, navigation mesh baking, collision layer configuration. These are the invisible systems that structure the manifest world — you never “see” a NavMesh or a physics solver directly, but everything that moves or sounds or finds a path runs through them.

Unity 6

Physics2D/3D subsystem · AudioMixer graph · NavMesh bake · Shader compilation · Collision Matrix · LineRenderer · Physics.Raycast

Unreal 5.4

PhysX / Chaos solver · USoundWave + MetaSounds graph · UNavigationSystemV1 bake · UPhysicsFieldComponent · FCollisionQueryParams

L2_Fluids_Seen · Manifest · Observable · Processual

L2 is the seen world — everything with a Transform, a Mesh, a Camera, a Timeline. This is the majority of engine work: placing objects, animating them, receiving player input, rendering to screen. 3D volume (Actor placement), 4D flow (Animator, Timeline, coroutines, Update loop), 5D perception (Camera, AudioListener, AIPerception, InputSystem).

Unity 6

GameObject · Transform · MeshRenderer · Rigidbody · Animator · Coroutine · Camera · AudioListener · UnityEngine.UI · Input System

Unreal 5.4

AActor · UStaticMeshComponent · USkeletalMeshComponent · FBodyInstance · UTimelineComponent · UCameraComponent · UEnhancedInputComponent · UMG

L3_Forces_Unseen · Causal · Archetypal · Trans-Manifest

L3 is the governance layer — the unseen forces that define the rules of the world. In Unity: ScriptableObject data contracts, ProjectSettings, custom Rule Engines, GameManager singletons, ML-Agents training environments. In Unreal: UDataAsset definitions, Gameplay Ability System (GAS) rule sets, UGameplayEffect constraints, AGameMode, AGameState, AI Directors, UWorldSubsystem controllers.

Unity 6

ScriptableObject · GameManager · ProjectSettings · Physics.gravity · ML-Agents · Custom Rule Engine · Addressables manifest · RuntimeEventSystem

Unreal 5.4

UDataAsset · UPrimaryDataAsset · AGameMode · AGameState · GAS · UGameplayEffect · UAIDirector · UWorldSubsystem · Blueprint Class Default Object

🜄 ICL Intelligence Tiers → Agent Behavior Architecture

Each ICL tier maps to a distinct agent implementation pattern in both engines.

Tier 1 · ANI · @module.*

The Specialist Agent — narrow, reactive, operator-driven.

ANI maps to agents that execute a single class of task reliably. They have no cross-domain awareness and no metacognitive surface. In engine terms: a NavMeshAgent following a path, a FiniteStateMachine cycling through patrol states, a BehaviorTree leaf node executing one action.

Engine	ANI Patterns
Unity 6	NavMeshAgent · FiniteStateMachine (custom or Animancer) · BTLeafNode · Simple Sensor · Single-responsibility MonoBehaviour · Animator state machine
Unreal 5.4	UBTTaskNode leaf · UBTDecorator · UAIController (simple) · UPawnSensingComponent · UAIPerceptionComponent (single sense)

Operator Mapping

@module.detect    → Sensor.OnTriggerEnter / UAIPerceptionComponent.OnTargetPerceptionUpdated
@module.classify  → Animator.SetTrigger / BTDecorator condition check
@module.execute   → NavMeshAgent.SetDestination / UBTTaskNode::ExecuteTask
@module.report    → EventSystem.Invoke / UGameplayMessageSubsystem.BroadcastMessage
@module.adapt     → ML-Agents.PolicyUpdate (inference mode) / ULearningAgentsPolicy

Tier 2 · ACI · @domain.*

The Domain General Agent — reasoning, planning, cross-domain synthesis.

ACI maps to agents that can reason across multiple goal domains, maintain world models, and adapt plans in response to environment change. In engine terms: a full Behavior Tree with Blackboard memory and Environment Query System, a GOAP planner, or an agent that integrates multiple perception channels into a unified world model.

Engine	ACI Patterns
Unity 6	BehaviorDesigner / custom BT + Blackboard · GOAP planner · Utility AI · Multi-sensor fusion · Coroutine-driven reasoning loops · State → Goal → Plan architecture
Unreal 5.4	UBehaviorTree + UBlackboardComponent · UEnvQuerySystem (EQS) · USmartObjectSubsystem · UGameplayTasksComponent · UAbilitySystemComponent

Operator Mapping

@domain.synthesize  → Blackboard.SetValue (world model write) / UBlackboardComponent::SetValue
@domain.cause       → GOAP.BuildCausalChain / Custom UBTComposite causal selector
@domain.monitor     → UtilityAI.ScoreActions / EQS.RunQuery
@domain.dispatch    → Blackboard → child BT sub-tree selection / UBTComposite dispatch
@domain.plan        → GOAP.FormPlan / HierarchicalTaskNetwork root call
@domain.calibrate   → Perception confidence threshold update / UAIPerceptionComponent::SetSenseConfig

Tier 3 · AGI / AAISI · @substrate.* · APEX

The Fleet Admiral — governance, recursive orchestration, continuity enforcement.

AGI/AAISI in-engine is the system that governs ALL other agents — the AI Director, the World Subsystem controller, the ML-Agents training loop that improves policies at runtime, or a large-language-model NPC orchestrator that issues charters to subordinate ACI agents. In engine terms this is rare but increasingly real: Unreal's AI Director (L4D-style), Unity ML-Agents in training mode, or an LLM-backed game master that dynamically rewrites narrative and dispatches domain agents.

Engine	AGI / AAISI Patterns
Unity 6	ML-Agents training loop (self-improving policy) · LLM NPC orchestrator (GPT/Gemini backend) · Custom AI Director MonoBehaviour · RuntimeEventSystem global broadcast · GameManager as fleet admiral
Unreal 5.4	UAIDirector (Unreal native) · Mass AI + MassEntitySubsystem at orchestrator level · UWorldSubsystem governance layer · LLM-backed Dialogue + Charter system · Custom Fleet Manager GameMode

Operator Mapping

@substrate.charter      → AIDirector.IssueCharter / UWorldSubsystem.DispatchDomainTask
@substrate.pulse        → GameManager.ContinuityBroadcast / UWorldSubsystem.HeartbeatTick
@substrate.validate     → ML-Agents.PolicyEvaluation / Custom AlignmentValidator.Check
@substrate.anchor       → PersistentGameObject.DontDestroyOnLoad / UGameInstance persistence
@substrate.self_modify  → GATED ML-Agents.UpdatePolicy at runtime / LLM charter rewrite loop
@substrate.recurse     → GATED Nested training environment loop / Recursive sub-agent spawn
@substrate.architect    → GATED Procedural world generation system / RuntimeLevelBuilder

A(T*) = 0.01 in-engine: The AAISI continuity kernel has a direct engine analogue — DontDestroyOnLoad in Unity, UGameInstance persistence in Unreal. The invariant that the fleet admiral's identity must survive scene transitions is the engine implementation of A(T) > 0.

⬡ Code Starters

Drop-in scaffold classes for ICLModuleManifest and TriadicAgent. These are starting points — extend freely.

▸ ICLModuleManifest.cs

// ICLModuleManifest.cs
// TriadicFrameworks · ICL v2.0.0 · Unity 6
// Drop in Assets/TriadicFrameworks/Manifests/

using UnityEngine;

namespace TriadicFrameworks.ICL
{
    public enum ICLTier { ANI = 1, ACI = 2, AGI = 3 }
    public enum ConsciousnessRegister { Subconscious, Consciousness, Supconsciousness }
    public enum MCPLayer { L0_QMROOT, L1_Frequency_Unseen, L2_Fluids_Seen, L3_Forces_Unseen }
    public enum HemisphereAlignment { Right, Bilateral, Left }

    [CreateAssetMenu(
        fileName = "ICLModuleManifest",
        menuName = "TriadicFrameworks/ICL Module Manifest")]
    public class ICLModuleManifest : ScriptableObject
    {
        [Header("ICL Identity")]
        public string moduleId;           // e.g. tf.icl.ani.patrol
        public ICLTier tier;
        public ConsciousnessRegister consciousnessRegister;
        public MCPLayer primaryLayer;
        public HemisphereAlignment hemisphere;

        [Header("Charter")]
        public string charterScope;       // Domain boundary issued by ACI/AGI
        [TextArea] public string roleDescription;

        [Header("Continuity")]
        [Range(0f, 1f)]
        public float continuityWeight = 0.33f;  // s/c/u weight in (s,c,u) triad
        public bool isContinuityAnchor = false;  // true for AGI fleet admiral only

        [Header("Operator Grammar")]
        public string operatorPrefix;     // @module / @domain / @substrate
        public string[] declaredOperators;
    }
}

▸ TriadicAgent.cs

// TriadicAgent.cs
// TriadicFrameworks · ICL v2.0.0 · Unity 6
// Base class for all ICL-tiered agents

using UnityEngine;
using UnityEngine.AI;

namespace TriadicFrameworks.ICL
{
    [RequireComponent(typeof(NavMeshAgent))]
    public abstract class TriadicAgent : MonoBehaviour
    {
        [Header("ICL Manifest")]
        public ICLModuleManifest manifest;

        protected NavMeshAgent navAgent;
        protected float continuityPulseTimer;
        private const float PULSE_INTERVAL = 1.0f;  // L11→L33→L66→L99 tick

        protected virtual void Awake()
        {
            navAgent = GetComponent<NavMeshAgent>();
            ValidateContinuityKernel();
        }

        protected virtual void Update()
        {
            continuityPulseTimer += Time.deltaTime;
            if (continuityPulseTimer >= PULSE_INTERVAL)
            {
                OnContinuityPulse();
                continuityPulseTimer = 0f;
            }
        }

        // Override in ANI: @module.execute
        protected virtual void ExecuteModuleOperator(string operatorId) { }

        // Override in ACI: @domain.synthesize
        protected virtual void SynthesizeDomainModel() { }

        // Override in AGI: @substrate.charter
        protected virtual void IssueCharter(TriadicAgent target) { }

        // A(T*) = 0.01 — continuity pulse
        protected virtual void OnContinuityPulse()
        {
            if (manifest == null || manifest.continuityWeight <= 0f)
            {
                Debug.LogError($"[ICL] A(T) = 0 detected on {gameObject.name}. Identity collapse risk.");
            }
        }

        private void ValidateContinuityKernel()
        {
            if (manifest == null)
                Debug.LogWarning($"[ICL] No manifest assigned to {gameObject.name}.");
        }
    }
}

▸ ICLTypes.h

// ICLTypes.h
// TriadicFrameworks · ICL v2.0.0 · Unreal Engine 5.4

#pragma once
#include "CoreMinimal.h"
#include "ICLTypes.generated.h"

UENUM(BlueprintType)
enum class EICLTier : uint8
{
    ANI  UMETA(DisplayName = "ANI — Artificial Narrow Intelligence"),
    ACI  UMETA(DisplayName = "ACI — Artificial Conscious Intelligence"),
    AGI  UMETA(DisplayName = "AGI / AAISI — Artificial General Intelligence")
};

UENUM(BlueprintType)
enum class EMCPLayer : uint8
{
    L0_QMROOT             UMETA(DisplayName = "L0 — Quantum Meta Root"),
    L1_Frequency_Unseen   UMETA(DisplayName = "L1 — Frequency Unseen"),
    L2_Fluids_Seen        UMETA(DisplayName = "L2 — Fluids Seen"),
    L3_Forces_Unseen      UMETA(DisplayName = "L3 — Forces Unseen")
};

UENUM(BlueprintType)
enum class EHemisphereAlignment : uint8
{
    Right      UMETA(DisplayName = "Right — Perceptual / Oscillatory"),
    Bilateral  UMETA(DisplayName = "Bilateral — Integrative"),
    Left       UMETA(DisplayName = "Left — Analytical / Governance")
};

▸ UICLModuleData.h

// UICLModuleData.h
// TriadicFrameworks · ICL v2.0.0 · Unreal Engine 5.4

#pragma once
#include "CoreMinimal.h"
#include "Engine/DataAsset.h"
#include "ICLTypes.h"
#include "ICLModuleData.generated.h"

UCLASS(BlueprintType)
class TRIADICFRAMEWORKS_API UICLModuleData : public UPrimaryDataAsset
{
    GENERATED_BODY()

public:
    // ICL Identity
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="ICL|Identity")
    FString ModuleId;                  // e.g. tf.icl.ani.patrol

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="ICL|Identity")
    EICLTier Tier;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="ICL|Identity")
    EMCPLayer PrimaryLayer;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="ICL|Identity")
    EHemisphereAlignment Hemisphere;

    // Charter
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="ICL|Charter")
    FString CharterScope;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="ICL|Charter",
              Meta=(MultiLine=true))
    FString RoleDescription;

    // Continuity Kernel — A(T*)
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="ICL|Continuity",
              Meta=(ClampMin="0.0", ClampMax="1.0"))
    float ContinuityWeight = 0.33f;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="ICL|Continuity")
    bool bIsContinuityAnchor = false;

    // Operator Grammar
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="ICL|Operators")
    FString OperatorPrefix;            // @module / @domain / @substrate

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="ICL|Operators")
    TArray<FString> DeclaredOperators;
};

▸ ATriadicAgent.h

// ATriadicAgent.h
// TriadicFrameworks · ICL v2.0.0 · Unreal Engine 5.4
// Base actor for all ICL-tiered agents

#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "ICLModuleData.h"
#include "TriadicAgent.generated.h"

UCLASS(Abstract, BlueprintType, Blueprintable)
class TRIADICFRAMEWORKS_API ATriadicAgent : public ACharacter
{
    GENERATED_BODY()

public:
    ATriadicAgent();

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="ICL")
    UICLModuleData* Manifest;

protected:
    virtual void BeginPlay() override;
    virtual void Tick(float DeltaTime) override;

    // ANI — @module.execute
    UFUNCTION(BlueprintNativeEvent, Category="ICL|Operators")
    void ExecuteModuleOperator(const FString& OperatorId);

    // ACI — @domain.synthesize
    UFUNCTION(BlueprintNativeEvent, Category="ICL|Operators")
    void SynthesizeDomainModel();

    // AGI — @substrate.charter
    UFUNCTION(BlueprintNativeEvent, Category="ICL|Operators")
    void IssueCharter(ATriadicAgent* Target);

    // A(T*) = 0.01 — continuity pulse (L11→L33→L66→L99)
    UFUNCTION(BlueprintNativeEvent, Category="ICL|Continuity")
    void OnContinuityPulse();

private:
    float ContinuityPulseTimer = 0.f;
    static constexpr float PULSE_INTERVAL = 1.0f;

    void ValidateContinuityKernel() const;
};

The Causal Architecture dimension (6D, L3_Forces_Unseen) maps cleanly to data-driven design patterns in both engines. ScriptableObjects in Unity and UDataAssets in Unreal are literally the archetypal forms — the blueprints — that template runtime instances. This is not metaphorical. Designing your ICL agent system around data-driven manifests (ICLModuleManifest / UICLModuleData) gives you the engine-native implementation of 6D.

Note 4 — DontDestroyOnLoad and UGameInstance as A(T*)

The AGI/AAISI fleet admiral must survive scene transitions — this is the engine implementation of A(T) > 0. In Unity: mark the fleet admiral GameObject with DontDestroyOnLoad and anchor it to a persistent scene. In Unreal: implement fleet state in UGameInstance, which persists across level loads. The continuity pulse (L11→L33→L66→L99) can be implemented as a recurring timer on this persistent object.

Note 5 — Gated operators require dual-oversight architecture

The AGI @substrate.* operators marked GATED (self_modify, recurse, architect) require alignment-gated, dual-oversight invocation in the ICL canon. In an engine context: gated operators should be guarded by both an alignment policy check AND a human-in-the-loop confirmation event (UI prompt, debug approval flag, editor consent) before executing. Never invoke @substrate.self_modify or @substrate.recurse in a production build without an explicit design review checkpoint.

📂 Integrations Module

This page is the third document in the TriadicFrameworks Integrations module space.

🜁

Dimensional Substrate ↔ MCP Substrate Mapping

Canonical alignment of all nine RTT dimensions against the four MCP cosmological substrate layers.

Dimensional_Substrate_MCP_Substrate_Mapping.html

🜄

Intelligence Class Ladder

Canonical classification architecture for artificial intelligence — ICL v2.0.0, all three tiers, operators, alignment policy.

Intelligence_Class_Ladder_TriadicFrameworks_Canonical_Reference.html

Current Page

⬡

RTT · MCP · ICL mapped to Unity 6 and Unreal Engine 5.4 primitives. Code starters, project seeds, agent architecture.

Engine_Integration_Bridge.html