Building Personalized Adaptive Learning Curriculums Pack

The Zoo of Static Learning Paths

We built this so you don't have to. If you're an engineer tasked with building an adaptive learning platform, you know the trap. You start with a simple knowledge graph in NetworkX, add a basic spaced repetition scheduler, and think you're done. Then the data comes in. Students drift. Concepts decay at different rates. Prerequisites unlock at unpredictable intervals. Your static graph can't handle the restless nature of human memory.

The engineering reality is that educational data is messy. You're trying to merge a directed acyclic graph (DAG) of prerequisites with a reinforcement learning agent that has no idea how long a concept stays in a student's working memory. Most teams try to patch this together using a Curriculum Design Pack for the structure and then bolt on a basic Adaptive Learning Engine with Spaced Repetition Pack for the scheduling. It works for a demo. It fails in production.

When you model learning as a simple Markov chain or a flat graph, you ignore the interdependent processes that define real education. A student struggling with Calculus II isn't just failing Calculus II; they're failing the prerequisite chain. If your scheduler doesn't account for this, you waste their time. Worse, if you're managing a fleet of learners, you're facing a constrained resource allocation problem. Multi-action restless multi-armed bandits (RMABs) are the mathematically sound framework for this, but implementing them from scratch is a nightmare of unstable gradients and replay buffer mismatches ^[2]. You spend months debugging the RL agent instead of shipping the product.

Why "Just Add Spaced Repetition" Fails at Scale

The cost of a naive adaptive system isn't just technical debt; it's student churn. When you use a standard SM-2 algorithm or a fixed interval scheduler, you treat every node in isolation. You assume that if a student reviews a concept, the probability of retention increases by a fixed delta. But memory isn't a static bucket; it's a dynamic system subject to interference from other concepts being learned simultaneously.

Restless Multi-Armed Bandit (RMAB) models represent a foundational class of sequential decision problems where the state of each arm evolves independently of the decision maker's actions ^[6]. In an educational context, this means a student's knowledge of "Pointers" decays whether they are studying "Pointers" or "Memory Management". If your curriculum engine doesn't model this decay, your agent will keep pulling the "Pointers" arm because its interval expired, while the "Memory Management" arm decays into oblivion because the agent was too busy reviewing the wrong thing.

Implementing an RMAB requires solving the Whittle index or using a Lagrange relaxation policy to determine which arm to pull next. This isn't just a scheduling tweak; it's a fundamental shift in how you model the state space. You need to track the decay rate of every concept for every student, update those rates in real-time, and use that signal to optimize the learning path. If you get the replay buffer wrong, or if your state representation doesn't capture the prerequisites, your agent learns a policy that maximizes short-term review clicks but destroys long-term retention. The downstream incident isn't a server crash; it's a cohort of students dropping out because the system felt "dumb".

A Fintech's Three Error Schemas (Hypothetical Illustration)

Imagine an EdTech startup shipping a beta for a coding bootcamp platform. They have 5,000 active learners. Their curriculum is a DAG of Python concepts. They use a standard spaced repetition algorithm for review intervals. By week three, retention drops to 40%. The support tickets are flooding in: "Why am I being asked to review if/else when I just aced the quiz?" and "I can't understand recursion because I haven't reviewed stacks in weeks."

The team realizes their system has three fatal flaws. First, it treats concepts as independent arms. It doesn't know that a student who hasn't reviewed "Pointers" in C++ is likely to fail "Memory Management" next week. Second, it ignores the restless nature of decay. The interval for "Pointers" expired two days ago, but the student's mastery of it is still high because they used it yesterday. The algorithm forces a review, wasting time and causing engagement fatigue ^[4]. Third, it has no mechanism to dynamically re-sequence the curriculum based on real-time performance. It's a static list masquerading as an adaptive engine.

This is exactly the problem Restless Multi-Armed Bandits solve. Unlike controlled bandits where the arm only moves when you pull it, restless bandits evolve whether you interact with them or not ^[1]. A 2024 study on EdNetRMABs showed that modeling these interdependent learning processes with RMABs significantly outperforms static sequencing rules ^[4]. The team doesn't need to guess which student to teach next; they need an agent that learns the decay rate of every concept in real-time, using adaptive arm sequencing to maximize long-term retention ^[3]. They need to stop patching and start building a proper RMAB curriculum agent.

