MIRA is redesigning how people interact with AI memory!

AI Memory is a Black Box

Large language models, such as ChatGPT and Claude, are beginning to introduce persistent memory features that store information about users’ preferences, goals, and past interactions. These systems handle increasingly complex personal contexts over time. However, the way this information is stored and used is largely invisible to users, which often leads to confusion when responses appear inconsistent—sometimes the system remembers certain information and sometimes it does not, while users have no clear way to see what has been stored, how it is structured, or when it influences the generated response.

Problem:

Users repeatedly restate context across sessions
Users cannot easily correct incorrect memory
Users cannot understand why AI responses change

We envision a transparent memory layer that reduces repetitive feedback, improves context persistence, and gives users greater control over how AI remembers and uses information.

So we proposed MIRA! MIRA = Memory + Iterative Refinement Agent

MIRA is a persistent memory layer that:

Stores structured knowledge
Retrieves relevant context
Adapts through user feedback
Reduces repetitive prompts
Improves memory transparency

The underlying memory infrastructure was developed by our algorithm teammates. Technical details are available in our GitHub repository

MIRA goes beyond chat.
It enables a self-evolving AI memory system.

While the underlying algorithm enables persistent AI memory, the current interaction design still presents several usability barriers. To better understand these challenges, I conducted a heuristic evaluation using a selected subset of Nielsen’s usability principles and identified several opportunities for improvement.

Heuristic Evaluation of Current LLM Memory Layer

Usability Heuristic

Visibility of System Status

Match with Real-world Expectations

User Control and Freedom

Consistency

Recognition
Rather Than Recall

Flexibility and Efficiency of Use

Error Recovery

Current LLM Memory
Premium users can see which conversation a memory was created from. However, the process by which memories are retrieved and used during AI responses remains opaque, limiting users’ understanding of how stored memories influence system behavior

Memories are stored in natural language, but they are presented as a flat list of entries without clear structure or categorization

Memory management is largely system-controlled. Users have limited ability to configure stored memories (e.g., editing, adjusting importance, or versioning) beyond deleting them

While the memory interface maintains visual consistency, the underlying memory recording mechanisms are inconsistent. Both session-based and persistent memory are used in the system, which can lead to unpredictable AI responses

Users often need to restate context and preferences across conversations

Users can search for specific memory entries, but the interface lacks efficient navigation mechanisms for quickly scanning or reviewing stored memories

When incorrect or outdated memories are stored, users have limited ways to correct or refine them

Design Opportunities
Make memory retrieval transparent by explicitly indicating which memory items are accessed or referenced when generating AI responses

Organize memories into structured categories aligned with how people naturally organize information.

Provide users with greater control over memory management, including editing, adjusting importance, or organizing memory entries

Consistently using cross-section persistent memory (MIRA) to improve response stability

Surface previously stored memories or context cues so users can easily recognize existing information

Provide efficient navigation and overview tools for browsing memories, such as structured summaries, filters, or visual memory navigation

Allow users to easily correct inaccurate memories

Current Memory Interface Features

The current memory interface provides only a limited set of interactions,
mainly supporting browsing, sorting, and basic memory management.

Browsing Memories

Sorting Memories

System-Level Memory Management

Individual Memory Management

Key Design Directions

Feature 1:
Structured Memory Organization:

Memories should be organized into meaningful structures. For each memory item, it should include:

labels for categorization
a short summary for quick understanding

This helps users better understand and navigate stored memories.

Feature 2:
Editable Memory Nodes:

Memories should not remain static prompts. Instead, memory nodes should evolve through user interaction.
Users should be able to:

adjust the weight or importance of a memory
edit memory content
merge redundant memory nodes

The system should also automatically update memories based on user behavior and feedback.

Feature 3:
Transparent Memory Interaction:

Users should be able to clearly see how stored memories are retrieved and influence AI responses.

For each memory item, users should be able to view:

which conversation the memory came from
how the memory has changed over time

Design Rationale: QOC Analysis

To translate the key design directions into actual interface features, I explored multiple design alternatives using the QOC (Questions–Options–Criteria) framework. In this framework, Questions represent the design challenges, Options describe possible solutions, and Criteria are used to evaluate these options. When assessing the options, solid lines indicate that an option supports a criterion, while dashed lines indicate that an option does not support or only partially satisfies it. This analysis helps me to visualize the trade-offs between different design alternatives.

Feature 1:
Structured Memory Organization:

a short summary for quick understanding

labels for categorization

Feature 2:
Editable Memory Nodes:

adjust the weight or importance of a memory

edit memory content

merge redundant memory nodes

Feature 3:
Transparent Memory Interaction:

Users should be able to clearly see how stored memories are retrieved and influence AI responses

which conversation the memory came from

how the memory has changed over time

Since we are targeting desktop, we chose Inline Toggle. Clicking a summary card expands its detail in place. This preserves scan speed and keeps detail access effort low, at the cost of screen real estate, which is an acceptable trade-off on desktop, where vertical scrolling is low-friction and the wider viewport helps users maintain their position in the list.

Similarly, since we are targeting desktop, we chose Always Visible Colored Chips. The sufficient screen real estate allows us to trade some space efficiency in exchange for higher label discoverability, readability, and glanceability. To partially offset the space cost, we cap the display at two chips per card, with any additional labels collapsed into a +N indicator.

For tag interaction, we chose both Filter and Edit. Clicking a chip filters the memory list by that category, and users can also delete existing tags or add new ones within the tag library.

Although this introduces slightly more interaction complexity, it enables richer functionality and keeps filtering and editing intuitive and low-friction, giving users greater control over their memories.

