CoTutor: AI Copilot for Programming Ed

• CoTutor is an AI-assisted personalized education framework for programming that combines interpretable knowledge tracing, signal processing, and convex optimization.
• It processes multimodal student data to continuously update a transparent learner model, driving adaptive feedback and resource allocation.
• The system integrates a generative-AI copilot with human oversight to provide personalized tutoring while ensuring reliable, interpretable instruction.

Searching arXiv for the primary paper and adjacent tutoring/student-modeling work to ground the article. Searching (Wang et al., 28 Sep 2025) CoTutor CoTutor is an AI-assisted personalized education framework for programming education that combines interpretable knowledge tracing, signal processing, convex optimization, and a generative-AI copilot. It is presented not as a purely end-to-end chatbot, but as a structured human-AI cotutoring system whose central purpose is to estimate a learner’s evolving knowledge state from interaction data and use that state to drive adaptive feedback, resource allocation, and learning support. Its target users are primarily university students learning programming in environments such as online judge systems, coding platforms, quizzes, and chatbot interfaces; instructors are secondary users because the system is designed to support pedagogical oversight and intervention rather than replace educators (Wang et al., 28 Sep 2025).

1. Conceptual framing and pedagogical scope

CoTutor addresses a specific limitation of conventional educational tools and many LLM-based tutoring systems: they either do not maintain an explicit model of student learning or do not adapt in real time in an interpretable way. The framework therefore aims to bridge student interaction data and instructional decisions through a continuously updated, transparent learner model. In the paper’s own framing, it is an “AI copilot” that automates and scales learning analytics while reserving pedagogical judgment for humans (Wang et al., 28 Sep 2025).

This positioning distinguishes CoTutor from generic conversational assistants. Its operative unit is not the isolated chat turn, but the learner’s evolving state across sessions, submissions, and feedback channels. The framework treats programming education as a domain that generates rich digital traces—submission logs, participation patterns, chatbot queries, feedback surveys, assessment outcomes, timestamps, execution time, memory use, number of attempts before success, and problem difficulty—which can be modeled as temporally structured signals rather than as disconnected observations.

A frequent misconception is to treat CoTutor as a generalized tutoring chatbot with adaptive language generation. The published description instead presents a layered system in which the generative component is downstream of learner-state estimation and recommendation. The student model and optimization layer determine what kinds of hints, materials, or tasks should be presented; generation is a delivery mechanism, not the primary reasoning substrate. This places CoTutor within a broader line of educational systems that combine structured student modeling with generative interaction, such as CogGen’s coupling of Bayesian Knowledge Tracing with pedagogically constrained tutoring over programming videos (Li et al., 25 Jun 2025).

2. System architecture and data-processing pipeline

CoTutor is organized as an iterative closed loop. Inputs are multichannel student interaction data, including assignment submissions, scores, timestamps, numbers of attempts, problem difficulty, execution time, memory use, attendance, forum activity, resource-access logs, chatbot questions, and post-module surveys. These inputs are transformed into time-indexed feature vectors $\mathbf{z}_i$, then smoothed and aggregated to produce $\tilde{\mathbf{z}}_i$, which feed the knowledge-tracing module (Wang et al., 28 Sep 2025).

The paper writes the signal stream as

$S = \{(t_i, \mathbf{z}_i, y_i)\},$

where $t_i$ is a timestamp, $\mathbf{z}_i$ is a contextual feature vector, and $y_i$ is observed performance, typically correctness. For online judge deployment, each student history is similarly written as

$D^{(j)} = \{(t_i, \mathbf{z}_i, y_i)\}_{i=1}^{T}.$

The signal-processing layer denoises and temporally filters these observations before inference. The recursive smoother is given as

$$\bar{\mathbf{z}}_i \leftarrow \alpha \mathbf{z}_i + (1 - \alpha)\bar{\mathbf{z}}_{i-1},$$

followed by a recent-window summary

$$\tilde{\mathbf{z}}_i \leftarrow \text{Aggregate}(\bar{\mathbf{z}}_{i-W:i}).$$

In the online judge section, the same idea appears as

