CalcTutor: Multi-Agent LLM Grading of Handwritten Mathematics with RAG-Grounded Feedback for Adaptive Learning Support

Abstract

Personalized instruction remains a major bottleneck in higher education, especially in large classes where timely, individualized feedback is difficult to achieve. Existing automation typically relies on rigid rule-based pipelines or computationally heavy deep learning models, making it difficult to simultaneously achieve interpretability, instructional usability, and scalable deployment. In this study, we present CalcTutor, a generative-AI-based assessment and feedback system designed to support open-ended handwritten calculus problem solving. The system organizes instructional support through three coordinated components: (1) a multi-agent large language model (LLM) mechanism that evaluates solution processes and produces diagnostic feedback, (2) a retrieval-augmented generation (RAG) pipeline that links diagnosed difficulties to aligned instructional materials, and (3) real-time learner analytics for both students and instructors, forming an integrated instructional support workflow rather than an automated answer-checking tool. In offline evaluation and a pilot classroom deployment, the multi-agent grader achieved a weighted agreement accuracy of 0.931 and an F1-score of 0.934 on 1055 handwritten solutions. Participant feedback and workflow testing indicated that CalcTutor can be stably integrated into routine classroom use and enables students to interpret and act upon the provided feedback. These results indicate that automated assessment, diagnostic feedback, and targeted review can operate coherently within a single instructional process that supports instructor-led assessment practices. Using undergraduate calculus as an application domain for open-ended handwritten mathematical assessment, the study demonstrates the operational feasibility of a closed-loop assessment–feedback–revision workflow and provides a deployable instructional infrastructure for formative instructional support in real classroom contexts.

1. Introduction

University mathematics courses, particularly calculus, are commonly taught at a uniform instructional pace. As class sizes increase, heterogeneous student backgrounds and learning progress become difficult to accommodate. Weaker students may fail to consolidate prerequisite concepts, while advanced learners receive insufficient challenge, gradually widening learning gaps. This issue is especially pronounced in calculus, where conceptual understanding is cumulative and interdependent. In large-class settings, instructors have difficulty examining students’ reasoning processes and providing timely, targeted guidance.

The central instructional difficulty is, therefore, not assigning scores but delivering formative feedback on open-ended solution processes. Classroom grading relies on verification of reasoning steps and identification of misconceptions, yet such process-oriented assessment is labor-intensive and difficult to implement consistently at scale.

From a technical perspective, two main challenges underlie this bottleneck. Challenge 1: Balancing personalization and scalability in grading and feedback. Traditional automated grading systems rely on rule-based [1], feature-based [2], or similarity-based [3] approaches. Although computationally efficient, these methods typically require extensive labeled data and mainly produce correctness judgments with limited diagnostic explanation [4]. Large language models (LLMs) show potential for identifying misconceptions and generating explanations [5,6,7], yet hallucinations and reasoning inconsistencies [8] limit their reliability in instructional settings. Fluent explanations from a single LLM do not guarantee alignment with pedagogical grading criteria or stable reasoning verification. Challenge 2: Disconnect between diagnostic assessment and instructional intervention. Existing recommendation methods, including rule-based [9], collaborative filtering [10], and deep learning approaches [11,12], often operate independently of grading diagnostics. As a result, automated assessment, feedback generation, and learning support are implemented as separate modules rather than as a coordinated instructional process. Existing systems, therefore, address only partial components of the instructional workflow. Grading systems provide scores but limited pedagogical explanation; tutoring or chatbot systems generate explanations but lack grading alignment; and recommendation systems suggest materials without grounding in diagnostic assessment. The absence of integration limits classroom usability, where instructors require coherent assessment–feedback–revision cycles.

To address these challenges, we present CalcTutor, a generative-AI-based instructional assessment support system. CalcTutor is organized around a formative feedback workflow integrating diagnostic grading, targeted instructional retrieval, and learner analytics. A multi-agent framework analyzes handwritten solution processes to identify conceptual difficulties rather than directly assigning scores. A Retrieval-Augmented Generation (RAG) pipeline links diagnosed difficulties to lecture notes, slides, and video materials. Real-time analytics dashboards support instructor interpretation and student self-reflection. The system is implemented using React Native and Django, integrates GPT-4o Mini for real-time processing, and has undergone end-to-end validation through authentic classroom pilot deployment. The system is designed for instructional support rather than instructor replacement, making reasoning-oriented feedback accessible in classes while preserving instructor judgement.

