Skip to article frontmatterSkip to article content
Site not loading correctly?

This may be due to an incorrect BASE_URL configuration. See the MyST Documentation for reference.

Memory for Longitudinal Coaching

Memory for longitudinal coaching

A system that only sees the current take can critique what just happened. It cannot notice that the same passage has been unstable for three weeks, that improvement follows rest days, or that a student responds better to analogy than to metronome talk. Educational LLM-agent surveys therefore treat memory as a first-class module alongside tools and planning Chu et al. (2025): short-term interaction state plus longer-term learner knowledge, summarised and retrieved rather than pasted into the prompt.

A survey of agent memory mechanisms sorts systems by source, form, and operation, and it is the operations, writing and consolidating and forgetting, where systems differ most Zhang et al. (2024). Reading and writing are not symmetric. Reading memory means putting some text into the prompt, writing it means asking a model to decide what is true about a student. If that decision is wrong, every later session starts from the wrong place.

How general agents handle memory

LLM Agents keeps a list of observations and periodically runs reflection: a model call that reads recent observations and writes higher-level statements about the person back into the list Park et al. (2023). MemoryBank gives each memory a strength that decays along the Ebbinghaus curve and keeps a running portrait of the user Zhong et al. (2024). Codex CLI’s memory code is open source OpenAI (2026), showing a profile document goes into every prompt. After each session, one model call extracts a record and a second merges it into the profile, working from a version-controlled diff.

A write path running left to right from session log through extract and consolidate into a learner profile, each stage costing a model call, above a read path in which the profile is injected into the session prompt with no model call.

Figure 1:The Codex write and read paths OpenAI (2026). Reading is a prompt injection every session. Writing is two offline model calls, and is where claims about the learner get made.

Reflection and the user portrait both turn events into claims about a person. Neither paper checks whether the claims are correct, and in a simulated town or a chat companion a wrong one costs little.

How tutoring systems handle memory

DeepTutor builds its learner profile in layers: raw interaction traces become curated facts, and curated facts become a short profile. Because each layer points at the one below it, you can ask why the profile says what it says Zhao et al. (2026). The useful idea is a memory you can audit, rather than an embedding of everything that ever happened.

A ring labelled agent loop with Chat, Solve and Mastery Path inside it, connected to six boxes: sub-agents, memory with three layers labelled raw event traces, per-capability summaries and cross-surface memory, knowledge bases, skills, and personal context.

Figure 2:DeepTutor’s engine Zhao et al. (2026). The memory box, bottom left, holds the three layers: raw event traces, per-capability summaries, and the cross-surface profile the agent loop reads. Memory sits beside tools, skills and knowledge bases as one shared module rather than inside any single capability.

ScaffoldLM assesses every turn before it updates memory Li et al. (2026). The memory holds the plan, a progress flag for each step, and the dialogue history. Every turn goes into the history together with the inferred student state, such as correct, confused or off-topic. Only the progress flag waits for the assessment: a step is marked done when the student’s answer meets that step’s target. This memory covers one math problem and does not carry over to the next session.

Skill model from a practice agent’s memory

How to represent, organize, and corordinate the sheer amount of memory that the student created on the longitudinal arc? We hypothesize that, for a practice agent, the centre of memory is a skill model built from the record of attempts. Querying and writing memory serve it (Figure 3).

A three-row table. Rows: skill model from memory, querying the memory, writing into memory. Columns: how agent systems implement it, and what it means in a practice agent.

Figure 3:A practice agent’s memory: the skill model, then querying and writing, with how published systems implement each and the practice-agent version.

Skill model from memory. Knowledge tracing keeps a probability per skill and updates it after every attempt Corbett & Anderson (1994), Piech et al. (2015). LLM tutors are starting to keep it beside their text memory. TutorLLM conditions an LLM tutor’s answers on the learning state a knowledge-tracing model predicts (Figure 4) Li et al. (2025), and Scarlatos and colleagues use an LLM to label the skills in each dialogue turn so that knowledge tracing can run on tutoring conversations Scarlatos et al. (2025).

TutorLLM architecture. A table of interactions with user id, item id, correctness and skill id feeds a knowledge-tracing model whose output, the students' learning state, goes to a retrieval-augmented LLM together with a knowledge database; the LLM talks to the student through a plugin.

Figure 4:TutorLLM Li et al. (2025). The interaction log (bottom left) is the memory; knowledge tracing turns it into a learning state that the LLM reads beside the retrieved course knowledge. Figure from the paper, CC BY 4.0.

Music already has such state. SingPAD scores every sung note against pitch and rhythm concepts, and deep knowledge tracing predicts the next note at 0.83 AUC against 0.69 for Bayesian knowledge tracing Zhang et al. (2024). Yousician keeps 433 guitar skills per student at four forgetting rates and uses them to predict how a student will do on an unplayed song Müllerschön et al. (2025).

Querying the memory. MemGPT splits memory the way an operating system does: a small working context sits in the prompt and the model edits it, while the full history lives outside and is searched by function call Packer et al. (2023). For a practice agent the prompt holds a short profile: the current pieces, goals, and what the teacher has asked for. The analysis of each take stays outside. When the agent searches it, Generative Agents’ scoring applies: each memory is ranked by recency, importance and relevance, with importance rated by the model when the memory is written Park et al. (2023). For a practice agent, relevance means the same piece and passage, possibly technique, and an instruction from the real teacher should outrank hypothesis.