$$\tilde{\mathbf{z}}_i = \alpha \mathbf{z}_i + (1 - \alpha)\tilde{\mathbf{z}}_{i-1}.$$

The text explicitly summarizes preprocessing as “multimodal learning analytics of data digitalization $\tilde{\mathbf{z}}_i$0 smoothing and normalization $\tilde{\mathbf{z}}_i$1 sampling $\tilde{\mathbf{z}}_i$2 feature embedding $\tilde{\mathbf{z}}_i$3 multimodal data aggregation” (Wang et al., 28 Sep 2025).

After preprocessing, the system estimates current mastery $\tilde{\mathbf{z}}_i$4, computes a recommendation

$\tilde{\mathbf{z}}_i$5

updates policy parameters through

$\tilde{\mathbf{z}}_i$6

$\tilde{\mathbf{z}}_i$7

and refines the latent learner representation through

$\tilde{\mathbf{z}}_i$8

The output is an updated learner model together with a personalized recommendation. This architecture indicates a stateful adaptive system rather than a stateless request-response service.

3. Knowledge tracing, signal processing, and optimization

The formal core of CoTutor is Bayesian Knowledge Tracing. For activity or skill $\tilde{\mathbf{z}}_i$9 at session $S = \{(t_i, \mathbf{z}_i, y_i)\},$0, the model defines $S = \{(t_i, \mathbf{z}_i, y_i)\},$1 as the probability that the student has mastered that skill. The paper gives the forward update and predicted correctness probability as

$S = \{(t_i, \mathbf{z}_i, y_i)\},$2

$S = \{(t_i, \mathbf{z}_i, y_i)\},$3

where $S = \{(t_i, \mathbf{z}_i, y_i)\},$4 is the learn probability, $S = \{(t_i, \mathbf{z}_i, y_i)\},$5 the slip probability, and $S = \{(t_i, \mathbf{z}_i, y_i)\},$6 the guess probability (Wang et al., 28 Sep 2025).

After each response, mastery is updated with the standard BKT posterior rules. For a correct response,

$S = \{(t_i, \mathbf{z}_i, y_i)\},$7

and for an incorrect response,

$S = \{(t_i, \mathbf{z}_i, y_i)\},$8

The paper also writes the main update abstractly as

$S = \{(t_i, \mathbf{z}_i, y_i)\},$9

which indicates that correctness and processed contextual features jointly inform the update, even though the exact modified posterior beyond standard BKT is not fully derived.

Convex optimization is the second technical pillar. At the general level, the paper frames educational adaptation and resource allocation as convex programs, for example

$t_i$0

where $t_i$1 is intervention weight, $t_i$2 cost, and $t_i$3 predicted gain. A more concrete session-level planning model allocates educational resources

$t_i$4

with precedence constraints and a sentiment or engagement state

$t_i$5

The objective is to maximize cumulative engagement subject to budget and dependency constraints. In the programming-education case, resource utility is tied directly to traced mastery through an inverted-U challenge curve,

$t_i$6

so that theory, practice, review, or challenge are allocated according to an “optimal challenge” principle. This suggests that CoTutor’s novelty lies less in replacing BKT with an opaque end-to-end learner model than in embedding BKT within a larger signal-conditioned and optimization-guided personalization loop.

4. Generative-AI copilot and human oversight

The generative component of CoTutor is an interaction and delivery layer. The paper describes CoTutor as an “AI copilot” implemented on programming education platforms such as My Code Weapon and Nemobot. It turns backend student-model outputs into conversational tutoring actions, including proactive reminders, natural-language responses to student questions, and personalized resource recommendations with hyperlinks and references (Wang et al., 28 Sep 2025).

This layer is explicitly state-guided. When mastery is low, the copilot can recommend more foundational exercises; when mastery is high, it can recommend more advanced challenges. The crucial point is that generation is grounded in persistent learner-state estimates and optimization outputs rather than prompt context alone. CoTutor is therefore framed as distinct from generic LLM tutoring systems that support isolated conversations without an explicit model of the learner’s trajectory.

