LearnerAgent: Modeling & Simulating Learners

• LearnerAgent is a conceptual family that models and simulates learner behavior by centering on personalized profiles, latent state, and adaptive interactions.
• It employs diverse methodologies—from learner simulation for data generation to adaptive tutoring and social learning—to validate educational policies with empirical metrics.
• Recent implementations use explicit state representations and intermediate reasoning to align AI-supported actions with durable human learning outcomes.

Searching arXiv for the papers on arXiv and closely related "LearnerAgent" works to ground the article with cited sources. arxiv_search(query="LearnerAgent educational agent learner simulation personalized learning agent", max_results=10, sort_by="submittedDate") LearnerAgent denotes a family of AI agent designs that place the learner—not only the tutor, recommender, or evaluator—at the center of the computational model. Across recent work, the term is used for at least three closely related objects: a simulated student that generates realistic practice trajectories, an adaptive learner model that estimates knowledge state and guides next actions, and a learning-oriented human–AI scaffold that aims to convert assisted performance into durable human capability (2505.20642, Gao et al., 17 Jan 2025, Yan et al., 9 Apr 2026). The resulting literature spans explicit observation-based apprenticeship architectures, inference-based learner-like agents for material selection, multimodal student simulators, cohort-aware roll-call simulators, psychologically grounded year-long learning simulations, and multi-agent tutoring systems whose internal state is organized around learner profiles, memory, misconceptions, and transfer (Costa et al., 2014, Jen et al., 2020, Xu et al., 2024, Gao et al., 13 Jun 2026, Yuan et al., 7 Aug 2025).

1. Scope, lineage, and representative forms

The literature does not treat LearnerAgent as a single architecture. Instead, it appears as a unifying abstraction for systems that model learner state, simulate learner behavior, or regulate educational interaction around learner-specific constraints. Early work emphasized direct observation of experts through “agent software images,” with explicit snapshots of conditions and actions enabling recall- and classification-based learning by observation (Costa et al., 2014). Later work used a learner-like agent as an evaluator of materials, where performance on fill-in-the-blank inference tasks served as a proxy for the helpfulness of near-synonym examples (Jen et al., 2020). Recent systems move further toward longitudinal, personalized, and multi-agent settings, including fine-grained code-learning simulation, cohort-aware retrospective diagnosis, embodied teaching, and state-transition classroom simulation (2505.20642, Gao et al., 13 Jun 2026, Sesay et al., 15 Jun 2026, Ye et al., 28 May 2026).

System	LearnerAgent role	Distinctive mechanism
CoderAgent	Fine-grained programming learner simulator	ACT-R-inspired memory and PTOT debugging (2505.20642)
Agent4Edu	Personalized response generator for IESs	Learner profile, memory, action, reflection (Gao et al., 17 Jan 2025)
ALIGNAgent	Gap-identification and next-step guidance agent	Topic proficiency, concept diagnosis, recommendation (Tokoli et al., 22 Jan 2026)
AgentTutor	Multi-turn personalized teaching system	Bloom-aligned learner graph and LATS planning (Liu et al., 24 Dec 2025)
Edu-Theater	Cohort-aware learner simulator	Roll-call probing and cohort memory (Gao et al., 13 Jun 2026)
AgentSchool	Stateful classroom learner simulator	Knowledge graph, workflows, misconceptions, social state (Ye et al., 28 May 2026)

A second distinction concerns operational setting. Some systems simulate learners to generate synthetic data or pre-evaluate educational policies, as in Agent4Edu, EduAgent, CoderAgent, and Edu-Theater (Gao et al., 17 Jan 2025, Xu et al., 2024, 2505.20642, Gao et al., 13 Jun 2026). Others are deployed as adaptive educational agents that estimate proficiency, diagnose misconceptions, recommend interventions, or teach through multi-turn interaction, as in ALIGNAgent, ExpertAgent, AgentTutor, and LectūraAgents (Tokoli et al., 22 Jan 2026, Zhu et al., 8 Oct 2025, Liu et al., 24 Dec 2025, Sesay et al., 15 Jun 2026). A third strand is explicitly theoretical: Agentivism defines learning under human–AI interaction not by immediate performance, but by selective delegation, verification, reconstructive internalization, and transfer under reduced support (Yan et al., 9 Apr 2026).

2. Internal state, memory, and learner representation

