Mohammed Mahdi Jahangiri

Featured Work

Projects demonstrating forward-deployed AI engineering, legacy C++/C# system integration, deterministic LLM guardrails, and cross-org client delivery.

[Creation Kit Mod: CompanionLLMV01.esp]
        ↓
[Papyrus In-Game Hook: MMJ_TavernWitnessChatLauncher]
        ↓ (Writes request.json via JContainers / PapyrusUtil)
        ↓
[Python Orchestrator: bridge.py]
    ├── [data_director.py]         → IO, Session Memory, & Logging 
    ├── [llm_payload_builder.py]   → Profile & Quest State Prompt Injection
    ├── [Inference Engine]         → Online Cloud APIs & Offline Local Gemma 2B
    └── [llm_reply_processor.py]   → JSON Sanitisation & Quest Policy Validation
        ↓
        ↓ (Writes response.json via JContainers / PapyrusUtil)
[Skyrim Quest Engine: MMJ_PoisonedMeadQuestScript]

#This is sent with the main prompt to give a template for the llm's reply
def build_output_contract() -> Dict[str, Any]:
    """
    Defines the strict JSON schema contract for the LLM output.
    The response must strictly adhere to this structure to pass 
    the Papyrus state-machine validation layer.
    """
    return {
        "schema_version": "1.0",
        "dialogue": "Short, 1-3 sentence player-facing NPC dialogue.",
        "player_intent": "Selected from allowed intents (e.g., 'ask_for_information').",
        "topic": "Selected from allowed topics (e.g., 'suspect', 'weapon').",
        "policy_id": "One specific state-machine policy available to this NPC.",
        "response_type": "Must strictly align with the chosen policy_id.",
        "clue_revealed": ["Zero or more validated clue IDs (e.g., 'C1')"],
        "action_request": None,
    }

=== EMPIRICAL EVALUATION HARNESS (1,500 Trials / 100 Scenarios) ===

State-Machine Routing Accuracy:
├── Base 2B Baseline        :  [====                ] 19.0%
├── Base 26B Baseline       :  [======              ] 29.0%
└── Fine-Tuned Gemma 2B     :  [===========         ] 53.4% (p < 0.001)

Inference Performance (AMD RX 6900 XT @ 4-bit QLoRA):
├── Median Latency          :  0.98s
├── Token Throughput        :  36.2 TPS
└── Peak VRAM Allocation    :  7.1 GB (Strict Edge Budget)

Bounded LLM Orchestrator & Legacy System Integration

Python • Legacy C++ Integration • Cloud & Local LLMs (QLoRA) • Deterministic State Machines • Benchmarking

MSc Thesis deployed as the Skyrim LLM Bridge: an end-to-end generative pipeline supporting both online cloud and offline local models inside an authoritative legacy C++ runtime.

• Legacy System Integration: Built an asynchronous IPC bridge connecting Skyrim's C++/Papyrus engine to both online and offline LLM endpoints without thread-blocking.
• Deterministic Guardrails: Gated LLM inference behind a JSON state-machine validator and epistemic clue gating to eliminate hallucinations.
• Edge QLoRA Fine-Tuning: Adapted Gemma 2B via 4-bit QLoRA, raising state-machine routing compliance from 19.0% → 53.4% (p < 0.001).
• Empirical Benchmarking: Evaluated across 1,500 automated trials, achieving 0.98s median latency and 36.2 TPS within a 7.1 GB VRAM budget.