Reliability constraints are central to this design. Because free-form generation can hallucinate, the paper states that CoTutor standardizes replies where possible, for example by linking directly to lecture timestamps or exercise references, and logs all outputs for instructor review. The student model thus functions as a guardrail: generation is meant to be grounded in estimated mastery and linked resources, not left unconstrained.

The division of responsibility is explicit. CoTutor handles routine educational analytics—tracking signals, estimating knowledge state, selecting candidate interventions, and generating chatbot-mediated support—while human educators retain responsibility for high-level pedagogical judgment and consequential decisions. The governance model includes educator approval for consequential actions, override justifications, instructor training, immutable logs of AI suggestions and educator actions, model cards documenting decision boundaries and confidence thresholds, and periodic transparency disclosures. The system is described as aligning with the EU AI Act’s high-risk category for systems that dynamically adapt feedback based on student progress, while clarifying that it is not designed for admissions or automated grading decisions (Wang et al., 28 Sep 2025).

5. Empirical performance and deployment evidence

The paper evaluates CoTutor on both public-dataset benchmarking and a real university controlled study. On the EdNet KT1 dataset, after preprocessing to remove duplicates, missing answers, undefined skill tags, and students with fewer than 10 interactions, CoTutor is compared against BKT, DKT, and Code-DKT. The reported results are: BKT with Accuracy $t_i$7, AUC-ROC $t_i$8, PR-AUC $t_i$9, RMSE $\mathbf{z}_i$0, and NLL $\mathbf{z}_i$1; DKT with Accuracy $\mathbf{z}_i$2, AUC-ROC $\mathbf{z}_i$3, PR-AUC $\mathbf{z}_i$4, RMSE $\mathbf{z}_i$5, and NLL $\mathbf{z}_i$6; Code-DKT with Accuracy $\mathbf{z}_i$7, AUC-ROC $\mathbf{z}_i$8, PR-AUC $\mathbf{z}_i$9, RMSE $y_i$0, and NLL $y_i$1; and CoTutor with Accuracy $y_i$2, AUC-ROC $y_i$3, PR-AUC $y_i$4, RMSE $y_i$5, and NLL $y_i$6 (Wang et al., 28 Sep 2025).

These numbers indicate that CoTutor outperforms all baselines across all five reported metrics. Relative to BKT, the accuracy gain is $y_i$7 percentage points; relative to DKT and Code-DKT, the gains are $y_i$8 and $y_i$9 points respectively. The discussion summarizes this as a $D^{(j)} = \{(t_i, \mathbf{z}_i, y_i)\}_{i=1}^{T}.$0 to $D^{(j)} = \{(t_i, \mathbf{z}_i, y_i)\}_{i=1}^{T}.$1 increase in accuracy, depending on baseline and interpretation.

