hanzo.ai/app/(marketing)/university/courses-data.ts

import { phrase } from '@hanzo/i18n'
export interface CourseWeek {
  week: string
  code: string
  title: string
  summary: string
  lectures: string[]
  readings: string[]
  lab: string
}

export interface UniversityCourse {
  slug: string
  code: string
  title: string
  credential: string
  credentialFull: string
  track: 'coding' | 'marketing' | 'rl' | 'systems' | 'architect'
  units: number
  price: number
  rebateCredits: number
  duration: string
  level: string
  prerequisites: string
  summary: string
  capstone: string
  competencies: string[]
  planId: string
  featured?: boolean
  instructor: {
    name: string
    role: string
    avatar?: string
  }
  syllabus: CourseWeek[]
}

export interface CouponResult {
  valid: boolean
  code: string
  discountPercent?: number
  discountAmount: number
  originalPrice: number
  finalPrice: number
  rebateCredits: number
  /** The English source of what to say, drawn with `t(message, { code, label, amount })`. */
  message: string
  /** The applied promotion's English name, translated where it is drawn. */
  label?: string
}

export const KNOWN_COUPONS: Record<string, { percent?: number; amount?: number; label: string }> = {
  HANZO20: { percent: 20, label: phrase('20% Off Hanzo University') },
  STUDENT50: { percent: 50, label: phrase('50% Off Academic / Student Grant') },
  STUDENTS50: { percent: 50, label: phrase('50% Off Academic / Student Grant') },
  STUDENT: { percent: 50, label: phrase('50% Off Academic / Student Grant') },
  STUDENTS: { percent: 50, label: phrase('50% Off Academic / Student Grant') },
  '50OFF': { percent: 50, label: phrase('50% Off Promotion') },
  EARLYBIRD: { amount: 50, label: phrase('$50 Off Early Enrollment') },
  LAUNCH25: { percent: 25, label: phrase('25% Off Launch Promotion') },
  DEVCOMMUNITY: { percent: 30, label: phrase('30% Off Developer Community') },
  VIP100: { amount: 100, label: phrase('$100 Off Principal Fellowship') },
  KAI: { percent: 35, label: phrase('35% Off Decision Engineering') },
}

export function validateCoupon(rawCode: string, originalPrice: number): CouponResult {
  const code = (rawCode || '').trim().toUpperCase()
  if (!code) {
    return {
      valid: false,
      code: '',
      discountAmount: 0,
      originalPrice,
      finalPrice: originalPrice,
      rebateCredits: Math.ceil(originalPrice * 0.25),
      message: '',
    }
  }

  const promo = KNOWN_COUPONS[code]
  if (!promo) {
    return {
      valid: false,
      code,
      discountAmount: 0,
      originalPrice,
      finalPrice: originalPrice,
      rebateCredits: Math.ceil(originalPrice * 0.25),
      message: phrase('Coupon code "{code}" is invalid or expired.'),
    }
  }

  let discountAmount = 0
  let discountPercent = promo.percent
  if (promo.percent) {
    discountAmount = Math.round((originalPrice * promo.percent) / 100)
  } else if (promo.amount) {
    discountAmount = Math.min(originalPrice - 1, promo.amount)
    discountPercent = Math.round((discountAmount / originalPrice) * 100)
  }

  const finalPrice = Math.max(1, originalPrice - discountAmount)
  const rebateCredits = Math.ceil(finalPrice * 0.25)

  return {
    valid: true,
    code,
    discountPercent,
    discountAmount,
    originalPrice,
    finalPrice,
    rebateCredits,
    message: phrase('✓ Applied: {label} (-${amount})'),
    label: promo.label,
  }
}

