Does Bolt Remember Between Sessions? Chat Threads, Knowledge, and Short-Term Memory, Explained

Short answer: the project remembers, because the project never goes away. Your code, your chat thread, your version history, and your backups are all still there when you come back tomorrow, so picking the work back up feels continuous. But Bolt does not build a learned memory of you or your decisions the way a memory product does. What carries between sessions is the work itself, plus whatever context you wrote down by hand in its Knowledge settings.

Bolt's own settings page gives the game away. Under Project settings, the Context control is described in one line: clear Bolt's short-term memory of your project. Short-term memory is exactly what Bolt has, and understanding what sits in it, and what sits outside it, tells you what will and will not survive the night.

What actually persists between sessions

The project itself. A Bolt project lives in a workspace, with its files, code, and development environment intact. Reopen it next week and the app is exactly where it was left, preview and all. Bolt even remembers small working choices for you: switch a project to the Max agent and Bolt remembers that selection and uses the same agent the next time you open the project.

One shared chat thread. Every project has a single shared chat thread. Collaborators prompt and edit in the same project at the same time, and the conversation continues in that one thread instead of fragmenting across private chats. The thread is the project's running conversation, and returning to the project means returning to it.

Version history and backups. Bolt keeps a version history you can restore from, and projects are backed up automatically. Restoring a backup creates a fork, a duplicate of the project at that point, without disturbing the current version. The past states of the work are never lost, even when the present one goes wrong.

Knowledge, the part you write. This is Bolt's persistent context, and it is hand-written. Account knowledge holds background instructions Bolt follows across all of your projects: goals, style expectations, terminology, constraints, workflow habits. Project knowledge holds the same kind of context for one specific project. Bolt's skills documentation puts it plainly: knowledge gives Bolt persistent context that applies to every prompt. Skills sit beside it as reusable instructions for specific situations, applied when a prompt matches or when you invoke one by name. Workspace skills can be turned on per project; project skills are stored in the project's code and are always on.

What that list is missing

Nothing on the list was learned automatically. Knowledge persists because someone typed it. Skills persist because someone wrote or imported them. The thread persists because it is a log. None of these is a system that watches the work, extracts what mattered, and carries it forward on its own. A decision reached at the end of a long build session lives in the thread and in the code it produced. If it never made it into the code, the knowledge, or a skill, the next session knows it only as well as a long thread can be re-read.

The working context is explicitly short-term. Bolt separates the two ideas cleanly: knowledge is the persistent layer, and the project's context is short-term memory with a Clear context button attached. Clearing it is sometimes the right move, and that is the point. The live working picture Bolt holds of your project is treated as disposable in a way your hand-written instructions are not.

Knowledge crosses projects only at the account level, and only the part you wrote. Account knowledge follows you across all your projects, which is genuinely useful for style and terminology. But what one project learned while being built, a bug pattern, a data quirk, a customer's constraint, stays in that project unless you promote it into account knowledge yourself. Projects also stay in the workspace where they were created; switching workspaces does not move them, and the context does not travel with you across that line either.

None of it reaches outside Bolt. This is the border that matters once the app is live. The app Bolt built usually ends up wired to scheduled work elsewhere: an n8n workflow processing its signups, a Make scenario sending its follow-ups, a cron agent checking its data overnight. Bolt's thread, knowledge, and skills are invisible to all of that. The scheduled agent starts each run with no idea what was decided in Bolt yesterday, and what it learns overnight is never waiting in the project in the morning.

Three ways to work with the border

1. Treat knowledge as a maintained briefing, not a notebook. Account knowledge for what is true everywhere, project knowledge for what is true of one app, skills for repeatable procedures. Update them when decisions change, because they are the only context guaranteed to be applied to every prompt.

2. Promote decisions out of the thread the day they are made. Anything settled in conversation that a future session must respect belongs in project knowledge or a skill before the session ends. A thread is a record you can scroll, not a guarantee the next session will act on what it finds there.

3. Give the work outside Bolt one shared memory. The automations around the app need memory that is scoped to the work, not to one builder. Vilix AI is a cloud-hosted memory layer that tools connect to over MCP, with zero infrastructure to run. The same memory is available to your chat tools, coding tools, and scheduled agents, so a decision made in one place is present in the next run somewhere else. It stores full conversation history, not just extracted facts, so the actual exchange behind a decision can be revisited later. The free plan is free forever, the 7-day Pro trial needs no credit card, and your memory can be exported or deleted at any time.

The bottom line

Bolt remembers between sessions in the way a well-kept workshop remembers: the project is on the bench where you left it, the conversation is one continuing thread, every earlier version can be restored, and the instructions you pinned to the wall are still pinned. Account knowledge even follows you from project to project.

What Bolt does not keep is a learned memory of the work, and its own settings call the live context what it is: short-term memory. Everything durable had to be written down by someone, and everything written down stays inside Bolt. When context still goes missing, it usually goes missing at that wall, between the builder and the tools and automations doing the rest of the work.