The controlled classroom study was conducted in a university AI course with 203 students over one semester. Students were randomly assigned to five groups: four AI-assisted groups using BKT, DKT, Code-DKT, or CoTutor, each with roughly $D^{(j)} = \{(t_i, \mathbf{z}_i, y_i)\}_{i=1}^{T}.$2 to $D^{(j)} = \{(t_i, \mathbf{z}_i, y_i)\}_{i=1}^{T}.$3, plus a control group with $D^{(j)} = \{(t_i, \mathbf{z}_i, y_i)\}_{i=1}^{T}.$4. Across five graded assignments and associated class activities, the reported averages were: Control with assignment $D^{(j)} = \{(t_i, \mathbf{z}_i, y_i)\}_{i=1}^{T}.$5, survey $D^{(j)} = \{(t_i, \mathbf{z}_i, y_i)\}_{i=1}^{T}.$6, participation $D^{(j)} = \{(t_i, \mathbf{z}_i, y_i)\}_{i=1}^{T}.$7; BKT with assignment $D^{(j)} = \{(t_i, \mathbf{z}_i, y_i)\}_{i=1}^{T}.$8, survey $D^{(j)} = \{(t_i, \mathbf{z}_i, y_i)\}_{i=1}^{T}.$9, participation $$\bar{\mathbf{z}}_i \leftarrow \alpha \mathbf{z}_i + (1 - \alpha)\bar{\mathbf{z}}_{i-1},$$0, prediction accuracy $$\bar{\mathbf{z}}_i \leftarrow \alpha \mathbf{z}_i + (1 - \alpha)\bar{\mathbf{z}}_{i-1},$$1; DKT with assignment $$\bar{\mathbf{z}}_i \leftarrow \alpha \mathbf{z}_i + (1 - \alpha)\bar{\mathbf{z}}_{i-1},$$2, survey $$\bar{\mathbf{z}}_i \leftarrow \alpha \mathbf{z}_i + (1 - \alpha)\bar{\mathbf{z}}_{i-1},$$3, participation $$\bar{\mathbf{z}}_i \leftarrow \alpha \mathbf{z}_i + (1 - \alpha)\bar{\mathbf{z}}_{i-1},$$4, prediction accuracy $$\bar{\mathbf{z}}_i \leftarrow \alpha \mathbf{z}_i + (1 - \alpha)\bar{\mathbf{z}}_{i-1},$$5; Code-DKT with assignment $$\bar{\mathbf{z}}_i \leftarrow \alpha \mathbf{z}_i + (1 - \alpha)\bar{\mathbf{z}}_{i-1},$$6, survey $$\bar{\mathbf{z}}_i \leftarrow \alpha \mathbf{z}_i + (1 - \alpha)\bar{\mathbf{z}}_{i-1},$$7, participation $$\bar{\mathbf{z}}_i \leftarrow \alpha \mathbf{z}_i + (1 - \alpha)\bar{\mathbf{z}}_{i-1},$$8, prediction accuracy $$\bar{\mathbf{z}}_i \leftarrow \alpha \mathbf{z}_i + (1 - \alpha)\bar{\mathbf{z}}_{i-1},$$9; and CoTutor with assignment $$\tilde{\mathbf{z}}_i \leftarrow \text{Aggregate}(\bar{\mathbf{z}}_{i-W:i}).$$0, survey $$\tilde{\mathbf{z}}_i \leftarrow \text{Aggregate}(\bar{\mathbf{z}}_{i-W:i}).$$1, participation $$\tilde{\mathbf{z}}_i \leftarrow \text{Aggregate}(\bar{\mathbf{z}}_{i-W:i}).$$2, prediction accuracy $$\tilde{\mathbf{z}}_i \leftarrow \text{Aggregate}(\bar{\mathbf{z}}_{i-W:i}).$$3 (Wang et al., 28 Sep 2025).

Thus CoTutor’s assignment-score gains are $$\tilde{\mathbf{z}}_i \leftarrow \text{Aggregate}(\bar{\mathbf{z}}_{i-W:i}).$$4 points over control, $$\tilde{\mathbf{z}}_i \leftarrow \text{Aggregate}(\bar{\mathbf{z}}_{i-W:i}).$$5 over BKT, $$\tilde{\mathbf{z}}_i \leftarrow \text{Aggregate}(\bar{\mathbf{z}}_{i-W:i}).$$6 over DKT, and $$\tilde{\mathbf{z}}_i \leftarrow \text{Aggregate}(\bar{\mathbf{z}}_{i-W:i}).$$7 over Code-DKT. In prediction accuracy, CoTutor improves by $$\tilde{\mathbf{z}}_i \leftarrow \text{Aggregate}(\bar{\mathbf{z}}_{i-W:i}).$$8, $$\tilde{\mathbf{z}}_i \leftarrow \text{Aggregate}(\bar{\mathbf{z}}_{i-W:i}).$$9, and $$\tilde{\mathbf{z}}_i = \alpha \mathbf{z}_i + (1 - \alpha)\tilde{\mathbf{z}}_{i-1}.$$0 points over BKT, DKT, and Code-DKT respectively. The paper also reports $$\tilde{\mathbf{z}}_i = \alpha \mathbf{z}_i + (1 - \alpha)\tilde{\mathbf{z}}_{i-1}.$$1-tests, $$\tilde{\mathbf{z}}_i = \alpha \mathbf{z}_i + (1 - \alpha)\tilde{\mathbf{z}}_{i-1}.$$2-values, and Cohen’s $$\tilde{\mathbf{z}}_i = \alpha \mathbf{z}_i + (1 - \alpha)\tilde{\mathbf{z}}_{i-1}.$$3, claiming medium to strong effect sizes for most CoTutor-versus-baseline comparisons, with one weaker comparison on participation versus Code-DKT.

