Skip to main content
ZeroTwo’s Memory system automatically learns from your conversations and retains important information across sessions. Unlike conversation history (which is limited to individual chats), Memory provides persistent context that enhances all your interactions with the AI.

​
What is Memory?

Memory is ZeroTwo’s intelligent context retention system that stores and recalls relevant information about you, your projects, preferences, and previous conversations. It helps the AI provide more personalized and contextually aware responses without requiring you to repeat information.
Think of Memory as the AI’s long-term knowledge about you and your work—like how a human colleague remembers your preferences, projects, and past discussions.

​
How Memory works

Memory operates through several interconnected systems:
1

Automatic extraction

As you interact with ZeroTwo, the Memory system identifies and extracts important information from your conversations—preferences, facts about your projects, decisions you’ve made, and contextual details.
2

Intelligent storage

Extracted information is stored in structured memory stores, categorized by type (biographical facts, project details, technical preferences, etc.) and associated with relevant context.
3

Contextual recall

When you start a new conversation, Memory automatically retrieves relevant information based on your current query, ensuring the AI has appropriate context without cluttering the conversation.
4

Continuous learning

Memory updates as you provide new information, correct previous details, or as your projects and preferences evolve.
Memory works seamlessly in the background. You don’t need to explicitly “save” information—the system learns naturally from your conversations.

​
Types of memory

ZeroTwo maintains different categories of memory for optimal context management:

​
Biographical memory

Personal information and preferences about you:
  • Your role and expertise level
  • Technologies and tools you use
  • Programming languages you prefer
  • Years of experience in different areas
Example memories:
- "Senior full-stack developer with 8 years experience"
- "Prefers TypeScript over JavaScript"
- "Uses React, Node.js, and PostgreSQL primarily"
  • Company or organization details
  • Team size and structure
  • Current responsibilities
  • Industry or domain focus
Example memories:
- "Works at a fintech startup"
- "Team of 5 developers"
- "Building a payment processing platform"
  • Desired response style
  • Level of detail preferred
  • Technical depth expectations
  • Code comment preferences
Example memories:
- "Prefers concise explanations with code examples"
- "Likes detailed inline comments"
- "Wants security considerations highlighted"

​
Project memory

Information about your active projects:
​
Project details
object
Names, descriptions, and contexts of projects you’re working on.
Example:
- Project: "TaskFlow Pro"
- Description: "SaaS project management tool"
- Tech stack: "Next.js, TypeScript, Supabase"
- Stage: "MVP development"
​
Technical decisions
array
Architecture choices, design patterns, and technology selections you’ve made.
Example:
- "Using Zustand for state management instead of Redux"
- "Chose PostgreSQL for relational data with jsonb for flexibility"
- "Implementing authentication with NextAuth.js"
​
Current challenges
array
Problems you’re working through and their context.
Example:
- "Optimizing real-time collaboration performance"
- "Implementing offline-first architecture"
- "Debugging race condition in WebSocket handlers"

​
Conversation memory

Context from previous interactions:

​
Technical preferences

Your coding style and technical preferences: 
{
  "language_preferences": {
    "primary": "TypeScript",
    "secondary": ["Python", "Go"]
  },
  "code_style": {
    "pattern": "functional programming",
    "naming": "camelCase for variables, PascalCase for components",
    "comments": "detailed for complex logic"
  },
  "frameworks": {
    "frontend": "React with Next.js",
    "backend": "Node.js with Express",
    "database": "PostgreSQL with Prisma ORM"
  },
  "testing": {
    "unit": "Jest",
    "integration": "Playwright",
    "preference": "test critical paths, not trivial code"
  }
}

​
When Memory is used

Memory automatically activates in relevant situations:
When you start a new chat, Memory provides context:
You: "Help me add authentication to the app"

Memory recalls:
- Your app is "TaskFlow Pro" built with Next.js
- You previously chose NextAuth.js
- You use PostgreSQL with Prisma
- You prefer TypeScript

AI response incorporates this context without you repeating it.

​
Memory and privacy

Privacy and control:
  • Memory is stored securely and associated with your account only
  • Memory is not shared between users or across organizations
  • You have full control to view, edit, and delete any memories
  • You can disable Memory entirely if you prefer
  • Memory data is not used to train AI models