The main contributions of this work are as follows: (1) We propose a closed-loop formative feedback paradigm as an instructional support workflow, integrating grading, recommendation, and analytics into a coordinated assessment–feedback–revision process. (2) We design a multi-agent diagnostic grading mechanism and an RAG-based instructional linkage pipeline that organizes feedback around students’ solution processes rather than final answers alone. (3) We implement and validate a prototype system achieving 93.1% grading agreement on 1055 handwritten solutions and demonstrate its operational feasibility in real classroom use through pilot deployment and user feedback.

By structurally linking diagnosis, intervention, and feedback, CalcTutor establishes an operational instructional technology framework that can be incorporated into routine teaching practice. Undergraduate calculus is adopted as a representative instructional context to examine the operational feasibility of integrating assessment, feedback, and revision workflows in authentic classroom practice.

2. Related Work

2.1. Adaptive Learning and Automated Feedback

Adaptive learning platforms (ALPs) aim to provide personalized instructional support at scale and have demonstrated positive effects on engagement and learning outcomes across diverse educational contexts [13,14,15,16,17]. However, most ALPs primarily adapt content sequencing or difficulty levels, while diagnostic feedback on open-ended problem solving remains limited in authentic classroom settings.

Automated grading systems (AGSs) provide the technical foundation for adaptive feedback [18]. Classical AGSs rely on rule-based matching [1], feature extraction [2], or similarity scoring [3]. Although efficient, these approaches often require large labeled datasets [4,19,20,21] and typically produce static correctness judgments rather than explanatory feedback.

Recent large language models (LLMs) enable analysis of open-ended solutions and generation of richer explanations [5,7,22,23,24]. However, hallucinations and inconsistent reasoning [8] limit their reliability in instructional grading. Multi-agent collaboration frameworks, such as AutoGen [25], decompose reasoning tasks into coordinated roles, improving consistency and interpretability. Prior work, therefore, improves grading capability but typically treats grading as an isolated scoring or explanation module. In classroom instruction, grading must support diagnosis and subsequent intervention. CalcTutor adopts multi-agent diagnostic grading to enable this instructional function rather than to optimize scoring accuracy alone.

2.2. Personalized Recommendation and Instructional Retrieval

Personalized recommendation is another key component of adaptive learning. Rule-based systems offer transparency but limited adaptability [9]. Collaborative filtering and deep sequence models [10,11,12] improve personalization but suffer from cold-start and sparsity issues and are generally driven by historical interaction data rather than immediate learning needs.

Retrieval-Augmented Generation (RAG) grounds generated responses in external knowledge sources by retrieving relevant materials and conditioning generation on them [26]. In educational settings, this enables support tied to instructional materials rather than generic explanations. Recent studies have also explored virtual student agents and learner modeling to simulate diverse learning behaviors [27]. However, recommendation systems are typically independent of assessment systems and rely on predicted preferences or historical patterns rather than verified reasoning difficulties. CalcTutor links recommendation directly to diagnostic grading outcomes so that retrieved materials correspond to specific conceptual errors observed in students’ written solutions.

2.3. Learner Analytics and CalcTutor’s Positioning

Learner analytics dashboards visualize learning trajectories at the individual and cohort levels and support formative reflection. Existing dashboards emphasize monitoring and modular integration [9], but they are often loosely coupled with grading and recommendation components, limiting their role in instructional adjustment. Beyond standard sequence models, graph-based encodings of temporal traces (e.g., visibility graphs) have been surveyed for time series prediction and classification and may be useful for modeling learner performance trajectories as part of future work [28]. Across automated grading, recommendation, and analytics research, most prior systems study components independently. Grading evaluates correctness, recommendation selects materials, and analytics visualizes performance, whereas the instructional workflow connecting evaluation, feedback, and revision is rarely implemented as a unified process.

CalcTutor is positioned as an instructional support framework rather than a single intelligent module. By integrating multi-agent diagnostic grading, RAG-grounded recommendation, and learner analytics, the system forms a closed-loop assessment–feedback–revision cycle that supports student self-regulation and instructor instructional adjustment.

Table 1. Summary of automated grading and recommendation system approaches.

(A) Automated Grading Systems
Approach	Flexibility	Feedback Type	Scalability
Rule-based	Low	Pre-defined, static	High
Machine learning	Moderate	Limited personalization	Moderate
LLM + Multi-Agent (CalcTutor)	High	Personalized, real-time	High
(B) Recommendation Systems
Approach	Personalization	Explainability	Computational Cost
Rule-based	Low	High	Low
Collaborative filtering	Moderate	Moderate	Moderate
Deep learning	High	Low	High
RAG-based (CalcTutor)	Very High	High	Moderate