Writing into memory. Mem0 Chhikara et al. (2025) extracts candidate facts from each new exchange, fetches the most similar stored memories, and has the model choose ADD, UPDATE, DELETE or NOOP for each. Zep Rasmussen et al. (2025) stores when each fact became true and when it stopped being true, so a contradicting fact closes the old one instead of sitting beside it. A practice agent needs the second behaviour, with the old fact kept: when bar 12 is finally played clean, “rushes bar 12” gets an end date, and the three weeks of rushing stay in the history the skill model reads.

Open problems

Evaluation: Long-term memory benchmarks measure whether a system can recall facts from earlier conversations Maharana et al. (2024), and DeepTutor’s TutorBench measures tutoring against a learner profile Zhao et al. (2026). PAST-Bench comes closest. It runs a personal agent through 204 ordered episodes across 26 scenarios with retained experience switched on and off, and scores memory, reuse of tool routines, information gathering, and replacing outdated state Xue et al. (2026). Gains were uneven, and agents with the same gain often got it without the save, retrieve, update path the benchmark was built to measure. None of the three fits. A practice agent writes memory from audio analysis rather than from conversation, and the question is not whether it can recall what it wrote. The question is whether what it wrote was true of the student. We are not aware of a public dataset that follows learners over months with both recordings and teacher notes, which is what checking that would take.

References
  1. Chu, Z., Wang, S., Xie, J., Zhu, T., Yan, Y., Ye, J., Zhong, A., Hu, X., Liang, J., Yu, P. S., & Wen, Q. (2025). LLM Agents for Education: Advances and Applications. Findings of the Association for Computational Linguistics: EMNLP 2025, 13782–13810. 10.18653/v1/2025.findings-emnlp.743
  2. Zhang, Z., Bo, X., Ma, C., Li, R., Chen, X., Dai, Q., Zhu, J., Dong, Z., & Wen, J.-R. (2024). A Survey on the Memory Mechanism of Large Language Model based Agents. arXiv Preprint arXiv:2404.13501.
  3. Park, J. S., O’Brien, J. C., Cai, C. J., Morris, M. R., Liang, P., & Bernstein, M. S. (2023). Generative Agents: Interactive Simulacra of Human Behavior. Proceedings of the 36th Annual ACM Symposium on User Interface Software and Technology (UIST). 10.1145/3586183.3606763
  4. Zhong, W., Guo, L., Gao, Q., Ye, H., & Wang, Y. (2024). MemoryBank: Enhancing Large Language Models with Long-Term Memory. Proceedings of the AAAI Conference on Artificial Intelligence, 38, 19724–19731.
  5. OpenAI. (2026). Codex CLI. https://github.com/openai/codex
  6. Zhao, B., Zhang, J., Ren, X., Guo, Z., Chu, T., Ma, Y., & Huang, C. (2026). DeepTutor: Towards Agentic Personalized Tutoring. arXiv Preprint arXiv:2604.26962.
  7. Li, Z., Zhu, Q., Wang, M., Li, J., & Huang, H. (2026). Planning-Guided Tutoring with Assessment-Driven Memory for Pedagogical LLM Tutors. Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 7165–7188. 10.18653/v1/2026.acl-long.325
  8. Corbett, A. T., & Anderson, J. R. (1994). Knowledge Tracing: Modeling the Acquisition of Procedural Knowledge. User Modeling and User-Adapted Interaction, 4(4), 253–278.
  9. Piech, C., Bassen, J., Huang, J., Ganguli, S., Sahami, M., Guibas, L., & Sohl-Dickstein, J. (2015). Deep Knowledge Tracing. Advances in Neural Information Processing Systems, 28.
  10. Li, Z., Yazdanpanah, V., Wang, J., Gu, W., Shi, L., Cristea, A. I., Kiden, S., & Stein, S. (2025). TutorLLM: Customizing Learning Recommendations with Knowledge Tracing and Retrieval-Augmented Generation.
  11. Scarlatos, A., Baker, R. S., & Lan, A. (2025). Exploring Knowledge Tracing in Tutor-Student Dialogues using LLMs. Proceedings of the 15th International Learning Analytics and Knowledge Conference (LAK). 10.1145/3706468.3706501
  12. Zhang, Y., Zhang, Y., Xu, W., Wang, Z., & Sun, J. (2024). SingPAD: A Knowledge Tracing Dataset Based on Music Performance Assessment. Proceedings of the 17th International Conference on Educational Data Mining (EDM), Short Papers. 10.5281/zenodo.12729828
  13. Müllerschön, M., Klapuri, A., Rodriguez, M., & Cardin, C. (2025). Playability Prediction in Digital Guitar Learning Using Interpretable Student and Song Representations. Proceedings of the 26th International Society for Music Information Retrieval Conference (ISMIR), 631–637. 10.5281/zenodo.17811448
  14. Packer, C., Wooders, S., Lin, K., Fang, V., Patil, S. G., Stoica, I., & Gonzalez, J. E. (2023). MemGPT: Towards LLMs as Operating Systems.
  15. Chhikara, P., Khant, D., Aryan, S., Singh, T., & Yadav, D. (2025). Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory.