Memory
Memory enables agents to remember information across conversations. Without memory, every conversation starts from zero. With memory, agents build up context about users, teams, and past interactions over time.
Why Memory Matters
Without memory:
Conversation 1: "My laptop is a MacBook Pro M3" -- "Got it!"
Conversation 2 (next day): "My laptop is running slow" -- "What kind of laptop do you have?" (forgot)
With memory:
Conversation 1: "My laptop is a MacBook Pro M3" -- "Got it, I'll remember that!"
Conversation 2 (next day): "My laptop is running slow" -- "I see you're using a MacBook Pro M3. Let me help..." (remembers)
Memory Types
MeetLoyd has four types of memory, each with a different scope:
| Type | Scope | Persists Across Sessions | Shared With | Use Case |
|---|---|---|---|---|
| Conversation | Single conversation | No | Same conversation only | Short-term context within a dialogue |
| User | Per user, per agent | Yes (configurable retention) | Same user + agent | Personalization, preferences, past issues |
| Team | All agents in a team | Yes (until replaced or deleted) | All team agents | A small keyed set: current priorities, decisions, status others depend on |
| Knowledge | Per agent | Yes (until deleted) | Same agent | Reference documents, guides, policies |
Conversation Memory
Automatic within a single conversation. No configuration needed -- the agent naturally remembers everything said in the current thread.
User Memory
Persists across conversations for a specific user. The agent remembers your name, preferences, devices, and past issues from previous sessions. Retention is configurable (default 90 days).
Team Memory
Shared across all agents in a team. When one agent publishes something important (e.g., "we're investigating an email outage"), it appears in every teammate's context on their next run -- nobody has to go looking for it.
Team memory is deliberately small and curated, not a second copy of everything the team knows. Entries are stored under a key, and writing the same key again replaces it. So a team keeps a handful of well-named keys current -- current_priorities, decisions_log, pipeline_status -- rather than accumulating an ever-growing log.
| Reading | Automatic. Every agent on the team sees the current entries in its context. No setting to turn on. |
| Writing | Requires the team-memory tools. Team blueprints grant them to the team's lead or orchestrator, which is what keeps the shared set curated. |
Good candidates: what the team is working on right now, a decision and the reason behind it, status other agents depend on, a durable fact about how this team operates. Not: transient chatter, secrets, or anything specific to a single conversation.
Knowledge Memory
Structured information uploaded to an agent as reference material -- employee handbooks, product documentation, troubleshooting guides. The agent can search and reference this content when answering questions.
How Agents Use Memory
Agents use memory tools automatically during conversations:
| Action | What Happens |
|---|---|
| User shares personal info | Agent stores it (name, department, devices, preferences) |
| User asks a factual question | Agent searches knowledge base and memories |
| User returns for a new conversation | Agent retrieves relevant context from past sessions |
| Agent learns something the team needs | Agent with the team-memory tools publishes it under a key, replacing the previous value |
Files and Memory
Files uploaded to conversations are automatically parsed and their content is cached. When a user attaches files to a message, the full parsed text is injected into the agent's prompt -- agents can read documents instantly without calling a download tool.
Agents can then store key facts from documents as memories for future conversations. For RAG use cases, uploaded files are automatically chunked and searchable alongside memories.
See Files and Attachments for details on storage, parsing, and content injection.
Configuring Memory
Enable User Memory
In the agent's settings, toggle User Memory on and set the retention period. Default retention is 90 days.
| Setting | Description |
|---|---|
| Enabled | Turn user memory on or off for this agent |
| Retention | How long memories are kept (30d, 90d, 180d, or unlimited) |
| Auto-cleanup | Automatically delete expired memories |
Team Memory
There is no switch to flip. Every agent that belongs to a team already reads the team's shared memory -- the current entries are placed in its context automatically.
What you control is who writes. Publishing needs the team-memory tools, and the team blueprints grant them to the team's lead or orchestrator. If you want another agent to publish as well, add the team-memory tools to that agent in its settings.
Keep the set small. Because keys replace rather than append, a team that publishes under a stable handful of keys stays useful; one that invents a new key per update turns its shared memory into noise.
Adding Knowledge
Upload documents to an agent's knowledge base from the dashboard:
- Open the agent's settings
- Go to the Knowledge section
- Upload documents (PDF, DOCX, TXT, etc.)
- Content is automatically parsed, chunked, and indexed
Agents can then search this knowledge base when answering questions.
Memory in System Prompts
Guide how your agents use memory by including instructions in the system prompt:
What to remember:
- User's name, role, and department
- Device information (laptop model, phone)
- Communication preferences
- Past issues and their resolutions
- Explicitly requested preferences ("Remember that I prefer bullet points")
What NOT to remember:
- Passwords or credentials
- Credit card numbers
- Sensitive personal data
- Temporary or one-time information
- Anything the user asks to forget
Using memory well:
- Check memory at the start of conversations for context
- Save important information proactively
- Reference past interactions naturally ("I remember you had a similar VPN issue last month...")
- Update outdated information when you learn it has changed
Privacy and Compliance
User Control
Users can request that an agent forget everything about them. This permanently deletes all user-scoped memories for that agent.
Data Retention
Configure automatic cleanup so memories do not persist indefinitely. Retention settings are per-agent and can be adjusted at any time.
Audit Trail
All memory operations (store, retrieve, delete) are logged for compliance and audit purposes.
Troubleshooting
| Issue | Check |
|---|---|
| Agent does not remember between conversations | Verify user memory is enabled in agent settings |
| Memories seem missing | Check retention settings -- memories may have expired |
| Agent not using knowledge base | Verify documents were successfully parsed (check parse status) |
| Team agents not sharing context | Reading is automatic -- so check the other side: does any agent on the team hold the team-memory tools to publish with? |