diff --git a/api/server/controllers/agents/client.js b/api/server/controllers/agents/client.js
index 7cb265464e..299c2e6ac6 100644
--- a/api/server/controllers/agents/client.js
+++ b/api/server/controllers/agents/client.js
@@ -46,6 +46,7 @@ const {
   attachAskUserQuestionArgs,
   createContentIndexOffsetHandlers,
   getRequestMemories,
+  getMemoryAgentId,
   createMemoryProcessor,
   agentHasInlineMemoryTools,
   loadAgent: loadAgentFn,
@@ -536,10 +537,34 @@ class AgentClient extends BaseClient {
      *  keys + token metadata) is reserved for agents that can call
      *  `delete_memory`; everyone else gets the unkeyed values only. */
     const memories = await this.useMemory();
+    /** Partition the loaded memories belong to (the primary agent's). */
+    const loadedMemoryAgentId = getMemoryAgentId(this.options.agent);
     const buildMemoryContext = (text) =>
       text ? `${memoryInstructions}\n\n# Existing memory about the user:\n${text}` : undefined;
-    const memoryContext = buildMemoryContext(memories?.withoutKeys);
-    const keyedMemoryContext = buildMemoryContext(memories?.withKeys);
+    /** Resolves formatted memories for an agent's own partition. A defined
+     *  `memories` means the run-level gates (permission, opt-out, config)
+     *  passed; agents on other partitions fetch through the request-scoped
+     *  cache so repeated partitions share one query. */
+    const getAgentPartitionMemories = async (agent) => {
+      if (!memories) {
+        return undefined;
+      }
+      const agentPartition = getMemoryAgentId(agent);
+      if (agentPartition === loadedMemoryAgentId) {
+        return memories;
+      }
+      try {
+        return await getRequestMemories({
+          req: this.options.req,
+          userId: this.options.req.user.id + '',
+          agentId: agentPartition,
+          getFormattedMemories: db.getFormattedMemories,
+        });
+      } catch (error) {
+        logger.error('[AgentClient] Error loading partition memories', error);
+        return undefined;
+      }
+    };
 
     const sharedRunContext = sharedRunContextParts.join('\n\n');
     const memoryAgentEnabled = isMemoryAgentEnabled(this.options.req.config?.memory);
@@ -588,15 +613,17 @@ class AgentClient extends BaseClient {
     const configServers = await resolveConfigServers(this.options.req);
 
     await Promise.all(
-      allAgents.map(({ agent, agentId }) => {
+      allAgents.map(async ({ agent, agentId }) => {
         const agentRunContextParts = [sharedRunContext];
         const agentHasMemory = agentHasInlineMemoryTools(agent);
-        const agentMemoryContext = agentHasMemory ? keyedMemoryContext : memoryContext;
-        if (
-          agentMemoryContext &&
-          (agentId === this.options.agent.id || memoryAgentEnabled || agentHasMemory)
-        ) {
-          agentRunContextParts.push(agentMemoryContext);
+        if (agentId === this.options.agent.id || memoryAgentEnabled || agentHasMemory) {
+          const partitionMemories = await getAgentPartitionMemories(agent);
+          const agentMemoryContext = buildMemoryContext(
+            agentHasMemory ? partitionMemories?.withKeys : partitionMemories?.withoutKeys,
+          );
+          if (agentMemoryContext) {
+            agentRunContextParts.push(agentMemoryContext);
+          }
         }
         const scopedContext = agentScopedContext.get(agentId);
         if (scopedContext) {
@@ -674,6 +701,8 @@ class AgentClient extends BaseClient {
     }
 
     const userId = this.options.req.user.id + '';
+    /** Memory partition of the primary agent; undefined = shared personal pool */
+    const memoryAgentId = getMemoryAgentId(this.options.agent);
     this.processMemory = undefined;
 
     if (!isMemoryAgentEnabled(memoryConfig)) {
@@ -681,6 +710,7 @@ class AgentClient extends BaseClient {
         const { withKeys, withoutKeys } = await getRequestMemories({
           req: this.options.req,
           userId,
+          agentId: memoryAgentId,
           getFormattedMemories: db.getFormattedMemories,
         });
         return { withKeys, withoutKeys };
@@ -786,6 +816,7 @@ class AgentClient extends BaseClient {
     const streamId = this.options.req?._resumableStreamId || null;
     const [withoutKeys, processMemory] = await createMemoryProcessor({
       userId,
+      agentId: memoryAgentId,
       config,
       messageId,
       streamId,
@@ -805,6 +836,7 @@ class AgentClient extends BaseClient {
       ({ withKeys } = await getRequestMemories({
         req: this.options.req,
         userId,
+        agentId: memoryAgentId,
         getFormattedMemories: db.getFormattedMemories,
       }));
     } catch (error) {
diff --git a/api/server/routes/memories.js b/api/server/routes/memories.js
index e71e94f457..bfd15640a0 100644
--- a/api/server/routes/memories.js
+++ b/api/server/routes/memories.js
@@ -1,13 +1,21 @@
 const express = require('express');
 const { Tokenizer, generateCheckAccess } = require('@librechat/api');
-const { PermissionTypes, Permissions } = require('librechat-data-provider');
+const {
+  PermissionTypes,
+  PermissionBits,
+  ResourceType,
+  Permissions,
+} = require('librechat-data-provider');
+const { findAccessibleResources } = require('~/server/services/PermissionService');
 const {
   getAllUserMemories,
+  getUserMemories,
   toggleUserMemories,
   getRoleByName,
   createMemory,
   deleteMemory,
   setMemory,
+  getAgents,
 } = require('~/models');
 const { requireJwtAuth, configMiddleware } = require('~/server/middleware');
 
@@ -43,6 +51,37 @@ const checkMemoryOptOut = generateCheckAccess({
 
 router.use(requireJwtAuth);
 
+/** Normalizes the optional agent partition param; undefined = shared personal pool */
+const getAgentIdParam = (value) =>
+  typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined;
+
+/** Resolves agent display names for agent-partitioned memories, restricted
+ *  to agents the requester can VIEW — `agentId` is caller-supplied on write,
+ *  so an unrestricted lookup would leak private agents' names. */
+const withAgentNames = async (memories, user) => {
+  const agentIds = [...new Set(memories.map((m) => m.agentId).filter(Boolean))];
+  if (agentIds.length === 0) {
+    return memories;
+  }
+  try {
+    const accessibleIds = await findAccessibleResources({
+      userId: user.id,
+      role: user.role,
+      resourceType: ResourceType.AGENT,
+      requiredPermissions: PermissionBits.VIEW,
+    });
+    const agents = await getAgents({ id: { $in: agentIds }, _id: { $in: accessibleIds } });
+    const namesById = new Map(agents.map((agent) => [agent.id, agent.name]));
+    return memories.map((memory) =>
+      memory.agentId
+        ? { ...memory, agentName: namesById.get(memory.agentId) ?? undefined }
+        : memory,
+    );
+  } catch (_error) {
+    return memories;
+  }
+};
+
 /**
  * GET /memories
  * Returns all memories for the authenticated user, sorted by updated_at (newest first).
@@ -52,12 +91,14 @@ router.get('/', checkMemoryRead, configMiddleware, async (req, res) => {
   try {
     const memories = await getAllUserMemories(req.user.id);
 
-    const sortedMemories = memories.sort(
+    const sortedMemories = (await withAgentNames(memories, req.user)).sort(
       (a, b) => new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime(),
     );
 
+    /** Usage totals reflect the shared personal pool only — `tokenLimit`
+     *  applies per partition, matching the inline tools' enforcement. */
     const totalTokens = memories.reduce((sum, memory) => {
-      return sum + (memory.tokenCount || 0);
+      return sum + (memory.agentId ? 0 : memory.tokenCount || 0);
     }, 0);
 
     const appConfig = req.config;
@@ -90,6 +131,7 @@ router.get('/', checkMemoryRead, configMiddleware, async (req, res) => {
  */
 router.post('/', memoryPayloadLimit, checkMemoryCreate, configMiddleware, async (req, res) => {
   const { key, value } = req.body;
+  const agentId = getAgentIdParam(req.body.agentId);
 
   if (typeof key !== 'string' || key.trim() === '') {
     return res.status(400).json({ error: 'Key is required and must be a non-empty string.' });
@@ -118,7 +160,7 @@ router.post('/', memoryPayloadLimit, checkMemoryCreate, configMiddleware, async
   try {
     const tokenCount = Tokenizer.getTokenCount(value, 'o200k_base');
 
-    const memories = await getAllUserMemories(req.user.id);
+    const memories = await getUserMemories({ userId: req.user.id, agentId });
 
     const appConfig = req.config;
     const memoryConfig = appConfig?.memory;
@@ -141,13 +183,14 @@ router.post('/', memoryPayloadLimit, checkMemoryCreate, configMiddleware, async
       key: key.trim(),
       value: value.trim(),
       tokenCount,
+      agentId,
     });
 
     if (!result.ok) {
       return res.status(500).json({ error: 'Failed to create memory.' });
     }
 
-    const updatedMemories = await getAllUserMemories(req.user.id);
+    const updatedMemories = await getUserMemories({ userId: req.user.id, agentId });
     const newMemory = updatedMemories.find((m) => m.key === key.trim());
 
     res.status(201).json({ created: true, memory: newMemory });
@@ -199,6 +242,7 @@ router.patch('/preferences', checkMemoryOptOut, async (req, res) => {
 router.patch('/:key', memoryPayloadLimit, checkMemoryUpdate, configMiddleware, async (req, res) => {
   const { key: urlKey } = req.params;
   const { key: bodyKey, value } = req.body || {};
+  const agentId = getAgentIdParam(req.query.agentId);
 
   if (typeof value !== 'string' || value.trim() === '') {
     return res.status(400).json({ error: 'Value is required and must be a non-empty string.' });
@@ -224,7 +268,7 @@ router.patch('/:key', memoryPayloadLimit, checkMemoryUpdate, configMiddleware, a
   try {
     const tokenCount = Tokenizer.getTokenCount(value, 'o200k_base');
 
-    const memories = await getAllUserMemories(req.user.id);
+    const memories = await getUserMemories({ userId: req.user.id, agentId });
     const existingMemory = memories.find((m) => m.key === urlKey);
 
     if (!existingMemory) {
@@ -242,13 +286,14 @@ router.patch('/:key', memoryPayloadLimit, checkMemoryUpdate, configMiddleware, a
         key: newKey,
         value,
         tokenCount,
+        agentId,
       });
 
       if (!createResult.ok) {
         return res.status(500).json({ error: 'Failed to create new memory.' });
       }
 
-      const deleteResult = await deleteMemory({ userId: req.user.id, key: urlKey });
+      const deleteResult = await deleteMemory({ userId: req.user.id, key: urlKey, agentId });
       if (!deleteResult.ok) {
         return res.status(500).json({ error: 'Failed to delete old memory.' });
       }
@@ -258,6 +303,7 @@ router.patch('/:key', memoryPayloadLimit, checkMemoryUpdate, configMiddleware, a
         key: newKey,
         value,
         tokenCount,
+        agentId,
       });
 
       if (!result.ok) {
@@ -265,7 +311,7 @@ router.patch('/:key', memoryPayloadLimit, checkMemoryUpdate, configMiddleware, a
       }
     }
 
-    const updatedMemories = await getAllUserMemories(req.user.id);
+    const updatedMemories = await getUserMemories({ userId: req.user.id, agentId });
     const updatedMemory = updatedMemories.find((m) => m.key === newKey);
 
     res.json({ updated: true, memory: updatedMemory });
@@ -281,9 +327,10 @@ router.patch('/:key', memoryPayloadLimit, checkMemoryUpdate, configMiddleware, a
  */
 router.delete('/:key', checkMemoryDelete, async (req, res) => {
   const { key } = req.params;
+  const agentId = getAgentIdParam(req.query.agentId);
 
   try {
-    const result = await deleteMemory({ userId: req.user.id, key });
+    const result = await deleteMemory({ userId: req.user.id, key, agentId });
 
     if (!result.ok) {
       return res.status(404).json({ error: 'Memory not found.' });
diff --git a/client/src/common/agents-types.ts b/client/src/common/agents-types.ts
index b5e6aefb37..dd6bd79017 100644
--- a/client/src/common/agents-types.ts
+++ b/client/src/common/agents-types.ts
@@ -5,6 +5,7 @@ import type {
   AgentToolOptions,
   SupportContact,
   AgentProvider,
+  MemoryScope,
   GraphEdge,
   Agent,
 } from 'librechat-data-provider';
@@ -40,6 +41,8 @@ export type AgentForm = {
   tool_options?: AgentToolOptions;
   skills?: string[];
   skills_enabled?: boolean;
+  /** Memory partition: 'agent' isolates memories per (user, agent); default shared pool */
+  memory_scope?: MemoryScope;
   provider?: AgentProvider | OptionWithIcon;
   /** @deprecated Use edges instead */
   agent_ids?: string[];
diff --git a/client/src/components/SidePanel/Agents/AgentPanel.tsx b/client/src/components/SidePanel/Agents/AgentPanel.tsx
index c575939794..4e6787bcc4 100644
--- a/client/src/components/SidePanel/Agents/AgentPanel.tsx
+++ b/client/src/components/SidePanel/Agents/AgentPanel.tsx
@@ -5,6 +5,7 @@ import { useWatch, useForm, FormProvider } from 'react-hook-form';
 import { useGetModelsQuery } from 'librechat-data-provider/react-query';
 import {
   Tools,
+  MemoryScope,
   SystemRoles,
   ResourceType,
   EModelEndpoint,
@@ -78,6 +79,7 @@ export function composeAgentUpdatePayload(data: AgentForm, agent_id?: string | n
     tool_options,
     skills,
     skills_enabled,
+    memory_scope,
     avatar_action: avatarActionState,
   } = data;
 
@@ -107,6 +109,9 @@ export function composeAgentUpdatePayload(data: AgentForm, agent_id?: string | n
       tool_options,
       skills,
       skills_enabled,
+      /** A hidden stale 'agent' scope must not survive disabling memory —
+       *  runtime partitioning keys off memory_scope alone. */
+      memory_scope: data.memory === true ? memory_scope : MemoryScope.user,
       ...(shouldResetAvatar ? { avatar: null } : {}),
     },
     provider,
diff --git a/client/src/components/SidePanel/Agents/Memory.tsx b/client/src/components/SidePanel/Agents/Memory.tsx
index 0ce1b489af..69c409f8f6 100644
--- a/client/src/components/SidePanel/Agents/Memory.tsx
+++ b/client/src/components/SidePanel/Agents/Memory.tsx
@@ -1,6 +1,6 @@
 import { memo } from 'react';
-import { AgentCapabilities } from 'librechat-data-provider';
-import { useFormContext, Controller } from 'react-hook-form';
+import { useFormContext, Controller, useWatch } from 'react-hook-form';
+import { MemoryScope, AgentCapabilities } from 'librechat-data-provider';
 import {
   Checkbox,
   HoverCard,
@@ -17,50 +17,101 @@ function Memory() {
   const localize = useLocalize();
   const methods = useFormContext<AgentForm>();
   const { control } = methods;
+  const memoryEnabled = useWatch({ control, name: AgentCapabilities.memory });
 
   return (
-    <HoverCard openDelay={50}>
-      <div className="my-2 flex items-center">
-        <Controller
-          name={AgentCapabilities.memory}
-          control={control}
-          render={({ field }) => (
-            <Checkbox
-              {...field}
-              id="memory-checkbox"
-              checked={field.value === true}
-              onCheckedChange={field.onChange}
-              className="relative float-left mr-2 inline-flex h-4 w-4 cursor-pointer"
-              value={(field.value === true).toString()}
-              aria-labelledby="memory-label"
-            />
-          )}
-        />
-        <label
-          id="memory-label"
-          htmlFor="memory-checkbox"
-          className="form-check-label text-token-text-primary cursor-pointer text-sm"
-        >
-          {localize('com_agents_enable_memory')}
-        </label>
-        <HoverCardTrigger asChild className="ml-2">
-          <button
-            type="button"
-            className="inline-flex items-center"
-            aria-label={localize('com_agents_memory_info')}
+    <div>
+      <HoverCard openDelay={50}>
+        <div className="my-2 flex items-center">
+          <Controller
+            name={AgentCapabilities.memory}
+            control={control}
+            render={({ field }) => (
+              <Checkbox
+                {...field}
+                id="memory-checkbox"
+                checked={field.value === true}
+                onCheckedChange={field.onChange}
+                className="relative float-left mr-2 inline-flex h-4 w-4 cursor-pointer"
+                value={(field.value === true).toString()}
+                aria-labelledby="memory-label"
+              />
+            )}
+          />
+          <label
+            id="memory-label"
+            htmlFor="memory-checkbox"
+            className="form-check-label text-token-text-primary cursor-pointer text-sm"
           >
-            <CircleHelpIcon className="h-4 w-4 text-text-tertiary" />
-          </button>
-        </HoverCardTrigger>
-        <HoverCardPortal>
-          <HoverCardContent side={ESide.Top} className="w-80">
-            <div className="space-y-2">
-              <p className="text-sm text-text-secondary">{localize('com_agents_memory_info')}</p>
-            </div>
-          </HoverCardContent>
-        </HoverCardPortal>
-      </div>
-    </HoverCard>
+            {localize('com_agents_enable_memory')}
+          </label>
+          <HoverCardTrigger asChild className="ml-2">
+            <button
+              type="button"
+              className="inline-flex items-center"
+              aria-label={localize('com_agents_memory_info')}
+            >
+              <CircleHelpIcon className="h-4 w-4 text-text-tertiary" />
+            </button>
+          </HoverCardTrigger>
+          <HoverCardPortal>
+            <HoverCardContent side={ESide.Top} className="w-80">
+              <div className="space-y-2">
+                <p className="text-sm text-text-secondary">{localize('com_agents_memory_info')}</p>
+              </div>
+            </HoverCardContent>
+          </HoverCardPortal>
+        </div>
+      </HoverCard>
+      {memoryEnabled === true && (
+        <HoverCard openDelay={50}>
+          <div className="my-2 ml-6 flex items-center">
+            <Controller
+              name="memory_scope"
+              control={control}
+              render={({ field }) => (
+                <Checkbox
+                  {...field}
+                  id="memory-scope-checkbox"
+                  checked={field.value === MemoryScope.agent}
+                  onCheckedChange={(checked) =>
+                    field.onChange(checked === true ? MemoryScope.agent : MemoryScope.user)
+                  }
+                  className="relative float-left mr-2 inline-flex h-4 w-4 cursor-pointer"
+                  value={(field.value === MemoryScope.agent).toString()}
+                  aria-labelledby="memory-scope-label"
+                />
+              )}
+            />
+            <label
+              id="memory-scope-label"
+              htmlFor="memory-scope-checkbox"
+              className="form-check-label text-token-text-primary cursor-pointer text-sm"
+            >
+              {localize('com_agents_memory_scope')}
+            </label>
+            <HoverCardTrigger asChild className="ml-2">
+              <button
+                type="button"
+                className="inline-flex items-center"
+                aria-label={localize('com_agents_memory_scope_info')}
+              >
+                <CircleHelpIcon className="h-4 w-4 text-text-tertiary" />
+              </button>
+            </HoverCardTrigger>
+            <HoverCardPortal>
+              <HoverCardContent side={ESide.Top} className="w-80">
+                <div className="space-y-2">
+                  <p className="text-sm text-text-secondary">
+                    {localize('com_agents_memory_scope_info')}
+                  </p>
+                </div>
+              </HoverCardContent>
+            </HoverCardPortal>
+          </div>
+        </HoverCard>
+      )}
+    </div>
   );
 }
 
diff --git a/client/src/components/SidePanel/Memories/MemoryCard.tsx b/client/src/components/SidePanel/Memories/MemoryCard.tsx
index b160aaf455..6234f84c80 100644
--- a/client/src/components/SidePanel/Memories/MemoryCard.tsx
+++ b/client/src/components/SidePanel/Memories/MemoryCard.tsx
@@ -27,9 +27,17 @@ export default function MemoryCard({ memory, hasUpdateAccess }: MemoryCardProps)
         'hover:bg-surface-secondary',
       )}
     >
-      {/* Row 1: Key + Token count + Actions */}
+      {/* Row 1: Key + Agent badge + Token count + Actions */}
       <div className="flex items-center gap-2">
         <span className="truncate text-sm font-semibold text-text-primary">{memory.key}</span>
+        {memory.agentId != null && (
+          <span
+            className="shrink-0 truncate rounded-full border border-border-light px-2 py-0.5 text-xs text-text-secondary"
+            title={localize('com_ui_memory_agent_badge')}
+          >
+            {memory.agentName ?? memory.agentId}
+          </span>
+        )}
         {memory.tokenCount !== undefined && (
           <span className="shrink-0 text-xs text-text-secondary">
             {memory.tokenCount}{' '}
diff --git a/client/src/components/SidePanel/Memories/MemoryCardActions.tsx b/client/src/components/SidePanel/Memories/MemoryCardActions.tsx
index c1dcb87eed..564d485cd1 100644
--- a/client/src/components/SidePanel/Memories/MemoryCardActions.tsx
+++ b/client/src/components/SidePanel/Memories/MemoryCardActions.tsx
@@ -39,15 +39,18 @@ export default function MemoryCardActions({ memory }: MemoryCardActionsProps) {
   );
 
   const confirmDelete = () => {
-    deleteMemory(memory.key, {
-      onSuccess: () => {
-        showToast({ message: localize('com_ui_deleted'), status: 'success' });
-        setDeleteOpen(false);
+    deleteMemory(
+      { key: memory.key, agentId: memory.agentId },
+      {
+        onSuccess: () => {
+          showToast({ message: localize('com_ui_deleted'), status: 'success' });
+          setDeleteOpen(false);
+        },
+        onError: () => {
+          showToast({ message: localize('com_ui_error'), status: 'error' });
+        },
       },
-      onError: () => {
-        showToast({ message: localize('com_ui_error'), status: 'error' });
-      },
-    });
+    );
   };
 
   return (
diff --git a/client/src/components/SidePanel/Memories/MemoryEditDialog.tsx b/client/src/components/SidePanel/Memories/MemoryEditDialog.tsx
index b6a18e086d..5ec5d4c985 100644
--- a/client/src/components/SidePanel/Memories/MemoryEditDialog.tsx
+++ b/client/src/components/SidePanel/Memories/MemoryEditDialog.tsx
@@ -117,6 +117,7 @@ export default function MemoryEditDialog({
     updateMemory({
       key: key.trim(),
       value: value.trim(),
+      agentId: memory.agentId,
       ...(originalKey !== key.trim() && { originalKey }),
     });
   };
diff --git a/client/src/components/SidePanel/Memories/MemoryList.tsx b/client/src/components/SidePanel/Memories/MemoryList.tsx
index 30b4236468..6076896044 100644
--- a/client/src/components/SidePanel/Memories/MemoryList.tsx
+++ b/client/src/components/SidePanel/Memories/MemoryList.tsx
@@ -23,7 +23,7 @@ export default function MemoryList({
   return (
     <div className="space-y-2" role="list" aria-label={localize('com_ui_memories')}>
       {memories.map((memory) => (
-        <div key={memory.key} role="listitem">
+        <div key={`${memory.agentId ?? ''}:${memory.key}`} role="listitem">
           <MemoryCard memory={memory} hasUpdateAccess={hasUpdateAccess} />
         </div>
       ))}
diff --git a/client/src/components/SidePanel/Memories/MemoryPanel.tsx b/client/src/components/SidePanel/Memories/MemoryPanel.tsx
index 01ec7cb562..89f3e39658 100644
--- a/client/src/components/SidePanel/Memories/MemoryPanel.tsx
+++ b/client/src/components/SidePanel/Memories/MemoryPanel.tsx
@@ -6,6 +6,7 @@ import {
   Button,
   Checkbox,
   Spinner,
+  Dropdown,
   FilterInput,
   TooltipAnchor,
   OGDialogTrigger,
@@ -25,6 +26,10 @@ import MemoryList from './MemoryList';
 
 const pageSize = 10;
 
+/** Partition filter sentinels; any other value is an agent id */
+const PARTITION_ALL = 'all';
+const PARTITION_PERSONAL = 'personal';
+
 export default function MemoryPanel() {
   const localize = useLocalize();
   const { user } = useAuthContext();
@@ -33,6 +38,7 @@ export default function MemoryPanel() {
   const { showToast } = useToastContext();
   const [pageIndex, setPageIndex] = useState(0);
   const [searchQuery, setSearchQuery] = useState('');
+  const [partitionFilter, setPartitionFilter] = useState(PARTITION_ALL);
   const [createDialogOpen, setCreateDialogOpen] = useState(false);
   const [referenceSavedMemories, setReferenceSavedMemories] = useState(true);
 
@@ -85,20 +91,57 @@ export default function MemoryPanel() {
 
   const memories: TUserMemory[] = useMemo(() => memData?.memories ?? [], [memData]);
 
+  const partitionOptions = useMemo(() => {
+    const agentsById = new Map<string, string>();
+    for (const memory of memories) {
+      if (memory.agentId != null && !agentsById.has(memory.agentId)) {
+        agentsById.set(memory.agentId, memory.agentName ?? memory.agentId);
+      }
+    }
+    if (agentsById.size === 0) {
+      return null;
+    }
+    return [
+      { value: PARTITION_ALL, label: localize('com_ui_memories_all') },
+      { value: PARTITION_PERSONAL, label: localize('com_ui_memories_personal') },
+      ...[...agentsById.entries()].map(([value, label]) => ({ value, label })),
+    ];
+  }, [memories, localize]);
+
+  /** Falls back to "all" when the selected partition no longer exists
+   *  (e.g. the last memory of that agent was deleted), so the panel never
+   *  gets stuck filtering on a removed partition. */
+  const activePartition = useMemo(() => {
+    if (partitionFilter === PARTITION_ALL || partitionFilter === PARTITION_PERSONAL) {
+      return partitionFilter;
+    }
+    return partitionOptions?.some((option) => option.value === partitionFilter)
+      ? partitionFilter
+      : PARTITION_ALL;
+  }, [partitionOptions, partitionFilter]);
+
   const filteredMemories = useMemo(() => {
-    return matchSorter(memories, searchQuery, {
+    const partitionMemories =
+      activePartition === PARTITION_ALL
+        ? memories
+        : memories.filter((memory) =>
+            activePartition === PARTITION_PERSONAL
+              ? memory.agentId == null
+              : memory.agentId === activePartition,
+          );
+    return matchSorter(partitionMemories, searchQuery, {
       keys: ['key', 'value'],
     });
-  }, [memories, searchQuery]);
+  }, [memories, searchQuery, activePartition]);
 
   const currentRows = useMemo(() => {
     return filteredMemories.slice(pageIndex * pageSize, (pageIndex + 1) * pageSize);
   }, [filteredMemories, pageIndex]);
 
-  // Reset page when search changes
+  // Reset page when search or partition changes
   useEffect(() => {
     setPageIndex(0);
-  }, [searchQuery]);
+  }, [searchQuery, activePartition]);
 
   if (isLoading) {
     return (
@@ -155,6 +198,18 @@ export default function MemoryPanel() {
           )}
         </div>
 
+        {/* Partition filter (only when agent-scoped memories exist) */}
+        {partitionOptions && (
+          <Dropdown
+            value={activePartition}
+            onChange={setPartitionFilter}
+            options={partitionOptions}
+            className="w-full"
+            ariaLabel={localize('com_ui_memories_partition_filter')}
+            testId="memory-partition-filter"
+          />
+        )}
+
         {/* Controls: Usage Badge + Memory Toggle */}
         {(memData?.tokenLimit != null || hasOptOutAccess) && (
           <div className="flex items-center justify-between">
diff --git a/client/src/data-provider/Memories/queries.ts b/client/src/data-provider/Memories/queries.ts
index 53c2025228..357d2799a9 100644
--- a/client/src/data-provider/Memories/queries.ts
+++ b/client/src/data-provider/Memories/queries.ts
@@ -1,6 +1,6 @@
 /* Memories */
-import { QueryKeys, MutationKeys, dataService } from 'librechat-data-provider';
 import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+import { QueryKeys, MutationKeys, dataService } from 'librechat-data-provider';
 import type {
   UseQueryOptions,
   UseMutationOptions,
@@ -19,23 +19,32 @@ export const useMemoriesQuery = (
   });
 };
 
+export type DeleteMemoryParams = { key: string; agentId?: string };
 export const useDeleteMemoryMutation = () => {
   const queryClient = useQueryClient();
-  return useMutation((key: string) => dataService.deleteMemory(key), {
-    onSuccess: () => {
-      queryClient.invalidateQueries([QueryKeys.memories]);
+  return useMutation(
+    ({ key, agentId }: DeleteMemoryParams) => dataService.deleteMemory(key, agentId),
+    {
+      onSuccess: () => {
+        queryClient.invalidateQueries([QueryKeys.memories]);
+      },
     },
-  });
+  );
 };
 
-export type UpdateMemoryParams = { key: string; value: string; originalKey?: string };
+export type UpdateMemoryParams = {
+  key: string;
+  value: string;
+  originalKey?: string;
+  agentId?: string;
+};
 export const useUpdateMemoryMutation = (
   options?: UseMutationOptions<TUserMemory, Error, UpdateMemoryParams>,
 ) => {
   const queryClient = useQueryClient();
   return useMutation(
-    ({ key, value, originalKey }: UpdateMemoryParams) =>
-      dataService.updateMemory(key, value, originalKey),
+    ({ key, value, originalKey, agentId }: UpdateMemoryParams) =>
+      dataService.updateMemory(key, value, originalKey, agentId),
     {
       ...options,
       onSuccess: (...params) => {
@@ -74,7 +83,7 @@ export const useUpdateMemoryPreferencesMutation = (
   );
 };
 
-export type CreateMemoryParams = { key: string; value: string };
+export type CreateMemoryParams = { key: string; value: string; agentId?: string };
 export type CreateMemoryResponse = { created: boolean; memory: TUserMemory };
 
 export const useCreateMemoryMutation = (
@@ -82,7 +91,8 @@ export const useCreateMemoryMutation = (
 ) => {
   const queryClient = useQueryClient();
   return useMutation<CreateMemoryResponse, Error, CreateMemoryParams>(
-    ({ key, value }: CreateMemoryParams) => dataService.createMemory({ key, value }),
+    ({ key, value, agentId }: CreateMemoryParams) =>
+      dataService.createMemory({ key, value, agentId }),
     {
       ...options,
       onSuccess: (data, variables, context) => {
@@ -90,8 +100,9 @@ export const useCreateMemoryMutation = (
           if (!oldData) return oldData;
 
           const newMemories = [...oldData.memories, data.memory];
+          /** Usage totals track the shared personal pool only */
           const totalTokens = newMemories.reduce(
-            (sum, memory) => sum + (memory.tokenCount || 0),
+            (sum, memory) => sum + (memory.agentId ? 0 : memory.tokenCount || 0),
             0,
           );
           const tokenLimit = oldData.tokenLimit;
diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.json
index 1f19dd928d..a5976e8873 100644
--- a/client/src/locales/en/translation.json
+++ b/client/src/locales/en/translation.json
@@ -83,6 +83,8 @@
   "com_agents_mcp_name_placeholder": "Custom Tool",
   "com_agents_mcp_trust_subtext": "Custom connectors are not verified by LibreChat",
   "com_agents_memory_info": "When enabled, the agent can save, update, and delete memories about the user during the conversation using the set_memory and delete_memory tools.",
+  "com_agents_memory_scope": "Keep memories separate for this agent",
+  "com_agents_memory_scope_info": "When enabled, this agent reads and writes its own memories, isolated from your shared memories and from other agents. Existing shared memories are not shown to this agent.",
   "com_agents_missing_name": "Please type in a name before creating an agent.",
   "com_agents_missing_provider_model": "Please select a provider and model before creating an agent.",
   "com_agents_name_placeholder": "Agent name",
@@ -1368,8 +1370,12 @@
   "com_ui_memories_allow_read": "Allow reading Memories",
   "com_ui_memories_allow_update": "Allow updating Memories",
   "com_ui_memories_allow_use": "Allow using Memories",
+  "com_ui_memories_all": "All memories",
   "com_ui_memories_filter": "Filter memories...",
+  "com_ui_memories_partition_filter": "Filter memories by agent",
+  "com_ui_memories_personal": "Personal",
   "com_ui_memory": "Memory",
+  "com_ui_memory_agent_badge": "Agent-scoped memory",
   "com_ui_memory_already_exceeded": "Memory storage already full - exceeded by {{tokens}} tokens. Delete existing memories before adding new ones.",
   "com_ui_memory_created": "Memory created successfully",
   "com_ui_memory_deleted": "Memory deleted",
diff --git a/client/src/utils/memory.ts b/client/src/utils/memory.ts
index 49b383e9e4..ac26fb2e33 100644
--- a/client/src/utils/memory.ts
+++ b/client/src/utils/memory.ts
@@ -5,6 +5,13 @@ type HandleMemoryArtifactParams = {
   currentData: MemoriesResponse;
 };
 
+/** Usage totals track the shared personal pool only; agent-partition
+ *  writes never affect the personal usage badge. */
+const isPersonal = (agentId?: string) => agentId == null;
+
+const samePartition = (memory: TUserMemory, agentId?: string) =>
+  (memory.agentId ?? undefined) === (agentId ?? undefined);
+
 /**
  * Pure function to handle memory artifact updates
  * @param params - Object containing memoryArtifact and currentData
@@ -14,14 +21,14 @@ export function handleMemoryArtifact({
   memoryArtifact,
   currentData,
 }: HandleMemoryArtifactParams): MemoriesResponse | undefined {
-  const { type, key, value, tokenCount = 0 } = memoryArtifact;
+  const { type, key, value, tokenCount = 0, agentId } = memoryArtifact;
 
   if (type === 'update' && !value) {
     return undefined;
   }
 
   const memories = currentData.memories;
-  const existingIndex = memories.findIndex((m) => m.key === key);
+  const existingIndex = memories.findIndex((m) => m.key === key && samePartition(m, agentId));
 
   if (type === 'delete') {
     if (existingIndex === -1) {
@@ -32,7 +39,9 @@ export function handleMemoryArtifact({
     const newMemories = [...memories];
     newMemories.splice(existingIndex, 1);
 
-    const totalTokens = currentData.totalTokens - (deletedMemory.tokenCount || 0);
+    const totalTokens = isPersonal(agentId)
+      ? currentData.totalTokens - (deletedMemory.tokenCount || 0)
+      : currentData.totalTokens;
     const usagePercentage = currentData.tokenLimit
       ? Math.min(100, Math.round((totalTokens / currentData.tokenLimit) * 100))
       : null;
@@ -49,29 +58,30 @@ export function handleMemoryArtifact({
     const timestamp = new Date().toISOString();
     let totalTokens = currentData.totalTokens;
     let newMemories: TUserMemory[];
+    const updatedMemory: TUserMemory = {
+      key,
+      value: value!,
+      tokenCount,
+      updated_at: timestamp,
+      ...(agentId != null ? { agentId } : {}),
+    };
 
     if (existingIndex >= 0) {
       const oldTokenCount = memories[existingIndex].tokenCount || 0;
-      totalTokens = totalTokens - oldTokenCount + tokenCount;
+      if (isPersonal(agentId)) {
+        totalTokens = totalTokens - oldTokenCount + tokenCount;
+      }
 
       newMemories = [...memories];
       newMemories[existingIndex] = {
-        key,
-        value: value!,
-        tokenCount,
-        updated_at: timestamp,
+        ...updatedMemory,
+        agentName: memories[existingIndex].agentName,
       };
     } else {
-      totalTokens = totalTokens + tokenCount;
-      newMemories = [
-        ...memories,
-        {
-          key,
-          value: value!,
-          tokenCount,
-          updated_at: timestamp,
-        },
-      ];
+      if (isPersonal(agentId)) {
+        totalTokens = totalTokens + tokenCount;
+      }
+      newMemories = [...memories, updatedMemory];
     }
 
     const usagePercentage = currentData.tokenLimit
diff --git a/packages/api/src/agents/memory.spec.ts b/packages/api/src/agents/memory.spec.ts
index 124cf346ff..463a115d00 100644
--- a/packages/api/src/agents/memory.spec.ts
+++ b/packages/api/src/agents/memory.spec.ts
@@ -1,12 +1,14 @@
 import { Types } from 'mongoose';
 import { Run, Providers } from '@librechat/agents';
+import { MemoryScope } from 'librechat-data-provider';
 import type { IUser } from '@librechat/data-schemas';
 import type { Response } from 'express';
 import {
   processMemory,
   createMemoryTool,
-  createDeleteMemoryTool,
+  getMemoryAgentId,
   getRequestMemories,
+  createDeleteMemoryTool,
   invalidateRequestMemories,
   agentHasInlineMemoryTools,
 } from './memory';
@@ -706,4 +708,44 @@ describe('getRequestMemories caching', () => {
     await getRequestMemories({ req, userId: 'user-1', getFormattedMemories });
     expect(getFormattedMemories).toHaveBeenCalledTimes(2);
   });
+
+  it('caches and invalidates per partition', async () => {
+    const getFormattedMemories = jest
+      .fn()
+      .mockResolvedValue({ withKeys: '', withoutKeys: '', totalTokens: 10 });
+    const req = {};
+
+    await getRequestMemories({ req, userId: 'user-1', getFormattedMemories });
+    await getRequestMemories({ req, userId: 'user-1', agentId: 'agent_a', getFormattedMemories });
+    await getRequestMemories({ req, userId: 'user-1', agentId: 'agent_a', getFormattedMemories });
+    /** Personal pool and agent partition are distinct cache entries. */
+    expect(getFormattedMemories).toHaveBeenCalledTimes(2);
+    expect(getFormattedMemories).toHaveBeenLastCalledWith({
+      userId: 'user-1',
+      agentId: 'agent_a',
+    });
+
+    /** Invalidating one partition leaves the other cached. */
+    invalidateRequestMemories(req, 'agent_a');
+    await getRequestMemories({ req, userId: 'user-1', getFormattedMemories });
+    expect(getFormattedMemories).toHaveBeenCalledTimes(2);
+    await getRequestMemories({ req, userId: 'user-1', agentId: 'agent_a', getFormattedMemories });
+    expect(getFormattedMemories).toHaveBeenCalledTimes(3);
+  });
+});
+
+describe('getMemoryAgentId', () => {
+  it('resolves the agent partition only for memory_scope "agent"', () => {
+    expect(getMemoryAgentId({ id: 'agent_a', memory_scope: MemoryScope.agent })).toBe('agent_a');
+    expect(getMemoryAgentId({ id: 'agent_a', memory_scope: MemoryScope.user })).toBeUndefined();
+    expect(getMemoryAgentId({ id: 'agent_a' })).toBeUndefined();
+    expect(getMemoryAgentId({ memory_scope: MemoryScope.agent })).toBeUndefined();
+    expect(getMemoryAgentId(null)).toBeUndefined();
+  });
+
+  it('strips runtime id suffixes so added-conversation runs share the persisted partition', () => {
+    expect(getMemoryAgentId({ id: 'agent_a____1', memory_scope: MemoryScope.agent })).toBe(
+      'agent_a',
+    );
+  });
 });
diff --git a/packages/api/src/agents/memory.ts b/packages/api/src/agents/memory.ts
index e6b3dbebb3..1f4c362be8 100644
--- a/packages/api/src/agents/memory.ts
+++ b/packages/api/src/agents/memory.ts
@@ -6,10 +6,12 @@ import { Run, Providers, GraphEvents } from '@librechat/agents';
 import { HumanMessage } from '@librechat/agents/langchain/messages';
 import {
   Tools,
+  MemoryScope,
   Permissions,
   EModelEndpoint,
   PermissionTypes,
   AgentCapabilities,
+  stripAgentIdSuffix,
 } from 'librechat-data-provider';
 import type {
   OpenAIClientOptions,
@@ -117,6 +119,7 @@ type MemoryArtifactRecord = Record<Tools.memory, MemoryArtifact>;
  */
 export const createMemoryTool = ({
   userId,
+  agentId,
   setMemory,
   validKeys,
   charLimit,
@@ -125,6 +128,8 @@ export const createMemoryTool = ({
   onWrite,
 }: {
   userId: string | ObjectId;
+  /** Agent partition to write to; omit for the shared personal pool */
+  agentId?: string;
   setMemory: MemoryMethods['setMemory'];
   validKeys?: string[];
   charLimit?: number;
@@ -220,10 +225,11 @@ export const createMemoryTool = ({
               value,
               tokenCount,
               type: 'update',
+              ...(agentId ? { agentId } : {}),
             },
           };
 
-          const result = await setMemory({ userId, key, value, tokenCount });
+          const result = await setMemory({ userId, key, value, tokenCount, agentId });
           if (result.ok) {
             if (tokenLimit) {
               currentTotalTokens = newTotalTokens;
@@ -274,11 +280,14 @@ export const createMemoryTool = ({
  */
 export const createDeleteMemoryTool = ({
   userId,
+  agentId,
   deleteMemory,
   validKeys,
   onWrite,
 }: {
   userId: string | ObjectId;
+  /** Agent partition to delete from; omit for the shared personal pool */
+  agentId?: string;
   deleteMemory: MemoryMethods['deleteMemory'];
   validKeys?: string[];
   onWrite?: () => void;
@@ -299,10 +308,11 @@ export const createDeleteMemoryTool = ({
           [Tools.memory]: {
             key,
             type: 'delete',
+            ...(agentId ? { agentId } : {}),
           },
         };
 
-        const result = await deleteMemory({ userId, key });
+        const result = await deleteMemory({ userId, key, agentId });
         if (result.ok) {
           onWrite?.();
           logger.debug(`Memory deleted for key "${key}" for user "${userId}"`);
@@ -433,7 +443,25 @@ type GetRoleByName = (
   fieldsToSelect?: string | string[],
 ) => Promise<IRole | null>;
 
-type InlineMemoryAgent = { tools?: unknown[]; memoryToolsRegistered?: boolean } | null | undefined;
+type InlineMemoryAgent =
+  | { id?: string; tools?: unknown[]; memoryToolsRegistered?: boolean; memory_scope?: MemoryScope }
+  | null
+  | undefined;
+
+/**
+ * Resolves the memory partition an agent reads/writes: its persisted id when
+ * the agent opted into isolated memory (`memory_scope: 'agent'`), otherwise
+ * `undefined` for the shared personal pool. Runtime ids carry a `____N`
+ * suffix in added-conversation paths, so the suffix is stripped to keep the
+ * partition stable across single- and multi-agent runs. Ephemeral agents
+ * never carry `memory_scope`, so they always resolve to the shared pool.
+ */
+export function getMemoryAgentId(agent: InlineMemoryAgent): string | undefined {
+  if (agent?.memory_scope === MemoryScope.agent && typeof agent.id === 'string' && agent.id) {
+    return stripAgentIdSuffix(agent.id);
+  }
+  return undefined;
+}
 
 /**
  * Whether an agent carries the inline memory tools. Prefers the LibreChat-only
@@ -463,35 +491,44 @@ export function agentHasInlineMemoryTools(agent: InlineMemoryAgent): boolean {
 /**
  * Request-scoped cache so that multiple memory-enabled agents in one run (and
  * the run's memory context load) share a single `getFormattedMemories` call
- * instead of each re-fetching the same user's memories.
+ * per partition instead of each re-fetching the same memories.
  */
-const requestMemoriesCache = new WeakMap<object, Promise<FormattedMemoriesResult>>();
+const requestMemoriesCache = new WeakMap<object, Map<string, Promise<FormattedMemoriesResult>>>();
 
 export function getRequestMemories({
   req,
   userId,
+  agentId,
   getFormattedMemories,
 }: {
   req: object;
   userId: string | ObjectId;
+  /** Agent partition; omit for the shared personal pool */
+  agentId?: string;
   getFormattedMemories: MemoryMethods['getFormattedMemories'];
 }): Promise<FormattedMemoriesResult> {
-  let cached = requestMemoriesCache.get(req);
+  let partitions = requestMemoriesCache.get(req);
+  if (!partitions) {
+    partitions = new Map();
+    requestMemoriesCache.set(req, partitions);
+  }
+  const partitionKey = agentId ?? '';
+  let cached = partitions.get(partitionKey);
   if (!cached) {
-    cached = getFormattedMemories({ userId });
-    requestMemoriesCache.set(req, cached);
+    cached = getFormattedMemories({ userId, agentId });
+    partitions.set(partitionKey, cached);
   }
   return cached;
 }
 
 /**
- * Drops the cached memories for a request so the next {@link getRequestMemories}
- * re-fetches. Inline `set_memory`/`delete_memory` writes call this on success so
- * a later tool round in the same response is seeded with the post-write usage
- * total instead of a stale pre-write one.
+ * Drops the cached memories for a request partition so the next
+ * {@link getRequestMemories} re-fetches. Inline `set_memory`/`delete_memory`
+ * writes call this on success so a later tool round in the same response is
+ * seeded with the post-write usage total instead of a stale pre-write one.
  */
-export function invalidateRequestMemories(req: object): void {
-  requestMemoriesCache.delete(req);
+export function invalidateRequestMemories(req: object, agentId?: string): void {
+  requestMemoriesCache.get(req)?.delete(agentId ?? '');
 }
 
 /**
@@ -563,6 +600,7 @@ export async function buildInlineMemoryTool({
 
   const memoryConfig = req?.config?.memory;
   const validKeys = memoryConfig?.validKeys as string[] | undefined;
+  const memoryAgentId = getMemoryAgentId(agent);
 
   if (toolName === DELETE_MEMORY_TOOL_NAME) {
     const allowed = await isMemoryToolAllowed({
@@ -575,9 +613,10 @@ export async function buildInlineMemoryTool({
     }
     return createDeleteMemoryTool({
       userId,
+      agentId: memoryAgentId,
       deleteMemory: memoryMethods.deleteMemory,
       validKeys,
-      onWrite: () => invalidateRequestMemories(req),
+      onWrite: () => invalidateRequestMemories(req, memoryAgentId),
     });
   }
 
@@ -598,6 +637,7 @@ export async function buildInlineMemoryTool({
       const formatted = await getRequestMemories({
         req,
         userId,
+        agentId: memoryAgentId,
         getFormattedMemories: memoryMethods.getFormattedMemories,
       });
       totalTokens = formatted?.totalTokens ?? 0;
@@ -611,12 +651,13 @@ export async function buildInlineMemoryTool({
 
   return createMemoryTool({
     userId,
+    agentId: memoryAgentId,
     setMemory: memoryMethods.setMemory,
     validKeys,
     charLimit,
     tokenLimit,
     totalTokens,
-    onWrite: () => invalidateRequestMemories(req),
+    onWrite: () => invalidateRequestMemories(req, memoryAgentId),
   });
 }
 
@@ -647,6 +688,7 @@ export class BasicToolEndHandler implements EventHandler {
 export async function processMemory({
   res,
   userId,
+  agentId,
   setMemory,
   deleteMemory,
   messages,
@@ -665,6 +707,8 @@ export async function processMemory({
   setMemory: MemoryMethods['setMemory'];
   deleteMemory: MemoryMethods['deleteMemory'];
   userId: string | ObjectId;
+  /** Agent partition; omit for the shared personal pool */
+  agentId?: string;
   memory: string;
   messageId: string;
   conversationId: string;
@@ -680,6 +724,7 @@ export async function processMemory({
   try {
     const memoryTool = createMemoryTool({
       userId,
+      agentId,
       tokenLimit,
       setMemory,
       validKeys,
@@ -687,6 +732,7 @@ export async function processMemory({
     });
     const deleteMemoryTool = createDeleteMemoryTool({
       userId,
+      agentId,
       validKeys,
       deleteMemory,
     });
@@ -874,6 +920,7 @@ ${memory ?? 'No existing memories'}`;
 export async function createMemoryProcessor({
   res,
   userId,
+  agentId,
   messageId,
   memoryMethods,
   conversationId,
@@ -885,6 +932,8 @@ export async function createMemoryProcessor({
   messageId: string;
   conversationId: string;
   userId: string | ObjectId;
+  /** Agent partition; omit for the shared personal pool */
+  agentId?: string;
   memoryMethods: RequiredMemoryMethods;
   config?: MemoryConfig;
   streamId?: string | null;
@@ -895,6 +944,7 @@ export async function createMemoryProcessor({
 
   const { withKeys, withoutKeys, totalTokens } = await memoryMethods.getFormattedMemories({
     userId,
+    agentId,
   });
 
   return [
@@ -904,6 +954,7 @@ export async function createMemoryProcessor({
         return await processMemory({
           res,
           userId,
+          agentId,
           messages,
           validKeys,
           llmConfig,
diff --git a/packages/api/src/agents/validation.ts b/packages/api/src/agents/validation.ts
index 8fc63414e5..666dea3d9f 100644
--- a/packages/api/src/agents/validation.ts
+++ b/packages/api/src/agents/validation.ts
@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { MAX_SUBAGENTS, ViolationTypes, ErrorTypes } from 'librechat-data-provider';
+import { MemoryScope, MAX_SUBAGENTS, ViolationTypes, ErrorTypes } from 'librechat-data-provider';
 import type { Agent, TModelsConfig } from 'librechat-data-provider';
 import type { Request, Response } from 'express';
 
@@ -388,6 +388,7 @@ export const agentBaseSchema: z.ZodObject<
     tools: z.ZodOptional<z.ZodArray<z.ZodString, 'many'>>;
     skills: z.ZodOptional<z.ZodArray<z.ZodString, 'many'>>;
     skills_enabled: z.ZodOptional<z.ZodBoolean>;
+    memory_scope: z.ZodOptional<z.ZodNativeEnum<typeof MemoryScope>>;
     /** @deprecated Use edges instead */
     agent_ids: z.ZodOptional<z.ZodArray<z.ZodString, 'many'>>;
     edges: z.ZodOptional<
@@ -688,6 +689,7 @@ export const agentBaseSchema: z.ZodObject<
   tools: z.array(z.string()).optional(),
   skills: z.array(z.string()).optional(),
   skills_enabled: z.boolean().optional(),
+  memory_scope: z.nativeEnum(MemoryScope).optional(),
   /** @deprecated Use edges instead */
   agent_ids: z.array(z.string()).optional(),
   edges: z.array(graphEdgeSchema).optional(),
@@ -732,6 +734,7 @@ export const agentCreateSchema: z.ZodObject<
     model_parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     skills: z.ZodOptional<z.ZodArray<z.ZodString, 'many'>>;
     skills_enabled: z.ZodOptional<z.ZodBoolean>;
+    memory_scope: z.ZodOptional<z.ZodNativeEnum<typeof MemoryScope>>;
     agent_ids: z.ZodOptional<z.ZodArray<z.ZodString, 'many'>>;
     edges: z.ZodOptional<
       z.ZodArray<
@@ -1042,6 +1045,7 @@ export const agentUpdateSchema: z.ZodObject<
     tools: z.ZodOptional<z.ZodArray<z.ZodString, 'many'>>;
     skills: z.ZodOptional<z.ZodArray<z.ZodString, 'many'>>;
     skills_enabled: z.ZodOptional<z.ZodBoolean>;
+    memory_scope: z.ZodOptional<z.ZodNativeEnum<typeof MemoryScope>>;
     agent_ids: z.ZodOptional<z.ZodArray<z.ZodString, 'many'>>;
     edges: z.ZodOptional<
       z.ZodArray<
diff --git a/packages/data-provider/src/api-endpoints.ts b/packages/data-provider/src/api-endpoints.ts
index b08e9c5106..374a377f19 100644
--- a/packages/data-provider/src/api-endpoints.ts
+++ b/packages/data-provider/src/api-endpoints.ts
@@ -490,7 +490,8 @@ export const verifyTwoFactorTemp = () => `${BASE_URL}/api/auth/2fa/verify-temp`;
 
 /* Memories */
 export const memories = () => `${BASE_URL}/api/memories`;
-export const memory = (key: string) => `${memories()}/${encodeURIComponent(key)}`;
+export const memory = (key: string, agentId?: string) =>
+  `${memories()}/${encodeURIComponent(key)}${agentId ? `?agentId=${encodeURIComponent(agentId)}` : ''}`;
 export const memoryPreferences = () => `${memories()}/preferences`;
 
 export const searchPrincipals = (params: q.PrincipalSearchParams) => {
diff --git a/packages/data-provider/src/data-service.ts b/packages/data-provider/src/data-service.ts
index d06c138e0d..4d5fa37fa2 100644
--- a/packages/data-provider/src/data-service.ts
+++ b/packages/data-provider/src/data-service.ts
@@ -1307,16 +1307,17 @@ export const getMemories = (): Promise<q.MemoriesResponse> => {
   return request.get(endpoints.memories());
 };
 
-export const deleteMemory = (key: string): Promise<void> => {
-  return request.delete(endpoints.memory(key));
+export const deleteMemory = (key: string, agentId?: string): Promise<void> => {
+  return request.delete(endpoints.memory(key, agentId));
 };
 
 export const updateMemory = (
   key: string,
   value: string,
   originalKey?: string,
+  agentId?: string,
 ): Promise<q.TUserMemory> => {
-  return request.patch(endpoints.memory(originalKey || key), { key, value });
+  return request.patch(endpoints.memory(originalKey || key, agentId), { key, value });
 };
 
 export const updateMemoryPreferences = (preferences: {
@@ -1328,6 +1329,7 @@ export const updateMemoryPreferences = (preferences: {
 export const createMemory = (data: {
   key: string;
   value: string;
+  agentId?: string;
 }): Promise<{ created: boolean; memory: q.TUserMemory }> => {
   return request.post(endpoints.memories(), data);
 };
diff --git a/packages/data-provider/src/schemas.ts b/packages/data-provider/src/schemas.ts
index 47e40bf589..f36dee6258 100644
--- a/packages/data-provider/src/schemas.ts
+++ b/packages/data-provider/src/schemas.ts
@@ -344,6 +344,8 @@ export const defaultAgentFormValues = {
   subagents: undefined as
     | { enabled?: boolean; allowSelf?: boolean; agent_ids?: string[] }
     | undefined,
+  /** Memory partition: 'agent' isolates memories per (user, agent); default shared pool */
+  memory_scope: undefined as MemoryScope | undefined,
 };
 
 export const ImageVisionTool: FunctionTool = {
@@ -837,11 +839,23 @@ export const tMessageSchema = z.object({
   quotes: z.array(z.string()).optional(),
 });
 
+/**
+ * Which memory partition an agent reads/writes.
+ * `user` = the shared personal pool (default); `agent` = a partition
+ * isolated per (user, agent) so the agent only sees its own memories.
+ */
+export enum MemoryScope {
+  user = 'user',
+  agent = 'agent',
+}
+
 export type MemoryArtifact = {
   key: string;
   value?: string;
   tokenCount?: number;
   type: 'update' | 'delete' | 'error';
+  /** Agent partition the write targeted; absent = shared personal pool */
+  agentId?: string;
 };
 
 export type UIResource = {
diff --git a/packages/data-provider/src/types/assistants.ts b/packages/data-provider/src/types/assistants.ts
index bae2a7a72f..57e20f5dbd 100644
--- a/packages/data-provider/src/types/assistants.ts
+++ b/packages/data-provider/src/types/assistants.ts
@@ -1,5 +1,5 @@
 import type { OpenAPIV3 } from 'openapi-types';
-import type { AssistantsEndpoint, AgentProvider } from 'src/schemas';
+import type { AssistantsEndpoint, AgentProvider, MemoryScope } from 'src/schemas';
 import type { Agents, GraphEdge } from './agents';
 import type { ContentTypes } from './runs';
 import type { TFile } from './files';
@@ -301,6 +301,8 @@ export type Agent = {
   skills_enabled?: boolean;
   /** Subagent spawning configuration — isolated-context child agents. */
   subagents?: AgentSubagentsConfig;
+  /** Memory partition: `agent` isolates memories per (user, agent); default shared pool */
+  memory_scope?: MemoryScope;
 };
 
 export type TAgentsMap = Record<string, Agent | undefined>;
@@ -329,6 +331,7 @@ export type AgentCreateParams = {
   | 'skills'
   | 'skills_enabled'
   | 'subagents'
+  | 'memory_scope'
 >;
 
 export type AgentUpdateParams = {
@@ -356,6 +359,7 @@ export type AgentUpdateParams = {
   | 'skills'
   | 'skills_enabled'
   | 'subagents'
+  | 'memory_scope'
 >;
 
 export type AgentListParams = {
diff --git a/packages/data-provider/src/types/queries.ts b/packages/data-provider/src/types/queries.ts
index f763632d81..b7c968c4e4 100644
--- a/packages/data-provider/src/types/queries.ts
+++ b/packages/data-provider/src/types/queries.ts
@@ -150,6 +150,10 @@ export type TUserMemory = {
   value: string;
   updated_at: string;
   tokenCount?: number;
+  /** Agent partition this memory belongs to; absent = shared personal pool */
+  agentId?: string;
+  /** Display name of the partition's agent, resolved server-side when available */
+  agentName?: string;
 };
 
 export type MemoriesResponse = {
diff --git a/packages/data-schemas/src/methods/memory.spec.ts b/packages/data-schemas/src/methods/memory.spec.ts
new file mode 100644
index 0000000000..48c8c3b5ab
--- /dev/null
+++ b/packages/data-schemas/src/methods/memory.spec.ts
@@ -0,0 +1,156 @@
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import type { IMemoryEntry } from '~/types';
+import { createMemoryMethods, type MemoryMethods } from './memory';
+import { createModels } from '~/models';
+
+jest.mock('~/config/winston', () => ({
+  error: jest.fn(),
+  warn: jest.fn(),
+  info: jest.fn(),
+  debug: jest.fn(),
+}));
+
+let mongoServer: InstanceType<typeof MongoMemoryServer>;
+let MemoryEntry: mongoose.Model<IMemoryEntry>;
+let methods: MemoryMethods;
+
+const userId = new mongoose.Types.ObjectId();
+const otherUserId = new mongoose.Types.ObjectId();
+const agentId = 'agent_partition_a';
+const otherAgentId = 'agent_partition_b';
+
+beforeAll(async () => {
+  mongoServer = await MongoMemoryServer.create();
+  createModels(mongoose);
+  MemoryEntry = mongoose.models.MemoryEntry as mongoose.Model<IMemoryEntry>;
+  methods = createMemoryMethods(mongoose);
+  await mongoose.connect(mongoServer.getUri());
+});
+
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+beforeEach(async () => {
+  await MemoryEntry.deleteMany({});
+});
+
+describe('memory partitions', () => {
+  it('writes to the shared personal pool when agentId is omitted', async () => {
+    await methods.setMemory({ userId, key: 'preference', value: 'likes tea', tokenCount: 3 });
+
+    const personal = await methods.getUserMemories({ userId });
+    expect(personal).toHaveLength(1);
+    expect(personal[0].agentId == null).toBe(true);
+
+    const agentScoped = await methods.getUserMemories({ userId, agentId });
+    expect(agentScoped).toHaveLength(0);
+  });
+
+  it('isolates the same key across partitions', async () => {
+    await methods.setMemory({ userId, key: 'context', value: 'personal', tokenCount: 1 });
+    await methods.setMemory({ userId, key: 'context', value: 'agent a', tokenCount: 2, agentId });
+    await methods.setMemory({
+      userId,
+      key: 'context',
+      value: 'agent b',
+      tokenCount: 3,
+      agentId: otherAgentId,
+    });
+
+    const personal = await methods.getUserMemories({ userId });
+    const partitionA = await methods.getUserMemories({ userId, agentId });
+    const partitionB = await methods.getUserMemories({ userId, agentId: otherAgentId });
+
+    expect(personal.map((m) => m.value)).toEqual(['personal']);
+    expect(partitionA.map((m) => m.value)).toEqual(['agent a']);
+    expect(partitionB.map((m) => m.value)).toEqual(['agent b']);
+    expect(await MemoryEntry.countDocuments({ userId })).toBe(3);
+  });
+
+  it('upserts within a partition instead of duplicating', async () => {
+    await methods.setMemory({ userId, key: 'context', value: 'first', tokenCount: 1, agentId });
+    await methods.setMemory({ userId, key: 'context', value: 'second', tokenCount: 2, agentId });
+
+    const partitionA = await methods.getUserMemories({ userId, agentId });
+    expect(partitionA).toHaveLength(1);
+    expect(partitionA[0].value).toBe('second');
+  });
+
+  it('treats legacy entries without an agentId field as the personal pool', async () => {
+    await MemoryEntry.collection.insertOne({
+      userId,
+      key: 'legacy',
+      value: 'pre-partition entry',
+      tokenCount: 4,
+      updated_at: new Date(),
+    });
+
+    const personal = await methods.getUserMemories({ userId });
+    expect(personal.map((m) => m.key)).toEqual(['legacy']);
+
+    await methods.setMemory({ userId, key: 'legacy', value: 'updated', tokenCount: 4 });
+    expect(await MemoryEntry.countDocuments({ userId })).toBe(1);
+    expect((await methods.getUserMemories({ userId }))[0].value).toBe('updated');
+  });
+
+  it('deletes only within the targeted partition', async () => {
+    await methods.setMemory({ userId, key: 'context', value: 'personal', tokenCount: 1 });
+    await methods.setMemory({ userId, key: 'context', value: 'agent a', tokenCount: 2, agentId });
+
+    const agentDelete = await methods.deleteMemory({ userId, key: 'context', agentId });
+    expect(agentDelete.ok).toBe(true);
+    expect(await methods.getUserMemories({ userId })).toHaveLength(1);
+    expect(await methods.getUserMemories({ userId, agentId })).toHaveLength(0);
+
+    const missingDelete = await methods.deleteMemory({ userId, key: 'context', agentId });
+    expect(missingDelete.ok).toBe(false);
+  });
+
+  it('scopes createMemory duplicate detection to the partition', async () => {
+    await methods.createMemory({ userId, key: 'context', value: 'personal', tokenCount: 1 });
+
+    await expect(
+      methods.createMemory({ userId, key: 'context', value: 'dupe', tokenCount: 1 }),
+    ).rejects.toThrow('already exists');
+
+    const created = await methods.createMemory({
+      userId,
+      key: 'context',
+      value: 'agent a',
+      tokenCount: 2,
+      agentId,
+    });
+    expect(created.ok).toBe(true);
+  });
+
+  it('formats memories per partition with partition-scoped totals', async () => {
+    await methods.setMemory({ userId, key: 'one', value: 'personal one', tokenCount: 5 });
+    await methods.setMemory({ userId, key: 'two', value: 'agent two', tokenCount: 7, agentId });
+
+    const personal = await methods.getFormattedMemories({ userId });
+    expect(personal.totalTokens).toBe(5);
+    expect(personal.withoutKeys).toContain('personal one');
+    expect(personal.withoutKeys).not.toContain('agent two');
+
+    const partitionA = await methods.getFormattedMemories({ userId, agentId });
+    expect(partitionA.totalTokens).toBe(7);
+    expect(partitionA.withKeys).toContain('"key": "two"');
+    expect(partitionA.withKeys).not.toContain('personal one');
+  });
+
+  it('returns every partition from getAllUserMemories and wipes them all on deleteAllUserMemories', async () => {
+    await methods.setMemory({ userId, key: 'one', value: 'personal', tokenCount: 1 });
+    await methods.setMemory({ userId, key: 'two', value: 'agent a', tokenCount: 1, agentId });
+    await methods.setMemory({ userId: otherUserId, key: 'three', value: 'other', tokenCount: 1 });
+
+    const all = await methods.getAllUserMemories(userId);
+    expect(all).toHaveLength(2);
+
+    const deleted = await methods.deleteAllUserMemories(userId);
+    expect(deleted).toBe(2);
+    expect(await MemoryEntry.countDocuments({ userId: otherUserId })).toBe(1);
+  });
+});
diff --git a/packages/data-schemas/src/methods/memory.ts b/packages/data-schemas/src/methods/memory.ts
index 7c89535198..6e5cc82263 100644
--- a/packages/data-schemas/src/methods/memory.ts
+++ b/packages/data-schemas/src/methods/memory.ts
@@ -9,14 +9,32 @@ const formatDate = (date: Date): string => {
   return date.toISOString().split('T')[0];
 };
 
+/** Partition filter: `agentId: null` matches both null and missing fields,
+ *  so pre-partition entries remain part of the shared personal pool. */
+const partitionFilter = (agentId?: string) => ({ agentId: agentId ?? null });
+
 // Factory function that takes mongoose instance and returns the methods
 export function createMemoryMethods(mongoose: typeof import('mongoose')): {
-  setMemory: ({ userId, key, value, tokenCount }: t.SetMemoryParams) => Promise<t.MemoryResult>;
-  createMemory: ({ userId, key, value, tokenCount }: t.SetMemoryParams) => Promise<t.MemoryResult>;
-  deleteMemory: ({ userId, key }: t.DeleteMemoryParams) => Promise<t.MemoryResult>;
+  setMemory: ({
+    userId,
+    key,
+    value,
+    tokenCount,
+    agentId,
+  }: t.SetMemoryParams) => Promise<t.MemoryResult>;
+  createMemory: ({
+    userId,
+    key,
+    value,
+    tokenCount,
+    agentId,
+  }: t.SetMemoryParams) => Promise<t.MemoryResult>;
+  deleteMemory: ({ userId, key, agentId }: t.DeleteMemoryParams) => Promise<t.MemoryResult>;
   getAllUserMemories: (userId: string | Types.ObjectId) => Promise<t.IMemoryEntryLean[]>;
+  getUserMemories: ({ userId, agentId }: t.GetUserMemoriesParams) => Promise<t.IMemoryEntryLean[]>;
   getFormattedMemories: ({
     userId,
+    agentId,
   }: t.GetFormattedMemoriesParams) => Promise<t.FormattedMemoriesResult>;
   deleteAllUserMemories: (userId: string | Types.ObjectId) => Promise<number>;
 } {
@@ -29,6 +47,7 @@ export function createMemoryMethods(mongoose: typeof import('mongoose')): {
     key,
     value,
     tokenCount = 0,
+    agentId,
   }: t.SetMemoryParams): Promise<t.MemoryResult> {
     try {
       if (key?.toLowerCase() === 'nothing') {
@@ -36,7 +55,11 @@ export function createMemoryMethods(mongoose: typeof import('mongoose')): {
       }
 
       const MemoryEntry = mongoose.models.MemoryEntry;
-      const existingMemory = await MemoryEntry.findOne({ userId, key });
+      const existingMemory = await MemoryEntry.findOne({
+        userId,
+        key,
+        ...partitionFilter(agentId),
+      });
       if (existingMemory) {
         throw new Error('Memory with this key already exists');
       }
@@ -46,6 +69,7 @@ export function createMemoryMethods(mongoose: typeof import('mongoose')): {
         key,
         value,
         tokenCount,
+        ...(agentId ? { agentId } : {}),
         updated_at: new Date(),
       });
 
@@ -65,6 +89,7 @@ export function createMemoryMethods(mongoose: typeof import('mongoose')): {
     key,
     value,
     tokenCount = 0,
+    agentId,
   }: t.SetMemoryParams): Promise<t.MemoryResult> {
     try {
       if (key?.toLowerCase() === 'nothing') {
@@ -73,10 +98,11 @@ export function createMemoryMethods(mongoose: typeof import('mongoose')): {
 
       const MemoryEntry = mongoose.models.MemoryEntry;
       await MemoryEntry.findOneAndUpdate(
-        { userId, key },
+        { userId, key, ...partitionFilter(agentId) },
         {
           value,
           tokenCount,
+          ...(agentId ? { agentId } : {}),
           updated_at: new Date(),
         },
         {
@@ -96,10 +122,18 @@ export function createMemoryMethods(mongoose: typeof import('mongoose')): {
   /**
    * Deletes a specific memory entry for a user
    */
-  async function deleteMemory({ userId, key }: t.DeleteMemoryParams): Promise<t.MemoryResult> {
+  async function deleteMemory({
+    userId,
+    key,
+    agentId,
+  }: t.DeleteMemoryParams): Promise<t.MemoryResult> {
     try {
       const MemoryEntry = mongoose.models.MemoryEntry;
-      const result = await MemoryEntry.findOneAndDelete({ userId, key });
+      const result = await MemoryEntry.findOneAndDelete({
+        userId,
+        key,
+        ...partitionFilter(agentId),
+      });
       return { ok: !!result };
     } catch (error) {
       throw new Error(
@@ -109,7 +143,7 @@ export function createMemoryMethods(mongoose: typeof import('mongoose')): {
   }
 
   /**
-   * Gets all memory entries for a user
+   * Gets all memory entries for a user across every partition
    */
   async function getAllUserMemories(
     userId: string | Types.ObjectId,
@@ -125,13 +159,35 @@ export function createMemoryMethods(mongoose: typeof import('mongoose')): {
   }
 
   /**
-   * Gets and formats all memories for a user in two different formats
+   * Gets a user's memory entries for a single partition
+   * (the shared personal pool when `agentId` is omitted)
+   */
+  async function getUserMemories({
+    userId,
+    agentId,
+  }: t.GetUserMemoriesParams): Promise<t.IMemoryEntryLean[]> {
+    try {
+      const MemoryEntry = mongoose.models.MemoryEntry;
+      return (await MemoryEntry.find({
+        userId,
+        ...partitionFilter(agentId),
+      }).lean()) as t.IMemoryEntryLean[];
+    } catch (error) {
+      throw new Error(
+        `Failed to get memories: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      );
+    }
+  }
+
+  /**
+   * Gets and formats a partition's memories for a user in two different formats
    */
   async function getFormattedMemories({
     userId,
+    agentId,
   }: t.GetFormattedMemoriesParams): Promise<t.FormattedMemoriesResult> {
     try {
-      const memories = await getAllUserMemories(userId);
+      const memories = await getUserMemories({ userId, agentId });
 
       if (!memories || memories.length === 0) {
         return { withKeys: '', withoutKeys: '', totalTokens: 0 };
@@ -187,6 +243,7 @@ export function createMemoryMethods(mongoose: typeof import('mongoose')): {
     createMemory,
     deleteMemory,
     getAllUserMemories,
+    getUserMemories,
     getFormattedMemories,
     deleteAllUserMemories,
   };
diff --git a/packages/data-schemas/src/schema/agent.ts b/packages/data-schemas/src/schema/agent.ts
index 5ef6a9cf0d..7000d28688 100644
--- a/packages/data-schemas/src/schema/agent.ts
+++ b/packages/data-schemas/src/schema/agent.ts
@@ -125,6 +125,12 @@ const agentSchema: Schema<IAgent> = new Schema<IAgent>(
       type: Schema.Types.Mixed,
       default: undefined,
     },
+    /** Memory partition: 'agent' isolates memories per (user, agent); default shared pool */
+    memory_scope: {
+      type: String,
+      enum: ['user', 'agent'],
+      default: undefined,
+    },
     tenantId: {
       type: String,
       index: true,
diff --git a/packages/data-schemas/src/schema/memory.ts b/packages/data-schemas/src/schema/memory.ts
index 773fa87115..fc58833458 100644
--- a/packages/data-schemas/src/schema/memory.ts
+++ b/packages/data-schemas/src/schema/memory.ts
@@ -20,6 +20,11 @@ const MemoryEntrySchema: Schema<IMemoryEntry> = new Schema({
     type: String,
     required: true,
   },
+  /** Agent partition; null/absent = shared personal pool */
+  agentId: {
+    type: String,
+    default: undefined,
+  },
   tokenCount: {
     type: Number,
     default: 0,
@@ -34,4 +39,6 @@ const MemoryEntrySchema: Schema<IMemoryEntry> = new Schema({
   },
 });
 
+MemoryEntrySchema.index({ userId: 1, agentId: 1, key: 1 });
+
 export default MemoryEntrySchema;
diff --git a/packages/data-schemas/src/types/agent.ts b/packages/data-schemas/src/types/agent.ts
index 416112141d..5c833c3484 100644
--- a/packages/data-schemas/src/types/agent.ts
+++ b/packages/data-schemas/src/types/agent.ts
@@ -1,6 +1,7 @@
 import { Document, Types } from 'mongoose';
 import type {
   GraphEdge,
+  MemoryScope,
   AgentToolOptions,
   AgentToolResources,
   AgentSubagentsConfig,
@@ -50,5 +51,7 @@ export interface IAgent extends Omit<Document, 'model'> {
   tool_options?: AgentToolOptions;
   /** Subagent spawning configuration — isolated-context child agents. */
   subagents?: AgentSubagentsConfig;
+  /** Memory partition: 'agent' isolates memories per (user, agent); default shared pool */
+  memory_scope?: MemoryScope;
   tenantId?: string;
 }
diff --git a/packages/data-schemas/src/types/memory.ts b/packages/data-schemas/src/types/memory.ts
index 4d9b4fbefd..06f5905496 100644
--- a/packages/data-schemas/src/types/memory.ts
+++ b/packages/data-schemas/src/types/memory.ts
@@ -5,6 +5,8 @@ export interface IMemoryEntry extends Document {
   userId: Types.ObjectId;
   key: string;
   value: string;
+  /** Agent partition; null/absent = shared personal pool */
+  agentId?: string;
   tokenCount?: number;
   updated_at?: Date;
   tenantId?: string;
@@ -15,6 +17,7 @@ export interface IMemoryEntryLean {
   userId: Types.ObjectId;
   key: string;
   value: string;
+  agentId?: string;
   tokenCount?: number;
   updated_at?: Date;
   __v?: number;
@@ -26,15 +29,24 @@ export interface SetMemoryParams {
   key: string;
   value: string;
   tokenCount?: number;
+  /** Agent partition; omit for the shared personal pool */
+  agentId?: string;
 }
 
 export interface DeleteMemoryParams {
   userId: string | Types.ObjectId;
   key: string;
+  agentId?: string;
+}
+
+export interface GetUserMemoriesParams {
+  userId: string | Types.ObjectId;
+  agentId?: string;
 }
 
 export interface GetFormattedMemoriesParams {
   userId: string | Types.ObjectId;
+  agentId?: string;
 }
 
 // Result interfaces