A recurrent design pattern is to represent LearnerAgent as a structured latent state rather than a pure prompt-conditioned persona. CoderAgent equips each human learner with a cognitive state that captures programming knowledge, coding ability, style, and common error profiles; its long-term memory $M_{LT}$ is updated iteratively from the learner’s programming history $H_n = \{h_1, h_2, \dots, h_n\}$, where $h_i = (e_i, c_i, f_i)$, and the long-term update is written as $M_{LT}^i(t+1) = f(M_{LT}^i(t), H_t^i)$ (2505.20642). Agent4Edu uses a similarly explicit profile-memory separation: stable profile factors include activity, practice diversity, success rate, preference, and IRT-estimated problem-solving ability, while dynamic knowledge proficiency is maintained in memory rather than the profile (Gao et al., 17 Jan 2025).

Several systems refine this representation further. AgentTutor models the learner through a profile environment plus a tutor-maintained directed acyclic graph $G = (V, E)$ whose nodes store sub-goals, Bloom levels, and proficiencies, with per-sub-goal assessment written as $A(b_j) = (l_j, p_j)$ and $$p_j = \frac{1}{m}\sum_{k=1}^m \beta_k \cdot f_k(b_j, r)$$ (Liu et al., 24 Dec 2025). AgentSchool makes the state even more explicit, defining student state as $$x^s_{i,t} = (M_{i,t}, K_{i,t}, W_{i,t}, Z_{i,t}, P_i, \eta_i, S^{soc}_{i,t})$$, where $K_{i,t}$ is a weighted subject knowledge graph, $W_{i,t}$ a thinking-workflow pool, $H_n = \{h_1, h_2, \dots, h_n\}$0 a misconception set, and $H_n = \{h_1, h_2, \dots, h_n\}$1 a social state (Ye et al., 28 May 2026). This state-transition formulation is presented as an alternative to persona-conditioned role-play, with learning represented as updates to mastery, misconceptions, workflows, and social ties rather than as stylistic dialogue alone (Ye et al., 28 May 2026).

Memory design is correspondingly layered. Agent4Edu distinguishes factual memory, short-term memory, and long-term memory; factual memory stores all response records, short-term memory stores the most recent $H_n = \{h_1, h_2, \dots, h_n\}$2 records, and long-term memory stores reinforced facts, a summary reflection, and dynamic knowledge proficiency, with forgetting defined by $H_n = \{h_1, h_2, \dots, h_n\}$3 and triggered when this exceeds a threshold $H_n = \{h_1, h_2, \dots, h_n\}$4 (Gao et al., 17 Jan 2025). CoderAgent uses short-term memory for current exercise context, recent code, and debugging logs, and long-term memory for declarative and procedural components aligned with ACT-R (2505.20642). Edu-Theater substitutes cohort memory for dense per-learner trajectories, constructing cohort-level proficiency priors and then refining individual state with a small number of diagnostic retrospective queries (Gao et al., 13 Jun 2026). LectūraAgents adds a three-part adaptive memory $H_n = \{h_1, h_2, \dots, h_n\}$5 for session context, persistent learner history, and dynamic patterns that condition both content generation and embodied delivery (Sesay et al., 15 Jun 2026).

This progression shows a clear shift from simple learner descriptors toward multi-timescale state representations. A plausible implication is that LearnerAgent research increasingly treats “learner state” as a compositional object comprising knowledge, ability, style, misconception structure, recent traces, and, in some cases, social embedding.

3. Decision-making, reasoning, and control policies

The control layer of a LearnerAgent varies widely by task domain, but recent systems share a preference for explicit intermediate reasoning rather than direct response generation. In programming simulation, CoderAgent introduces Programming Tree of Thought (PTOT), a domain-specific decomposition of iterative debugging into four steps—why, how, where, and what—driven by current code $H_n = \{h_1, h_2, \dots, h_n\}$6, problem description $H_n = \{h_1, h_2, \dots, h_n\}$7, and compiler feedback $H_n = \{h_1, h_2, \dots, h_n\}$8 (2505.20642). PTOT plans a localized modification $H_n = \{h_1, h_2, \dots, h_n\}$9, after which the action module transforms the relevant code segment via $h_i = (e_i, c_i, f_i)$0, and a reflection module checks both ability alignment and profile consistency before either accepting the edit or returning to planning (2505.20642).