​
What Memory doesn’t store

Memory focuses on professionally relevant context:
  • ❌ Sensitive personal information (passwords, API keys, secrets)
  • ❌ Private conversations you mark as private
  • ❌ Financial or health information
  • ❌ Data you explicitly ask not to remember
  • ❌ Temporary or example data
ZeroTwo uses secure storage and encryption for Memory data. See Data and Compliance for complete privacy information.

​
Memory vs. conversation history

Understanding the difference helps you use both effectively:

Conversation History

Scope: Single conversation threadDuration: Exists only within one chatPurpose: Maintain immediate contextLimitation: Forgotten when chat ends or exceeds token limitBest for: Iterating on current tasks

Memory

Scope: All conversationsDuration: Persistent across sessionsPurpose: Long-term context retentionLimitation: Stores key facts, not entire conversationsBest for: Personalization and consistency

​
Using both together

1

Conversation provides immediate context

Your current chat maintains detailed, turn-by-turn context for the active task.
2

Memory provides background context

Memory informs the conversation with relevant background about you and your projects.
3

Memory learns from conversations

Important information from conversations gets extracted into Memory for future use.
4

Conversations reference Memory

New conversations automatically benefit from previously established context.

​
Memory accuracy and updates

Memory evolves as your context changes:

​
Automatic updates

Scenario 1 - Initial learning:
You: "I'm building a todo app with React"
Memory stores: "Building todo app with React"

Scenario 2 - Correction:
You: "Actually, I switched to using Vue instead of React"
Memory updates: "Building todo app with Vue"

Scenario 3 - Addition:
You: "I'm using Supabase for the backend"
Memory adds: "Using Supabase for backend"

​
Explicit corrections

You can explicitly correct Memory: 
"Remember that I prefer async/await over promises"
"Update my profile: I'm now a senior engineer"
"Forget about the old authentication system—we migrated to Auth0"
If the AI seems to have outdated context, explicitly mention the change. Memory will update automatically.

​
Memory and assistants

Assistants work in conjunction with Memory:
  • Memory provides user-level context (who you are, your preferences)
  • Assistants provide task-specific behaviors (how to respond for specific use cases)
  • Together they create highly personalized, contextually appropriate interactions
Example with Code Review Assistant:
- Memory knows: Your tech stack, coding style, past patterns
- Assistant provides: Code review expertise and structured feedback
- Result: Code reviews tailored to your stack and style preferences

​
Limitations and considerations

Memory retrieval consumes tokens from your context window. The system intelligently selects only relevant memories for each conversation.
Not all memories apply to every conversation. The system determines which memories are contextually relevant.
Very recent information (from the current session) may not yet be in Memory—it’s still in conversation history.
While extensive, Memory focuses on key information rather than storing every detail of every conversation.

​
Best practices for using Memory

1

Be explicit about preferences

When you have strong preferences, state them clearly so Memory captures them.
"I always want TypeScript types in code examples"
"I prefer functional components over class components"
"Always include error handling in implementations"
2

Provide project context early

When starting work on a new project, provide context upfront.
"I'm starting a new project: an e-commerce platform using 
Next.js, Stripe, and PostgreSQL. Target launch in 3 months."
3

Correct outdated information

When your context changes, update it explicitly.
"We switched from AWS to Vercel for deployment"
"I moved from using Redux to Zustand for state management"
4

Leverage Memory across conversations

Don’t repeat context—Memory should handle it automatically.
Instead of: "In my Next.js app that uses Supabase..."
Just say: "In my app..."
Memory provides the context.

​
Memory for teams

In team workspaces, Memory behavior depends on settings:
Team Memory (if enabled):
  • Shared context about team projects
  • Team-wide technical decisions
  • Shared code patterns and preferences
Individual Memory:
  • Your personal preferences
  • Your role-specific context
  • Your communication style

​
Next steps

Manage Memory

View, edit, and control your Memory data

Custom instructions

Complement Memory with persistent instructions

Create assistants

Build specialized assistants with Memory context

Privacy and data

Learn about data privacy and compliance