100xprompt remembers what matters across sessions and stays focused through long tasks - while you control what it keeps. You stop re-explaining your stack, your conventions, and last week’s decision every time you open the project. Two capabilities do this work. Memory carries durable facts between conversations. Long context keeps a single long task coherent as its history grows. This page covers both, plus the commands and settings that put you in charge.

​
Understand the two abilities

Keep the two capabilities separate - they solve different problems.

Memory

Durable facts and preferences that carry across sessions - your preferred language, your team’s conventions, the shape of your project.

Long context

Staying focused within a single long task - condensing older back-and-forth so a big job can keep going without stalling.
Memory decides what survives between conversations. Long context keeps one conversation coherent as it grows. Together they make 100xprompt feel like it already knows your project and never loses its place.

​
Carry context across sessions with Memory

Suppose you told 100xprompt yesterday that your team uses pnpm, not npm. Today it should already know. Tell it something durable about how you work - “our API errors always return a typed result,” “I prefer terse commit messages” - and it holds on to that and brings it back the next time you open the project. You stop repeating yourself, and its suggestions arrive already shaped to your world.
Memory is yours, not a project’s. Durable facts about you and how you work - your preferred language, your conventions - carry across every project you open, so you set them once. Notes tied to a specific codebase (its context, its decisions) are tagged to that project and only resurface when you’re working in it.

​
See how remember and recall work

You say something once. Later, 100xprompt acts on it without being reminded. Only what’s relevant to the current task comes back into focus, so memory helps rather than clutters.

​
Tell it to remember or forget

No special syntax. Plain language works.
1

Ask it to remember

Say something like “Remember that we deploy from the release branch” or “From now on, prefer functional components.” 100xprompt saves it as a durable memory so it survives into later sessions.
2

Let it pick things up on its own

When you state a clear, lasting preference in the natural course of work, 100xprompt can note it without being asked. These are always facts about your project and how you work - never anything you’d consider private.
3

Ask it to forget

Changed your mind? Say “Forget that we use Yarn” or “Don’t remember my old team size anymore.” The note is dropped and won’t come back in future sessions.
100xprompt will not store secrets or sensitive data - API keys, tokens, passwords, credentials, or personal contact and payment details - even if they come up in conversation. Memory is for durable project facts and preferences, not confidential information.

​
Know where your memories live

Your memories are stored locally on your machine, in your personal 100xprompt data - not in any single repo. Short facts are kept as simple entries; richer notes are saved as plain-text files you can open, edit, or delete by hand. They’re yours, they stay on your machine, and you can inspect or clear them whenever you want. Nothing about memory requires shipping your work somewhere else to be remembered.
Because memory lives with you rather than with a repo, the facts you teach 100xprompt about yourself follow you into every project. Notes about a particular codebase are tagged to it and only come back when you’re in that project.

​
Stay on track through long tasks with Long context

Big tasks produce a lot of conversation - files read, commands run, decisions made, dead ends explored. As that history grows, 100xprompt keeps working by condensing older context automatically. It compresses the earlier parts of the conversation into a faithful summary and preserves the recent, active details, so the task continues instead of stalling. You usually won’t think about this. It happens on its own as a session gets long, and the work keeps moving.

​
See how condensing keeps a session coherent

The recent turns - where the live work is happening - stay in full detail. The important facts and decisions from earlier carry forward in the summary. What gets compressed is the bulk that’s no longer needed verbatim.

​
Condense on demand

You don’t have to wait for automatic condensing. Two commands trigger it yourself, and each takes an optional instruction to steer what’s kept:
CommandWhat it does
/compactCondenses the current session’s history so a long task can keep going. Add an instruction to guide it, e.g. /compact keep the auth refactor details.
/summarizeCondenses the session with optional instructions - a quick way to reset focus while carrying the essentials forward.
Reach for /compact right before starting a big new phase of a long task. Condensing at a natural boundary - after a feature lands, before the next one begins - keeps the most relevant context front and center.

​
Control what it keeps

Memory and automatic condensing can each be tuned to match how you work. Memory settings live under a memory section in 100xprompt.json; every part is on by default, so you only add what you want to turn off. 
{
  "memory": {
    "enabled": true,
    "extraction": true,
    "consolidation": true,
    "recall": true
  }
}
ControlTypeEffect
memory.enabledSettingMaster switch for memory. Set to false to turn the whole feature off - nothing is recorded, recalled, or brought into context.
memory.extractionSettingWhether 100xprompt notes new durable facts on its own as you work. Set to false to stop it recording anything unprompted.
memory.recallSettingWhether saved memories are surfaced into new sessions. Set to false to keep them on disk but ignore them.
HUNDREDXPROMPT_MEMORY_DISABLEDEnvironment variableTurns memory off entirely for a run - nothing is recorded and nothing is recalled. Takes precedence over the config.
HUNDREDXPROMPT_DISABLE_MEMORY_RECALLEnvironment variableLeaves recording on but stops memories being recalled into sessions for that run.
HUNDREDXPROMPT_DISABLE_AUTOCOMPACTEnvironment variableDisables automatic condensing so history is only condensed when you run /compact or /summarize.
<leader>cKeybindingCompacts the current session from the keyboard.
Turning memory off doesn’t erase anything you’ve already saved - it simply stops recording and recalling. To remove a specific note, ask 100xprompt to forget it, or clear your saved memories directly.

​
Keep control of your data

Memory is about you and your work - and you stay in control.
  • Memories are stored locally on your machine, in your personal 100xprompt data - not shipped anywhere to be remembered.
  • Facts about you follow you across projects; notes about a specific codebase are tagged to it and only resurface there.
  • 100xprompt records durable, work-related facts - never secrets, credentials, tokens, or personal contact and payment details.
  • You can tell it to remember or forget anything in plain language, at any time.
  • You can turn memory off whenever you want, and existing notes stay untouched until you clear them.
Continuity should feel helpful, never intrusive. If a note no longer fits how you work, say the word and it’s gone.

Settings

Configure 100xprompt, including memory and session behavior.

Rules

Set standing instructions and conventions that guide every task.

Codebase Understanding

See how 100xprompt reads your repo to build precise, relevant context.