export const UNIVERSITY_COURSES: UniversityCourse[] = [
  {
    slug: 'agentic-coding',
    code: 'ENG 100',
    title: phrase('Agentic Coding Systems with Hanzo Dev & Zen 6'),
    credential: 'HACE',
    credentialFull: phrase('Hanzo Certified Agentic Coding Engineer'),
    track: 'coding',
    units: 4.0,
    price: 199,
    rebateCredits: 50,
    duration: phrase('4 Weeks · Self-Paced'),
    level: phrase('Advanced'),
    prerequisites: phrase('Proficiency in Python/Rust/Go/TS + standard Git workflows'),
    summary:
      phrase('Architect autonomous coding agents capable of multi-file refactoring, test-driven debugging, and opening verified pull requests using Zen 6, ZAP RPC, and isolated Hanzo Visor sandboxes.'),
    capstone: phrase('Build an autonomous SWE-bench repair bot that resolves real GitHub issues within strict budget caps.'),
    competencies: [
      phrase('Zen 6 (27.3B) & Zen 6 Flash local serving'),
      phrase('SWE-bench self-healing test execution loops'),
      phrase('ZAP Zero-Copy Cap’n Proto multi-agent swarms'),
      phrase('Physical sandbox pod leasing & Hanzo Visor isolation'),
    ],
    planId: 'course-eng-100',
    featured: true,
    instructor: {
      name: 'Dr. Ethan Vance',
      role: phrase('Principal Systems Architect, Hanzo Autonomous Infrastructure'),
    },
    syllabus: [
      {
        week: phrase('Week 1'),
        code: 'ENG 100.1',
        title: phrase('Runtime Virtualization, Ephemeral Sandboxes & Zero-Copy ZAP RPC'),
        summary:
          phrase('Analyze the systems boundary of autonomous code execution. Configure local high-throughput quantized serving for Zen 6 (27.3B) and Zen 6 Flash. Engineer Hanzo Visor user-space kernel virtualization with ephemeral lease lifecycles and zero-copy Cap’n Proto RPC channels.'),
        lectures: [
          phrase('Zen 6 architecture: quantized GGUF/AWQ local inference on Apple Silicon (Metal) and Linux (CUDA)'),
          phrase('The 4-surface boundary contract: unified ergonomics across CLI, SDKs, HTTP REST, and MCP sockets'),
          phrase('ZAP Zero-Copy RPC over Cap’n Proto: replacing high-overhead JSON serialization with microsecond IPC'),
          phrase('User-space container virtualization: Hanzo Visor / runsc process boundaries and ephemeral rootfs mounts'),
        ],
        readings: [
          'Google Engineering: Container Isolation through User-Space Kernel Virtualization (Hanzo Visor Architecture)',
          'Kent: Cap’n Proto Serialization and RPC Protocol Specification',
        ],
        lab: phrase('Lab 1: Provision an isolated multi-process execution jail with ZAP IPC socket bridge and evaluate inter-process latency.'),
      },
      {
        week: phrase('Week 2'),
        code: 'ENG 100.2',
        title: phrase('Abstract Syntax Trees, Context Distillation & Dual-Index Retrieval'),
        summary:
          phrase('Train agents to navigate 100,000+ line repositories without exceeding token context boundaries. Extract AST symbol graphs using tree-sitter grammars and synthesize dual-index retrieval combining BM25 keyword matching with dense vector embeddings.'),
        lectures: [
          phrase('AST-based symbol extraction using tree-sitter across Python, TypeScript, Go, and Rust codebases'),
          phrase('Dual-index code retrieval: combining BM25 exact keyword inverted indexes with dense vector embeddings'),
          phrase('Context compression algorithms: distilling 50-file call chains into a 4k-token working memory scratchpad'),
          phrase('Three-tier memory hierarchy: immediate scratchpad, thread history log, and long-term vector stores'),
        ],
        readings: [
          'Bruns et al.: Tree-sitter: An Incremental Parsing System for Programming Tools',
          'Robertson et al.: The Probabilistic Relevance Framework: BM25 and Beyond',
        ],
        lab: phrase('Lab 2: Implement an autonomous AST file scout that isolates defect locations across a 100k-line repo in < 3 tool hops.'),
      },
      {
        week: phrase('Week 3'),
        code: 'ENG 100.3',
        title: phrase('Test-Driven Self-Healing & Finite-State Kai Verification'),
        summary:
          phrase('Close the autonomous execution feedback loop. Engineer agents that parse natural-language issue tickets, synthesize minimal reproducible failing tests, generate syntax-safe AST patches, and verify state transitions with Kai zero-token heuristics.'),
        lectures: [
          phrase('Automated reproduction synthesis: generating failing pytest / cargo test cases directly from GitHub issues'),
          phrase('AST diff validation: guaranteeing generated patches introduce zero syntax regressions or unused symbols'),
          phrase('Kai finite-state decision checkpoints: zero-token verification scoring, completion heuristics, and state branching'),
          phrase('Micro-USD economic governance: enforcing hard pre-call cost ceilings and handling in-band budget refusals'),
        ],
        readings: [
          'Hanzo Research: Finite-State Decision Models: Zero-Token Control in Autonomous Software Construction',
          'Monperrus: Automatic Software Repair: A Survey on Principles, Benchmarks, and Verification',
        ],
        lab: phrase('Lab 3: Build an autonomous test runner that iterates on AST patches in an isolated pod until test exit code 0.'),
      },
      {
        week: phrase('Week 4'),
        code: 'ENG 100.4',
        title: phrase('Coordinator-Worker Swarms & SWE-bench Capstone Defense'),
        summary:
          phrase('Deploy distributed multi-agent teams with specialized role partitioning. Build a coordinator-worker architecture where an Architect agent drafts repair strategies, a Coder synthesizes diffs, and a Critic reviews test executions against SWE-bench benchmarks.'),
        lectures: [
          phrase('Coordinator-Worker swarm topology: role delegation, bidirectional task leasing, and consensus protocols'),
          phrase('Conflict resolution in concurrent branch synthesis: optimistic locking and semantic three-way merge'),
          phrase('SWE-bench Lite and Verified harness: real-world benchmark harness automation and regression verification'),
          phrase('W3C Verifiable Credential generation: signing evaluation artifacts and issuing tamper-proof HACE certificates'),
        ],
        readings: [
          'Jimenez et al. (Princeton NLP): SWE-bench: Can Language Models Resolve Real-World GitHub Issues?',
          'W3C Recommendation: Verifiable Credentials Data Model v2.0',
        ],
        lab: phrase('Capstone Project: Autonomously resolve 5 SWE-bench benchmark issues with 100% test pass rate and < $0.50 spend per issue.'),
      },
    ],
  },
  {
    slug: 'reinforcement-learning',
    code: 'RL 101',
    title: phrase('Native Reinforcement Learning & Post-Training'),
    credential: 'HARLE',
    credentialFull: phrase('Hanzo Certified Reinforcement Learning Engineer'),
    track: 'rl',
    units: 5.0,
    price: 249,
    rebateCredits: 63,
    duration: phrase('5 Weeks · Advanced Lab'),
    level: phrase('Expert'),
    prerequisites: phrase('Foundational linear algebra, Python ML libraries, and basic MDP comprehension'),
    summary:
      phrase('Implement native Gymnasium environments on the Hanzo Cloud Fabric. Fine-tune models with Zoo Gym, design multi-objective reward functions, and train learned routing policies.'),
    capstone: phrase('Train a custom MDP reinforcement learning policy and deploy it as a production model router.'),
    competencies: [
      phrase('Gymnasium HanzoAgentEnv MDP implementation'),
      phrase('Post-training & fine-tuning with Zoo Gym'),
      phrase('Multi-objective reward modeling (PPO, GRPO, DPO)'),
      phrase('LinUCB router policy training via /v1/ai/feedback'),
    ],
    planId: 'course-rl-101',
    featured: true,
    instructor: {
      name: 'Dr. Mira Thorne',
      role: phrase('Head of Alignment & RL Research, Hanzo Labs'),
    },
    syllabus: [
      {
        week: phrase('Week 1'),
        code: 'RL 101.1',
        title: phrase('Markov Decision Processes for Code & Tool Agents'),
        summary: phrase('Formalize tool invocation and multi-step reasoning as discrete-action Markov Decision Processes.'),
        lectures: [
          phrase('MDP formulation: state spaces, action observation histories, and transition kernels'),
          phrase('Tool execution environments: defining episodic boundaries and termination predicates'),
          phrase('Discount factors, horizon truncation, and sparse vs dense reward landscapes'),
        ],
        readings: ['Sutton & Barto: Reinforcement Learning: An Introduction (Chapters 3-4)'],
        lab: phrase('Lab 1: Wrap the Hanzo Tool API into a compliant Gymnasium environment with observation spaces.'),
      },
      {
        week: phrase('Week 2'),
        code: 'RL 101.2',
        title: phrase('Reward Engineering: Multi-Objective & Process Supervision'),
        summary: phrase('Build reward models that resist reward hacking, verbosity bloat, and hallucinated proofs.'),
        lectures: [
          phrase('Outcome vs process supervision: step-level scoring versus terminal exit code reward'),
          phrase('Regularization penalties: token cost budgets, execution latency, and safety constraints'),
          phrase('Training preference models with Direct Preference Optimization (DPO) and KTO'),
        ],
        readings: ['Rafailov et al.: Direct Preference Optimization: Your Language Model is Secretly a Reward Model'],
        lab: phrase('Lab 2: Implement a multi-objective reward function incorporating test exit code, latency, and cost.'),
      },
      {
        week: phrase('Week 3'),
        code: 'RL 101.3',
        title: phrase('Policy Gradient Optimization: PPO & GRPO at Scale'),
        summary: phrase('Train open weights models using Proximal Policy Optimization and Group Relative Policy Optimization.'),
        lectures: [
          phrase('PPO actor-critic architectures and clipping dynamics'),
          phrase('GRPO: group relative advantages without dedicated critic networks'),
          phrase('Distributed rollout collection across vLLM and TensorRT-LLM nodes'),
        ],
        readings: ['Schulman et al.: Proximal Policy Optimization Algorithms', 'DeepSeek-AI: DeepSeekMath & GRPO'],
        lab: phrase('Lab 3: Execute a 1,000-step GRPO fine-tuning loop on Zen 6 Flash for multi-hop tool routing.'),
      },
      {
        week: phrase('Week 4'),
        code: 'RL 101.4',
        title: phrase('Contextual Bandits & Learned Model Routers'),
        summary: phrase('Deploy real-time contextual bandit policies (LinUCB, Thompson Sampling) for dynamic model tiering.'),
        lectures: [
          phrase('Exploration vs exploitation in production request dispatch'),
          phrase('Feature vectors: prompt complexity, token count, task classification, and latency requirements'),
          phrase('Streaming updates via POST /v1/ai/feedback and counterfactual regret minimization'),
        ],
        readings: ['Li et al.: A Contextual-Bandit Approach to Personalized News Article Recommendation'],
        lab: phrase('Lab 4: Deploy a real-time LinUCB router dispatching requests between Zen 6 Flash and Zen 6 27B.'),
      },
      {
        week: phrase('Week 5'),
        code: 'RL 101.5',
        title: phrase('Production Evaluation, Safety & Capstone Defense'),
        summary: phrase('Evaluate trained policies on unseen benchmark suites, verify safety bounds, and defend the capstone.'),
        lectures: [
          phrase('Out-of-distribution generalization testing and catastrophic forgetting mitigation'),
          phrase('Safety guardrail integration and automated adversarial red-teaming'),
          phrase('Issuance of HARLE W3C Verifiable Credentials'),
        ],
        readings: ['Anthropic: Sleeper Agents & Out-of-Distribution Robustness'],
        lab: phrase('Capstone Defense: Train and deploy a custom MDP router achieving 92% benchmark accuracy at 40% lower cost.'),
      },
    ],
  },
  {
    slug: 'systems-engineering',
    code: 'SYS 103',
    title: phrase('Hanzo AI Systems Engineering Foundation'),
    credential: 'HCAISE',
    credentialFull: phrase('Hanzo Certified AI Systems Engineer'),
    track: 'systems',
    units: 3.0,
    price: 149,
    rebateCredits: 38,
    duration: phrase('3 Weeks · Comprehensive'),
    level: phrase('Intermediate'),
    prerequisites: phrase('Basic command line fluency and experience consuming REST APIs'),
    summary:
      phrase('The definitive engineering standard for production AI. Master the 4-surface parity, finite-state Kai decision loops, hybrid retrieval, and strict integer micro-USD budget governance.'),
    capstone: phrase('Ship a high-concurrency 4-surface AI service with sub-50ms latency and strict budget ceilings.'),
    competencies: [
      phrase('Unified 4-surface API (CLI, SDKs, HTTP, MCP)'),
      phrase('Finite-state Kai decision loops with 0 output tokens'),
      phrase('Hybrid retrieval (knowledge, graph, search)'),
      phrase('Integer micro-USD nested budget governance'),
    ],
    planId: 'course-sys-103',
    instructor: {
      name: 'Marcus Brody',
      role: phrase('Director of Developer Platform, Hanzo'),
    },
    syllabus: [
      {
        week: phrase('Week 1'),
        code: 'SYS 103.1',
        title: phrase('The 4-Surface Architecture & Zero-Copy Protocol'),
        summary: phrase('Master the unified developer interface across CLI, SDKs, REST endpoints, and MCP protocols.'),
        lectures: [
          phrase('Architecting for 4-surface parity: CLI, Python/TS SDKs, REST HTTP, and Model Context Protocol'),
          phrase('Token streaming protocols: Server-Sent Events, WebSockets, and binary gRPC channels'),
          phrase('Connection pooling and resilient retry jitter strategies'),
        ],
        readings: ['Hanzo Platform Architecture Whitepaper: The 4-Surface Contract'],
        lab: phrase('Lab 1: Build a tool that executes synchronously across CLI and MCP socket simultaneously.'),
      },
      {
        week: phrase('Week 2'),
        code: 'SYS 103.2',
        title: phrase('Kai Decision Heuristics & Zero-Token Logic'),
        summary: phrase('Replace expensive generative model calls with fast logit-based decision checkpoints.'),
        lectures: [
          phrase('Why generative classification fails at scale: cost, latency, and indeterminacy'),
          phrase('Kai zero-token logit scoring across structured choice schemas'),
          phrase('Integrating Kai decision trees inside multi-tier agent pipelines'),
        ],
        readings: ['Hanzo AI: Kai Technical Report — Deterministic State Transitions without Output Tokens'],
        lab: phrase('Lab 2: Replace 3 LLM classification steps with Kai checkpoints, reducing latency by 85%.'),
      },
      {
        week: phrase('Week 3'),
        code: 'SYS 103.3',
        title: phrase('Budget Envelopes, Circuit Breakers & Capstone Service'),
        summary: phrase('Enforce micro-USD budget ceilings and deploy a resilient high-throughput production service.'),
        lectures: [
          phrase('Pre-invocation budget checks with micro-USD precision'),
          phrase('Circuit breakers and graceful service degradation under load'),
          phrase('Capstone presentation and HCAISE credential verification'),
        ],
        readings: ['Google SRE: Site Reliability Engineering: Managing Cascading Failures'],
        lab: phrase('Capstone Project: Deliver a sub-50ms AI microservice that handles 500 RPS without budget overruns.'),
      },
    ],
  },
]