summarizes representative approaches. Rather than introducing a new grading or recommendation algorithm alone, CalcTutor structurally combines these components to operationalize adaptive learning within routine classroom practice.

3. System Architecture

CalcTutor is implemented as an Android-based learning platform organized around a three-tier architecture comprising presentation, application logic, and data layers (Figure 1). This structure follows the principle of separation of concerns [29], improving modularity, maintainability, and scalability while enabling data flow across the grading, recommendation, and learner analytics components.

3.1. Presentation Layer

The presentation layer provides interfaces for students and instructors and is implemented with React Native to support cross-platform deployment and rapid updates. Students can access instructional materials, complete quizzes, and upload handwritten solutions via a built-in scanning function. The system is optimized for bandwidth-limited classroom environments to ensure timely feedback delivery.

In practice, students typically follow a “learn–attempt–diagnose–review” cycle: they study materials, submit responses, receive step-level feedback, and review recommended resources aligned with diagnosed difficulties. Students may also access a personal analytics page displaying their performance history and progress trends for self-monitoring.

The instructor interface supports course management and analytics. Instructors can organize teaching materials, monitor class performance, observe error distributions, and track learning progress. These summaries help identify common misconceptions and guide follow-up instruction (Figure 2). Communication with backend services is handled through RESTful APIs, decoupling user interaction from processing modules.

3.2. Application Logic Layer

The application logic layer, implemented in Django (Python), serves as the system’s intelligent processing core. When a handwritten solution is submitted, a multi-agent grading pipeline built on AutoGen [25] is triggered. The pipeline includes three stages: the LaTeX agent performs OCR transcription, the solver agent generates a step-by-step reference solution, and the grader agent compares the student solution with the reference under predefined rubrics to produce feedback. Agents are coordinated via a GroupChatManager to ensure consistent execution. GPT-4o Mini [30] is used as the reasoning model for multimodal processing with a manageable computational cost.

By decomposing grading into expression interpretation, reasoning verification, and scoring decision stages, grading does not depend on a single generated response. Recognition or reasoning errors can be checked during subsequent comparison steps, improving reliability in instructional settings.

After grading, the system initiates a Retrieval-Augmented Generation (RAG) process that searches a curated knowledge base—including lecture notes, slides, and video transcripts—to generate targeted review recommendations. Interaction data, including grading outcomes and feedback histories, are aggregated and provided to instructor analytics dashboards. The modular design allows grading and recommendation components to be updated without restructuring the overall system.

3.3. Data Layer

The data layer manages both structured and unstructured data. User profiles, course metadata, and learning logs are stored in a PostgreSQL relational database to ensure consistency and transactional integrity. Instructional materials are embedded and stored in a Chroma vector database to support semantic retrieval for RAG recommendations [31]. Separating transactional records from retrieval resources preserves persistent learner records while maintaining stable content retrieval.

3.4. Deployment and End-to-End Workflow

CalcTutor is deployed on Amazon Web Services (AWS). The backend runs on EC2 instances with autoscaling and monitoring via CloudWatch, while lecture media are delivered through S3 and CloudFront. Data transmissions use HTTPS encryption and anonymized access control for privacy protection.

The workflow proceeds as follows: students upload handwritten solutions through the interface, the backend performs multi-agent grading and diagnosis, the RAG pipeline retrieves relevant instructional materials and generates recommendations, and feedback is returned in real time. Meanwhile, interaction data are recorded and visualized for instructors, supporting instructional adjustment and follow-up exercises. Assessment outputs, therefore, serve both student revision and instructor decision-making, linking diagnosis, intervention, and follow-up assessment within a continuous instructional process.

4. GenAI Functionalities

To support scalable, interpretable, and pedagogically aligned personalization, CalcTutor integrates two complementary GenAI mechanisms: a multi-agent grading process and a Retrieval-Augmented Generation (RAG) pipeline for instructional guidance. Assessment is formulated as a staged workflow in which handwritten solutions are processed through notation interpretation, reasoning verification, and rubric-based feedback generation. The RAG module then links diagnostic outcomes to curriculum-aligned materials and returns actionable review guidance. These mechanisms support a closed-loop assessment–feedback–revision use pattern.

4.1. Multi-Agent Grading