What Changes Once the Pack Is Installed

Once you install this skill, you stop patching. You get a production-grade pipeline that integrates three complex systems into a single, validated workflow. We've done the heavy lifting so you can focus on the domain logic.

Your knowledge graph is no longer a fragile JSON blob. It's defined by a strict YAML schema that enforces node types, edge semantics, and FSRS integration points. You can't accidentally create a cycle in your prerequisites, and every node is guaranteed to have the attributes required for spaced repetition tracking. Your spaced repetition isn't a hardcoded heuristic. It uses the canonical Free Spaced Repetition Scheduler (FSRS) parameter structure, giving you scientifically backed weight vectors for request retention. You're not guessing intervals; you're calculating them based on the student's history and the concept's difficulty. Your curriculum sequencing isn't a static list. It's driven by a Stable Baselines3 RMAB agent trained with HerReplayBuffer, optimizing learning paths dynamically. The agent learns which concepts decay fastest for which student profiles and adjusts the review schedule accordingly. You have validators that catch structural errors before they hit production. If your graph violates d-separation rules or your RMAB config misses a required key, the pipeline fails fast. No more silent failures in the training loop.

This pack is designed to slot into your broader Educational Technology Pack workflow. It handles the adaptive logic, while you use the LMS Setup Pack for platform integration and the Assessment & Rubric Pack to close the feedback loop on student performance. If you need to boost retention further, the Student Engagement Pack provides the gamification strategies to keep learners motivated while the RMAB agent works in the background.

What's in the Pack

• skill.md — Orchestrator skill defining the 360° expert workflow for building adaptive learning systems. Covers Knowledge Graphs (NetworkX), Spaced Repetition (FSRS), and RMAB Curriculum Sequencing (Stable Baselines3). References all templates, scripts, validators, and references.
• templates/knowledge_graph_schema.yaml — Production-grade YAML schema for defining educational knowledge graphs using NetworkX conventions. Specifies node types (Concept, Skill, Resource), edge semantics (prerequisite, related_to), and attributes for mastery tracking and FSRS integration.
• templates/rmab_config.yaml — Real Stable Baselines3 configuration for Restless Multi-Armed Bandit curriculum sequencing. Uses HerReplayBuffer, DQN/SAC models, and goal selection strategies to optimize learning path generation.
• templates/fsrs_params.json — Canonical Free Spaced Repetition Scheduler (FSRS) parameter structure. Defines the weight vector, request retention, and maximum interval for calculating optimal review intervals in the curriculum.
• scripts/build_curriculum.py — Executable Python script that constructs a curriculum plan. Uses NetworkX for graph traversal (BFS/DFS), applies FSRS intervals to nodes, and outputs a structured JSON curriculum. Real imports and logic.
• scripts/train_rmab.sh — Executable shell script that wraps Stable Baselines3 training for the RMAB curriculum agent. Sets environment variables, runs the training loop, and handles model saving. Real commands.
• validators/validate_kg.py — Validator script that checks a Knowledge Graph JSON against the schema. Exits non-zero on structural or type errors. Ensures graph integrity before curriculum generation.
• validators/check_rmab_config.py — Validator script that verifies RMAB configuration against Stable Baselines3 requirements. Checks for required keys, valid model classes, and replay buffer compatibility. Exits non-zero on failure.
• references/knowledge_graphs.md — Canonical reference on NetworkX for educational knowledge graphs. Embeds graph traversal algorithms (BFS/DFS), text representation logic, and d-separation concepts for causal knowledge modeling.
• references/spaced_repetition.md — Canonical reference on Spaced Repetition and FSRS. Details the algorithm, weight vectors, request retention, and OSR community standards for long-term retention in adaptive learning.
• references/rmab_curriculum.md — Canonical reference on RMABs and curriculum sequencing. Embeds Stable Baselines3 implementation details, HER replay buffer usage, and goal selection strategies for optimizing learning paths.
• examples/curriculum_plan.json — Worked example of a generated curriculum plan. Demonstrates the output structure of the build script, including nodes, edges, FSRS intervals, and recommended sequencing.

Install and Ship

Stop guessing. Start optimizing. Upgrade to Pro to install the Adaptive Learning Curriculums Pack.