Build production-ready AI agents for intelligent NPCs, procedural content generation, automated QA, and live service automation
Market Size (Gaming AI)
Course Price
Students (Year 1)
Studios Using AI
15 sessions × 90-120 minutes each (22.5-30 hours total)
Live cohort-based + hands-on exercises + homework
Python (intermediate), basic game dev experience, Unity/Unreal helpful
Certificate + Production-ready capstone project
Master AI agent frameworks and establish development environment
Quest Generator Agent: Build a LangGraph agent that generates RPG quests based on player level, class, game lore, and recent actions. Outputs structured JSON with quest objectives, rewards, and dialogue.
Working quest generator that creates diverse quests with structured output
Dynamic Quest Chain System: Create a LangGraph application with 3-quest storyline, quest state tracking, NPC memory of player interactions, dynamic reward scaling, and graceful quest abandonment handling.
Multi-quest system with state persistence and Unity integration
Game Feature Design Crew: Build a CrewAI team that takes high-level feature request (e.g., "crafting system"), creates detailed mechanics spec, validates technical feasibility, balances gameplay, and outputs production-ready design document.
Multi-agent development crew that generates complete game feature specs
Build NPC AI, procedural content generation, and advanced game systems
Part 1: Build LLM-powered NPCs with natural language understanding, context-aware dialogue, personality systems, and Unity/Unreal integration. Create Tavern Keeper NPC with memory and quest integration.
Part 2: Implement cross-platform NPC memory (game + Discord), voice-enabled NPCs with speech-to-text/text-to-speech, emotional states, and multi-NPC coordination. Deploy NPCs at scale for multiplayer.
Capstone Deliverable: Cross-platform NPC network with Discord bot and Unity game client sharing conversation memory via Firebase.
Build reinforcement learning agents for NPC behavior using Unity ML-Agents. Implement utility AI for dynamic decision-making. Train NPCs to learn from player interactions. Combine RL for actions with LLM for tactics.
Exercise: Combat AI Agent that learns to dodge, attack optimally, and use terrain. Train 500k+ steps, achieve 50%+ longer survival vs scripted AI.
Session 7 - Fundamentals: Build LLM-powered level generators, procedural quest systems, validation pipelines. Deploy complete PCG system for dungeon and quest generation with Unity integration.
Session 8 - Advanced: Generate 3D game assets (meshes, textures), create game mechanics from natural language, implement runtime PCG, build player-adaptive content systems.
Build AI game master systems for dynamic storytelling. Implement branching narratives that adapt to player choices. Create coherent long-form narratives with LLMs. Design narrative guardrails to maintain story quality.
Deliverable: AI Game Master that generates coherent 3-act story with meaningful player choice consequences over 2+ hours.
Automated testing, live ops, deployment, and optimization at scale
Part 1: Build RL agents that playtest games automatically. Implement player archetype simulations (explorer, speedrunner, combatant). Create automated bug detection and reporting. Analyze playtesting data for balance insights.
Part 2: Implement computer vision visual testing, accessibility testing with AI agents, stress testing for multiplayer, comprehensive QA dashboards. Achieve 94% SLA compliance.
Build AI systems for LiveOps automation. Implement player behavior analysis and segmentation. Create personalized content delivery. Design predictive analytics for retention and monetization.
Exercise: Complete LiveOps platform ingesting telemetry, segmenting players, predicting churn, generating personalized content, and measuring impact on retention/revenue.
Deploy multi-agent systems to production cloud (AWS/GCP). Implement monitoring, logging, and observability. Optimize costs for large-scale deployment (90% reduction). Design failover and redundancy.
Deliverable: Cloud deployment with auto-scaling, Redis caching, managed database, monitoring dashboard, and cost projections for 1K-100K DAU.
Optimize AI models for real-time game performance (60+ FPS). Implement edge computing for low-latency inference. Use model quantization and compression. Deploy on consumer hardware (NVIDIA Jetson, mobile).
Target: <100ms latency, 60 FPS with 50+ AI agents, <2GB memory, minimal quality loss.
Student presentations (10 min each): project overview, live demo, technical deep dive, Q&A
Ship a production-ready multi-agent game system demonstrating mastery of AI technologies used by AAA studios like Ubisoft, EA, and Square Enix.
Python, LangGraph, CrewAI, Unity ML-Agents, Claude 3.5 Sonnet, Unity/Unreal Engine, Firebase, AWS/GCP
Demonstrate enterprise-grade AI engineering skills. Showcase ability to build, deploy, and scale AI systems used by top game studios. Perfect for landing AI game developer roles at Ubisoft, EA, Epic Games, or indie studios.
Joshua brings real-world experience from AAA studios where he built the exact systems you'll learn in this course. He's implemented multi-agent AI at Epic Games scale, optimized real-time performance for millions of concurrent players, and deployed production systems that handle massive load. You'll learn industry-proven patterns from someone who's shipped commercial games using these technologies.
Expected Completion Rate
Avg Time to Complete Capstone
Studios Using AI (You'll Join Them)
# LangGraph Quest Generator Agent (Session 1 Example)
from langgraph.graph import StateGraph
from langchain.chat_models import ChatOpenAI
class QuestState:
player_level: int
player_class: str
game_lore: str
quest_type: str
quest_output: dict
def generate_quest(state: QuestState) -> QuestState:
"""Generate RPG quest using LLM based on player context"""
llm = ChatOpenAI(model="gpt-4")
prompt = f"""Generate a {state.quest_type} quest for a level {state.player_level}
{state.player_class}. Game lore: {state.game_lore}
Output JSON with: title, objectives, rewards, dialogue, difficulty"""
quest = llm.invoke(prompt)
state.quest_output = parse_quest_json(quest)
return state
# Build LangGraph workflow
graph = StateGraph(QuestState)
graph.add_node("generator", generate_quest)
graph.set_entry_point("generator")
quest_agent = graph.compile()
# Usage
result = quest_agent.invoke({
"player_level": 10,
"player_class": "Warrior",
"game_lore": "Ancient kingdom at war",
"quest_type": "combat"
})