CalcTutor adopts a multi-agent collaboration framework built on AutoGen [25] to conduct rubric-based, process-oriented assessment of open-ended handwritten mathematical solutions rather than evaluating final answers alone. In mathematics instruction, grading primarily verifies reasoning processes and identifies misconceptions. A single LLM may generate fluent explanations, but it does not reliably adhere to step-based pedagogical grading criteria. Therefore, grading is modeled as a staged assessment workflow rather than a single inference step.

AutoGen enables structured multi-turn interaction among specialized agents [32]. Accordingly, the grading procedure is implemented as a fixed evaluation pipeline (Figure 3), improving stability and interpretability by separating perceptual interpretation, reasoning reference construction, and rubric-based judgement (full prompts in Appendix A):

• LaTeX Agent (interpretation stage). This agent uses GPT-4o Mini’s OCR to transcribe handwritten solutions into and explicitly marks blanks and illegible symbols. Its role is restricted to expression interpretation, making perceptual uncertainty explicit rather than embedding it within grading decisions.
• Solver Agent (reasoning reference stage). The agent generates a step-by-step reference solution for the given problem. This reference path serves as a semantic anchor so that grading is based on logical equivalence rather than surface symbol matching.
• Grader Agent (evaluation and feedback stage). The agent applies a structured rubric to compare the student solution with the reference and produces personalized feedback. Scoring depends on the validity and completeness of reasoning steps; local transcription errors do not necessarily cause incorrect grading when the mathematical logic remains consistent.

All agents are orchestrated sequentially by a GroupChatManager, ensuring consistent information flow and reproducible outcomes. System reliability derives from the staged mechanism: grading decisions are grounded in reasoning consistency and rubric alignment rather than token-level recognition accuracy.

The data flow is formalized as:

$$S_{\mathrm{LaTeX}}=\mathrm{OCR}\left(S_{\mathrm{image}}\right),$$

$$A_{\mathrm{solution}}=\mathcal{F}\left(Q_{\mathrm{input}}\right),$$

$$G,{\mathcal{P}}_{\mathrm{feedback}}=\mathcal{E}\left(S_{\mathrm{LaTeX}},A_{\mathrm{solution}},R\right),$$

where OCR performs transcription, $\mathcal{F}$ denotes the reasoning process for the input, and $\mathcal{E}$ represents rubric-based pedagogical evaluation.

We adopt a process-oriented rubric consistent with classroom grading practice (Figure 4). For two-mark items, full credit requires both a correct method and a correct final answer; answer-only responses receive 0. Equivalent forms and alternative valid solution paths are accepted, and minor arithmetic slips are not penalized when reasoning is correct. For one-mark items, full credit requires a correct answer accompanied by minimal working; answer-only responses receive 0.

Within the system, the rubric is embedded in the staged workflow: transcription structures expressions, the solver provides a reasoning reference, and the grader performs rubric-based judgement and feedback. Consequently, local symbol-recognition errors do not necessarily propagate into grading errors, as evaluation depends on logical consistency with the reference solution rather than surface token matching.

4.2. RAG-Based Personalized Learning Recommendations

While automated grading can identify misconceptions, students often lack immediate access to instructional resources that address their specific weaknesses. The instructional challenge is, therefore, translating diagnostic results into actionable learning support. To bridge this diagnosis–intervention gap, CalcTutor employs Retrieval-Augmented Generation (RAG) to align grading feedback with course materials, generating diagnosis-driven review recommendations (Figure 5).

The recommendation pipeline consists of three stages. First, the system aggregates grading feedback and uses an LLM to extract key weak areas, which are encoded as query vectors. Next, lecture notes, slides, and transcript texts (from video lectures) are segmented into semantically coherent chunks and embedded into a Chroma vector database. For each query vector Q, cosine similarity is computed against document vectors $D_i$,

$$\mathrm{Similarity}(Q,D_i)={\displaystyle \frac{Q·D_i}{\parallel Q\parallel \parallel D_i\parallel }},$$

and the top k most relevant chunks are retrieved. Finally, retrieved chunks and metadata (e.g., page numbers, slide indices, timestamps) are passed to an LLM, which generates a structured review summary and targeted revision guidance rather than general content recommendation.

In classroom use, the system presents an overall performance summary and matched review resources after each quiz (Figure 6). For example, for difficulties in double integrals, CalcTutor may recommend a lecture segment on Fubini’s Theorem, prerequisite note pages on single integrals, and pages introducing the framework for evaluating double integrals, diagnosing learners’ learning difficulties and directing them to the most relevant parts of the lecture slides and video lectures (for example), explaining why each part matters for their solution process.