GitHub Repo → Hugging Face Model → Nexus Mods (Mod #194492) →

// Called during the LaunchSequence coroutine to animate letters along an arc
private void ApplyLetterTransforms(float t)
{
    foreach (OrbitLetter orbitLetter in letters)
    {
        Transform letterTransform = orbitLetter.letter.transform;

        // Interpolate the linear base position from start to end
        Vector3 basePosition = Vector3.Lerp(
            orbitLetter.startPoint.position,
            orbitLetter.endPoint.position,
            t
        );

        // Calculate a vertical arc offset using a sine wave to simulate projectile-like motion
        float arcOffset = Mathf.Sin(t * Mathf.PI) * arcHeight;

        letterTransform.position = basePosition + (Vector3.up * arcOffset);

        // Apply spherical interpolation for smooth rotation alignment
        letterTransform.rotation = Quaternion.Slerp(
            orbitLetter.startPoint.rotation,
            orbitLetter.endPoint.rotation,
            t
        );
    }
}

[ContextMenu("Restart Orbit Launch")]
public void RestartSequence()
{
    // Validates references and logs errors before attempting execution
    if (!ValidateLetters()) 
        return;

    StopAllCoroutines();
    StartCoroutine(LaunchSequence());
}

Cross-Org Systems Engineering — Awkward Studios (CULTVR & Media Cymru)

Unity C# • Applied Mathematics • TextMesh Pro Vertex Buffers • State-Machine APIs • GitHub PR Workflow

Forward-deployed R&D for venue partner CULTVR Lab and sponsor Media Cymru, delivering custom spatial UI and math correction for a 360° dome installation.

• Ambiguous Client R&D: Collaborated across organisations to bridge gaps in open-source 360° dome tooling where no off-the-shelf UI spec existed.
• Applied Math Engineering: Solved 360° spherical distortion in C# by manipulating vertex buffers with custom trigonometry and Quaternions.
• Boundary & State APIs: Engineered a half-sphere clipping system to eliminate visual artifacts and built decoupled state APIs using C# delegates.

// Radial search algorithm optimizing unit placement and avoiding inefficient .Sum() allocations
int maxNumberOfSurroundingCircles = 50;
int[] expectedPositionCounts = new int[maxNumberOfSurroundingCircles];
float[] angleIncValues = new float[maxNumberOfSurroundingCircles];
float[] currentAngles = new float[maxNumberOfSurroundingCircles];
float[] offsets = new float[maxNumberOfSurroundingCircles];

int currentTotalPositions = 0;
for (int i = 0; currentTotalPositions < amount && i < maxNumberOfSurroundingCircles; i++) 
{
    offsets[i] = offset * (i + 1);
    expectedPositionCounts[i] = Mathf.FloorToInt(2.0f * Mathf.PI * offsets[i] / ((refUnit.Radius + spacing) * 2.0f));
    if (expectedPositionCounts[i] == 0) expectedPositionCounts[i] = 1;
        
    angleIncValues[i] = 360f / expectedPositionCounts[i]; 
    currentAngles[i] = 0.0f;
    currentTotalPositions += expectedPositionCounts[i];
}

Engineering Team Lead — Landell Games (Apoceus)

Agile/Scrum • Technical Leadership • Performance Profiling • Git/Plastic SCM • Steam

Production engineering leadership and cross-department delivery on a live-service project shipping to Steam.

• Coordinated a 3–6 person engineering team, translating production priorities into sprint tasks and raising sprint completion from 40% → 90%.
• Profiled CPU and rendering bottlenecks, improving runtime performance by 10–30 FPS on target hardware.
• Led rigorous code reviews and enforced clean branch hygiene across a distributed remote team.
• Owned weekly release pipelines and aligned technical architecture across 5 department leads.

View on Steam →

[AI Safety Cardiff University (AISCU)]
        ↓ (Spring 2026 Fundamentals Fellowship)
[Research & Evaluation Domains]
    ├── Catastrophic AI Risks & Governance
    ├── Reward Hacking & Specification Gaming
    ├── Deception, Scheming & Model Evals
    └── Cyber Risks & AI / Biosecurity
        ↓
[Focus: AI Safety, Biosecurity & Human Autonomy]

AI Safety Cardiff University (AISCU) — Founding Fellow

AI Safety • Model Evaluation • AI Governance • Biosecurity • Risk Alignment

Founding member and fellow of the Spring 2026 Fundamentals Fellowship at AI Safety Cardiff University.

• Evaluated specification gaming, deception/scheming, and model evaluation frameworks for frontier AI systems.
• Analysed AI governance, cyber risks, and safety controls at the biosecurity interface.
• Focused research on autonomous AI alignment, behavioral data privacy, and human autonomy.

[Player Microphone Input]
        ↓
[Unreal C++ Mic Capture]
        ↓ (HTTP REST API)
[Python FastAPI Microservice]
    ├── [Whisper] → Real-time Speech-to-Text
    ├── [Wit.ai] → Intent Classification
    └── [Hugging Face] → Voice Emotion Model
        ↓ (JSON Response)
[Unreal Behavior Tree] → Real-time Action Logic

AI-Driven NPC Interaction Prototype

Python • FastAPI • PyTorch • Hugging Face • C++ • Unreal Engine 5 • Whisper • Wit.ai

A real-time, voice-driven AI microservice bridging live microphone audio to autonomous C++ behavior logic.

• Architected a local Python FastAPI server bridging real-time audio input to a C++ runtime via REST API.
• Orchestrated Whisper (STT), Wit.ai (intent), and Hugging Face transformers for real-time emotion detection.
• Curated custom voice datasets to train the emotion classifier and configure domain-specific intent schemas.
• Wired low-latency C++ audio capture to drive autonomous Behavior Tree decision logic in real time.

Publication — ICHORA 2024

LLMs • NLP • Pursuit Learning Automata • Edge Compute Optimization

Balancing Game Satisfaction and Resource Efficiency: LLM and Pursuit Learning Automata for NPC Dialogues

• Published peer-reviewed research proposing a resource-efficient local LLM pipeline for interactive systems.
• Applied Pursuit Learning Automata to dynamically balance output quality against local compute constraints.
• Demonstrated real-time feasibility of hybrid ML orchestration in hardware-constrained environments.

View on Google Scholar →

About

Forward Deployed Engineer / AI Engineer

Forward Deployed Engineer & AI Engineer bridging local LLM/NLP pipelines with complex C++/C# systems and cross-org client R&D. Published researcher (ICHORA 2024), Engineering Team Lead (40% → 90% sprint delivery), and Founding Fellow at AI Safety Cardiff University.

Read Full Profile

CV

View CV Document Download PDF

Contact

Available for Forward Deployed Engineer and AI Engineer roles.

• GitHub: github.com/devPirate01
• LinkedIn: linkedin.com/in/m-mahdi-jahangiri
• Hugging Face: huggingface.co/devPirate01
• Nexus Mods: nexusmods.com (Mod #194492)
• Email: mapjiv@live.com

● Expanded View