The system-level deployment argument is that localized pre-LLM computation and caching reduce LLM prompts by $$\tilde{\mathbf{z}}_i = \alpha \mathbf{z}_i + (1 - \alpha)\tilde{\mathbf{z}}_{i-1}.$$4, yielding estimated cost savings of $$\tilde{\mathbf{z}}_i = \alpha \mathbf{z}_i + (1 - \alpha)\tilde{\mathbf{z}}_{i-1}.$$5 for GPT-4o and $$\tilde{\mathbf{z}}_i = \alpha \mathbf{z}_i + (1 - \alpha)\tilde{\mathbf{z}}_{i-1}.$$6 for Claude 3.7. These are cost estimates rather than educational-outcome ablations. The paper does not provide a formal ablation isolating the independent value of signal smoothing, optimization, and generative delivery, and this is one of its central methodological limitations.

6. Governance, limitations, and research context

CoTutor gives substantial attention to privacy, ethics, transparency, and human oversight. It processes only digitally recorded educational interactions such as submissions, quiz logs, participation metrics, chatbot logs, and surveys. Data is described as pseudonymized and encrypted in transit and storage, with strict role-based access control. Differential privacy techniques are mentioned as part of the protection strategy, though at the policy level rather than through a demonstrated experimental mechanism (Wang et al., 28 Sep 2025).

Several limitations remain explicit. The paper does not fully specify a mathematically complete modified BKT model that integrates contextual feature vectors into posterior inference beyond the abstract $$\tilde{\mathbf{z}}_i = \alpha \mathbf{z}_i + (1 - \alpha)\tilde{\mathbf{z}}_{i-1}.$$7 notation. Some formulas appear with typesetting errors. The optimization case study centers on a sentiment/resource-allocation model rather than a directly validated tutoring-policy objective tied to learning gains. There is no rigorous component ablation, no subgroup fairness analysis, and the classroom study is limited to one course and one semester.

These limitations are consequential because contemporary evaluation work shows that high final-answer competence does not imply tutoring competence. TutorGym, for example, embeds AI agents inside existing ITSs and reports that current LLMs are poor at tutoring: none did better than chance at labeling incorrect actions, and next-step actions were correct only about $$\tilde{\mathbf{z}}_i = \alpha \mathbf{z}_i + (1 - \alpha)\tilde{\mathbf{z}}_{i-1}.$$8–$$\tilde{\mathbf{z}}_i = \alpha \mathbf{z}_i + (1 - \alpha)\tilde{\mathbf{z}}_{i-1}.$$9 of the time (Weitekamp et al., 2 May 2025). This contextualizes CoTutor’s emphasis on structured learner modeling and human oversight. A plausible implication is that state tracking, explicit skill estimation, and constrained intervention policies may be necessary conditions for reliable tutoring behavior, not optional add-ons.

Within the broader research landscape, CoTutor belongs to a family of systems that re-center pedagogical structure around explicit intermediate representations. CogGen links programming-video segmentation, Cognitive Apprenticeship tutoring moves, and BKT-based student modeling (Li et al., 25 Jun 2025); CoTAL uses rubric-grounded chain-of-thought prompting and active learning for formative assessment scoring (Cohn et al., 3 Apr 2025); and platform-integrated tutoring systems based on GPT-4 and Microsoft Copilot Studio emphasize delivery, adaptive content, and teacher analytics inside existing institutional infrastructure (Chen, 2024). CoTutor’s distinctive claim within this landscape is to wrap BKT-style knowledge tracing inside a signal-driven, optimization-guided, chatbot-mediated personalization loop while explicitly retaining human pedagogical control.