Personalizing STEM Learning at Scale: Building an Adaptive AI Tutor That Works in Real Classrooms

Most STEM classrooms face the same structural problem: students arrive with wildly different levels of prior knowledge, but instruction moves at a single pace. Some students are pushed forward before they’re ready; others wait while the class catches up. Teachers know this mismatch well — but without real‑time mastery data, adapting instruction for 30 students at once is nearly impossible.

The Adaptive Tutoring Suite (ATS) grew out of that gap. It’s a modular AI system designed to make personalization practical, not theoretical: a hybrid student model, a constrained curriculum sequencer, an explainable feedback engine, and a teacher dashboard that respects teacher time. What makes ATS different is not just the algorithms, but how the components work together.

1. Modeling Student Knowledge: Combining BKT and Transformers

Traditional Bayesian Knowledge Tracing (BKT) gives interpretable mastery probabilities, but it only sees correctness. Transformers understand the meaning of student responses, but they’re not naturally calibrated. ATS fuses both.

The model maintains a BKT posterior while also generating a semantic embedding of each response. A learned gating network decides how much to trust each source at every step.

# Hybrid mastery update (simplified)
bkt_p = update_bkt(prev_p, response_correct)

embed_p = sigmoid(embedding_layer(response_text))

# Learned fusion gate
features = torch.cat([prev_p, engagement_vec], dim=-1)
w = torch.sigmoid(gate_network(features))

# Final mastery estimate
p_new = w * bkt_p + (1 - w) * embed_p

Early in a student’s history, embeddings carry more weight. As evidence accumulates, BKT becomes dominant. The result is a model that handles cold‑start conditions without sacrificing interpretability.

2. Sequencing: Choosing the Next Best Learning Unit

Once the system knows what a student understands, it needs to decide what they should do next. ATS uses a two‑layer approach:

• Offline MIQP batch scheduling to generate an initial plan for the whole class
• Online contextual bandits to adapt per student in real time

The MIQP layer optimizes expected time‑to‑mastery under constraints like prerequisites and time budgets. The bandit layer handles moment‑to‑moment decisions.

# Thompson Sampling for next-unit selection
posterior = prior + observed_rewards
sample = torch.distributions.Normal(posterior.mean, posterior.std).sample()
chosen_unit = torch.argmax(sample)
assign_unit(student_id, chosen_unit)

This combination gives the system both global structure and local flexibility — something neither pure RL nor pure scheduling achieves on its own.

3. Feedback: Hints That Don’t Hallucinate

Automated feedback is powerful, but only if it’s trustworthy. ATS uses a hybrid pipeline:

1. LLM generates a candidate hint
2. Symbolic validator checks correctness
3. Confidence score decides whether to deliver or route to teacher review

For mathematical domains, symbolic validation is strict:

# Symbolic correctness check
if sympy.simplify(student_expr - correct_expr) == 0:
    label = "correct"
else:
    label = "incorrect"

If the validator and LLM disagree, the system raises the confidence threshold. Low‑confidence hints go to a teacher review queue instead of being shown to students. Teacher edits become training data, creating a continuous improvement loop.

4. The Teacher Dashboard: Designed for 10 Minutes a Day

Teachers don’t need another analytics tool that demands an hour of attention. ATS was designed around a simple constraint: teachers have about 10 minutes per class per day.

The dashboard surfaces:

• Mastery heatmaps
• Intervention alerts
• A feedback review queue
• Student progress timelines

Every element is actionable. No digging, no dashboards for dashboards’ sake.

5. What We Found in Experiments

Across public datasets (ASSISTments, EdNet) and synthetic classroom simulations:

• The hybrid student model improves mastery calibration over standard BKT
• The MIQP‑bandit sequencer reduces expected time‑to‑mastery
• The hybrid feedback pipeline produces fewer high‑confidence errors than LLM‑only systems
• The microservice architecture meets real‑time latency constraints

These results suggest that personalization at scale is not just possible — it’s deployable.

6. Why This Matters

Personalized learning has always been a compelling idea, but rarely a practical one. ATS shows that with the right architecture — interpretable models, constrained optimization, explainable feedback, and teacher‑centered design — it’s possible to build systems that adapt to students without overwhelming teachers.

The goal isn’t automation. It’s amplification: giving teachers the data and tools they need to support every student, not just the ones who raise their hands.

Full Paper here — DOI: 10.5281/zenodo.20258056