One-sentence Summary

Researchers from The University of Hong Kong present DeepTutor, an open-source agentic framework that unifies citation-grounded problem tutoring with difficulty-calibrated question generation via a hybrid personalization engine coupling static knowledge grounding and dynamic learner memory, improving personalized metrics by 10.8% and boosting agentic reasoning across five backbone models by 29.4%.

Key Contributions

• DeepTutor is an open-source agentic tutoring framework that unifies citation-grounded problem tutoring and difficulty-calibrated question generation through a hybrid personalization engine coupling static knowledge grounding with a trace-forest-based dynamic learner memory.
• TutorBench, a student-centric benchmark with source-grounded learner profiles and a first-person interactive simulator, evaluates personalized tutoring across five university-level disciplines in multi-turn dialogue.
• DeepTutor improves personalized tutoring quality by 10.8% on average and boosts general agentic reasoning across five backbone models by 29.4%, with human-alignment and ablation studies confirming the complementary roles of knowledge grounding and learner memory.

Introduction

Effective human tutoring integrates diagnosis, scaffolded explanation, and targeted practice into a continuous feedback loop. Current LLM-based educational systems treat problem tutoring and question generation as separate, task-local workflows. They lack a fine-grained, evolving model of the learner, tracking only coarse skill inventories rather than the reasoning traces that reveal how a student errs. This fragmentation means tutoring traces do not condition the next practice item, and practice outcomes do not update future explanations. The authors introduce DeepTutor, an agentic framework that unifies problem tutoring and question generation through a shared personalization engine. DeepTutor uses a trace forest, a hierarchical memory that distills interaction histories into an evolving learner profile, creating a closed loop where every interaction personalizes the next. The authors also construct TutorBench, a student-centric benchmark with first-person interactive evaluation across five university-level disciplines, to test adaptive behavior end to end.

Dataset

The authors introduce TutorBench, a dataset designed for interactive tutoring evaluation where each entry pairs a detailed learner persona with knowledge gaps grounded in source materials.

Dataset composition and sources

• TutorBench draws on 30 knowledge bases across five disciplines: humanities, sciences, engineering, business, and frontier research.
• Source materials include university-level textbooks and research papers, which are indexed into a dual-representation knowledge base and organized into a domain hierarchy.

Key details for each subset

• For every knowledge base, three learner profiles are instantiated using beginner, intermediate, and advanced as starting points, yielding 90 profiles total.
• Each profile is grounded in educational background, learning purpose, and fine-grained per-topic mastery states: known well, partially known, and unknown.
• For each profile, source pages are sampled to generate three types of grounded knowledge gaps: misconceptions, incomplete understanding, and missing knowledge.
• Every gap includes a manifestation (how the student exhibits it) and the correct understanding (reserved for evaluation).
• After rejection sampling, exactly three interactive tasks are retained per profile, producing 270 tasks in total.
• Tasks cover concept understanding, problem solving, application, and comparison-oriented formats.
• All entries carry three source-grounded knowledge gaps, each anchored to specific pages from the source materials.

Processing and filtering

• Interactive tasks are generated around selected gaps using rejection sampling, which verifies gap coherence, task–gap alignment, and conversational naturalness.
• All generated profiles and tasks undergo a final human review where annotators check factual correctness, profile plausibility, gap–task consistency, and pedagogical naturalness before inclusion.

How the paper uses the data

• During evaluation, all tutor systems receive the same task interface and access to the same source knowledge base.
• The learner profile and gap manifestations initialize a student simulator, while the correct understandings are withheld from tutor systems and used only for judging.

Method

The authors propose DeepTutor, a framework that unifies problem tutoring and question generation through a shared Hybrid Personalization Engine. This engine couples course knowledge $K$K with an evolving learner profile $\mathcal{D} = (\mathcal{D}_s, \mathcal{D}_w, \mathcal{D}_r)$D=(Ds​,Dw​,Dr​) to assemble a personalization context $C_{\mathrm{mem}}$Cmem​ before each agent step. Problem tutoring proceeds through investigation, guided solving, and iterative writing, while question generation separates idea selection from verified construction.

The Hybrid Personalization Engine relies on two complementary forms of context: domain expertise and learner awareness. To support heterogeneous course materials, the authors implement Static Knowledge Grounding (SKG) by decomposing source documents into atomic content units. These units are indexed via a dual-index retrieval substrate. A knowledge graph $\mathcal{G}$G organizes structural and contextual relations, while dense encoders project units into an embedding index $B$B. At query time, graph traversal and dense search candidate sets are fused via reciprocal rank fusion to yield domain grounding $C_{\mathrm{rag}}$Crag​.

Simultaneously, Dynamic Personal Memory (DPM) captures learner engagement via a Trace Forest $\mathcal{F}$F. Each tree in the forest records a tutoring interaction as a multi-resolution artifact organized into three levels: session-level summaries, intermediate planning units, and fine-grained execution records. A programmatic TraceToolkit allows agents to search, list, and read traces. Specialized memory agents actively query this toolkit to update the learner profile $\mathcal{D}$D, which consists of session history $\mathcal{D}_s$Ds​, an evidence-backed weakness inventory $\mathcal{D}_w$Dw​, and pedagogical self-reflections $\mathcal{D}_r$Dr​.

For personalized problem tutoring, the authors disentangle the process into three stages to manage context and reasoning depth. In the Personalized Investigation stage, a planner decomposes the student question into meta-questions and gathers evidence from $K$K and $\mathcal{F}$F. It produces a tutoring plan $\mathcal{P} = \langle s_1, \ldots, s_K \rangle$P=⟨s1​,…,sK​⟩ of concrete sub-goals tailored to the learner's gaps. During Step-by-step Guided Solving, a solver analyzes each sub-goal $s_k$sk​ and acts using a shared tool suite. Mechanisms like self-notes and hierarchical compression manage the reasoning context, and adaptive replanning occurs if the plan proves inadequate. Finally, in Evidence-based Iterative Writing, a writer extracts structured evidence and constructs the answer through refinement passes. The learner context $C_{\mathrm{mem}}$Cmem​ steers the explanation depth to the learner's Zone of Proximal Development.