For adjusting memory weight, I chose Positive / Negative toggle. In practice, users adjust weight for a simple reason: either the system is over-relying on a memory that feels unimportant, or under-relying on one that feels significant. This is fundamentally a binary judgment, making precise numeric control unnecessary and potentially anxiety-inducing, as users have no meaningful basis for choosing between, say, a weight of 70 versus 80.

Most importantly, Positive / Negative directly matches users' mental model of how they want to influence the system, and can be reversed at any time.

I chose the side panel for editing memory content, as it satisfies all three criteria: preserving context by keeping the memory list visible, while offering both editing flexibility and discoverability.

Clicking the edit button on a memory card slides in a panel from the right. Users can edit the memory content directly in the text field, then confirm via a Save button, which triggers a success toast to confirm the update. A Cancel option is available to discard any changes.

For merging memory nodes, System Suggests Merge meets all three criteria. Since identifying redundant memories involves comparing across the entire list at a semantic level, this task is better handled by the system than the user, significantly reducing cognitive effort. At the same time, merging is a destructive operation, so user confirmation is essential to retain user control and ensure accuracy.

To let users clearly see how stored memories are retrieved and influence AI responses, we adopted an on-demand display strategy. Since users only want to investigate which memories influenced a response when they have concerns, displaying references only when actively requested keeps the interface clean while respecting user agency.

The primary trade-off is entry point visibility. To relive this, I placed a contextual toolbar below each AI response containing a dedicated button with an explicit tooltip, ensuring the entry point is discoverable without cluttering the conversation interface.

For viewing the source conversation, I chose to place it inside the side panel. Since source information is only relevant when a user is actively inspecting a memory, placing it inside the panel is the most natural fit. Although this reduces immediate accessibility, it avoids burdening users with information they did not ask for, keeping their mental effort focused on what actually matters.

For viewing memory change history, we placed it as a dedicated tab within the side panel. Given that change history is sequential and structured, the panel provides sufficient space to present it clearly, ensuring high readability. While a dedicated changelog page might offer even more room, as most LLM products currently do, the additional navigation required to reach it introduces unnecessary friction.

System Flow

Based on the design decisions derived from the QOC analysis, it forms a system flow of MIRA. The system flow of MIRA contains three areas: an onboarding flow that guides users from the home page to the main interface, an AI chat flow where the memory feedback loop takes place, and a memory management flow where users can actively inspect and refine their stored memories.

Wireframe Design

Key Feature Wireframe Interfaces

The following wireframes illustrate the key interaction surfaces of MIRA, comparing the current LLM memory experience with the redesigned interface. Showing how the design decisions derived from the QOC analysis translate into concrete UI.

Feature 1:

Structured Memory Organization:

Memories are organized into structures.
Each memory item includes:

labels for categorization
a short summary for quick understanding

Feature 2:
Editable Memory Nodes:

Memory nodes evolve through user interaction.
Users can:

adjust the weight or importance of a memory
edit memory content
merge redundant memory nodes

Feature 3:
Transparent Memory Interaction:

Users can clearly see how stored memories are retrieved and influence AI responses.
For each memory item, users can view:

Which conversation did the memory come from
How the memory has changed over time

Current LLM, Browsing Memories

After Redesign, Browsing Memories

Current LLM, Memory Node Interaction

After Redesign, Memory Node Interactions

Visible and adjustable retrieved memory in response

Visible memory provenance and evolution

Wireframe Workflow

This interaction flow demonstrates how MIRA integrates AI interaction, memory inspection, and feedback-driven learning into a continuous workflow that evolves over time.

Hi-fi Interfaces Design

Building on the wireframes, I explored multiple visual directions and color palettes to define the overall interface language of MIRA, to better express the product’s identity. I compared different highlight colors, background treatments, and interaction states to understand how each direction shaped the perceived tone of the product. Some versions felt more futuristic and expressive, while others emphasized calmness, legibility, and system transparency. The designs shown here highlight the final visual direction selected by the team, which we felt best balanced a sense of intelligence, softness, and usability.

High-fidelity interfaces helped us evaluate how the system would feel in actual use. By adding color, typography, emphasis states, and more polished component treatments, we were able to test how the interface could communicate clarity, trust, and adaptability across different parts of the experience, including AI interaction, memory browsing, and account settings.

This final color system feels lightweight enough for long-term use, while still giving enough visual distinction to help users notice interactive states, memory structures, and key actions without overwhelming the workspace.

Working Prototype MiraMemoria.com

The working prototype was used as a high-fidelity interface for early design evaluation through scenario walkthroughs and interactive prototype testing.

Ongoing Testing & Evaluation

To further validate the interaction model of MIRA, we are currently recruiting early users to participate in prototype testing. We're aim to observe how people interact with the interface in realistic workflows while also evaluating the reliability of the underlying memory update mechanisms.

At this stage, the evaluation focuses on three key questions:

Does user understand how memory evolves over time?
Can users easily inspect and edit stored memory?
Does the interface reduce the need to repeatedly provide context during AI interaction?

In addition to observing interaction behaviors, these early trials also help us evaluate several system-level aspects, including:

the robustness of the feedback-to-memory conversion process
how users navigate and manage evolving memory structures
how the interface supports long-term collaboration between users and AI systems

Early Observations
Through scenario walkthroughs and interactive prototype testing, we made several early observations about how users understand and interact with MIRA’s evolving memory system.

Memory visualization helps users better understand how AI reasoning evolves across interactions.
Editable memory increases perceived transparency and trust in the system.
Integrating memory controls directly within the AI workspace reduces cognitive switching during interaction.

These observations will help guide future iterations of both the memory infrastructure and the interface design as the system continues to evolve. We are excited to continue refining MIRA and appreciate your interest in following the development of the project.