Skip to main content

​
About Agent Memory

Cheetah AI includes an intelligent memory system that stores your preferences, coding conventions, and project-specific context across conversations and sessions. When you tell the AI about your preferences or how you like to work, it remembers this information and applies it to future interactions automatically. Memory helps the AI behave more like an experienced team member who knows your codebase and understands your preferences. Instead of repeating the same instructions in every conversation, you can tell the AI once and it will remember.

​
How Memory Works

When you share preferences or project-specific information with the AI, it can store them as memories. These memories persist across conversations and sessions, so the AI applies them automatically without you needing to remind it. Example of memory in action: 
You: "I prefer using TypeScript over JavaScript for all new files"
AI: "I'll remember that you prefer TypeScript. I'll use TypeScript for any
     new files I create."

[Later, in a new conversation]

You: "Create a utility function for formatting dates"
AI: [Creates the file in TypeScript without being asked]
The AI stored your TypeScript preference and applied it automatically in the later conversation.

​
What Gets Stored

Memory is designed for explicit preferences, conventions, and factual information about your projects. The AI distinguishes between information worth remembering and temporary context that’s only relevant to the current conversation. Ideal for memory:
  • Coding style preferences - “I prefer functional components over class components”
  • Project conventions - “Our API uses snake_case for JSON keys”
  • Technology choices - “We use PostgreSQL for our database”
  • Documentation standards - “Always add JSDoc comments to public functions”
  • Team practices - “We follow the Airbnb style guide”
  • Framework preferences - “We use React Query for data fetching”
  • Testing conventions - “Use Jest with React Testing Library for tests”
Not stored:
  • Questions and queries (these are conversational, not preferences)
  • One-time task requests
  • Temporary debugging context
  • Sensitive information like API keys or passwords

​
Storing Preferences

You can store preferences by simply stating them in conversation: 
"Remember that I prefer Prettier for code formatting"

"Store that our project uses pnpm instead of npm"

"I always want error boundaries around async components"

"Our team uses conventional commits for commit messages"
You can also ask the AI to remember something after it provides a response: 
You: "How should I structure API responses?"
AI: [Provides recommendation]
You: "Remember that structure for future API work"

​
Automatic Application

Once stored, preferences are applied automatically. You don’t need to remind the AI or reference memories explicitly. Before storing preference: 
You: "Create a button component"
AI: [Creates JavaScript component]
After storing “I prefer TypeScript”: 
You: "Create a button component"
AI: [Creates TypeScript component with proper types]
The AI considers all relevant memories when responding to your requests. If you have preferences about file structure, naming conventions, and coding style, the AI applies all of them together.

​
Memory Categories

Memories are organized by category to help the AI apply them appropriately:
CategoryExamples
Coding Style”Use 2-space indentation”, “Prefer arrow functions”, “Always use const over let”
Framework”We use Next.js 14 with App Router”, “Using Zustand for state management”
Tools”Use pnpm for package management”, “Format with Prettier, lint with ESLint”
Conventions”Components go in src/components/”, “Use barrel exports for modules”
Testing”Use Vitest instead of Jest”, “Prefer integration tests over unit tests”
Documentation”Add JSDoc to all exported functions”, “Include usage examples in comments”

​
Viewing and Managing Memories

You can ask the AI about what it remembers: 
"What preferences do you remember about this project?"

"What coding conventions have I told you about?"
To update a memory: 
"Update my preference: I now use Bun instead of pnpm"
To remove a memory: 
"Forget my preference about using tabs for indentation"

​
Project-Specific Context

Memories can include project-specific information that helps the AI understand your codebase: 
"This project uses Zustand for state management"

"API endpoints are defined in src/api/"

"We use Zod for runtime validation"

"The database schema is defined in prisma/schema.prisma"
This context helps the AI make better decisions when working in your project. It knows where to look for things and what patterns to follow.

​
Best Practices

​
Be Specific

Vague preferences are hard to apply consistently. Be specific about what you want: Less effective: 
"I like clean code"
More effective: 
"Extract functions longer than 20 lines into separate helper functions"

​
State Facts, Not Questions

Questions are conversational and won’t be stored. State your preferences as facts: Won’t be stored: 
"Should I use TypeScript?"
Will be stored: 
"I use TypeScript for all new projects"

​
Include Project Context

Store information about your project’s architecture and conventions: 
"This project uses a feature-based folder structure"

"All API calls go through the apiClient in src/lib/api.ts"

"We use React Hook Form for all forms"

​
Update Outdated Preferences

When your preferences change, explicitly update them: 
"Update my preference: I now use Tailwind CSS instead of styled-components"
This ensures the AI uses your current preferences, not outdated ones.

​
Privacy and Storage

  • Memories are stored locally on your machine
  • They’re associated with your workspace for project-specific context
  • No memory data is sent to external servers beyond what’s needed for AI responses
  • You can clear all memories at any time through settings

​
Limitations

Memory is optimized for preferences and conventions, not arbitrary data storage:
  • Very specific or highly contextual information may not be retained
  • Memory works best for patterns that apply across multiple interactions
  • Temporary or one-off information should be provided in the conversation context
  • The AI may not remember every detail of long or complex preferences
For information that’s only relevant to a single conversation, include it in your messages rather than trying to store it as a memory.