In adaptive tutoring, planning is often formulated as sequential search over instructional options. AgentTutor defines the educational process as $h_i = (e_i, c_i, f_i)$1 and seeks an optimal strategy $h_i = (e_i, c_i, f_i)$2 (Liu et al., 24 Dec 2025). Its Dynamic Strategy Module uses LATS with node value $h_i = (e_i, c_i, f_i)$3 and UCT selection $h_i = (e_i, c_i, f_i)$4, combining LLM evaluation, self-consistency, and tree-search exploration (Liu et al., 24 Dec 2025). AgentSchool instead frames teacher action selection around Zone of Proximal Development (ZPD), with compatibility defined per concept and action and teacher policy choosing actions near the learner’s assisted upper bound rather than maximizing immediate task completion (Ye et al., 28 May 2026).

Other LearnerAgent variants prioritize continual adaptation or partner selection. The self-learning agent with Progressive Neural Network integrated Transformer assigns each new task a new PNN column, freezes prior columns, and augments adaptation with LoRA, MAML-like meta-learning, and EWC regularization, explicitly targeting task-incremental continual learning without catastrophic forgetting (Sivakumar et al., 3 Apr 2025). InqEduAgent formalizes partner matching with Gaussian process augmentation over learner, partner, and domain features, using inputs $h_i = (e_i, c_i, f_i)$5, predictive target $h_i = (e_i, c_i, f_i)$6, and Pareto-front filtering before selecting the partner with the largest predicted gain (Zhao et al., 5 Aug 2025).

Reasoning control also appears in content delivery. LectūraAgents’ TASA algorithm aligns speech and embodied teaching actions through temporal semantic segmentation and salience heuristics, generating sequences $h_i = (e_i, c_i, f_i)$7 over slide regions and speech timestamps (Sesay et al., 15 Jun 2026). Although this is tutor-side rather than learner-side control, the framework is explicitly mapped into a LearnerAgent perspective by centering learner profile $h_i = (e_i, c_i, f_i)$8 and adaptive memory in the planning, generation, and delivery loop (Sesay et al., 15 Jun 2026).

4. Interaction regimes: simulation, tutoring, collaboration, and transfer

LearnerAgent systems differ not only in internal architecture but also in what interaction loop they instantiate. One major regime is learner simulation for data generation and policy evaluation. Agent4Edu generates learner responses for personalized learning algorithms, including CAT, by combining profile, memory, and action modules; EduAgent predicts and simulates per-transcript gaze AOIs, motor AOIs, cognitive states, and question answers from course content, AOIs, and a short history; Edu-Theater replaces dense per-learner simulation with cohort-aware roll-call over retrospective logs; and CoderAgent simulates multi-step code drafts, compiler feedback, debugging, revisions, and final AC versus non-AC outcomes (Gao et al., 17 Jan 2025, Xu et al., 2024, Gao et al., 13 Jun 2026, 2505.20642).

A second regime is adaptive instruction. ALIGNAgent implements a closed loop of topic-level proficiency estimation, concept-level misconception diagnosis, preference-aware recommendation, summary feedback, and an “intervene-before-advance” controller (Tokoli et al., 22 Jan 2026). ExpertAgent combines dynamic planning, retrieval-augmented generation, and long-chain reasoning, with a student model that updates after each interaction and directly drives the next instructional plan (Zhu et al., 8 Oct 2025). AgentTutor organizes curriculum decomposition, learner assessment, strategy selection, reflection, and experience memory into a multi-turn tutoring system, while LectūraAgents extends this pattern to end-to-end adaptive embodied teaching with speech-aligned highlighting, underlining, circling, and handwriting (Liu et al., 24 Dec 2025, Sesay et al., 15 Jun 2026).

A third regime centers on social and collaborative learning. InqEduAgent matches partners for inquiry-oriented learning using persona features such as subject preference and logical preference, then has paired learners discuss the problem stem without answer options before reattempting the exercise (Zhao et al., 5 Aug 2025). The year-long LearnerAgent framework with Deep, Surface, Lazy, and General profiles introduces weekly learning, monthly strategic choices, periodic exams, and teacher-moderated peer debates capped at $h_i = (e_i, c_i, f_i)$9 rounds (Yuan et al., 7 Aug 2025). AgentSchool further embeds learners in a dynamic social graph, modeling peripheral participation, clique formation, aggressor-induced cohesion, and opinion-leader emergence through updates such as $M_{LT}^i(t+1) = f(M_{LT}^i(t), H_t^i)$0 (Ye et al., 28 May 2026).

