Beijing University of Posts and Telecommunications, Tsinghua University, and Shanghai Jiao Tong University jointly developed the MemSlides system to address challenges in personalized and iterative revision of AI-generated presentations. The system retrieves user profile memories during initial generation, influencing page organization and expression based on user preferences. It also incorporates working memory to store temporary constraints for the current task, ensuring delayed preferences remain effective. Through a Plan-Act-Guard process, it enables precise local edits while preventing changes from propagating across the entire document. Experiments show that tool memory increases editing convergence rate by 2.27 times and reduces core tool time to 0.327 times. The system was named Hugging Face Daily Papers’ Paper of the Day and has received over 400 stars on GitHub. This research offers valuable insights into memory management for agents in long-duration tasks.Author and source: AI New Era
The most awkward moment is often not when the AI PPT generation fails.
Instead, it has already generated a fairly good set of slides, and you simply say: "Make the bottom-right section on page 8 look more like a flowchart."
The next second, page 8 might have changed, but the heading hierarchy on page 3 shifted, and the color scheme on page 12 drifted off—everything you carefully refined earlier was thrown out of sync again.
This is a more common pain point in real-world PPT workflows.
The first draft is just a preliminary version; the revisions are where the real work happens.
From "generate a set" to "generate like this user"
Over the past few years, automated slide generation has made significant progress. Many systems can now generate well-structured, visually decent drafts from papers, product descriptions, or even a single topic sentence.
But in real-world use, the key point of the first version of the slides isn't just whether it was generated, but whether it already aligns with a specific user's expression habits.
The same Transformer paper can be presented as an introductory lesson, a team meeting presentation, a paper deep-dive, or a technical training session. Different users care about distinct page roles, content density, boundaries of evidence, and ways of elaborating mechanisms. Some prefer to start with conclusions and key takeaways, while others want definitions, mechanisms, and boundary conditions clearly broken down.
This is precisely the role of user profile memory in the round-0 stage.
MemSlides, developed collaboratively by Beijing University of Posts and Telecommunications, Tsinghua University, and Shanghai Jiao Tong University, does not wait for users to make multiple revisions before beginning to "remember." Instead, during the first generation, it retrieves user profiles based on the current task intent and routes compatible long-term preferences into the current working memory to influence page organization and presentation.
Paper link: https://arxiv.org/abs/2606.17162
Project homepage: https://memslides.github.io/
Demo link: https://memslides.com/
Code link: https://github.com/huohua325/Memslides
HF link: https://huggingface.co/papers/2606.17162
This work was named Hugging Face Daily Papers' Paper of the Day, has garnered over 400 stars on GitHub, and its demo website has attracted over 100 verified users to try it out.
Figure 1 does not depict a generic "rendered effect." Instead, it illustrates how the system breaks down paper content into sections such as definitions, core mechanisms, experimental evidence, common misconceptions, and boundary conditions. These choices reflect user preferences regarding content structure, information density, and evidence-based presentation.
Figure 1: The first-round generation demonstrates not only completeness but also the impact of user profile memory on page organization, content density, and evidence boundaries.
The project also offers an online demo. Users can upload materials, select a memory profile or template, generate a draft, proceed to revision, and download the current version as a PPTX, HTML, or PDF file.
In other words, MemSlides covers the entire process from personalized drafts to ongoing revisions.
Once the first version begins to align with users, subsequent questions become more pointed: Can the system continue to preserve these preferences through multiple rounds of revisions? Will requests made temporarily in the current session lose their effect after a few rounds? When a user only wants to modify a localized area, can the system avoid disrupting previously aligned sections of the page?
Divide the memory workload
Many people, upon hearing "Agent memory," naturally think: just put the historical conversation into a longer context.
MemSlides did not do this.
The reason is simple: the longer the history, the more conflicts it contains. Today, a user saying “use blue headings for this report” doesn’t mean all their future PPTs should have blue headings; a tool error encountered during one editing session shouldn’t be mixed with “what style they prefer.”
Therefore, MemSlides models personalized slide generation as a stateful authoring process: the system first generates a round-0 draft based on source materials, user profile memory, and optional templates; subsequent rounds of feedback update the current session state, enabling localized edits around the current deck.
Its memory organization has two perspectives.
From a lifecycle perspective, there is long-term memory and working memory. Long-term memory stores information that remains stable across tasks, while working memory holds temporary constraints, modified objectives, and execution states that are still valid in the current deck.
From a functional perspective, there are user profile memory and tool memory. The former answers, "What preferences should this set of slides reflect?" while the latter answers, "How should the Agent be improved for greater stability?"
In other words, MemSlides doesn’t make the Agent remember more irrelevant details—it helps it determine which information should be retained long-term, which is only relevant for the current task, which reflects user preferences, and which stems from tool experience.
Figure 2: MemSlides organizes long-term memory, working memory, user profile memory, and tool memory into a single multi-round revision workflow.
User profile
True personalization cannot usually be achieved with just a role prompt.
For academic presentations, some prefer to display only one key conclusion per slide, while others retain formulas and experimental details; similarly, for business pitches, some favor dense tables, while others rely more on trend charts and comparison charts.
These differences are not labels from a single prompt, but rather habits that users gradually reveal through prolonged writing and editing.
MemSlides saves cross-task preferences using user profile memory. Instead of appending the entire profile to the front of the prompt, it retrieves relevant preferences based on the current intent at the start of each task and aligns them with the current request.
If long-term preferences are compatible with the current explicit instructions, they will both enter working memory; if there is a conflict, the explicit requirements of these slides take precedence.
This step is crucial. Otherwise, the system may mistakenly interpret "this time I want a blue title" as "the user always prefers blue titles."
After the task is complete, MemSlides does not write back every piece of feedback to the long-term profile. It only retains stable, transferable interaction signals to make the next generation more aligned with the user—not more chaotic.
Figure 3: User profile memory undergoes retrieval, routing, current task utilization, and stabilization of signals after task completion.
Working memory
In multiple rounds of revisions, there is another category of information that is more subtle.
It is not a long-term preference, but it must remain valid within the current deck.
For example, if the user says in the second round: “If new summary/tip boxes are added later, use a light gray background.” At that time, the system had not yet introduced such elements, so this requirement had no immediate target to act upon. Several rounds later, if the user requests the insertion of a page containing a summary box, this rule should be triggered.
If the agent only considers the current input, it may easily overlook these delayed-effect constraints.
MemSlides' working memory serves as the status board for the current writing task: active temporary preferences, carryover instructions, resolved targets, and coverage status are all stored here. The Plan phase reads these states to determine the scope of modifications, the Act phase performs constrained edits based on them, and the Guard phase updates the inspection results accordingly.
This turns multiple rounds of revisions from isolated, individual prompts into a continuous editing process centered around the same set of slides.
Figure 4: Working memory maintains previously proposed but subsequently triggered temporary style preferences.
Only change what needs to be changed.
For human editors, "just change this one spot" is a natural phrase.
For generative systems, this sentence is difficult.
Because many systems re-read or rewrite large sections of content when processing feedback, the target area may be corrected correctly, but non-target pages also change. Users appear to have made a small request, yet the system ends up completely reorganizing the entire PPT.
MemSlides addresses this issue using scoped slide-local revisions.
Each feedback is first mapped to the smallest effective modification area, then enters the Plan-Act-Guard process.
In the Plan phase, convert natural language requests into execution contracts, clearly defining the target slide, scope of impact, selector hints, and coverage requirements.
In the Act phase, select the editing tool based on the page structure and perform the minimum effective action within restricted limits. In the Guard phase, treat “completion” as a state requiring verification: do not hastily finalize if the target is not fully covered, rebind if the snapshot has expired, and do not expand partial requests into a complete deck rewrite.
This step transforms “the model thinks it’s finished” into “the system can verify whether this modification truly covers the target and stays within bounds.”
Figure 5: Plan-Act-Guard breaks down local modifications into scope planning, controlled execution, and outcome verification.
Tool memory
Slide editing is not merely rewriting text.
A local modification may involve changes to the page structure, selectors, style rules, layout snapshots, and validation logic. Even if the agent understands what the user wants, it may misread the target area, engage in repeated trial-and-error, expand the scope of changes, or terminate prematurely before the target has been fully addressed.
Therefore, MemSlides also introduces tool memory.
The tool's memory does not record what users like, but rather what execution paths are effective and which errors to avoid in similar editing tasks.
The paper organizes the content into two granularities: round-scope task experience, which records experiences, error summaries, and transferable patterns from a single round of revisions; and operation-scope tool-chain experience, which stores finer-grained reasoning-tool-observation fragments retrieved as references before similar tool invocations.
This design separates goals from execution.
User profiles determine the direction slides should take, while tool memory helps the agent avoid detours, reducing ineffective exploration and execution uncertainty.
Figure 6: Tool memory focuses on tool invocation experience, not user aesthetic preferences.
Experimental results
MemSlides' evaluation does not provide a single overall generation score; instead, it separately validates the capabilities corresponding to different memory components: user profile memory is assessed through round-0 persona alignment, working memory through delayed preference carryover across multiple turns, and tool memory through isolated validation in a diagnostic matched-pair modify setting.
In personalized generation, user profile memory enhances persona alignment under multi-persona and multi-intent settings. The paper further notes that this improvement is evident not only in becoming "more like a specific template," but also in planning decisions regarding content emphasis, page role, evidence organization, and persona differentiation.
In partial modification pairing diagnostics, the changes brought by tool memory are more direct:
Meanwhile, the core tool time ratio decreased to 0.327x.
Note that these figures come from a diagnostic matched-pair modification setting and should not be interpreted as indicating monotonic superiority in all scenarios. More accurately, they support a procedural conclusion: when tool memory provides reusable execution experience, the Agent is more likely to converge on closed-loop completion, rigorous validation, and identifying the first correct edit path.
Figure 7: Local editing comparison is a qualitative case from the paper, demonstrating the differences in the editing process before and after tool memory injection.
Next steps for PPT Agent
It's a long-term collaboration.
MemSlides discusses PPTs, but the issues behind it extend beyond just PPTs.
When agents undertake long-duration tasks such as document generation, code modification, data analysis, or enterprise knowledge systems, they encounter similar challenges: which information should be retained long-term, which states belong solely to the current task, which execution insights can be reused, and which content must remain unchanged during local modifications.
If one-click generation solves the challenge from 0 to 1, then multiple rounds of refinement test the journey from 1 to usable.
The future Slides Agent will not only generate more beautiful first slides but also continuously understand users and maintain editorial boundaries through iterative revisions, steadily guiding the presentation toward the version the user truly wants.