By combining general-purpose LLMs with curated lecture content, CalcTutor supports a timely feedback–review loop that operationalizes an assessment–feedback–revision workflow. The RAG module is positioned as instructional support that enables learners to act on diagnostic feedback, rather than as direct evidence of improved learning outcomes.

5. Evaluation

To assess CalcTutor’s assessment reliability and instructional usability, we conducted two complementary studies: an offline evaluation using real handwritten student solutions and a pilot classroom deployment accompanied by user surveys. The offline study examines grading behavior by comparing system decisions with instructor grading on open-ended handwritten responses, whereas the pilot deployment evaluates whether feedback, recommendations, and analytics can be meaningfully interpreted and used in routine instructional activities.

Handwritten calculus solutions contain intermediate derivations and mathematical notation; accordingly, the task is framed as rubric-guided interpretive judgement rather than answer classification. Agreement with human grading is, therefore, adopted as the primary evaluation criterion, indicating whether the system follows reasoning-verification principles consistent with step-level classroom grading. The reported accuracy and F1-score represent decision consistency across diverse solution forms, notation variations, and handwriting noise, rather than classification performance.

The pilot deployment provides complementary instructional validation by examining whether students can revise their work based on feedback and whether instructors can monitor learning progress and adjust instruction through analytics. The two studies offer system-level validation: the offline evaluation verifies the reliability of the grading mechanism, and the classroom deployment demonstrates the operational feasibility of an assessment–feedback–revision workflow in authentic instructional settings.

5.1. Multi-Agent Grading Accuracy

5.1.1. Experimental Setup

We collected 1055 handwritten calculus solutions from actual university quizzes, covering 16 problems in partial differentiation, multiple integrals, and vector calculus. Each problem was labeled as a one-mark ($n=106$) or two-mark ($n=949$) item based on grading complexity. All responses were annotated by human instructors using the rubric defined in Section 4.1, and subsequently graded by CalcTutor’s multi-agent pipeline.

Figure 7 shows representative handwriting samples. Unlike standardized benchmarks, the dataset originates from routine classroom submissions and contains natural variation in layout, notation conventions, and image quality. This setting corresponds to the intended application scenario: open-ended handwritten solutions represent a common and challenging assessment form in mathematics teaching, requiring both visual interpretation and reasoning verification.

5.1.2. Overall Results

Table 2. Multi-agent grading performance compared to human scores.

Metric	1-Mark	2-Mark	Weighted
Accuracy	0.953	0.928	0.931
Precision	0.954	0.938	0.939
Recall	0.953	0.928	0.931
F1-score	0.953	0.932	0.934

reports grading outcomes compared with human annotations. CalcTutor achieved a weighted accuracy of 93.1% and a weighted F1-score of 93.4%. These values should be interpreted as agreement with instructor judgement rather than classification accuracy, indicating that the system reproduces step-based evaluation decisions across diverse handwritten solutions.

5.1.3. Category-Wise Analysis and Typical Errors

Figure 8 shows confusion matrices for one-mark and two-mark problems.

For one-mark problems, accuracy reached 0.953 with very few misclassifications. Most discrepancies occurred when students provided only a final answer without required working, where the system assigned full credit but the instructor label was 0. This behavior reflects reliance on observable solution evidence: in step-based grading, the presence of required reasoning steps is essential.

For two-mark problems, accuracy was 0.928 and F1-score 0.932. False negatives were more common than false positives, mainly due to (i) missing intermediate steps and (ii) OCR recognition errors (e.g., ${\displaystyle \frac{8}{3}}$ misread as ${\displaystyle \frac{8}{7}}$). When the submitted work did not support full reasoning verification, the system tended to deduct credit conservatively, reflecting a grading strategy based on reasoning-chain completeness rather than final-answer correctness alone.

5.1.4. Pedagogical Insights

Performance is more stable on one-mark problems, whereas two-mark items are more sensitive to missing steps and OCR errors. This reflects a property of open-ended mathematical assessment: grading depends on the verifiability of reasoning processes rather than solely on final answers. As scoring is determined by the validity and completeness of the observable reasoning chain, feedback can identify where a derivation becomes incomplete or inconsistent, supporting step-level diagnosis rather than correctness-only judgement. Future improvements will focus on enhancing mathematical OCR robustness and refining grader-agent prompting to reduce deductions caused by non-critical omissions while maintaining rigorous reasoning verification.

5.2. Pilot User Feedback

5.2.1. Deployment and Survey Setup

