Skip to content
Jules Games Unity 6 LTS Beta Development
Last edited 33 days ago by Alexander Holmefjord-Sarabi.
Jules Games Unity 6 LTS Beta Development
Multi-LLM Adaptive Learning Platform - OPTIMIZED PLAN
4-Month Beta Program | $300K Budget | 2-Developer Team + Support
<analysis>
Key Optimizations Made:
Executive Summary
Project Vision
We're building an intelligent Jules "School of Fish" Computational Thinking platform that hedges across multiple AI providers (OpenAI, Claude, and Grok) to determine the optimal solution for personalized learning. This beta will serve as a real-world testing ground to identify which AI performs best for teaching Computational Thinking (CT) concepts to preschoolers (ages 4-7) before committing to a primary provider for production.
Jules School of Fish Focus
Building on the award-winning School of Fish curriculum, we're creating an AI-enhanced version that teaches the four core Computational Thinking concepts:
Strategic AI Approach: The Three-Provider Hedge
Instead of betting on a single AI provider, we're implementing all three major LLMs in parallel:
During the beta, we'll A/B/C test these providers to determine:
Optimized Team Structure
Investment Breakdown
Technology Stack: Complete Architecture
Multi-LLM Architecture with Modern Database Stack
┌─────────────────────────────────────────────────────────┐
│ STUDENT INTERFACE │
│ Unity 6.1 LTS Client │
├─────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Rendering │ │ Learning │ │ AI Router │ │
│ │ Engine │ │ Modules │ │ & Manager │ │
│ │ (URP) │ │ │ │ │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ Intelligent LLM Selection Layer │ │
│ │ (Routes to optimal AI for each task) │ │
│ └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
↕
┌─────────────────────────────────────────────────────────┐
│ AI PROVIDER LAYER │
├─────────────────────────────────────────────────────────┤
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ OpenAI │ │ Claude │ │ Grok │ │
│ │ GPT-4 │ │ API │ │ API │ │
│ │ │ │ │ │ │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
└─────────────────────────────────────────────────────────┘
↕
┌─────────────────────────────────────────────────────────┐
│ DATABASE & SERVICES │
├─────────────────────────────────────────────────────────┤
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Supabase │ │ Convex.dev │ │ Unity │ │
│ │ (Auth + │ │ (Real-time │ │ Analytics │ │
│ │ Storage) │ │ Sync) │ │ │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ Learning Analytics & Progress DB │ │
│ └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
Core Technology Components
1. Unity 6.1 LTS Foundation
Technical Specifications:
Business Value: Unity's proven stability with 2+ years guaranteed support ensures our educational platform won't need major technical updates during critical school years. Cross-platform deployment from a single codebase saves 40% in development costs.
2. Multi-LLM Integration Strategy
Technical Implementation:
public class MultiLLMOrchestrator
{
private readonly Dictionary<LLMProvider, ILLMService> providers = new()
{
{ LLMProvider.OpenAI, new OpenAIService() },
{ LLMProvider.Claude, new ClaudeService() },
{ LLMProvider.Grok, new GrokService() }
};
public async Task<LLMResponse> GetOptimalResponse(
CTQuery query,
ChildProfile child)
{
// Intelligent routing based on Jules CT concepts:
// - Algorithmic Thinking → GPT-4 (step-by-step reasoning)
// - Pattern Recognition → Claude (detailed explanations)
// - Decomposition → Grok (engaging, playful breakdown)
// - Abstraction → Provider rotation for comparison
// - Cost optimization (Grok for simple concepts)
// - Child's age and learning style
// - Provider availability and response time
var selectedProvider = DetermineOptimalCTProvider(query, child);
return await providers[selectedProvider].GenerateResponse(query);
}
// A/B/C testing framework with Jules CT focus
public async Task<CTComparisonResult> TestAllProviders(CTTestQuery query)
{
var results = await Task.WhenAll(
providers.Select(p => p.Value.GenerateCTResponse(query))
);
return AnalyzeCTResults(results);
}
}
OPTIMIZED Implementation Roadmap
Month 1: Foundation & Multi-LLM Architecture (Weeks 1-4)
Weeks 1-2: Environment Setup & Database Configuration
Developer 1 Focus: Unity & Infrastructure
Developer 2 Focus: AI & Database Integration
Tech Support Specialist Focus:
Part-time Content Creator Focus:
Deliverables:
Weeks 3-4: Asset Migration & AI Training Pipeline
Developer 1 Focus: Asset Pipeline
public class AssetMigrationSystem
{
// Automated asset processing
public async Task MigrateEducationalContent()
{
// 1. Import existing sprites, audio, animations
// 2. Optimize textures for mobile (ASTC compression)
// 3. Generate texture atlases for UI elements
// 4. Process curriculum data into Supabase
// 5. Create Convex schemas for real-time data
}
}
Developer 2 Focus: LLM Optimization
# LLM Response Evaluation System
class LLMEvaluator:
def compare_responses(self, query, responses):
metrics = {
'accuracy': self.evaluate_accuracy(responses),
'appropriateness': self.check_age_appropriate(responses),
'engagement': self.measure_engagement_potential(responses),
'cost': self.calculate_cost_per_response(responses),
'speed': self.measure_response_time(responses)
}
return self.determine_winner(metrics)
Deliverables:
Month 2: Core Learning System & Module 1 (Weeks 5-8)
Weeks 5-6: Adaptive Learning Engine
Developer 1 Focus: Game Mechanics
Developer 2 Focus: AI-Powered Jules CT Features
public class AdaptiveCTSystem
{
// Intelligent CT tutoring with rotating provider testing
public async Task<CTTutorResponse> GetPersonalizedCTHelp(
CTChallenge challenge,
ChildProfile child)
{
// Rotate provider for A/B/C testing
var provider = GetRotatingTestProvider(child.Id);
// Generate age-appropriate CT guidance
var response = await provider.GenerateCTHint(
challenge,
child.LearningStyle,
child.CTSkillLevel,
child.Age // 4-7 years old
);
// Log for Jules-specific CT comparison analysis
await LogCTInteraction(child, provider, response);
return response;
}
// Jules-specific CT assessment
public async Task<CTProgressAssessment> EvaluateCTProgress(
ChildProfile child,
CTConcept concept) // Decomposition, Abstraction, etc.
{
// Assess understanding of specific CT concepts
// Track progression through Jules curriculum milestones
}
}
Weeks 7-8: Complete Module 1 - Algorithmic Thinking (Pearly Whirly)
Collaborative Development: Both developers + content creator work together to complete:
Rotating Testing Matrix:
Table 83
Week
Student Batch 1
Student Batch 2
Student Batch 3
Week 7
OpenAI
Claude
Grok
Week 8
Claude
Grok
OpenAI
There are no rows in this table
Jules-Specific Learning Objectives:
Month 3: Additional Jules CT Modules & Optimization (Weeks 9-12)
Weeks 9-10: Module 2 - Pattern Recognition (Chomp Chomp)
Module Distribution:
Jules-Specific Learning Objectives:
Weeks 11-12: Module 3 - Decomposition (Manta Match Mania) + System Optimization
Final Jules CT Module:
Jules-Specific Learning Objectives:
Optimization Strategies:
// Optimized Caching Layer for Cost Reduction
const cacheStrategy = {
commonQueries: 'cache-forever', // Basic Q&A
personalizedHints: 'cache-1-hour', // Adaptive content
realTimeData: 'no-cache', // Current events (Grok)
// Provider-specific caching
openai: { ttl: 3600, maxSize: '100MB' },
claude: { ttl: 7200, maxSize: '150MB' },
grok: { ttl: 1800, maxSize: '50MB' } // Shorter due to real-time
};
Month 4: Beta Testing & Provider Evaluation (Weeks 13-16)
Weeks 13-14: Beta Deployment
Optimized Testing Infrastructure:
Want to print your doc?
This is not the way.
This is not the way.
Try clicking the ⋯ next to your doc name or using a keyboard shortcut (
CtrlP
) instead.