The personalized question generation pipeline separates idea selection from construction. In the Personalized Idea Generation stage, an idea agent maps the conceptual landscape around a topic, conditioning on $C_{\mathrm{rag}}$Crag​ and $C_{\mathrm{mem}}$Cmem​. It produces candidate ideas specifying target concepts and formats, which an evaluator filters into structured templates. In the Critic-Guided Generation stage, a generator produces question-answer-explanation triples $(q_i, a_i, e_i)$(qi​,ai​,ei​). A structurally separated validator checks factual correctness and pedagogical soundness. Failed pairs receive diagnostic feedback and are regenerated.

These components form a self-reinforcing cycle where interactions update the Trace Forest and profile $\mathcal{D}$D. Weaknesses diagnosed during tutoring propagate to $\mathcal{D}_w$Dw​ to shape future question generation, while performance on generated questions refines $\mathcal{D}_s$Ds​ and $\mathcal{D}_r$Dr​.

The authors further extend this architecture by treating the Hybrid Personalization Engine as a reusable substrate for broader adaptive learning.

This substrate supports a single agent loop driving capabilities such as Chat, Solve, and Mastery Path. It utilizes cross-surface memory, pluggable knowledge-base engines, installable skills, and consultable sub-agents. Extensions such as Deep Research, Visualize, and Co-Writer reuse this shared infrastructure rather than instantiating separate learner models. This design ensures that synthesis, representation, practice, and expression remain coupled to the same learner-aware context, allowing the system to scale from local tutoring turns to a comprehensive adaptive learning process.

Experiment

The evaluation employs a first-person interactive protocol with a simulated student and personalized rubrics to assess multi-turn tutoring across ten dimensions, revealing that DeepTutor outperforms baseline tutors with the most notable gains in personalization, vividness, and logical depth. Cross-domain analysis shows consistent quality across disciplines, while a human preference study confirms strong alignment between automated and human judgments. Ablation experiments demonstrate that static knowledge grounding and dynamic personal memory serve complementary roles, with grounding anchoring evidence and memory enabling learner adaptation. Finally, the investigate-solve-write scaffold generalizes to agentic problem solving, boosting performance across diverse benchmarks even without personalization.

The personalization substrate enables diverse system extensions by reusing a shared agent loop, cross-surface memory, and pluggable knowledge engines, avoiding fragmented learner models. Extensions span capability runtimes like deep research and visualization, long-horizon learning surfaces like mastery paths and co-writing, and multi-channel deployment through partner agents. This unified architecture allows each extension to inherit grounding and personalization without building parallel systems. Deep Research, Visualize, and Subagent capabilities reuse the same query decomposition, tool execution, and dialogue context as the core tutoring loop. Mastery Path and Co-Writer surfaces draw on the shared learner profile, weak concept tracking, and knowledge-base grounding rather than maintaining separate student models. Book Engine composes prior interactions, source exploration, and capability outputs into interactive books by reusing the substrate's input snapshot and concept graph. Partner agents extend capabilities beyond the web into proactive channels while sharing the same persona, skills, and scheduling infrastructure.

DeepTutor substantially outperforms all baseline tutors, achieving a 10.76% relative improvement in overall quality over the Naive Tutor. The other systems—CoT, Self-Refine, and ReAct—yield only marginal differences from the Naive Tutor, with overall quality changes within ±1.13%. Gains are most pronounced in Vividness, Personalization, and Groundedness, reflecting the impact of adaptive personalization and knowledge grounding. DeepTutor achieves the highest overall quality score (3.91) and the largest relative gain (+10.76%), while baseline tutors remain within 1.13% of the Naive Tutor. Vividness shows the widest gap: DeepTutor scores 4.81, far above the next best baseline (3.94), indicating more engaging explanations. Practice quality metrics are notably low for all baselines, with Groundedness around 2.5, but DeepTutor raises Groundedness to 2.96 and improves all practice dimensions. Ablation analysis reveals that removing static knowledge grounding degrades Source Faithfulness and Groundedness, while removing dynamic personal memory reduces Personalization and Fitness, confirming their complementary roles.

Adding the investigate–solve–write scaffold to several backbone models consistently improves agentic problem-solving across STEM reasoning, general agent tasks, and long-context benchmarks, even with personalization modules disabled. Relative gains average between 26% and 32%, demonstrating the scaffold's general utility beyond personalized tutoring. The largest absolute improvements appear on LiveBench and GAIA, including gains on the hardest GAIA difficulty level. The scaffold yields consistent relative improvements across all tested backbone models, with average gains ranging from 25.69% to 32.03%. Performance increases are broad, lifting scores on every benchmark; the most pronounced absolute jumps occur on LiveBench and GAIA, where overall accuracy and hardest-level performance both rise substantially.

The evaluation first validates a unified personalization substrate that lets diverse extensions (deep research, mastery paths, co-writing, partner agents) inherit grounding and learner memory from a shared loop, avoiding fragmented models. A human evaluation then shows that DeepTutor, built on this substrate, substantially outperforms naive and baseline tutors, with the largest gains in vividness, personalization, and groundedness; ablation confirms that static knowledge grounding and dynamic personal memory play complementary roles. Finally, the investigate–solve–write scaffold is tested across multiple backbone models on STEM, agent, and long-context benchmarks, demonstrating consistent 26–32% relative improvements even without personalization, proving its general utility for agentic problem-solving.