export const ADDITIONAL_COURSES: UniversityCourse[] = [
  {
    slug: 'agentic-marketing',
    code: 'MKT 102',
    title: phrase('Agentic Marketing & Autonomous Campaigns'),
    credential: 'HAME',
    credentialFull: phrase('Hanzo Certified Agentic Marketing Engineer'),
    track: 'marketing',
    units: 3.0,
    price: 149,
    rebateCredits: 38,
    duration: phrase('3 Weeks · Self-Paced'),
    level: phrase('Intermediate'),
    prerequisites: phrase('Familiarity with digital marketing concepts, APIs, and basic scripting'),
    summary:
      phrase('Engineer programmatic growth machines. Generate multi-channel copy, studio images, voiceovers, and videos with locked brand voice, direct CMS hooks, and closed-loop CRO reinforcement.'),
    capstone: phrase('Deploy an automated multi-channel campaign engine with real-time conversion reinforcement.'),
    competencies: [
      phrase('POST /v1/content/generate CMS pipelines'),
      phrase('Multi-modal asset generation (Zen 3, Wan 2.2)'),
      phrase('Event-driven campaign automation with /v1/auto'),
      phrase('Closed-loop A/B testing & LinUCB CRO optimization'),
    ],
    planId: 'course-mkt-102',
    instructor: {
      name: 'Elena Rostova',
      role: phrase('Growth Systems Lead, Hanzo Commercial Labs'),
    },
    syllabus: [
      {
        week: phrase('Week 1'),
        code: 'MKT 102.1',
        title: phrase('Brand Consistency & Deterministic Multimodal Pipelines'),
        summary: phrase('Lock brand voice, tone guidelines, and visual assets into deterministic programmatic generation pipelines.'),
        lectures: [
          phrase('Brand voice vector embeddings and system prompt constraint engineering'),
          phrase('Image and visual asset generation with consistent seeds, palettes, and typography'),
          phrase('Voiceover synthesis and audio mastering via /v1/audio/speech'),
        ],
        readings: ['Hanzo Documentation: Multimodal Content Synthesis and Brand Voice Guardrails'],
        lab: phrase('Lab 1: Generate 10 verified multi-channel marketing variants that pass automated brand voice checks.'),
      },
      {
        week: phrase('Week 2'),
        code: 'MKT 102.2',
        title: phrase('Event-Driven Workflow Orchestration with /v1/auto'),
        summary: phrase('Connect customer behavior events, webhook triggers, and autonomous agent workers.'),
        lectures: [
          phrase('Webhook payload ingestion and schema mapping'),
          phrase('Stateful customer journey graphs with conditional branching'),
          phrase('Rate limiting, email deliverability, and compliance auditing'),
        ],
        readings: ['Enterprise Automation: Event-Driven Lifecycle Messaging at Scale'],
        lab: phrase('Lab 2: Wire an event-driven automation flow that responds to user onboarding milestones.'),
      },
      {
        week: phrase('Week 3'),
        code: 'MKT 102.3',
        title: phrase('Closed-Loop Conversion Rate Optimization (CRO)'),
        summary: phrase('Build bandit-driven landing page optimization loops that iterate copy and layouts dynamically.'),
        lectures: [
          phrase('Multi-armed bandit testing vs traditional static A/B tests'),
          phrase('Real-time conversion feedback ingestion via /v1/analytics'),
          phrase('Capstone evaluation and HAME certification issuance'),
        ],
        readings: ['Scott: Multi-Armed Bandits for Digital Experimentation'],
        lab: phrase('Capstone Project: Deploy an autonomous landing page optimizer that increases conversion by > 15%.'),
      },
    ],
  },
  {
    slug: 'ai-practitioner',
    code: 'PRA 104',
    title: phrase('AI Practitioner & Tool Integration'),
    credential: 'HCAIP',
    credentialFull: phrase('Hanzo Certified AI Practitioner'),
    track: 'systems',
    units: 2.0,
    price: 99,
    rebateCredits: 25,
    duration: phrase('2 Weeks · Fast Track'),
    level: phrase('Foundational'),
    prerequisites: phrase('Basic programming literacy and familiarity with IDEs (Cursor/VSCode)'),
    summary:
      phrase('Master the fundamentals of the unified cloud. Understand model selection across Zen, Enso, and Kai, integrate the 13 unified MCP tools into your editor, and manage cloud spend.'),
    capstone: phrase('Integrate the full Hanzo MCP suite into Cursor and automate development workflows.'),
    competencies: [
      phrase('Navigating api.hanzo.ai and credential management'),
      phrase('Model family taxonomy and pricing contracts'),
      phrase('13 unified MCP tools configuration in Cursor/Claude'),
      phrase('Usage metering and quota monitoring via CLI'),
    ],
    planId: 'course-pra-104',
    instructor: {
      name: 'Aisha Al-Mansoor',
      role: phrase('Staff Solutions Engineer, Hanzo Developer Experience'),
    },
    syllabus: [
      {
        week: phrase('Week 1'),
        code: 'PRA 104.1',
        title: phrase('Cloud Foundations & Editor Integration'),
        summary: phrase('Configure API keys, set up local CLI tooling, and wire Model Context Protocol servers into Cursor.'),
        lectures: [
          phrase('Account setup, organization scoping, and API key provisioning'),
          phrase('Installing and configuring hanzo CLI across macOS and Linux'),
          phrase('Connecting Cursor and Claude Desktop to Hanzo MCP tool endpoints'),
        ],
        readings: ['Hanzo Developer Guide: Quickstart and Tool Integration'],
        lab: phrase('Lab 1: Configure Cursor with full access to Hanzo filesystem, search, and shell MCP tools.'),
      },
      {
        week: phrase('Week 2'),
        code: 'PRA 104.2',
        title: phrase('Model Selection & Workflow Automation'),
        summary: phrase('Pick optimal models for code, chat, vision, and reasoning while keeping spend under control.'),
        lectures: [
          phrase('Choosing between Zen 6, Zen 6 Flash, Enso, and specialized models'),
          phrase('Understanding tokens, context windows, and caching mechanisms'),
          phrase('Building daily developer automation scripts with the CLI'),
        ],
        readings: ['Hanzo Model Guide: Latency, Quality, and Economics Across the Zen Family'],
        lab: phrase('Capstone Project: Automate an end-to-end pull request review workflow using Hanzo MCP and CLI.'),
      },
    ],
  },
  {
    slug: 'ai-architect',
    code: 'ARC 105',
    title: phrase('Production AI Architect Masterclass'),
    credential: 'HCPAIA',
    credentialFull: phrase('Hanzo Certified Production AI Architect'),
    track: 'architect',
    units: 6.0,
    price: 499,
    rebateCredits: 125,
    duration: phrase('6 Weeks · Capstone Immersion'),
    level: phrase('Staff / Principal'),
    prerequisites: phrase('Senior/Staff software engineering experience, distributed systems, and Kubernetes'),
    summary:
      phrase('Enterprise AI architecture at scale. Build self-hosted zero-trust clusters, configure post-quantum RNS tunnels, deploy global BFT agent meshes, and govern enterprise billing.'),
    capstone: phrase('Design and deploy a fault-tolerant multi-cluster autonomous agent mesh across three regions.'),
    competencies: [
      phrase('Zero-trust cluster provisioning with hanzo up'),
      phrase('Post-quantum cryptography (ML-KEM, ML-DSA)'),
      phrase('Global agent mesh & BFT consensus with hanzod'),
      phrase('Multi-tenant IAM, KMS, and enterprise compliance'),
    ],
    planId: 'course-arc-105',
    instructor: {
      name: 'Vikram Sethi',
      role: phrase('VP of Infrastructure & Security Architecture, Hanzo'),
    },
    syllabus: [
      {
        week: phrase('Week 1'),
        code: 'ARC 105.1',
        title: phrase('Zero-Trust Cluster Provisioning & Hardware Topology'),
        summary: phrase('Provision sovereign compute clusters using hanzo up with isolated control planes.'),
        lectures: [
          phrase('Bare-metal and cloud GPU cluster topology design (NVIDIA H100, L40S, Apple Silicon)'),
          phrase('Automated bootstrapping with hanzo up and immutable OS images'),
          phrase('Multi-tenant network isolation with Cilium and eBPF data planes'),
        ],
        readings: ['Hanzo Infrastructure Engineering: Sovereign Cluster Architecture at Scale'],
        lab: phrase('Lab 1: Provision a 3-node Kubernetes cluster with eBPF network isolation and GPU scheduling.'),
      },
      {
        week: phrase('Week 2'),
        code: 'ARC 105.2',
        title: phrase('Post-Quantum Cryptography & RNS Network Tunnels'),
        summary: phrase('Secure inter-agent communication against quantum threats using ML-KEM and ML-DSA standards.'),
        lectures: [
          phrase('NIST Post-Quantum Cryptographic Standards (FIPS 203 ML-KEM, FIPS 204 ML-DSA)'),
          phrase('RNS (Resilient Network Sockets): low-latency authenticated P2P tunneling'),
          phrase('Key rotation lifecycles and hardware security module (HSM) integration'),
        ],
        readings: ['NIST Special Publication: Transitioning to Post-Quantum Cryptography'],
        lab: phrase('Lab 2: Establish an ML-KEM encrypted tunnel between two independent worker pods.'),
      },
      {
        week: phrase('Week 3'),
        code: 'ARC 105.3',
        title: phrase('Byzantine Fault Tolerant (BFT) Agent Consensus'),
        summary: phrase('Coordinate autonomous agent decision-making across untrusted networks using hanzod consensus.'),
        lectures: [
          phrase('Byzantine agreement protocols in autonomous decision pipelines'),
          phrase('Deploying hanzod consensus nodes for state machine replication'),
          phrase('Slashing and penalty conditions for malicious or hallucinating nodes'),
        ],
        readings: ['Castro & Liskov: Practical Byzantine Fault Tolerance'],
        lab: phrase('Lab 3: Deploy a 4-node hanzod validator cluster and simulate network partition recovery.'),
      },
      {
        week: phrase('Week 4'),
        code: 'ARC 105.4',
        title: phrase('Enterprise Multi-Tenant IAM, KMS & Sovereign Compliance'),
        summary: phrase('Design enterprise-grade identity, key management, and data sovereignty boundaries.'),
        lectures: [
          phrase('Fine-grained attribute-based access control (ABAC) in multi-tenant environments'),
          phrase('Bring-Your-Own-Key (BYOK) envelope encryption with KMS'),
          phrase('Zero-trust security frameworks, cryptographic audit logs, and compliance enforcement'),
        ],
        readings: ['Hanzo Enterprise Security Standard: Multi-Tenant Zero-Trust Model'],
        lab: phrase('Lab 4: Configure an organization hierarchy with isolated KMS keyrings and policy constraints.'),
      },
      {
        week: phrase('Week 5'),
        code: 'ARC 105.5',
        title: phrase('Global Observability, Distributed Tracing & Cost Auditing'),
        summary: phrase('Instrument distributed agent meshes with OpenTelemetry, ClickHouse datastores, and Prometheus.'),
        lectures: [
          phrase('Distributed trace propagation across multi-agent RPC hops'),
          phrase('Datastore ClickHouse schema design for high-cardinality token billing metrics'),
          phrase('Real-time anomaly detection for token runaway and runaway loops'),
        ],
        readings: ['OpenTelemetry Specification: Semantic Conventions for Generative AI Systems'],
        lab: phrase('Lab 5: Build a real-time observability dashboard tracking token usage across a 50-node agent swarm.'),
      },
      {
        week: phrase('Week 6'),
        code: 'ARC 105.6',
        title: phrase('Multi-Region Mesh Deployment & Capstone Defense'),
        summary: phrase('Deploy, stress-test, and defend a multi-cluster autonomous agent mesh across three geographic regions.'),
        lectures: [
          phrase('Geo-distributed failover, latency routing, and data replication strategies'),
          phrase('Disaster recovery drills and chaotic fault injection'),
          phrase('Capstone oral defense and HCPAIA credential issuance'),
        ],
        readings: ['Verma et al.: Large-Scale Cluster Management at Google with Borg'],
        lab: phrase('Capstone Project: Deploy and defend an active-active multi-region agent mesh maintaining 99.99% uptime under simulated regional blackouts.'),
      },
    ],
  },
]

export const ALL_COURSES: UniversityCourse[] = [
  ...UNIVERSITY_COURSES,
  ...ADDITIONAL_COURSES,
]

/** The courses `/university/[slug]` renders: every course /university lists; agentic-coding has a page of its own. */
export const COURSE_PAGES: UniversityCourse[] = ALL_COURSES.filter((c) => c.slug !== 'agentic-coding')

export function findCourse(slug: string): UniversityCourse | undefined {
  return ALL_COURSES.find((c) => c.slug === slug)
}