Skip to main content
Lovable remembers what you tell it, so a preference you state once keeps applying. Set a price format, rule out an approach, or correct the tone of your copy, and Lovable saves it. Lovable applies it in later conversations without being reminded. Memory is what Lovable saves as you work. It is the counterpart to Instructions, which you write yourself. Memory is enabled by default on all plans, and you can change or disable what Lovable remembers at any time.

What Lovable remembers about your project

Project memory belongs to one project, and Lovable adds to it as you chat. Everyone who can edit the project uses the same memory, so a teammate’s correction changes what Lovable does for you too. Lovable saves:
  • Preferences for how things should be done, and the corrections you make
  • Approaches you have ruled out, so Lovable does not propose them again
  • Design decisions, such as colors, typography, and tone of voice
  • Business facts, such as prices, rates, opening hours, delivery areas, formulas, and words to avoid
  • Links to references Lovable should use
For example, after a few conversations about a café app, Lovable applies facts such as these:
Technical and architecture decisions, such as which service handles payments or how your app’s pages are organized, are saved in your project files instead. See Rules in your project files.

What Lovable remembers about you

Personal memory is about you rather than any one project. Lovable saves how you want it to work with you: how long replies should be, how technical they can get, and whether it asks before making a small change. Lovable keeps a separate personal memory for you in each workspace, and applies it in that workspace’s projects and in Chats. What Lovable learns about you in one workspace does not carry over to your other workspaces. Each workspace has its own switch for personal memory, in your Memory settings. Disable it in a workspace where you do not want Lovable to use what it remembers about you. Personal memory is yours. Other people on a project cannot read it, and it is never saved into a project’s memory. When personal memory and project memory disagree about a project decision, project memory wins, because it is specific to what you are building.

What Lovable leaves out

Memory is for what still applies after the current task. Lovable leaves out anything it can read in your code, such as file paths and how a feature is built. It also leaves out the details of one build request and the summaries it writes of what it built. If a memory would contain an API key, a token, or a password, Lovable removes the value before saving the rest of the memory. Lovable recognizes only values in a known secret format, such as a provider’s API key, so it can miss other confidential text. Everyone who can edit the project can read what it remembers about that project. Keep personal data and other confidential information out of your messages.

Rules in your project files

Technical and architecture decisions do not go to memory. Lovable writes each one as a short rule, with a one-line reason, in a file named AGENTS.md at the top level of your project. Lovable reads that file when it works on your app. When the main file gets long, Lovable moves its rules that cover one part of the app into a second AGENTS.md beside that part. The main file stays short. Lovable reads the second file when it opens or edits a file in that part of the app. These files belong to your project. Open one in the code editor and edit it as you would any other file. It is included when Lovable syncs your project to GitHub. What Lovable remembers is stored separately, so memory never appears among your project files.

Dreaming: how Lovable keeps memory up to date

What Lovable remembers can go out of date as your app changes. A rule may describe a page you have since removed, or a price you have since changed. On paid plans, Lovable tidies up project memory in the background, a process called Dreaming. Dreaming does not use credits. During Dreaming, Lovable checks what it remembers about the project and the rules in its AGENTS.md files against your code and the project chat. Lovable rewrites what has changed and removes what no longer applies or appears twice. A rule you asked for stays as written, even when your code does not follow it yet. When Lovable later works on that code, it points out the difference and asks whether to keep the rule or change the code. Rules about approaches you have ruled out also stay.
  • Dreaming checks a few memories and AGENTS.md files at a time, starting with those checked least recently. In a large project, Lovable needs several passes to cover everything.
  • Dreaming never changes your app’s code, but it can move rules into a second AGENTS.md, as described in Rules in your project files.
  • Changes to AGENTS.md files show in the project chat and in version history as Lovable tidied up its notes. To see the exact edits, select View code changes on that version.
  • The project’s Memory settings show what Lovable remembers now, but not what Dreaming removed.
  • Dreaming does not change what Lovable remembers about you.
  • Dreaming does not run in projects that use Git sync, in workspaces with EU inference enabled, or in projects with Memory for this project set to Nothing.
To bring back something Lovable removed, tell Lovable in the project chat, or edit the AGENTS.md file in the code editor.

Tell Lovable what to remember or forget

You do not have to wait for Lovable to save something on its own. Say it in the project chat, and Lovable updates its memory while it handles that message:
The same works for a preference about you, such as asking for shorter replies from now on. You can say it in the project chat or in Chats.

See and change what Lovable remembers

On a computer, Account settings → Memory shows what Lovable remembers about you. Pick a workspace at the top to see your memory in it. On a phone, the same page opens under Workspace settings → Memory, for the workspace you are in. In a project, More → Settings → Memory shows what Lovable remembers about that project. Anyone who can edit the project can open that page. When the project’s memory setting is You and this project, the page also shows that Lovable uses what it remembers about you. Manage in Account settings opens that memory. Both Memory settings show a summary that Lovable writes, grouped under a few headings. To change part of it, select the text and choose Change in chat. Lovable opens the project chat with that text attached to an unsent message, and you say what to change. In Account settings, Lovable first asks which project’s chat to use.

Choose what memory Lovable uses

Use memory, in Account settings → Memory, controls whether Lovable uses what it remembers about you in the workspace you pick there. Disable it, and Lovable stops using and saving your personal memory in that workspace’s projects and Chats. Your other workspaces are not affected. Memory for this project, in the project’s Memory settings, has three options:
  • You and this project: Lovable uses what it remembers about the project, and what it remembers about you when Use memory is enabled for the workspace. This is the default.
  • Just this project: Lovable uses what it remembers about the project, and nothing about you.
  • Nothing: Lovable uses no memory in this project and stops saving new memory about it. It also stops adding rules to the project’s AGENTS.md files on its own, and Dreaming does not run for the project. If you ask Lovable to remember something, it tells you that memory is off for this project.
In a project set to Just this project or Nothing, Lovable neither uses nor adds to your personal memory. Neither setting deletes what Lovable has already saved. Neither one changes the rules in your project’s AGENTS.md files. To remove one thing, ask Lovable in the chat to forget it.

Memory or Instructions

Memory and Instructions both give Lovable lasting context, from two different places. Write an instruction when you know the rule up front and want it followed as written: coding standards, brand guidelines, or how your database is organized. Rely on memory for what comes up as you build, and correct it in the chat when Lovable gets it wrong.

FAQ

Everyone who can edit the project. Project memory belongs to the project, so a teammate’s correction changes what Lovable does for you too. What Lovable remembers about you is separate and is not shared with them. See What Lovable remembers about your project.
Lovable wrote it. As you settle technical and architecture decisions, Lovable records them there as short rules, so it keeps applying them. The file is yours to edit. See Rules in your project files.
Lovable updated it because a rule in it no longer matched your code. These changes show in the project chat and in version history as Lovable tidied up its notes. Lovable can also rewrite or remove what it remembers about the project, which is stored outside your project files. To bring something back, tell Lovable in the project chat or edit the file. See Dreaming.
Yes, from the Memory settings. For what Lovable remembers about you, open Account settings → Memory, pick the workspace, and disable Use memory, which covers that workspace’s projects and Chats. For one project, set Memory for this project to Nothing in that project’s Memory settings. To remove one thing, ask Lovable in the chat to forget it. See Choose what memory Lovable uses.
A remix inside the same workspace starts with the original project’s memory. A remix into another workspace starts with none, so the original project’s memory is not copied to people outside your workspace. What Lovable remembers about you is never copied.
In Chats, Lovable uses what it remembers about you, not the memory of any project. Project memory applies in the project chat and when Lovable builds.