During CalcTutor’s closed beta testing on the Google Play Store, a pilot classroom deployment was conducted with 15 participants who had basic calculus knowledge. Participants freely explored system functions during normal use and evaluated usability and learning-support experience. Feedback was collected through a structured questionnaire (Appendix B) adapted from the Technology Acceptance Model and the E-Learning Tool Evaluation rubric.

The questionnaire consisted of nine Likert-scale items (S1–S9). Items S1–S3 measured perceived usefulness in supporting the learning process, while S4–S9 evaluated operational experience, including grading behavior, feedback interpretability, learner analytics, and recommendation support (

Table 3. Mapping of questionnaire items used in the Likert-scale evaluation (S1–S9).

Item	Description	Category
S1	Enhances effectiveness of calculus learning	Usefulness
S2	Beneficial to learning	Usefulness
S3	Improves calculus performance	Usefulness
S4	Accurate grading of submitted solutions	System performance
S5	Feedback matches learning needs	System performance
S6	Feedback helpful for learning	System performance
S7	Analytics helps evaluate learning performance	System performance
S8	Analytics encourages reflection	System performance
S9	Recommended materials helpful for improvement	System performance

).

5.2.2. Feedback Summary

Multi-Agent Grading. As shown in Figure 9, 93.3% of participants agreed that the grading results were consistent with their solution processes. Participants reported that step-level feedback helped them understand their reasoning. One user commented:

“I was genuinely impressed by how accurately the system assessed my work. The personalized feedback gave me real insight into my problem-solving process.”

A few cases involved symbol-recognition errors (e.g., a square root interpreted as $\pi$), leading to incorrect scores. This indicates that current limitations are primarily related to mathematical OCR rather than grading logic, and suggests directions for technical improvement.

RAG Recommendations. All participants reported that the recommendation module supported targeted review. Users noted that the system directly pointed them to relevant instructional materials, reducing time spent identifying mistakes.

“The targeted guidance reduced the time I spent figuring out my mistakes and directed me efficiently to the right content.”

Learner Analytics. In total, 86.7% of respondents agreed that analytics helped monitor progress. However, cohort-level statistics were interpreted differently across learners, with some perceiving pressure from comparison. This suggests that analytics should be framed as formative self-monitoring rather than ranking information.

Overall Evaluation. Participants expressed generally positive attitudes toward the system and reported perceived improvement in understanding and confidence (self-reported perceptions rather than measured learning outcomes). In total, 93% found the interface user-friendly, and all participants indicated willingness to continue using the app. The word cloud in Figure 10 highlights frequently mentioned attributes, such as clarity, usefulness, and efficiency. Suggested improvements included a handwriting canvas and clearer feedback presentation.

These results provide experience-level evidence: learners were generally able to interpret and use the feedback, while also identifying improvement directions including OCR robustness, feedback presentation, and analytics personalization. User responses further suggest an implication for analytics design. Learners used the dashboard primarily for monitoring their own progress, but cohort comparison was sometimes interpreted as social evaluation. In AI-assisted instruction, analytics is, therefore, more effective as metacognitive support rather than competitive ranking. Considered together with the offline grading agreement study, the observations reveal a functional instructional process: diagnostic grading identifies reasoning difficulties, recommendations support targeted review, and analytics supports progress monitoring and instructional adjustment. Therefore, the pilot evaluates classroom usability and operational feasibility rather than long-term learning outcome effects.

6. Conclusions

This paper presented CalcTutor, an adaptive learning platform for university calculus instruction that integrates multi-agent automated grading and retrieval-augmented recommendations into a coordinated assessment–feedback–revision workflow. Offline evaluation on 1055 real handwritten solutions achieved a grading agreement of 93.1% with human instructors, indicating that the system reproduces rubric-based human judgement rather than simple answer matching. The RAG module linked diagnostic outcomes to curated course materials to support targeted review during routine instructional use, and pilot observations showed that learners were able to interpret and act on the provided feedback. The primary contribution is, therefore, not a claim of improved learning outcomes, but the operational validation that a multi-agent LLM-based instructional pipeline can function in authentic classroom environments. The results demonstrate that automated assessment, interpretable feedback, and targeted review can be integrated into a deployable instructional support workflow. In addition, the platform serves as a research infrastructure for studying learning processes. Continuous recording of solution traces, diagnostic feedback, and interaction records makes instructional activities observable in authentic settings. Pre–post studies, controlled experiments, and longitudinal analyses of conceptual understanding and self-regulated learning will guide future work.