A fourth regime is explicitly normative rather than predictive. Agentivism argues that in human–AI interaction, assisted performance cannot be assumed to indicate learning. It proposes a LearnerAgent design that enforces selective delegation, epistemic monitoring and verification, reconstructive internalization, and transfer under reduced support, with measurement constructs such as support level $M_{LT}^i(t+1) = f(M_{LT}^i(t), H_t^i)$1, independent performance $M_{LT}^i(t+1) = f(M_{LT}^i(t), H_t^i)$2, explanation rubric score $M_{LT}^i(t+1) = f(M_{LT}^i(t), H_t^i)$3, transfer performance $M_{LT}^i(t+1) = f(M_{LT}^i(t), H_t^i)$4, calibration index $M_{LT}^i(t+1) = f(M_{LT}^i(t), H_t^i)$5, verification coverage $M_{LT}^i(t+1) = f(M_{LT}^i(t), H_t^i)$6, error-detection rate $M_{LT}^i(t+1) = f(M_{LT}^i(t), H_t^i)$7, and reconstruction depth $M_{LT}^i(t+1) = f(M_{LT}^i(t), H_t^i)$8 (Yan et al., 9 Apr 2026). This shifts LearnerAgent from “simulate a learner” toward “scaffold a learner so that AI-assisted work becomes durable capability.”

5. Evaluation protocols and empirical findings

Empirical evaluation reflects this diversity of roles. CoderAgent is evaluated on four tasks—next modification intention, next edit location, next code submission, and next-submission acceptance—and is reported to complete Tasks 1–4, whereas OKT completes Tasks 1–3 and traditional KT methods only Task 4 (2505.20642). On CSEDM, CoderAgent with GPT-4o reaches ACC 0.3841 for intention prediction, ACC 0.5324 for edit-location prediction, CodeBLEU 0.7698 for next-code generation, and AUC 0.5493 for acceptance prediction; on CodeNet, the corresponding values are 0.4010, 0.4853, 0.5900, and 0.5522 (2505.20642). Agent4Edu, evaluated on EduData, reports ACC 66.70, F1 79.84, and ROUGE-3 37.97 with GPT-3.5-turbo, and its synthetic data improve CAT F1 by +2.28, +2.39, and +0.20 for FSI, KLI, and MAAT at testing length 5 (Gao et al., 17 Jan 2025).

Adaptive tutoring systems are evaluated against downstream educational targets rather than simulation realism alone. ALIGNAgent, validated against actual exam performance in two undergraduate CS courses, reports GPT-4o-based precision 0.87–0.90, recall 0.82–0.85, F1 0.84–0.87, and accuracy 0.68–0.72 for proficiency estimation (Tokoli et al., 22 Jan 2026). AgentTutor reports HumanEval Pass@1 of 92.7 with GPT-3.5-turbo and 96.9 with GPT-4, plus MBPP Pass@1 of 89.4 with GPT-3.5-turbo; its ablations show that removing DSM reduces HumanEval Pass@1 from 92.7 to 72.9, and removing CDM reduces it to 84.1 (Liu et al., 24 Dec 2025). ExpertAgent reports only internal user-acceptance results, with performance expectancy 4.33/5, effort expectancy 4.22/5, facilitating conditions 4.22/5, and social influence 2.78/5, and does not report large-scale learning-gain metrics (Zhu et al., 8 Oct 2025).

Cohort- and classroom-level simulators are evaluated for realism, efficiency, and downstream utility. Edu-Theater on DBE-KT22 with GPT-4.1-mini reports answer ACC 69.40, correctness ACC 73.03, F1 83.95, and ROUGE-3 42.85, while also reducing cost relative to EduAgent and Agent4Edu; on DBE-KT22 with GPT-3.5, the reported runtime and cost are 3h52m and \$M_{LT}^i(t+1) = f(M_{LT}^i(t), H_t^i)$947.5 for EduAgent and 6h30m and \$62.7 for Agent4Edu (Gao et al., 13 Jun 2026). The self-learning PNN-based LearnerAgent reports conversation perplexity dropping from 28.4 to 22.1, coding perplexity 19.8, code completion accuracy 0.85, and only +0.2 Task-1 perplexity degradation after Task 2, whereas a standard Transformer baseline degrades to 35.6 after learning the second task (Sivakumar et al., 3 Apr 2025).

Psychologically grounded simulations are evaluated longitudinally. In the year-long LearnerAgent study, only the Deep Learner is reported to achieve sustained cognitive growth, while trap questions diagnose the Surface Learner’s shallow knowledge and the General Learner develops surprisingly high self-efficacy despite cognitive limitations (Yuan et al., 7 Aug 2025). Debate metrics further differentiate profiles: Deep shows Persuasion 15.0%, Resist Wrong 98.4%, and Accept Correct 19.2%; Surface 8.38%, 96.4%, and 22.1%; Lazy 7.13%, 86.9%, and 17.1%; and General 12.0%, 90.9%, and 19.1% (Yuan et al., 7 Aug 2025). AgentSchool reports that structured student agents produce more differentiated mastery and misconception traces than a baseline simulator, and that teacher-agent comparisons show backbone-dependent patterns consistent with ZPD-informed adaptation (Ye et al., 28 May 2026).

6. Limitations, misconceptions, and open problems

A central conceptual tension in the LearnerAgent literature is the distinction between realistic performance and actual learning. Agentivism states this most directly: under generative and agentic AI, successful task completion can no longer be assumed to indicate durable understanding, weaker judgment may coexist with effective AI-supported output, and process measures during interaction may predict learning better than product quality alone (Yan et al., 9 Apr 2026). This directly qualifies an overly common interpretation of learner simulation results: a simulator that matches response traces or correctness distributions is not thereby a model of durable human capability.

A second limitation is external validity. Several systems report narrow domain scopes, small cohorts, or missing statistical controls. ALIGNAgent is validated on two undergraduate CS courses with 14 and 11 students and reports no formal significance tests (Tokoli et al., 22 Jan 2026). ExpertAgent reports user-acceptance scores but no hallucination-rate, learning-gain, or large-scale longitudinal results (Zhu et al., 8 Oct 2025). The psychologically grounded year-long LearnerAgent is limited to English grammar, while EduAgent centers on slide-based machine-learning lectures with AOI-grounded gaze and motor traces (Yuan et al., 7 Aug 2025, Xu et al., 2024). Edu-Theater depends on concept annotations and NeuralCD quality, and AgentSchool explicitly notes LLM-backbone sensitivity and only preliminary validation of classroom social phenomena (Gao et al., 13 Jun 2026, Ye et al., 28 May 2026).

A third limitation is systems engineering. CoderAgent cites API cost and sampled subsets; Edu-Theater is designed partly to reduce the LLM-call burden of individual-centric simulators; LectūraAgents notes latency and compute overhead from multi-agent orchestration and reliance on offline heuristics for TASA; the PNN-based self-learning agent does not report LoRA rank, placement, or exact EWC hyperparameters (2505.20642, Gao et al., 13 Jun 2026, Sesay et al., 15 Jun 2026, Sivakumar et al., 3 Apr 2025). These are not merely implementation details: they shape what kinds of learner state can be maintained, how often adaptation can occur, and whether a system can support classroom-scale deployment.

A fourth limitation is normative. Several papers are motivated by privacy regulations, sparse data, or the ethical difficulty of live experimentation, but dedicated safety and fairness analyses are often thin. Agent4Edu anonymizes personal identifiers and motivates simulation partly by the offline–online gap (Gao et al., 17 Jan 2025). ALIGNAgent notes the risk that preference-aware recommendation may reinforce modality preferences that are not optimal for learning (Tokoli et al., 22 Jan 2026). LectūraAgents highlights bias in personalization and the need for educator-in-the-loop validation (Sesay et al., 15 Jun 2026). AgentSchool argues that simulators optimized only to reproduce existing classrooms may structurally penalize institutional novelty, an issue that becomes sharper when LearnerAgent is used for counterfactual policy testing (Ye et al., 28 May 2026).

Taken together, these papers suggest that the most consequential open problem is not merely building a more realistic learner simulator. It is building LearnerAgents whose internal state is inspectable, whose adaptation is pedagogically meaningful, whose outputs can be evaluated under reduced support and delayed transfer, and whose use in educational decision-making does not confuse plausible traces with verified learning outcomes [260