diff --git a/frontend/src/app/routes/settings.tsx b/frontend/src/app/routes/settings.tsx
index 8c2778f45..2dfa7375e 100644
--- a/frontend/src/app/routes/settings.tsx
+++ b/frontend/src/app/routes/settings.tsx
@@ -8,6 +8,7 @@ import GeneralTab from '@/components/settings/general-tab'
 import { Button } from '@/components/ui/button'
 import { Icon } from '@/components/ui/icon'
 import DataControlTab from '@/components/settings/data-control-tab'
+import PersonalizationTab from '@/components/settings/personalization-tab'
 import CreditUsage from '@/components/credit-usage'
 import SubscriptionTab from '@/components/settings/subscription-tab'
 import { Logo } from '@/components/logo'
@@ -18,6 +19,7 @@ import { useIsSageTheme } from '@/hooks/use-is-sage-theme'
 
 enum SettingTab {
     GENERAL = 'general',
+    PERSONALIZATION = 'personalization',
     ACCOUNT = 'account',
     NOTIFICATIONS = 'notifications',
     CONNECTORS = 'connectors',
@@ -37,6 +39,7 @@ const Settings = () => {
 
     const tabs = [
         { key: SettingTab.GENERAL, label: t('settings.tabs.general') },
+        { key: SettingTab.PERSONALIZATION, label: t('settings.tabs.personalization') },
         { key: SettingTab.ACCOUNT, label: t('settings.tabs.account') },
         // { key: SettingTab.NOTIFICATIONS, label: t('settings.tabs.notifications') },
         // { key: SettingTab.CONNECTORS, label: t('settings.tabs.connectors') },
@@ -56,6 +59,8 @@ const Settings = () => {
         switch (activeTab) {
             case SettingTab.GENERAL:
                 return <GeneralTab />
+            case SettingTab.PERSONALIZATION:
+                return <PersonalizationTab />
             case SettingTab.ACCOUNT:
                 return <AccountTab />
             case SettingTab.DATA_CONTROLS:
diff --git a/frontend/src/components/agent-setting/tool-setting.tsx b/frontend/src/components/agent-setting/tool-setting.tsx
index 3d760e4cc..87b21834a 100644
--- a/frontend/src/components/agent-setting/tool-setting.tsx
+++ b/frontend/src/components/agent-setting/tool-setting.tsx
@@ -40,6 +40,7 @@ enum TOOL {
     REVIEW_AGENT = 'Review Agent',
     CODEX = 'Codex',
     CLAUDE_CODE = 'Claude Code',
+    AGENTIC_MEMORY = 'Agentic Memory',
     WEB_SEARCH = 'Web Search',
     WEB_VISIT = 'Web Visit',
     IMAGE_SEARCH = 'Image Search',
@@ -160,6 +161,9 @@ const ToolSetting = ({ className }: ToolSettingProps) => {
                 case TOOL.CLAUDE_CODE:
                     isActive = toolSettings?.claude_code || false
                     break
+                case TOOL.AGENTIC_MEMORY:
+                    isActive = toolSettings?.agentic_memory || false
+                    break
                 default:
                     isActive = tool.isActive || false
             }
@@ -222,6 +226,9 @@ const ToolSetting = ({ className }: ToolSettingProps) => {
                     newSettings.claude_code = shouldEnableClaudeCode
                     break
                 }
+                case TOOL.AGENTIC_MEMORY:
+                    newSettings.agentic_memory = checked
+                    break
                 case TOOL.WEB_SEARCH:
                     newChatSettings.web_search = checked
                     break
diff --git a/frontend/src/components/settings/memory-table.tsx b/frontend/src/components/settings/memory-table.tsx
new file mode 100644
index 000000000..e3e1ba7f2
--- /dev/null
+++ b/frontend/src/components/settings/memory-table.tsx
@@ -0,0 +1,667 @@
+import { useCallback, useEffect, useMemo, useState } from 'react'
+import { useTranslation } from 'react-i18next'
+import dayjs from 'dayjs'
+import utc from 'dayjs/plugin/utc'
+
+import { memoryService } from '@/services/memory.service'
+import type { Memory } from '@/typings/memory'
+import { cn } from '@/lib/utils'
+import { Button } from '../ui/button'
+import { Input } from '../ui/input'
+import { Textarea } from '../ui/textarea'
+import { Badge } from '../ui/badge'
+import { Icon } from '../ui/icon'
+import {
+    Table,
+    TableBody,
+    TableCell,
+    TableHead,
+    TableHeader,
+    TableRow
+} from '../ui/table'
+import {
+    Dialog,
+    DialogContent,
+    DialogFooter,
+    DialogHeader,
+    DialogTitle
+} from '../ui/dialog'
+import {
+    Select,
+    SelectContent,
+    SelectItem,
+    SelectTrigger,
+    SelectValue
+} from '../ui/select'
+import {
+    Collapsible,
+    CollapsibleContent,
+    CollapsibleTrigger
+} from '../ui/collapsible'
+import { toast } from 'sonner'
+
+dayjs.extend(utc)
+
+const PER_PAGE = 10
+
+const MemoryTable = () => {
+    const { t } = useTranslation()
+
+    // Data
+    const [memories, setMemories] = useState<Memory[]>([])
+    const [loading, setLoading] = useState(false)
+    const [allTopics, setAllTopics] = useState<string[]>([])
+
+    // Pagination
+    const [page, setPage] = useState(1)
+    const [total, setTotal] = useState(0)
+
+    // Search / Filter / Sort
+    const [search, setSearch] = useState('')
+    const [debouncedSearch, setDebouncedSearch] = useState('')
+    const [selectedTopic, setSelectedTopic] = useState('')
+    const [sortBy, setSortBy] = useState<
+        'updated_at' | 'memory' | 'topics_count'
+    >('updated_at')
+    const [sortOrder, setSortOrder] = useState<'asc' | 'desc'>('desc')
+
+    // Expandable rows
+    const [expandedRows, setExpandedRows] = useState<Set<string>>(new Set())
+
+    // Dialog states
+    const [formDialogOpen, setFormDialogOpen] = useState(false)
+    const [editingMemory, setEditingMemory] = useState<Memory | null>(null)
+    const [formMemory, setFormMemory] = useState('')
+    const [formTopics, setFormTopics] = useState('')
+    const [formSaving, setFormSaving] = useState(false)
+
+    // Delete state
+    const [deleteDialogOpen, setDeleteDialogOpen] = useState(false)
+    const [pendingDeleteId, setPendingDeleteId] = useState<string | null>(null)
+
+    const totalPages = useMemo(
+        () => Math.max(1, Math.ceil(total / PER_PAGE)),
+        [total]
+    )
+
+    // Fetch memories
+    const fetchMemories = useCallback(async () => {
+        setLoading(true)
+        try {
+            const result = await memoryService.listMemories({
+                page,
+                perPage: PER_PAGE,
+                search: debouncedSearch || undefined,
+                topics: selectedTopic || undefined,
+                sortBy,
+                sortOrder
+            })
+            setMemories(result.memories)
+            setTotal(result.total)
+        } catch {
+            toast.error(t('errors.generic'))
+        } finally {
+            setLoading(false)
+        }
+    }, [page, debouncedSearch, selectedTopic, sortBy, sortOrder, t])
+
+    // Debounce search
+    useEffect(() => {
+        const timer = setTimeout(() => {
+            setDebouncedSearch(search)
+            setPage(1)
+        }, 300)
+        return () => clearTimeout(timer)
+    }, [search])
+
+    // Fetch on param change
+    useEffect(() => {
+        fetchMemories()
+    }, [fetchMemories])
+
+    // Load topics for filter
+    useEffect(() => {
+        memoryService.getTopics().then(setAllTopics).catch(() => {})
+    }, [])
+
+    // Refresh topics after mutations
+    const refreshTopics = () => {
+        memoryService.getTopics().then(setAllTopics).catch(() => {})
+    }
+
+    // Sort handler
+    const handleSort = (column: 'updated_at' | 'memory' | 'topics_count') => {
+        if (sortBy === column) {
+            setSortOrder((prev) => (prev === 'asc' ? 'desc' : 'asc'))
+        } else {
+            setSortBy(column)
+            setSortOrder('desc')
+        }
+        setPage(1)
+    }
+
+    // Expand/collapse row
+    const toggleRow = (memoryId: string) => {
+        setExpandedRows((prev) => {
+            const next = new Set(prev)
+            if (next.has(memoryId)) next.delete(memoryId)
+            else next.add(memoryId)
+            return next
+        })
+    }
+
+    // Open add dialog
+    const openAddDialog = () => {
+        setEditingMemory(null)
+        setFormMemory('')
+        setFormTopics('')
+        setFormDialogOpen(true)
+    }
+
+    // Open edit dialog
+    const openEditDialog = (memory: Memory) => {
+        setEditingMemory(memory)
+        setFormMemory(memory.memory)
+        setFormTopics(memory.topics?.join(', ') ?? '')
+        setFormDialogOpen(true)
+    }
+
+    // Save (add or edit)
+    const handleSave = async () => {
+        if (!formMemory.trim()) return
+        setFormSaving(true)
+
+        const topicsList = formTopics
+            .split(',')
+            .map((t) => t.trim())
+            .filter(Boolean)
+
+        try {
+            if (editingMemory) {
+                await memoryService.updateMemory(editingMemory.memory_id, {
+                    memory: formMemory.trim(),
+                    topics: topicsList
+                })
+            } else {
+                await memoryService.createMemory({
+                    memory: formMemory.trim(),
+                    topics: topicsList
+                })
+            }
+            setFormDialogOpen(false)
+            fetchMemories()
+            refreshTopics()
+        } catch {
+            toast.error(t('errors.generic'))
+        } finally {
+            setFormSaving(false)
+        }
+    }
+
+    // Delete
+    const handleDelete = async () => {
+        if (!pendingDeleteId) return
+        try {
+            await memoryService.deleteMemory(pendingDeleteId)
+            setDeleteDialogOpen(false)
+            setPendingDeleteId(null)
+            fetchMemories()
+            refreshTopics()
+        } catch {
+            toast.error(t('errors.generic'))
+        }
+    }
+
+    // Pagination
+    const goPrev = () => setPage((p) => Math.max(1, p - 1))
+    const goNext = () => setPage((p) => Math.min(totalPages, p + 1))
+
+    const SortIndicator = ({
+        column
+    }: {
+        column: 'updated_at' | 'memory' | 'topics_count'
+    }) =>
+        sortBy === column ? (
+            <span className="ml-1 text-xs">
+                {sortOrder === 'asc' ? '↑' : '↓'}
+            </span>
+        ) : null
+
+    return (
+        <div>
+            {/* Header */}
+            <div className="mb-4">
+                <h2 className="text-[18px] font-semibold mb-1">
+                    {t('settings.personalization.memoriesTitle')}
+                </h2>
+                <p className="text-xs">
+                    {t('settings.personalization.memoriesDescription')}
+                </p>
+            </div>
+
+            {/* Toolbar */}
+            <div className="flex flex-col md:flex-row gap-3 mb-4">
+                <Input
+                    className="flex-1"
+                    placeholder={t(
+                        'settings.personalization.searchPlaceholder'
+                    )}
+                    value={search}
+                    onChange={(e) => setSearch(e.target.value)}
+                />
+                <Select
+                    value={selectedTopic}
+                    onValueChange={(v) => {
+                        setSelectedTopic(v === '__all__' ? '' : v)
+                        setPage(1)
+                    }}
+                >
+                    <SelectTrigger className="w-full md:w-[200px]">
+                        <SelectValue
+                            placeholder={t(
+                                'settings.personalization.filterByTopics'
+                            )}
+                        />
+                    </SelectTrigger>
+                    <SelectContent>
+                        <SelectItem value="__all__">
+                            {t('settings.personalization.allTopics')}
+                        </SelectItem>
+                        {allTopics.map((topic) => (
+                            <SelectItem key={topic} value={topic}>
+                                {topic}
+                            </SelectItem>
+                        ))}
+                    </SelectContent>
+                </Select>
+                <Button
+                    onClick={openAddDialog}
+                    className="h-12 bg-firefly border-firefly text-sky-blue-2 dark:bg-sky-blue dark:border-sky-blue-2 dark:text-black hover:opacity-90 px-6 rounded-xl text-sm font-medium"
+                >
+                    {t('settings.personalization.addMemory')}
+                </Button>
+            </div>
+
+            {/* Table */}
+            <div className="rounded-xl overflow-hidden border border-white/10">
+                <Table>
+                    <TableHeader>
+                        <TableRow>
+                            <TableHead className="w-8" />
+                            <TableHead className="py-3">
+                                <button
+                                    className="flex items-center cursor-pointer font-medium"
+                                    onClick={() => handleSort('memory')}
+                                >
+                                    {t(
+                                        'settings.personalization.columnMemory'
+                                    )}
+                                    <SortIndicator column="memory" />
+                                </button>
+                            </TableHead>
+                            <TableHead className="py-3 hidden md:table-cell">
+                                <button
+                                    className="flex items-center cursor-pointer font-medium"
+                                    onClick={() =>
+                                        handleSort('topics_count')
+                                    }
+                                >
+                                    {t(
+                                        'settings.personalization.columnTopics'
+                                    )}
+                                    <SortIndicator column="topics_count" />
+                                </button>
+                            </TableHead>
+                            <TableHead className="py-3">
+                                <button
+                                    className="flex items-center cursor-pointer font-medium"
+                                    onClick={() =>
+                                        handleSort('updated_at')
+                                    }
+                                >
+                                    {t(
+                                        'settings.personalization.columnUpdatedAt'
+                                    )}
+                                    <SortIndicator column="updated_at" />
+                                </button>
+                            </TableHead>
+                            <TableHead className="py-3 w-20" />
+                        </TableRow>
+                    </TableHeader>
+                    <TableBody>
+                        {loading && (
+                            <TableRow>
+                                <TableCell colSpan={5} className="py-8 text-center">
+                                    {t('common.loading')}
+                                </TableCell>
+                            </TableRow>
+                        )}
+                        {!loading && memories.length === 0 && (
+                            <TableRow>
+                                <TableCell colSpan={5} className="py-8 text-center text-muted-foreground">
+                                    {debouncedSearch || selectedTopic
+                                        ? t('settings.personalization.noMatchingMemories')
+                                        : t('settings.personalization.noMemories')}
+                                </TableCell>
+                            </TableRow>
+                        )}
+                        {!loading &&
+                            memories.map((mem) => (
+                                <Collapsible
+                                    key={mem.memory_id}
+                                    open={expandedRows.has(mem.memory_id)}
+                                    onOpenChange={() =>
+                                        toggleRow(mem.memory_id)
+                                    }
+                                    asChild
+                                >
+                                    <>
+                                        <TableRow className="group">
+                                            <TableCell className="py-3 pl-2">
+                                                <CollapsibleTrigger asChild>
+                                                    <button className="cursor-pointer p-1">
+                                                        <span
+                                                            className={cn(
+                                                                'inline-block transition-transform text-xs',
+                                                                expandedRows.has(
+                                                                    mem.memory_id
+                                                                ) &&
+                                                                    'rotate-90'
+                                                            )}
+                                                        >
+                                                            ▶
+                                                        </span>
+                                                    </button>
+                                                </CollapsibleTrigger>
+                                            </TableCell>
+                                            <TableCell className="py-3 max-w-[300px]">
+                                                <span className="line-clamp-2 text-sm">
+                                                    {mem.memory}
+                                                </span>
+                                            </TableCell>
+                                            <TableCell className="py-3 hidden md:table-cell">
+                                                <div className="flex flex-wrap gap-1">
+                                                    {mem.topics?.map(
+                                                        (topic) => (
+                                                            <Badge
+                                                                key={topic}
+                                                                variant="outline"
+                                                                className="text-[10px] px-1.5 py-0"
+                                                            >
+                                                                {topic}
+                                                            </Badge>
+                                                        )
+                                                    )}
+                                                </div>
+                                            </TableCell>
+                                            <TableCell className="py-3 text-sm text-muted-foreground whitespace-nowrap">
+                                                {mem.updated_at
+                                                    ? dayjs
+                                                          .unix(
+                                                              mem.updated_at
+                                                          )
+                                                          .format(
+                                                              'DD MMM YYYY'
+                                                          )
+                                                    : '—'}
+                                            </TableCell>
+                                            <TableCell className="py-3">
+                                                <div className="flex items-center gap-1">
+                                                    <Button
+                                                        variant="ghost"
+                                                        size="icon"
+                                                        className="size-8 text-black/70 dark:text-white/70 hover:text-black dark:hover:text-white hover:bg-black/10 dark:hover:bg-white/10"
+                                                        onClick={(e) => {
+                                                            e.stopPropagation()
+                                                            openEditDialog(
+                                                                mem
+                                                            )
+                                                        }}
+                                                        title={t(
+                                                            'settings.personalization.editMemory'
+                                                        )}
+                                                    >
+                                                        <Icon
+                                                            name="pencil-edit"
+                                                            className="size-4 stroke-current"
+                                                        />
+                                                    </Button>
+                                                    <Button
+                                                        variant="ghost"
+                                                        size="icon"
+                                                        className="size-8 text-red-400 hover:text-red-400 hover:bg-red-500/20"
+                                                        onClick={(e) => {
+                                                            e.stopPropagation()
+                                                            setPendingDeleteId(
+                                                                mem.memory_id
+                                                            )
+                                                            setDeleteDialogOpen(
+                                                                true
+                                                            )
+                                                        }}
+                                                        title={t(
+                                                            'settings.personalization.deleteMemory'
+                                                        )}
+                                                    >
+                                                        <Icon
+                                                            name="trash"
+                                                            className="size-4"
+                                                        />
+                                                    </Button>
+                                                </div>
+                                            </TableCell>
+                                        </TableRow>
+                                        <CollapsibleContent asChild>
+                                            <tr>
+                                                <td
+                                                    colSpan={5}
+                                                    className="bg-white/5 dark:bg-white/5 px-4 py-3"
+                                                >
+                                                    <div className="text-sm space-y-2">
+                                                        <p className="whitespace-pre-wrap">
+                                                            {mem.memory}
+                                                        </p>
+                                                        {mem.topics &&
+                                                            mem.topics.length >
+                                                                0 && (
+                                                                <div className="flex flex-wrap gap-1 md:hidden">
+                                                                    {mem.topics.map(
+                                                                        (
+                                                                            topic
+                                                                        ) => (
+                                                                            <Badge
+                                                                                key={
+                                                                                    topic
+                                                                                }
+                                                                                variant="outline"
+                                                                                className="text-[10px] px-1.5 py-0"
+                                                                            >
+                                                                                {
+                                                                                    topic
+                                                                                }
+                                                                            </Badge>
+                                                                        )
+                                                                    )}
+                                                                </div>
+                                                            )}
+                                                        {mem.created_at && (
+                                                            <div className="text-xs text-muted-foreground">
+                                                                <span>
+                                                                    {t(
+                                                                        'settings.personalization.expandCreatedAt'
+                                                                    )}
+                                                                    :{' '}
+                                                                    {dayjs
+                                                                        .unix(
+                                                                            mem.created_at
+                                                                        )
+                                                                        .format(
+                                                                            'DD MMM YYYY, HH:mm'
+                                                                        )}
+                                                                </span>
+                                                            </div>
+                                                        )}
+                                                    </div>
+                                                </td>
+                                            </tr>
+                                        </CollapsibleContent>
+                                    </>
+                                </Collapsible>
+                            ))}
+                    </TableBody>
+                </Table>
+            </div>
+
+            {/* Pagination */}
+            {total > PER_PAGE && (
+                <div className="flex items-center justify-center gap-2 py-4 select-none">
+                    <Button
+                        variant="ghost"
+                        size="sm"
+                        onClick={goPrev}
+                        disabled={page === 1}
+                    >
+                        <Icon
+                            name="arrow-left-2"
+                            className="size-4 fill-black/40 dark:fill-white/40"
+                        />
+                        {t('common.previous')}
+                    </Button>
+                    <Button
+                        variant="ghost"
+                        size="sm"
+                        className="pointer-events-none font-medium"
+                    >
+                        {page}
+                    </Button>
+                    {page < totalPages && (
+                        <Button
+                            variant="ghost"
+                            size="sm"
+                            onClick={() =>
+                                setPage(Math.min(totalPages, page + 1))
+                            }
+                            className="text-black/60 dark:text-white/60"
+                        >
+                            {page + 1}
+                        </Button>
+                    )}
+                    <Button
+                        variant="ghost"
+                        size="sm"
+                        onClick={goNext}
+                        disabled={page === totalPages}
+                    >
+                        {t('common.next')}
+                        <Icon
+                            name="arrow-right-2"
+                            className="size-4 fill-black/40 dark:fill-white/40"
+                        />
+                    </Button>
+                </div>
+            )}
+
+            {/* Add/Edit Dialog */}
+            <Dialog open={formDialogOpen} onOpenChange={setFormDialogOpen}>
+                <DialogContent>
+                    <DialogHeader>
+                        <DialogTitle className="text-black dark:text-white">
+                            {editingMemory
+                                ? t('settings.personalization.editMemory')
+                                : t('settings.personalization.addMemory')}
+                        </DialogTitle>
+                    </DialogHeader>
+                    <div className="space-y-4 py-2">
+                        <div>
+                            <label className="text-sm font-medium mb-1 block">
+                                {t(
+                                    'settings.personalization.memoryContent'
+                                )}
+                            </label>
+                            <Textarea
+                                value={formMemory}
+                                onChange={(e) =>
+                                    setFormMemory(e.target.value)
+                                }
+                                placeholder={t(
+                                    'settings.personalization.memoryContentPlaceholder'
+                                )}
+                                className="min-h-[100px]"
+                            />
+                        </div>
+                        <div>
+                            <label className="text-sm font-medium mb-1 block">
+                                {t(
+                                    'settings.personalization.topicsLabel'
+                                )}
+                            </label>
+                            <Input
+                                value={formTopics}
+                                onChange={(e) =>
+                                    setFormTopics(e.target.value)
+                                }
+                                placeholder={t(
+                                    'settings.personalization.topicsPlaceholder'
+                                )}
+                            />
+                        </div>
+                    </div>
+                    <DialogFooter>
+                        <Button
+                            variant="outline"
+                            onClick={() => setFormDialogOpen(false)}
+                        >
+                            {t('common.cancel')}
+                        </Button>
+                        <Button
+                            onClick={handleSave}
+                            disabled={!formMemory.trim() || formSaving}
+                            className="bg-firefly border-firefly text-sky-blue-2 dark:bg-sky-blue dark:border-sky-blue-2 dark:text-black hover:opacity-90 disabled:opacity-50"
+                        >
+                            {formSaving
+                                ? t('common.saving')
+                                : t('common.save')}
+                        </Button>
+                    </DialogFooter>
+                </DialogContent>
+            </Dialog>
+
+            {/* Delete Confirmation */}
+            <Dialog
+                open={deleteDialogOpen}
+                onOpenChange={setDeleteDialogOpen}
+            >
+                <DialogContent>
+                    <DialogHeader>
+                        <DialogTitle className="text-black dark:text-white">
+                            {t(
+                                'settings.personalization.deleteMemoryConfirmTitle'
+                            )}
+                        </DialogTitle>
+                    </DialogHeader>
+                    <p className="text-sm text-black/70 dark:text-white/70 py-2">
+                        {t(
+                            'settings.personalization.deleteMemoryConfirmDescription'
+                        )}
+                    </p>
+                    <DialogFooter>
+                        <Button
+                            variant="outline"
+                            onClick={() => setDeleteDialogOpen(false)}
+                        >
+                            {t('common.cancel')}
+                        </Button>
+                        <Button
+                            onClick={handleDelete}
+                            className="bg-red-500 hover:bg-red-600 text-white"
+                        >
+                            {t('common.delete')}
+                        </Button>
+                    </DialogFooter>
+                </DialogContent>
+            </Dialog>
+        </div>
+    )
+}
+
+export default MemoryTable
\ No newline at end of file
diff --git a/frontend/src/components/settings/personalization-tab.tsx b/frontend/src/components/settings/personalization-tab.tsx
new file mode 100644
index 000000000..30d0a9ccb
--- /dev/null
+++ b/frontend/src/components/settings/personalization-tab.tsx
@@ -0,0 +1,62 @@
+import { useEffect, useState } from 'react'
+import { useTranslation } from 'react-i18next'
+
+import { Switch } from '../ui/switch'
+import MemoryTable from './memory-table'
+import { useAppDispatch, useAppSelector } from '@/state/store'
+import { selectUserPreferences, setUser } from '@/state/slice/user'
+import { userService } from '@/services/user.service'
+import { authService } from '@/services/auth.service'
+import { toast } from 'sonner'
+
+const PersonalizationTab = () => {
+    const { t } = useTranslation()
+    const dispatch = useAppDispatch()
+    const preferences = useAppSelector(selectUserPreferences)
+
+    const [hasMemory, setHasMemory] = useState(preferences.has_memory)
+
+    useEffect(() => {
+        setHasMemory(preferences.has_memory)
+    }, [preferences.has_memory])
+
+    const handleToggle = async (value: boolean) => {
+        setHasMemory(value)
+        try {
+            await userService.updatePreferences({ has_memory: value })
+            const userRes = await authService.getCurrentUser()
+            dispatch(setUser(userRes))
+        } catch {
+            setHasMemory(!value)
+            toast.error(t('errors.generic'))
+        }
+    }
+
+    return (
+        <div>
+            <div className="divide-y divide-white/30">
+                <div className="flex flex-col md:flex-row md:items-center gap-4 justify-between pb-6">
+                    <div>
+                        <h2 className="text-[18px] font-semibold mb-1">
+                            {t('settings.personalization.referenceMemories')}
+                        </h2>
+                        <p className="text-xs max-w-[332px]">
+                            {t(
+                                'settings.personalization.referenceMemoriesDescription'
+                            )}
+                        </p>
+                    </div>
+                    <Switch
+                        checked={hasMemory}
+                        onCheckedChange={handleToggle}
+                    />
+                </div>
+            </div>
+            <div className="mt-8">
+                <MemoryTable />
+            </div>
+        </div>
+    )
+}
+
+export default PersonalizationTab
\ No newline at end of file
diff --git a/frontend/src/constants/tool.tsx b/frontend/src/constants/tool.tsx
index 508dc4a68..3a5e79be4 100644
--- a/frontend/src/constants/tool.tsx
+++ b/frontend/src/constants/tool.tsx
@@ -63,6 +63,17 @@ export const INIT_TOOLS = [
         isFill: false,
         isActive: false,
         isRequireKey: true
+    },
+    {
+        name: 'Agentic Memory',
+        nameKey: 'toolCatalog.init.agenticMemory.name',
+        description:
+            'Enables the agent to update user memories during a run, only when real-time updates, explicit memory commands, or complex memory reasoning are required.',
+        descriptionKey: 'toolCatalog.init.agenticMemory.description',
+        icon: 'magic-pen',
+        isFill: false,
+        isActive: false,
+        isRequireKey: false
     }
 ]
 
diff --git a/frontend/src/i18n/locales/en.json b/frontend/src/i18n/locales/en.json
index d84cbedb2..639ec4e1c 100644
--- a/frontend/src/i18n/locales/en.json
+++ b/frontend/src/i18n/locales/en.json
@@ -265,7 +265,8 @@
             "connectors": "Connectors",
             "dataControls": "Data Controls",
             "usage": "Usage",
-            "subscription": "Subscription"
+            "subscription": "Subscription",
+            "personalization": "Personalization"
         },
         "general": {
             "theme": "Theme",
@@ -307,6 +308,30 @@
             "noSharedLinks": "You haven't shared any conversations yet",
             "linkDeleted": "Shared link deleted successfully",
             "deleteError": "Failed to delete shared link"
+        },
+        "personalization": {
+            "referenceMemories": "Reference saved memories",
+            "referenceMemoriesDescription": "Let IIAgent save and use memories when responding.",
+            "memoriesTitle": "Saved Memories",
+            "memoriesDescription": "View and manage memories that IIAgent has saved about you.",
+            "searchPlaceholder": "Search memories...",
+            "filterByTopics": "Filter by topics",
+            "allTopics": "All topics",
+            "addMemory": "Add Memory",
+            "editMemory": "Edit Memory",
+            "deleteMemory": "Delete Memory",
+            "deleteMemoryConfirmTitle": "Delete Memory",
+            "deleteMemoryConfirmDescription": "Are you sure you want to delete this memory? This action cannot be undone.",
+            "memoryContent": "Memory",
+            "memoryContentPlaceholder": "Enter a memory...",
+            "topicsLabel": "Topics",
+            "topicsPlaceholder": "Enter topics separated by commas",
+            "noMemories": "No memories saved yet",
+            "noMatchingMemories": "No memories match your search",
+            "columnMemory": "Memory",
+            "columnTopics": "Topics",
+            "columnUpdatedAt": "Updated",
+            "expandCreatedAt": "Created"
         }
     },
     "userMenu": {
@@ -2390,6 +2415,10 @@
             "claudeCode": {
                 "name": "Claude Code",
                 "description": "Enable Claude Code for autonomous code generation"
+            },
+            "agenticMemory": {
+                "name": "Agentic Memory",
+                "description": "Enables the agent to update user memories during a run, only when real-time updates, explicit memory commands, or complex memory reasoning are required."
             }
         },
         "chatTools": {
diff --git a/frontend/src/i18n/locales/hi.json b/frontend/src/i18n/locales/hi.json
index 97b7c093b..68caa8cfd 100644
--- a/frontend/src/i18n/locales/hi.json
+++ b/frontend/src/i18n/locales/hi.json
@@ -207,7 +207,8 @@
             "connectors": "कनेक्टर",
             "dataControls": "डेटा नियंत्रण",
             "usage": "उपयोग",
-            "subscription": "सब्सक्रिप्शन"
+            "subscription": "सब्सक्रिप्शन",
+            "personalization": "वैयक्तिकरण"
         },
         "general": {
             "theme": "थीम",
@@ -249,6 +250,30 @@
             "noSharedLinks": "आपने अभी तक कोई बातचीत साझा नहीं की है",
             "linkDeleted": "साझा लिंक सफलतापूर्वक हटा दिया गया",
             "deleteError": "साझा लिंक हटाने में विफल"
+        },
+        "personalization": {
+            "referenceMemories": "सहेजी गई यादें देखें",
+            "referenceMemoriesDescription": "IIAgent को प्रतिक्रिया देते समय यादें सहेजने और उपयोग करने दें।",
+            "memoriesTitle": "सहेजी गई यादें",
+            "memoriesDescription": "IIAgent द्वारा आपके बारे में सहेजी गई यादें देखें और प्रबंधित करें।",
+            "searchPlaceholder": "यादें खोजें...",
+            "filterByTopics": "विषय से फ़िल्टर करें",
+            "allTopics": "सभी विषय",
+            "addMemory": "याद जोड़ें",
+            "editMemory": "याद संपादित करें",
+            "deleteMemory": "याद हटाएं",
+            "deleteMemoryConfirmTitle": "याद हटाएं",
+            "deleteMemoryConfirmDescription": "क्या आप वाकई इस याद को हटाना चाहते हैं? यह क्रिया पूर्ववत नहीं की जा सकती।",
+            "memoryContent": "याद",
+            "memoryContentPlaceholder": "एक याद दर्ज करें...",
+            "topicsLabel": "विषय",
+            "topicsPlaceholder": "अल्पविराम से अलग करके विषय दर्ज करें",
+            "noMemories": "अभी तक कोई याद सहेजी नहीं गई",
+            "noMatchingMemories": "कोई मिलती-जुलती याद नहीं",
+            "columnMemory": "याद",
+            "columnTopics": "विषय",
+            "columnUpdatedAt": "अपडेट",
+            "expandCreatedAt": "बनाया गया"
         }
     },
     "userMenu": {
@@ -2233,6 +2258,10 @@
             "claudeCode": {
                 "name": "Claude Code",
                 "description": "स्वचालित कोड जनरेशन के लिए Claude Code सक्षम करें"
+            },
+            "agenticMemory": {
+                "name": "एजेंट मेमोरी",
+                "description": "एजेंट को रन के दौरान उपयोगकर्ता की यादें अपडेट करने की अनुमति देता है, केवल जब रीयल-टाइम अपडेट, स्पष्ट मेमोरी कमांड या जटिल मेमोरी रीजनिंग की आवश्यकता हो।"
             }
         },
         "chatTools": {
diff --git a/frontend/src/i18n/locales/ja.json b/frontend/src/i18n/locales/ja.json
index daf3e123a..5bfa44211 100644
--- a/frontend/src/i18n/locales/ja.json
+++ b/frontend/src/i18n/locales/ja.json
@@ -207,7 +207,8 @@
             "connectors": "コネクタ",
             "dataControls": "データ管理",
             "usage": "使用量",
-            "subscription": "サブスクリプション"
+            "subscription": "サブスクリプション",
+            "personalization": "パーソナライゼーション"
         },
         "general": {
             "theme": "テーマ",
@@ -249,6 +250,30 @@
             "noSharedLinks": "まだ会話を共有していません",
             "linkDeleted": "共有リンクが正常に削除されました",
             "deleteError": "共有リンクの削除に失敗しました"
+        },
+        "personalization": {
+            "referenceMemories": "保存した記憶を参照",
+            "referenceMemoriesDescription": "IIAgentが応答時に記憶を保存・使用することを許可します。",
+            "memoriesTitle": "保存した記憶",
+            "memoriesDescription": "IIAgentがあなたについて保存した記憶を表示・管理します。",
+            "searchPlaceholder": "記憶を検索...",
+            "filterByTopics": "トピックで絞り込む",
+            "allTopics": "すべてのトピック",
+            "addMemory": "記憶を追加",
+            "editMemory": "記憶を編集",
+            "deleteMemory": "記憶を削除",
+            "deleteMemoryConfirmTitle": "記憶を削除",
+            "deleteMemoryConfirmDescription": "この記憶を削除してもよろしいですか？この操作は取り消せません。",
+            "memoryContent": "記憶",
+            "memoryContentPlaceholder": "記憶を入力...",
+            "topicsLabel": "トピック",
+            "topicsPlaceholder": "カンマ区切りでトピックを入力",
+            "noMemories": "まだ記憶が保存されていません",
+            "noMatchingMemories": "一致する記憶がありません",
+            "columnMemory": "記憶",
+            "columnTopics": "トピック",
+            "columnUpdatedAt": "更新日",
+            "expandCreatedAt": "作成日"
         }
     },
     "userMenu": {
@@ -2233,6 +2258,10 @@
             "claudeCode": {
                 "name": "Claude Code",
                 "description": "自律的なコード生成のためにClaude Codeを有効化"
+            },
+            "agenticMemory": {
+                "name": "エージェント記憶",
+                "description": "リアルタイム更新、明示的な記憶コマンド、または複雑な記憶推論が必要な場合にのみ、エージェントが実行中にユーザーの記憶を更新できるようにします。"
             }
         },
         "chatTools": {
diff --git a/frontend/src/i18n/locales/vi.json b/frontend/src/i18n/locales/vi.json
index 04e3086c4..3fe992f90 100644
--- a/frontend/src/i18n/locales/vi.json
+++ b/frontend/src/i18n/locales/vi.json
@@ -207,7 +207,8 @@
             "connectors": "Kết nối",
             "dataControls": "Kiểm soát dữ liệu",
             "usage": "Sử dụng",
-            "subscription": "Gói dịch vụ"
+            "subscription": "Gói dịch vụ",
+            "personalization": "Cá nhân hóa"
         },
         "general": {
             "theme": "Giao diện",
@@ -249,6 +250,30 @@
             "noSharedLinks": "Bạn chưa chia sẻ cuộc trò chuyện nào",
             "linkDeleted": "Liên kết chia sẻ đã được xóa thành công",
             "deleteError": "Không thể xóa liên kết chia sẻ"
+        },
+        "personalization": {
+            "referenceMemories": "Tham khảo ký ức đã lưu",
+            "referenceMemoriesDescription": "Cho phép IIAgent lưu và sử dụng ký ức khi phản hồi.",
+            "memoriesTitle": "Ký ức đã lưu",
+            "memoriesDescription": "Xem và quản lý ký ức mà IIAgent đã lưu về bạn.",
+            "searchPlaceholder": "Tìm kiếm ký ức...",
+            "filterByTopics": "Lọc theo chủ đề",
+            "allTopics": "Tất cả chủ đề",
+            "addMemory": "Thêm ký ức",
+            "editMemory": "Sửa ký ức",
+            "deleteMemory": "Xóa ký ức",
+            "deleteMemoryConfirmTitle": "Xóa ký ức",
+            "deleteMemoryConfirmDescription": "Bạn có chắc chắn muốn xóa ký ức này? Hành động này không thể hoàn tác.",
+            "memoryContent": "Ký ức",
+            "memoryContentPlaceholder": "Nhập ký ức...",
+            "topicsLabel": "Chủ đề",
+            "topicsPlaceholder": "Nhập chủ đề cách nhau bằng dấu phẩy",
+            "noMemories": "Chưa có ký ức nào được lưu",
+            "noMatchingMemories": "Không có ký ức nào phù hợp",
+            "columnMemory": "Ký ức",
+            "columnTopics": "Chủ đề",
+            "columnUpdatedAt": "Cập nhật",
+            "expandCreatedAt": "Tạo lúc"
         }
     },
     "userMenu": {
@@ -2249,6 +2274,10 @@
             "claudeCode": {
                 "name": "Claude Code",
                 "description": "Bật Claude Code để tạo code tự động"
+            },
+            "agenticMemory": {
+                "name": "Bộ nhớ chủ động",
+                "description": "Cho phép agent cập nhật ký ức người dùng trong phiên chạy, chỉ khi cần cập nhật thời gian thực, lệnh ghi nhớ rõ ràng hoặc suy luận ký ức phức tạp."
             }
         },
         "chatTools": {
diff --git a/frontend/src/services/memory.service.ts b/frontend/src/services/memory.service.ts
new file mode 100644
index 000000000..941b75a0a
--- /dev/null
+++ b/frontend/src/services/memory.service.ts
@@ -0,0 +1,70 @@
+import axiosInstance from '@/lib/axios'
+import type {
+    Memory,
+    MemoryListResponse,
+    MemoryCreateRequest,
+    MemoryUpdateRequest
+} from '@/typings/memory'
+
+interface ListMemoriesParams {
+    page?: number
+    perPage?: number
+    search?: string
+    topics?: string
+    sortBy?: 'updated_at' | 'memory' | 'topics_count'
+    sortOrder?: 'asc' | 'desc'
+}
+
+class MemoryService {
+    async listMemories(
+        params: ListMemoriesParams = {}
+    ): Promise<MemoryListResponse> {
+        const response = await axiosInstance.get<MemoryListResponse>(
+            '/v1/memories',
+            {
+                params: {
+                    page: params.page ?? 1,
+                    per_page: params.perPage ?? 10,
+                    search: params.search || undefined,
+                    topics: params.topics || undefined,
+                    sort_by: params.sortBy ?? 'updated_at',
+                    sort_order: params.sortOrder ?? 'desc'
+                }
+            }
+        )
+        return response.data
+    }
+
+    async getTopics(): Promise<string[]> {
+        const response = await axiosInstance.get<string[]>('/v1/memories/topics')
+        return response.data
+    }
+
+    async createMemory(data: MemoryCreateRequest): Promise<Memory> {
+        const response = await axiosInstance.post<Memory>('/v1/memories', data)
+        return response.data
+    }
+
+    async updateMemory(
+        memoryId: string,
+        data: MemoryUpdateRequest
+    ): Promise<Memory> {
+        const response = await axiosInstance.put<Memory>(
+            `/v1/memories/${memoryId}`,
+            data
+        )
+        return response.data
+    }
+
+    async deleteMemory(memoryId: string): Promise<void> {
+        await axiosInstance.delete(`/v1/memories/${memoryId}`)
+    }
+
+    async bulkDeleteMemories(memoryIds: string[]): Promise<void> {
+        await axiosInstance.post('/v1/memories/bulk-delete', {
+            memory_ids: memoryIds
+        })
+    }
+}
+
+export const memoryService = new MemoryService()
\ No newline at end of file
diff --git a/frontend/src/services/user.service.ts b/frontend/src/services/user.service.ts
index 633ba3691..1202fbbf9 100644
--- a/frontend/src/services/user.service.ts
+++ b/frontend/src/services/user.service.ts
@@ -39,6 +39,15 @@ class UserService {
         })
         return response.data
     }
+    async updatePreferences(body: {
+        has_memory?: boolean
+    }): Promise<{ message: string; preferences: { has_memory: boolean } }> {
+        const response = await axiosInstance.patch<{
+            message: string
+            preferences: { has_memory: boolean }
+        }>('/auth/me/preferences', body)
+        return response.data
+    }
 }
 
 export const userService = new UserService()
diff --git a/frontend/src/state/slice/settings.ts b/frontend/src/state/slice/settings.ts
index 51a8c638f..1baabfb5c 100644
--- a/frontend/src/state/slice/settings.ts
+++ b/frontend/src/state/slice/settings.ts
@@ -42,7 +42,8 @@ const initialState: SettingsState = {
         thinking_tokens: 10000,
         enable_reviewer: false,
         codex_tools: false,
-        claude_code: false
+        claude_code: false,
+        agentic_memory: false
     },
     chatToolSettings: {
         web_search: true,
diff --git a/frontend/src/state/slice/user.ts b/frontend/src/state/slice/user.ts
index a2a025e9e..81d7036c0 100644
--- a/frontend/src/state/slice/user.ts
+++ b/frontend/src/state/slice/user.ts
@@ -3,6 +3,10 @@ import type { CreditUsageResponse } from '@/typings/user'
 import { userService } from '@/services/user.service'
 import { SubscriptionPlan, type BillingCycle } from '@/typings/subscription'
 
+export interface UserPreferences {
+    has_memory: boolean
+}
+
 export interface User {
     id: string
     first_name: string
@@ -15,6 +19,7 @@ export interface User {
     subscription_billing_cycle?: BillingCycle
     subscription_current_period_end?: string
     language?: string
+    preferences?: UserPreferences
 }
 
 interface UserState {
@@ -127,3 +132,5 @@ export const selectSubscriptionBillingCycle = (state: { user: UserState }) =>
     state.user.user?.subscription_billing_cycle
 export const selectUserLanguage = (state: { user: UserState }) =>
     state.user.user?.language || 'en'
+export const selectUserPreferences = (state: { user: UserState }): UserPreferences =>
+    state.user.user?.preferences ?? { has_memory: true }
\ No newline at end of file
diff --git a/frontend/src/typings/agent.ts b/frontend/src/typings/agent.ts
index cbfaa8b2d..472ed3f34 100644
--- a/frontend/src/typings/agent.ts
+++ b/frontend/src/typings/agent.ts
@@ -599,6 +599,7 @@ export interface ToolSettings {
     design_document: boolean
     codex_tools: boolean
     claude_code: boolean
+    agentic_memory: boolean
 }
 
 export type {
diff --git a/frontend/src/typings/memory.ts b/frontend/src/typings/memory.ts
new file mode 100644
index 000000000..4f01b6be5
--- /dev/null
+++ b/frontend/src/typings/memory.ts
@@ -0,0 +1,26 @@
+export interface Memory {
+    memory_id: string
+    memory: string
+    topics: string[] | null
+    input: string | null
+    agent_id: string | null
+    created_at: number | null
+    updated_at: number | null
+}
+
+export interface MemoryListResponse {
+    memories: Memory[]
+    total: number
+    page: number
+    per_page: number
+}
+
+export interface MemoryCreateRequest {
+    memory: string
+    topics?: string[]
+}
+
+export interface MemoryUpdateRequest {
+    memory?: string
+    topics?: string[]
+}
\ No newline at end of file
diff --git a/migrations/versions/20260402_000003_add_user_memories_table.py b/migrations/versions/20260402_000003_add_user_memories_table.py
new file mode 100644
index 000000000..b6cf106f9
--- /dev/null
+++ b/migrations/versions/20260402_000003_add_user_memories_table.py
@@ -0,0 +1,65 @@
+"""Add user_memories table for persistent agent memory.
+
+Revision ID: 20260402_000003
+Revises: 20260402_000002
+Create Date: 2026-04-02
+"""
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects.postgresql import JSONB, UUID
+
+# revision identifiers, used by Alembic.
+revision = "20260402_000003"
+down_revision = "20260402_000002"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "user_memories",
+        sa.Column(
+            "id",
+            UUID(as_uuid=True),
+            server_default=sa.text("gen_random_uuid()"),
+            primary_key=True,
+        ),
+        sa.Column("memory_id", sa.String(), nullable=False, unique=True),
+        sa.Column(
+            "user_id",
+            UUID(as_uuid=True),
+            sa.ForeignKey("users.id", ondelete="CASCADE"),
+            nullable=False,
+        ),
+        sa.Column("agent_id", sa.String(), nullable=True),
+        sa.Column("memory", sa.String(), nullable=False),
+        sa.Column("topics", JSONB(), nullable=True),
+        sa.Column("input", sa.String(), nullable=True),
+        sa.Column("version", sa.BigInteger(), nullable=False, server_default="0"),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.func.now(),
+            nullable=False,
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.func.now(),
+            nullable=False,
+        ),
+    )
+
+    op.create_index("ix_user_memories_user_id", "user_memories", ["user_id"])
+    op.create_index("ix_user_memories_user_agent", "user_memories", ["user_id", "agent_id"])
+    op.create_index("ix_user_memories_memory_id", "user_memories", ["memory_id"], unique=True)
+    op.create_index("ix_user_memories_updated_at", "user_memories", ["updated_at"])
+
+
+def downgrade() -> None:
+    op.drop_index("ix_user_memories_updated_at", table_name="user_memories")
+    op.drop_index("ix_user_memories_memory_id", table_name="user_memories")
+    op.drop_index("ix_user_memories_user_agent", table_name="user_memories")
+    op.drop_index("ix_user_memories_user_id", table_name="user_memories")
+    op.drop_table("user_memories")
diff --git a/src/ii_agent/agents/agent.py b/src/ii_agent/agents/agent.py
index c70aba4fe..f71b6c63e 100644
--- a/src/ii_agent/agents/agent.py
+++ b/src/ii_agent/agents/agent.py
@@ -89,7 +89,10 @@
     store_media_util,
     validate_media_object_id,
 )
+from ii_agent.memory.manager import MemoryManager
 from ii_agent.agents.runs.events import (
+    create_memory_update_completed_event,
+    create_memory_update_started_event,
     create_post_hook_completed_event,
     create_post_hook_started_event,
     create_pre_hook_completed_event,
@@ -144,6 +147,16 @@ class IIAgent:
     # Session summary manager
     session_summary_manager: Optional[SessionSummaryManager] = None
 
+    # --- Agent Memory ---
+    # Memory manager for persistent user memories
+    memory_manager: Optional[MemoryManager] = None
+    # If True, the agent gets an update_user_memory tool to manage memories during conversation
+    enable_agentic_memory: bool = False
+    # If True, the agent auto-extracts memories from each run in a background task
+    update_memory_on_run: bool = False
+    # If True, inject existing memories into the system prompt
+    add_memories_to_context: bool = False
+
     # --- Agent Tools ---
     # A list of tools provided to the Model.
     # Tools are functions the model may generate JSON inputs for.
@@ -227,6 +240,9 @@ def __post_init__(self) -> None:
             self.session_store = NoOpSessionStore()
         if self.session_summary_manager is None:
             self._set_session_summary_manager()
+        # Initialize memory manager if any memory feature is enabled
+        if self.update_memory_on_run or self.enable_agentic_memory or self.memory_manager is not None:
+            self._set_memory_manager()
         # Initialize sub-agents
         if self.sub_agents is None:
             self.sub_agents = []
@@ -467,6 +483,128 @@ def _set_session_summary_manager(self) -> None:
             if self.session_summary_manager.model is None:
                 self.session_summary_manager.model = self.model
 
+    def _set_memory_manager(self) -> None:
+        """Initialize or configure the memory manager with defaults."""
+        if self.memory_manager is None:
+            self.memory_manager = MemoryManager(model=self.model)
+        if self.memory_manager.model is None:
+            self.memory_manager.model = self.model
+
+    def _get_update_user_memory_function(self, user_id: Optional[str] = None) -> Function:
+        """Create the agentic memory tool as a Function closure."""
+        memory_manager = cast(MemoryManager, self.memory_manager)
+
+        async def update_user_memory(task: str) -> str:
+            """Submit a task to modify the Agent's memory of a user.
+
+            The task can include adding a memory, updating a memory, deleting a memory, or clearing all memories.
+
+            Args:
+                task: The task to update the memory. Be specific and describe the task in detail.
+
+            Returns:
+                A string indicating the status of the task.
+            """
+            return await memory_manager.aupdate_memory_task(task=task, user_id=user_id)
+
+        return Function.from_callable(update_user_memory, name="update_user_memory")
+
+    async def _amake_memories(
+        self,
+        run_messages: RunMessages,
+        user_id: Optional[str] = None,
+    ) -> None:
+        """Extract memories from the current run messages (background task)."""
+        if self.memory_manager is None or not self.update_memory_on_run:
+            return
+
+        user_message_str = (
+            run_messages.user_message.content
+            if run_messages.user_message is not None and run_messages.user_message.content
+            else None
+        )
+        if not user_message_str or (isinstance(user_message_str, str) and not user_message_str.strip()):
+            return
+
+        try:
+            await self.memory_manager.acreate_user_memories(
+                message=user_message_str if isinstance(user_message_str, str) else str(user_message_str),
+                user_id=user_id,
+                agent_id=self.id,
+            )
+        except Exception as e:
+            logger.warning(f"Error creating memories: {e}")
+
+    async def aget_user_memories(self, user_id: Optional[str] = None) -> list:
+        """Public API: retrieve user memories."""
+        if self.memory_manager is None:
+            self._set_memory_manager()
+        return await self.memory_manager.aget_user_memories(user_id=user_id)  # type: ignore
+
+    async def _abuild_memory_context(self, user_id: Optional[str] = None) -> Optional[str]:
+        """Build the memory snippet to inject into the system prompt."""
+        if not self.add_memories_to_context:
+            return None
+
+        manager = self.memory_manager
+        temp_init = False
+        if manager is None:
+            self._set_memory_manager()
+            manager = self.memory_manager
+            temp_init = True
+
+        if manager is None:
+            return None
+
+        try:
+            user_memories = await manager.aget_user_memories(user_id=user_id or self.user_id)
+        except Exception as e:
+            logger.warning(f"Error fetching memories for context: {e}")
+            if temp_init:
+                self.memory_manager = None
+            return None
+
+        if temp_init:
+            self.memory_manager = None
+
+        lines: List[str] = []
+        if user_memories:
+            lines.append(
+                "You have access to user info and preferences from previous interactions "
+                "that you can use to personalize your response:\n"
+            )
+            lines.append("<memories_from_previous_interactions>")
+            for mem in user_memories:
+                lines.append(f"- {mem['memory']}")
+            lines.append("</memories_from_previous_interactions>\n")
+            lines.append(
+                "Note: this information is from previous interactions and may be updated "
+                "in this conversation. Always prefer information from the current conversation."
+            )
+        else:
+            lines.append(
+                "You have the capability to retain memories from previous interactions "
+                "with the user, but have not had any interactions yet."
+            )
+
+        if self.enable_agentic_memory:
+            lines.append("\n<updating_user_memories>")
+            lines.append(
+                "- You have access to the `update_user_memory` tool to add, update, delete, or clear memories."
+            )
+            lines.append(
+                "- If the user's message includes information worth remembering, use the tool."
+            )
+            lines.append(
+                "- Use this tool if the user asks to update, delete, or clear their memory."
+            )
+            lines.append(
+                "- If you use the `update_user_memory` tool, remember to pass on the response to the user."
+            )
+            lines.append("</updating_user_memories>")
+
+        return "\n".join(lines)
+
     def add_tool(self, tool: Union[Toolkit, Callable, Function, Dict, BaseAgentTool]):
         if not self.tools:
             self.tools = []
@@ -700,6 +838,13 @@ async def _arun(
 
             store_media_util(run_response, model_response)
 
+            # 7. Start memory creation in background task
+            memory_task: Optional[asyncio.Task] = None
+            if self.update_memory_on_run and self.memory_manager is not None:
+                memory_task = asyncio.create_task(
+                    self._amake_memories(run_messages=run_messages, user_id=user_id)
+                )
+
             # 13. Execute post-hooks (after output is generated but before response is returned)
             if self.post_hooks is not None:
                 async for _ in self._aexecute_post_hooks(
@@ -726,6 +871,13 @@ async def _arun(
                     run_context=run_context,
                 )
 
+            # 14. Wait for background memory creation
+            if memory_task is not None:
+                try:
+                    await memory_task
+                except Exception as e:
+                    logger.warning(f"Background memory creation failed: {e}")
+
             run_response.status = RunStatus.COMPLETED
             logger.debug(f"Agent Run End: {run_response.run_id}")
             return run_response
@@ -977,6 +1129,20 @@ async def _arun_stream(
             # Check for cancellation after model processing
             await raise_if_cancelled(run_response.run_id)  # type: ignore
 
+            # 7. Start memory creation in background task
+            memory_task: Optional[asyncio.Task] = None
+            if self.update_memory_on_run and self.memory_manager is not None:
+                if stream_events:
+                    yield handle_event(  # type: ignore
+                        create_memory_update_started_event(from_run_response=run_response),
+                        run_response,
+                        events_to_skip=self.events_to_skip,  # type: ignore
+                        store_events=self.store_events,
+                    )
+                memory_task = asyncio.create_task(
+                    self._amake_memories(run_messages=run_messages, user_id=user_id)
+                )
+
             if stream_events:
                 yield handle_event(  # type: ignore
                     create_run_content_completed_event(from_run_response=run_response),
@@ -1011,6 +1177,20 @@ async def _arun_stream(
                     yield event
                 return  # Stop execution here, run is paused
 
+            # 14. Wait for background memory creation
+            if memory_task is not None:
+                try:
+                    await memory_task
+                except Exception as e:
+                    logger.warning(f"Background memory creation failed: {e}")
+                if stream_events:
+                    yield handle_event(  # type: ignore
+                        create_memory_update_completed_event(from_run_response=run_response),
+                        run_response,
+                        events_to_skip=self.events_to_skip,  # type: ignore
+                        store_events=self.store_events,
+                    )
+
             # Update run_response.session_state before creating RunCompletedEvent
             # This ensures the event has the final state after all tool modifications
             if (
@@ -3033,6 +3213,14 @@ def _determine_tools_for_model(
             _functions.append(delegate_func)
             logger.debug(f"Added delegation tool for {len(self.sub_agents)} sub-agents")
 
+        # Add agentic memory tool
+        if self.enable_agentic_memory and self.memory_manager is not None:
+            memory_func = self._get_update_user_memory_function(user_id=user_id)
+            memory_func._agent = self
+            memory_func._run_context = run_context
+            _functions.append(memory_func)
+            logger.debug("Added update_user_memory tool for agentic memory")
+
         logger.debug(f"[V1 Agent] Converted {len(_functions)} tools to Functions for LLM")
         logger.debug(
             f"[V1 Agent] Function names: {[f.name if isinstance(f, Function) else str(f.get('name', 'unknown')) for f in _functions]}"
@@ -3075,13 +3263,28 @@ async def aget_system_message(
         1. If system_message is provided (str, callable, or Message), use that.
         2. If prompt_config is provided, use SystemPromptBuilder.
         3. Fall back to legacy behavior (description/instructions/additional_context).
+
+        Memory and agentic-memory instructions are appended when enabled.
         """
 
         # 1. If the system_message is provided, use that (highest priority)
         if self.system_message is not None:
             if isinstance(self.system_message, Message):
-                return self.system_message
-        return Message(role=self.model.system_message_role, content=self.system_message)
+                base_content = self.system_message.content or ""
+                role = self.system_message.role
+            else:
+                base_content = self.system_message
+                role = self.model.system_message_role
+        else:
+            base_content = ""
+            role = self.model.system_message_role
+
+        # Append memory context if enabled
+        memory_snippet = await self._abuild_memory_context(user_id=user_id)
+        if memory_snippet:
+            base_content = f"{base_content}\n\n{memory_snippet}" if base_content else memory_snippet
+
+        return Message(role=role, content=base_content)
 
     async def _aget_user_message(
         self,
diff --git a/src/ii_agent/agents/factory/agent.py b/src/ii_agent/agents/factory/agent.py
index 99d952b47..bfc919ed2 100644
--- a/src/ii_agent/agents/factory/agent.py
+++ b/src/ii_agent/agents/factory/agent.py
@@ -15,6 +15,7 @@
 from ii_agent.agents.factory.tools import AgentConfigManager, AgentType
 from ii_agent.agents.factory.tool_manager import AgentToolManager
 from ii_agent.agents.models.utils import get_model
+from ii_agent.memory.manager import MemoryManager
 from ii_agent.agents.sessions import SessionStore
 from ii_agent.agents.tools.task import SYSTEM_PROMPT, TaskAgentTool, DESCRIPTION
 from ii_agent.core.logger import logger
@@ -94,6 +95,8 @@ async def create_agent(
         has_task_agent = tool_args.get("task_agent", False)
         has_researcher = tool_args.get("deep_research", False)
         has_design_doc = tool_args.get("design_document", False)
+        has_memory = tool_args.get("has_memory", True)
+        has_agentic_memory_tool = tool_args.get("agentic_memory", False)
 
         # Get LLM client and model
         provider = llm_config.provider
@@ -162,6 +165,11 @@ async def create_agent(
 
         system_prompt = _append_prompt_section(system_prompt, skill_prompt_section)
 
+        # Build memory manager if any memory feature is enabled
+        memory_manager: Optional[MemoryManager] = None
+        if has_memory or has_agentic_memory_tool:
+            memory_manager = MemoryManager(model=model)
+
         sub_agents = []
         if has_task_agent:
             task_agent = await self.create_task_agent_tool(
@@ -187,6 +195,10 @@ async def create_agent(
             stream=True,
             stream_events=True,
             store_events=True,
+            memory_manager=memory_manager,
+            update_memory_on_run=has_memory,
+            enable_agentic_memory=has_agentic_memory_tool,
+            add_memories_to_context=has_memory or has_agentic_memory_tool,
         )
 
         # Set agent ID
diff --git a/src/ii_agent/app/routers.py b/src/ii_agent/app/routers.py
index 4dcd564ea..5ae8f21e0 100644
--- a/src/ii_agent/app/routers.py
+++ b/src/ii_agent/app/routers.py
@@ -29,6 +29,7 @@ def include_routers(app: FastAPI) -> None:
     from ii_agent.sessions.router import router as sessions_router
     from ii_agent.sessions.router import public_router as sessions_public_router
     from ii_agent.settings.router import router as settings_router
+    from ii_agent.memory.router import router as memory_router
 
     # ── Root-level routes (no /v1 prefix) ────────────────────────────────
     app.include_router(health_router)
@@ -54,6 +55,7 @@ def include_routers(app: FastAPI) -> None:
     v1_router.include_router(enhance_prompt_router)  # /v1/enhance-prompt
     v1_router.include_router(settings_router)  # /v1/user-settings (includes /models, /mcp, /skills)
     v1_router.include_router(media_router)  # /v1/media, /v1/media-templates, /v1/media-tools
+    v1_router.include_router(memory_router)  # /v1/memories
 
     app.include_router(v1_router)
 
diff --git a/src/ii_agent/chat/application/chat_service.py b/src/ii_agent/chat/application/chat_service.py
index 4459d34a9..8b48c4120 100644
--- a/src/ii_agent/chat/application/chat_service.py
+++ b/src/ii_agent/chat/application/chat_service.py
@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import uuid
-from typing import AsyncIterator, Dict, Optional, TYPE_CHECKING
+from typing import AsyncIterator, Dict, List, Optional, TYPE_CHECKING
 from datetime import datetime, timezone
 
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -48,6 +49,117 @@
 logger = logging.getLogger(__name__)
 
 
+# ---------------------------------------------------------------------------
+# Memory helpers (chat mode)
+# ---------------------------------------------------------------------------
+
+
+async def _load_memory_context_for_chat(
+    user_id: uuid.UUID,
+    container: "ApplicationContainer",
+) -> Optional[Message]:
+    """Build a system-role Message containing user memories.
+
+    Returns None when memory is disabled or user has no memories.
+    Uses the same cached path as the agent (MemoryManager.aget_user_memories).
+    """
+    try:
+        memory_service = container.memory_service
+        # Check user preference
+        async with get_db_session_local() as db:
+            prefs = await memory_service.load_user_memory_preferences(db, user_id)
+        if not prefs.get("has_memory", True):
+            return None
+
+        # Fetch memories via cache (no DB session needed on hit)
+        cache_svc = memory_service._cache
+        user_id_str = str(user_id)
+        cached = await cache_svc.get_user_memories(user_id_str)
+
+        if cached is None:
+            # Cache miss — query DB and populate
+            async with get_db_session_local() as db:
+                memories = await memory_service.get_user_memories(db, user_id)
+            mem_dicts = [
+                {"memory": m.memory}
+                for m in memories
+            ]
+        else:
+            mem_dicts = cached
+
+        if not mem_dicts:
+            return None
+
+        # Build the same XML format as agent mode
+        lines = [
+            "You have access to user info and preferences from previous interactions "
+            "that you can use to personalize your response:\n",
+            "<memories_from_previous_interactions>",
+        ]
+        for mem in mem_dicts:
+            lines.append(f"- {mem['memory']}")
+        lines.append("</memories_from_previous_interactions>\n")
+        lines.append(
+            "Note: this information is from previous interactions and may be updated "
+            "in this conversation. Always prefer information from the current conversation."
+        )
+
+        return Message(
+            id=uuid.uuid4(),
+            role=MessageRole.SYSTEM,
+            session_id=uuid.UUID(int=0),
+            parts=[TextContent(text="\n".join(lines))],
+            created_at=int(datetime.now(timezone.utc).timestamp()),
+            updated_at=int(datetime.now(timezone.utc).timestamp()),
+        )
+
+    except Exception as e:
+        logger.warning(f"Failed to load memory context for chat: {e}")
+        return None
+
+
+async def _extract_memories_for_chat(
+    user_message_text: str,
+    user_id: uuid.UUID,
+    model_config: ModelConfig,
+    container: "ApplicationContainer",
+) -> None:
+    """Background task: extract memories from the user message (chat mode).
+
+    Uses MemoryManager with a lightweight model call, same as agent mode.
+    """
+    try:
+        # Check preference
+        memory_service = container.memory_service
+        async with get_db_session_local() as db:
+            prefs = await memory_service.load_user_memory_preferences(db, user_id)
+        if not prefs.get("has_memory", True):
+            return
+
+        from ii_agent.memory.manager import MemoryManager
+        from ii_agent.agents.models.utils import get_model
+        from ii_agent.core.config.llm_config import LLMConfig
+
+        # Convert ModelConfig → LLMConfig for get_model()
+        llm_config = LLMConfig(
+            setting_id=model_config.setting_id,
+            model=model_config.model_id,
+            api_key=model_config.api_key,
+            base_url=model_config.base_url,
+            provider=model_config.provider,
+            api_type=model_config.api_type,
+            temperature=model_config.temperature,
+        )
+        model = get_model(llm_config.provider, llm_config=llm_config)
+        manager = MemoryManager(model=model)
+        await manager.acreate_user_memories(
+            message=user_message_text,
+            user_id=str(user_id),
+        )
+    except Exception as e:
+        logger.warning(f"Background memory extraction failed (chat): {e}")
+
+
 class ChatService:
     """Thin orchestrator for chat conversations."""
 
@@ -296,6 +408,12 @@ async def stream_chat_response(
                     f"Loaded full context for session {session_id} ({len(messages)} messages)"
                 )
 
+            # Inject user memories into context (system-role message at the start)
+            memory_msg = await _load_memory_context_for_chat(user_id, self._container)
+            if memory_msg is not None:
+                messages.insert(0, memory_msg)
+                logger.info(f"Injected memory context for user {user_id}")
+
             # Build user message content
             display_content = chat_request.content
             llm_content = chat_request.content
@@ -416,6 +534,16 @@ async def stream_chat_response(
             await cancel.cleanup_run(run_id)
             logger.info(f"Completed chat run {run_id} for session {session_id}")
 
+            # Background memory extraction (fire-and-forget)
+            asyncio.create_task(
+                _extract_memories_for_chat(
+                    user_message_text=chat_request.content,
+                    user_id=user_id,
+                    model_config=model_config,
+                    container=self._container,
+                )
+            )
+
         except (cancel.RunCancelledException, Exception) as e:
             is_cancelled = isinstance(e, cancel.RunCancelledException)
 
@@ -482,6 +610,12 @@ async def stream_council_chat_response(
                 f"Council: loaded context for session {session_id} ({len(messages)} messages)"
             )
 
+            # Inject user memories into context
+            memory_msg = await _load_memory_context_for_chat(user_id, self._container)
+            if memory_msg is not None:
+                messages.insert(0, memory_msg)
+                logger.info(f"Council: injected memory context for user {user_id}")
+
             # Build user message content
             display_content = chat_request.content
             llm_content = chat_request.content
@@ -680,6 +814,19 @@ async def stream_council_chat_response(
 
             logger.info(f"Completed council run {run_id} for session {session_id}")
 
+            # Background memory extraction (fire-and-forget)
+            # Use first council model config for memory extraction LLM
+            first_council_model_id = council_prefs.council_models[0].model_id
+            if first_council_model_id in model_configs:
+                asyncio.create_task(
+                    _extract_memories_for_chat(
+                        user_message_text=display_content,
+                        user_id=user_id,
+                        model_config=model_configs[first_council_model_id],
+                        container=self._container,
+                    )
+                )
+
         except (cancel.RunCancelledException, Exception) as e:
             is_cancelled = isinstance(e, cancel.RunCancelledException)
 
diff --git a/src/ii_agent/core/container.py b/src/ii_agent/core/container.py
index 32353ff40..58b5a4fa8 100644
--- a/src/ii_agent/core/container.py
+++ b/src/ii_agent/core/container.py
@@ -50,6 +50,9 @@
 from ii_agent.content.slides.design.repository import SlideDesignRepository
 from ii_agent.credits.repository import CreditBalanceRepository, CreditTransactionRepository
 from ii_agent.agents.sandboxes.repository import SandboxRepository
+from ii_agent.memory.repository import MemoryRepository
+from ii_agent.memory.cache_service import MemoryCacheService
+from ii_agent.memory.service import MemoryService
 
 # ── Schema classes (for TypedEntityCache) ────────────────────────────────
 from ii_agent.tasks.schemas import RunTaskResponse
@@ -160,6 +163,7 @@ class ApplicationContainer:
     plan_service: PlanService
     event_service: EventService
     workspace_explorer_service: WorkspaceExplorer
+    memory_service: MemoryService
 
     # ── Repositories (exposed for consumers that need direct repo access) ─
     event_repo: EventRepository = field(default_factory=EventRepository)
@@ -190,6 +194,9 @@ def init(cls) -> ApplicationContainer:
             redis_client=redis_client, namespace="composio", ttl=604800
         )
         media_cache = get_entity_cache(redis_client=redis_client, namespace="media", ttl=600)
+        memory_cache_backend = get_entity_cache(
+            redis_client=redis_client, namespace="memory", ttl=600
+        )
 
         # Repositories
         user_repo = UserRepository()
@@ -219,6 +226,7 @@ def init(cls) -> ApplicationContainer:
         wishlist_repo = WishlistRepository()
         subdomain_repo = SubdomainRepository()
         slide_template_repo = SlideTemplateRepository()
+        memory_repo = MemoryRepository()
 
         # services
         run_task_svc = RunTaskService(
@@ -236,6 +244,8 @@ def init(cls) -> ApplicationContainer:
         billing_svc = BillingService(settings=cfg)
         deployment_orch_svc = DeploymentOrchestrationService(config=cfg)
         message_svc = MessageService()
+        memory_cache_svc = MemoryCacheService(cache=memory_cache_backend)
+        memory_svc = MemoryService(memory_repo=memory_repo, cache=memory_cache_svc)
         credit_svc = CreditService(
             balance_repo=credit_balance_repo,
             transaction_repo=credit_tx_repo,
@@ -468,6 +478,7 @@ def init(cls) -> ApplicationContainer:
             plan_service=plan_svc,
             event_service=event_svc,
             workspace_explorer_service=workspace_explorer_svc,
+            memory_service=memory_svc,
             event_repo=event_repo,
         )
 
diff --git a/src/ii_agent/memory/__init__.py b/src/ii_agent/memory/__init__.py
new file mode 100644
index 000000000..445f023b1
--- /dev/null
+++ b/src/ii_agent/memory/__init__.py
@@ -0,0 +1,25 @@
+"""Memory domain — persistent user memory management."""
+
+from .models import UserMemory
+from .manager import MemoryManager
+from .service import MemoryService
+from .router import router
+from .schemas import (
+    MemoryCreateRequest,
+    MemoryData,
+    MemoryListResponse,
+    MemoryResponse,
+    MemoryUpdateRequest,
+)
+
+__all__ = [
+    "UserMemory",
+    "MemoryManager",
+    "MemoryService",
+    "router",
+    "MemoryCreateRequest",
+    "MemoryData",
+    "MemoryListResponse",
+    "MemoryResponse",
+    "MemoryUpdateRequest",
+]
diff --git a/src/ii_agent/memory/cache_service.py b/src/ii_agent/memory/cache_service.py
new file mode 100644
index 000000000..6d77f1d17
--- /dev/null
+++ b/src/ii_agent/memory/cache_service.py
@@ -0,0 +1,157 @@
+"""Redis cache service for memory system.
+
+Uses create_entity_cache() which auto-selects Redis vs in-memory
+based on whether a Redis client has been initialised.
+"""
+
+import logging
+import time
+from typing import Any
+
+from ii_agent.core.redis.cache import EntityCache
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryCacheService:
+    """Cache layer for user memory CRUD operations."""
+
+    # TTL values (seconds)
+    TTL_USER_PREFS = 3600  # 1 hour
+    TTL_USER_MEMORIES = 600  # 10 minutes
+    TTL_USER_TOPICS = 600  # 10 minutes
+    TTL_PAGINATED = 300  # 5 minutes
+    TTL_PAGE_VERSION = 600  # 10 minutes
+
+    def __init__(self, cache: EntityCache) -> None:
+        self._cache = cache
+
+    # ---- User preferences (has_memory flag) ----
+    # Key convention: namespace "memory" is added by EntityCache._make_key(),
+    # so keys here are just the semantic part: "prefs:{uid}", "list:{uid}", etc.
+    # Final Redis key example: "memory:prefs:<uuid>"
+
+    async def get_user_prefs(self, user_id: str) -> dict[str, Any] | None:
+        try:
+            result = await self._cache.get(f"prefs:{user_id}")
+            if result is not None and isinstance(result, dict):
+                return result
+        except Exception as e:
+            logger.warning(f"Cache get error for prefs:{user_id}: {e}")
+        return None
+
+    async def set_user_prefs(self, user_id: str, prefs: dict[str, Any]) -> None:
+        try:
+            await self._cache.set(f"prefs:{user_id}", prefs, ttl=self.TTL_USER_PREFS)
+        except Exception as e:
+            logger.warning(f"Cache set error for prefs:{user_id}: {e}")
+
+    async def evict_user_prefs(self, user_id: str) -> None:
+        try:
+            await self._cache.evict(f"prefs:{user_id}")
+        except Exception as e:
+            logger.warning(f"Cache evict error for prefs:{user_id}: {e}")
+
+    # ---- User memories list ----
+
+    async def get_user_memories(self, user_id: str) -> list[dict[str, Any]] | None:
+        try:
+            result = await self._cache.get(f"list:{user_id}")
+            if result is not None and isinstance(result, list):
+                return result
+        except Exception as e:
+            logger.warning(f"Cache get error for list:{user_id}: {e}")
+        return None
+
+    async def set_user_memories(self, user_id: str, memories: list[dict[str, Any]]) -> None:
+        try:
+            await self._cache.set(f"list:{user_id}", memories, ttl=self.TTL_USER_MEMORIES)
+        except Exception as e:
+            logger.warning(f"Cache set error for list:{user_id}: {e}")
+
+    async def evict_user_memories(self, user_id: str) -> None:
+        try:
+            await self._cache.evict(f"list:{user_id}")
+        except Exception as e:
+            logger.warning(f"Cache evict error for list:{user_id}: {e}")
+
+    # ---- User distinct topics ----
+
+    async def get_user_topics(self, user_id: str) -> list[str] | None:
+        try:
+            result = await self._cache.get(f"topics:{user_id}")
+            if result is not None and isinstance(result, list):
+                return result
+        except Exception as e:
+            logger.warning(f"Cache get error for topics:{user_id}: {e}")
+        return None
+
+    async def set_user_topics(self, user_id: str, topics: list[str]) -> None:
+        try:
+            await self._cache.set(f"topics:{user_id}", topics, ttl=self.TTL_USER_TOPICS)
+        except Exception as e:
+            logger.warning(f"Cache set error for topics:{user_id}: {e}")
+
+    async def evict_user_topics(self, user_id: str) -> None:
+        try:
+            await self._cache.evict(f"topics:{user_id}")
+        except Exception as e:
+            logger.warning(f"Cache evict error for topics:{user_id}: {e}")
+
+    # ---- Paginated memories (version-based invalidation) ----
+
+    async def _get_page_version(self, user_id: str) -> str:
+        try:
+            result = await self._cache.get(f"pver:{user_id}")
+            if result is not None:
+                return str(result)
+            ver = str(int(time.time() * 1000))
+            await self._cache.set(f"pver:{user_id}", ver, ttl=self.TTL_PAGE_VERSION)
+            return ver
+        except Exception as e:
+            logger.warning(f"Cache error for page version: {e}")
+            return ""
+
+    async def get_paginated_memories(
+        self, user_id: str, params_hash: str
+    ) -> dict[str, Any] | None:
+        try:
+            ver = await self._get_page_version(user_id)
+            if not ver:
+                return None
+            key = f"page:{user_id}:{ver}:{params_hash}"
+            result = await self._cache.get(key)
+            if result is not None and isinstance(result, dict):
+                return result
+        except Exception as e:
+            logger.warning(f"Cache get error for paginated memories: {e}")
+        return None
+
+    async def set_paginated_memories(
+        self, user_id: str, params_hash: str, data: dict[str, Any]
+    ) -> None:
+        try:
+            ver = await self._get_page_version(user_id)
+            if not ver:
+                return
+            key = f"page:{user_id}:{ver}:{params_hash}"
+            await self._cache.set(key, data, ttl=self.TTL_PAGINATED)
+        except Exception as e:
+            logger.warning(f"Cache set error for paginated memories: {e}")
+
+    async def evict_paginated_version(self, user_id: str) -> None:
+        try:
+            await self._cache.evict(f"pver:{user_id}")
+        except Exception as e:
+            logger.warning(f"Cache evict error for page version: {e}")
+
+    # ---- Bulk invalidation helper ----
+
+    async def evict_user_memory_data(self, user_id: str) -> None:
+        """Invalidate memories list, topics, and paginated cache for a user.
+
+        Call this after any write operation (upsert, delete, clear).
+        """
+        await self.evict_user_memories(user_id)
+        await self.evict_user_topics(user_id)
+        await self.evict_paginated_version(user_id)
diff --git a/src/ii_agent/memory/dependencies.py b/src/ii_agent/memory/dependencies.py
new file mode 100644
index 000000000..f9d7072f8
--- /dev/null
+++ b/src/ii_agent/memory/dependencies.py
@@ -0,0 +1,30 @@
+"""FastAPI dependencies for memory domain."""
+
+from typing import Annotated
+
+from fastapi import Depends
+
+from ii_agent.core.dependencies import ContainerDep
+from ii_agent.memory.repository import MemoryRepository
+from ii_agent.memory.service import MemoryService
+
+
+# ==================== Repository Dependencies ====================
+
+
+def get_memory_repository() -> MemoryRepository:
+    """Provide MemoryRepository instance."""
+    return MemoryRepository()
+
+
+MemoryRepositoryDep = Annotated[MemoryRepository, Depends(get_memory_repository)]
+
+
+# ==================== Service Dependencies ====================
+
+
+def _get_memory_service(container: ContainerDep) -> MemoryService:
+    return container.memory_service
+
+
+MemoryServiceDep = Annotated[MemoryService, Depends(_get_memory_service)]
diff --git a/src/ii_agent/memory/exceptions.py b/src/ii_agent/memory/exceptions.py
new file mode 100644
index 000000000..46c74958d
--- /dev/null
+++ b/src/ii_agent/memory/exceptions.py
@@ -0,0 +1,10 @@
+"""Domain-specific exceptions for memory."""
+
+from ii_agent.core.exceptions import NotFoundError
+
+
+class MemoryNotFoundError(NotFoundError):
+    """Raised when a requested memory does not exist."""
+
+    def __init__(self, memory_id: str) -> None:
+        super().__init__(f"Memory not found: {memory_id}")
diff --git a/src/ii_agent/memory/manager.py b/src/ii_agent/memory/manager.py
new file mode 100644
index 000000000..5caceac1e
--- /dev/null
+++ b/src/ii_agent/memory/manager.py
@@ -0,0 +1,525 @@
+"""MemoryManager — async orchestrator for user memory extraction and management.
+
+Uses a secondary LLM call with tool-calling to decide what to add/update/delete.
+This class is used by the agent at runtime (not by the HTTP API).
+It manages its own DB sessions via get_db_session_local().
+"""
+
+from __future__ import annotations
+
+import logging
+import uuid
+from dataclasses import dataclass, field
+from textwrap import dedent
+from typing import Any, Callable, Dict, List, Optional, Type, Union
+
+from pydantic import BaseModel
+
+from ii_agent.agents.models.base import Model
+from ii_agent.agents.models.message import Message
+from ii_agent.agents.tools.function import Function
+from ii_agent.core.db.base import get_db_session_local
+from ii_agent.memory.models import UserMemory
+from ii_agent.memory.schemas import MemorySearchResponse
+
+logger = logging.getLogger(__name__)
+
+
+async def _evict_memory_cache(user_id: str) -> None:
+    """Evict all memory cache entries for a user after a write in MemoryManager.
+
+    Tries the container's MemoryService first (shares the same cache instance).
+    Falls back to create_entity_cache() which works correctly with Redis.
+    """
+    try:
+        from ii_agent.core.container import get_app_container
+
+        container = get_app_container()
+        await container.memory_service._cache.evict_user_memory_data(user_id)
+        return
+    except (RuntimeError, AttributeError):
+        pass  # Container not initialised yet (tests, CLI)
+
+    try:
+        from ii_agent.core.redis.cache import create_entity_cache
+        from ii_agent.memory.cache_service import MemoryCacheService
+
+        cache_backend = create_entity_cache(namespace="memory", ttl=600)
+        cache_svc = MemoryCacheService(cache=cache_backend)
+        await cache_svc.evict_user_memory_data(user_id)
+    except Exception as e:
+        logger.debug(f"Could not evict memory cache for {user_id}: {e}")
+
+
+@dataclass
+class MemoryManager:
+    """Async memory manager for creating, retrieving, and managing user memories.
+
+    Operates outside the request scope — creates its own DB sessions.
+    """
+
+    model: Optional[Model] = None
+
+    system_message: Optional[str] = None
+    memory_capture_instructions: Optional[str] = None
+    additional_instructions: Optional[str] = None
+
+    add_memories: bool = True
+    update_memories: bool = True
+    delete_memories: bool = False
+    clear_memories: bool = False
+
+    memories_updated: bool = field(default=False, init=False)
+
+    # ------------------------------------------------------------------
+    # Public API — read
+    # ------------------------------------------------------------------
+
+    async def aget_user_memories(self, user_id: Optional[str] = None) -> list[dict[str, Any]]:
+        """Return all memories for a user as dicts.
+
+        Hot path — called every agent message (context injection + existing check).
+        Optimised to avoid DB session acquire when cache hits.
+
+        Strategy:
+        1. Try cache directly (no DB session needed) — O(1) Redis GET
+        2. On miss: open DB session, query, populate cache
+        3. Fallback: direct DB query (tests/CLI without container)
+        """
+        user_id = user_id or "default"
+        user_uuid = uuid.UUID(user_id)
+
+        # 1. Try cache-only path (no DB session)
+        try:
+            from ii_agent.core.container import get_app_container
+
+            cache_svc = get_app_container().memory_service._cache
+            cached = await cache_svc.get_user_memories(user_id)
+            if cached is not None:
+                # Cache stores list[dict] with memory_id, memory, topics etc.
+                # Return directly — no Pydantic round-trip needed.
+                return cached
+        except (RuntimeError, AttributeError):
+            cache_svc = None  # Container not initialised (tests, CLI)
+
+        # 2. Cache miss — need DB session to populate cache
+        async with get_db_session_local() as db:
+            from ii_agent.memory.repository import MemoryRepository
+            from ii_agent.memory.schemas import MemoryData
+
+            repo = MemoryRepository()
+            rows = await repo.get_user_memories(db, user_uuid)
+
+            # Use MemoryData.model_dump(mode="json") to guarantee the same
+            # serialisation format that MemoryService uses, so either writer
+            # can populate the cache and either reader can consume it.
+            full_dicts = [
+                MemoryData(
+                    memory_id=r.memory_id,
+                    memory=r.memory,
+                    topics=r.topics,
+                    user_id=r.user_id,
+                    input=r.input,
+                    agent_id=r.agent_id,
+                    created_at=r.created_at,
+                    updated_at=r.updated_at,
+                ).model_dump(mode="json")
+                for r in rows
+            ]
+
+        # Populate cache for next call (same format as MemoryService)
+        if cache_svc is not None:
+            await cache_svc.set_user_memories(user_id, full_dicts)
+
+        return full_dicts
+
+    # ------------------------------------------------------------------
+    # Public API — create / update (auto mode)
+    # ------------------------------------------------------------------
+
+    async def acreate_user_memories(
+        self,
+        *,
+        message: Optional[str] = None,
+        messages: Optional[List[Message]] = None,
+        user_id: Optional[str] = None,
+        agent_id: Optional[str] = None,
+    ) -> str:
+        """Extract memories from messages and persist them."""
+        if not messages and not message:
+            raise ValueError("Provide either message or messages")
+
+        if message:
+            messages = [Message(role="user", content=message)]
+        if not messages:
+            raise ValueError("Invalid messages list")
+
+        user_id = user_id or "default"
+        existing = await self.aget_user_memories(user_id=user_id)
+
+        return await self._acreate_or_update_memories(
+            messages=messages,
+            existing_memories=existing,
+            user_id=user_id,
+            agent_id=agent_id,
+        )
+
+    # ------------------------------------------------------------------
+    # Public API — task-based mutation (agentic mode)
+    # ------------------------------------------------------------------
+
+    async def aupdate_memory_task(
+        self,
+        task: str,
+        user_id: Optional[str] = None,
+    ) -> str:
+        """Execute a free-text task against the memory store."""
+        user_id = user_id or "default"
+        existing = await self.aget_user_memories(user_id=user_id)
+
+        return await self._arun_memory_task(
+            task=task,
+            existing_memories=existing,
+            user_id=user_id,
+        )
+
+    # ------------------------------------------------------------------
+    # Public API — clear
+    # ------------------------------------------------------------------
+
+    async def aclear_user_memories(self, user_id: Optional[str] = None) -> None:
+        user_id = user_id or "default"
+        async with get_db_session_local() as db:
+            from ii_agent.memory.repository import MemoryRepository
+
+            repo = MemoryRepository()
+            await repo.clear_user_memories(db, uuid.UUID(user_id))
+
+    # ------------------------------------------------------------------
+    # Public API — search
+    # ------------------------------------------------------------------
+
+    async def asearch_user_memories(
+        self,
+        query: str,
+        user_id: Optional[str] = None,
+        limit: Optional[int] = None,
+    ) -> list[dict[str, Any]]:
+        """Agentic semantic search over user memories."""
+        user_id = user_id or "default"
+        all_memories = await self.aget_user_memories(user_id=user_id)
+        if not all_memories:
+            return []
+        return await self._asearch_agentic(all_memories, query, limit)
+
+    # ------------------------------------------------------------------
+    # Internals — LLM-based memory extraction
+    # ------------------------------------------------------------------
+
+    def _get_model(self) -> Model:
+        if self.model is None:
+            raise ValueError("MemoryManager requires a model")
+        return self.model
+
+    def _get_system_message(
+        self,
+        existing_memories: Optional[List[Dict[str, Any]]] = None,
+    ) -> Message:
+        if self.system_message is not None:
+            return Message(role="system", content=self.system_message)
+
+        capture_instructions = self.memory_capture_instructions or dedent("""\
+            Memories should capture personal information about the user that is relevant to the current conversation, such as:
+            - Personal facts: name, age, occupation, location, interests, and preferences
+            - Opinions and preferences: what the user likes, dislikes, enjoys, or finds frustrating
+            - Significant life events or experiences shared by the user
+            - Important context about the user's current situation, challenges, or goals
+            - Any other details that offer meaningful insight into the user's personality, perspective, or needs
+        """)
+
+        lines = [
+            "You are a Memory Manager responsible for managing information and preferences about the user. "
+            "You will be provided with criteria for memories to capture and a list of existing memories.",
+            "",
+            "## When to add or update memories",
+            "- Decide if a memory needs to be added, updated, or deleted based on the user's message, or if no changes are needed.",
+            "- If the user's message meets the criteria below and that information is not already captured, you should capture it.",
+            "- If existing memories already capture all relevant information, no changes are needed.",
+            "",
+            "## How to add or update memories",
+            "- Create brief, third-person statements that encapsulate the most important aspect of the user's input.",
+            "- Don't make a single memory too long — create multiple memories if needed.",
+            "- Don't repeat the same information in multiple memories.",
+            "- When updating a memory, append new information rather than overwriting.",
+            "",
+            "<memories_to_capture>",
+            capture_instructions,
+            "</memories_to_capture>",
+            "",
+            "## Available actions",
+        ]
+        if self.add_memories:
+            lines.append("  - Add a new memory using the `add_memory` tool.")
+        if self.update_memories:
+            lines.append("  - Update an existing memory using the `update_memory` tool.")
+        if self.delete_memories:
+            lines.append("  - Delete an existing memory using the `delete_memory` tool.")
+        if self.clear_memories:
+            lines.append("  - Clear all memories using the `clear_memory` tool.")
+        lines.append("You can call multiple tools in a single response if needed.")
+
+        if existing_memories:
+            lines.append("\n<existing_memories>")
+            for mem in existing_memories:
+                lines.append(f"ID: {mem['memory_id']}")
+                lines.append(f"Memory: {mem['memory']}")
+                lines.append("")
+            lines.append("</existing_memories>")
+
+        if self.additional_instructions:
+            lines.append(self.additional_instructions)
+
+        return Message(role="system", content="\n".join(lines))
+
+    def _build_db_tools(
+        self,
+        user_id: str,
+        input_string: str,
+        agent_id: Optional[str] = None,
+    ) -> List[Callable]:
+        """Build closure-based tool functions that write directly to the store."""
+
+        async def add_memory(memory: str, topics: Optional[List[str]] = None) -> str:
+            """Add a new memory to the database.
+            Args:
+                memory: The memory text to store.
+                topics: Optional topic tags (e.g. ["name", "hobbies"]).
+            Returns:
+                Status message.
+            """
+            try:
+                async with get_db_session_local() as db:
+                    from ii_agent.memory.repository import MemoryRepository
+
+                    repo = MemoryRepository()
+                    record = UserMemory(
+                        memory_id=str(uuid.uuid4()),
+                        user_id=uuid.UUID(user_id),
+                        agent_id=agent_id,
+                        memory=memory,
+                        topics=topics,
+                        input=input_string,
+                    )
+                    await repo.upsert(db, record)
+                await _evict_memory_cache(user_id)
+                return "Memory added successfully"
+            except Exception as e:
+                logger.warning(f"Error adding memory: {e}")
+                return f"Error adding memory: {e}"
+
+        async def update_memory(
+            memory_id: str, memory: str, topics: Optional[List[str]] = None
+        ) -> str:
+            """Update an existing memory.
+            Args:
+                memory_id: The ID of the memory to update.
+                memory: The updated memory text.
+                topics: Optional updated topic tags.
+            Returns:
+                Status message.
+            """
+            if not memory:
+                return "Cannot update memory with empty string."
+            try:
+                async with get_db_session_local() as db:
+                    from ii_agent.memory.repository import MemoryRepository
+
+                    repo = MemoryRepository()
+                    record = UserMemory(
+                        memory_id=memory_id,
+                        user_id=uuid.UUID(user_id),
+                        memory=memory,
+                        topics=topics,
+                        input=input_string,
+                    )
+                    await repo.upsert(db, record)
+                await _evict_memory_cache(user_id)
+                return "Memory updated successfully"
+            except Exception as e:
+                logger.warning(f"Error updating memory: {e}")
+                return f"Error updating memory: {e}"
+
+        async def delete_memory(memory_id: str) -> str:
+            """Delete a single memory.
+            Args:
+                memory_id: The ID of the memory to delete.
+            Returns:
+                Status message.
+            """
+            try:
+                async with get_db_session_local() as db:
+                    from ii_agent.memory.repository import MemoryRepository
+
+                    repo = MemoryRepository()
+                    await repo.delete_by_memory_id(db, memory_id, uuid.UUID(user_id))
+                await _evict_memory_cache(user_id)
+                return "Memory deleted successfully"
+            except Exception as e:
+                logger.warning(f"Error deleting memory: {e}")
+                return f"Error deleting memory: {e}"
+
+        async def clear_memory() -> str:
+            """Remove all memories for this user.
+            Returns:
+                Status message.
+            """
+            await self.aclear_user_memories(user_id=user_id)
+            await _evict_memory_cache(user_id)
+            return "Memory cleared successfully"
+
+        tools: List[Callable] = []
+        if self.add_memories:
+            tools.append(add_memory)
+        if self.update_memories:
+            tools.append(update_memory)
+        if self.delete_memories:
+            tools.append(delete_memory)
+        if self.clear_memories:
+            tools.append(clear_memory)
+        return tools
+
+    def _callables_to_functions(self, callables: List[Callable]) -> List[Union[Function, dict]]:
+        """Convert callable tool functions to Function objects for the model."""
+        functions: List[Union[Function, dict]] = []
+        seen: set = set()
+        for tool in callables:
+            name = tool.__name__
+            if name in seen:
+                continue
+            seen.add(name)
+            try:
+                func = Function.from_callable(tool, strict=True)
+                func.strict = True
+                functions.append(func)
+            except Exception as e:
+                logger.warning(f"Could not register function {name}: {e}")
+        return functions
+
+    async def _acreate_or_update_memories(
+        self,
+        messages: List[Message],
+        existing_memories: List[Dict[str, Any]],
+        user_id: str,
+        agent_id: Optional[str] = None,
+    ) -> str:
+        model = self._get_model()
+
+        if len(messages) == 1:
+            input_string = messages[0].content or ""
+        else:
+            input_string = ", ".join(
+                str(m.content) for m in messages if m.role == "user" and m.content
+            )
+
+        tools = self._callables_to_functions(
+            self._build_db_tools(user_id, input_string, agent_id=agent_id)
+        )
+
+        messages_for_model = [
+            self._get_system_message(existing_memories=existing_memories),
+            *messages,
+        ]
+
+        response = await model.aresponse(messages=messages_for_model, tools=tools)
+        if response.tool_calls:
+            self.memories_updated = True
+
+        return response.content or "No response from model"
+
+    async def _arun_memory_task(
+        self,
+        task: str,
+        existing_memories: List[Dict[str, Any]],
+        user_id: str,
+    ) -> str:
+        model = self._get_model()
+
+        tools = self._callables_to_functions(self._build_db_tools(user_id, task))
+
+        messages_for_model = [
+            self._get_system_message(existing_memories=existing_memories),
+            Message(role="user", content=task),
+        ]
+
+        response = await model.aresponse(messages=messages_for_model, tools=tools)
+        if response.tool_calls:
+            self.memories_updated = True
+
+        return response.content or "No response from model"
+
+    async def _asearch_agentic(
+        self,
+        memories: List[Dict[str, Any]],
+        query: str,
+        limit: Optional[int] = None,
+    ) -> list[dict[str, Any]]:
+        model = self._get_model()
+
+        system_lines = [
+            "Your task is to search through user memories and return the IDs of the memories related to the query.\n",
+            "<user_memories>",
+        ]
+        for mem in memories:
+            system_lines.append(f"ID: {mem['memory_id']}")
+            system_lines.append(f"Memory: {mem['memory']}")
+            if mem.get("topics"):
+                system_lines.append(f"Topics: {','.join(mem['topics'])}")
+            system_lines.append("")
+        system_lines.append("</user_memories>")
+        system_lines.append("\nRETURN ONLY the IDs of memories related to the query.")
+
+        response_format: Union[Dict[str, Any], Type[BaseModel]]
+        if model.supports_native_structured_outputs:
+            response_format = MemorySearchResponse
+        elif model.supports_json_schema_outputs:
+            response_format = {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": MemorySearchResponse.__name__,
+                    "schema": MemorySearchResponse.model_json_schema(),
+                },
+            }
+        else:
+            response_format = {"type": "json_object"}
+
+        messages_for_model = [
+            Message(role="system", content="\n".join(system_lines)),
+            Message(role="user", content=f"Return memory IDs related to: {query}"),
+        ]
+
+        response = await model.aresponse(
+            messages=messages_for_model, response_format=response_format
+        )
+
+        search_result: Optional[MemorySearchResponse] = None
+        if (
+            model.supports_native_structured_outputs
+            and response.parsed is not None
+            and isinstance(response.parsed, MemorySearchResponse)
+        ):
+            search_result = response.parsed
+        elif isinstance(response.content, str):
+            try:
+                from ii_agent.agents.utils.string import parse_response_model_str
+
+                search_result = parse_response_model_str(response.content, MemorySearchResponse)
+            except Exception as e:
+                logger.warning(f"Failed to parse search response: {e}")
+                return []
+
+        if search_result is None:
+            return []
+
+        id_set = set(search_result.memory_ids)
+        matched = [m for m in memories if m["memory_id"] in id_set]
+        return matched[:limit] if limit else matched
diff --git a/src/ii_agent/memory/models.py b/src/ii_agent/memory/models.py
new file mode 100644
index 000000000..712b567e3
--- /dev/null
+++ b/src/ii_agent/memory/models.py
@@ -0,0 +1,42 @@
+"""SQLAlchemy models for memory domain."""
+
+import uuid
+from typing import Optional
+
+from sqlalchemy import BigInteger, ForeignKey, Index, String
+from sqlalchemy.dialects.postgresql import JSONB, UUID
+from sqlalchemy.orm import Mapped, mapped_column
+
+from ii_agent.core.db.base import Base
+
+
+class UserMemory(Base):
+    """Persistent storage for user memories.
+
+    Each record represents a single memory about a user, including:
+    - The memory text content
+    - Optional topic tags for categorization
+    - The original user input that triggered memory creation
+    - Association with user and agent
+    """
+
+    __tablename__ = "user_memories"
+
+    memory_id: Mapped[str] = mapped_column(String, nullable=False, unique=True)
+    user_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False
+    )
+    agent_id: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    memory: Mapped[str] = mapped_column(String, nullable=False)
+    topics: Mapped[Optional[list[str]]] = mapped_column(JSONB, nullable=True)
+    input: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    version: Mapped[int] = mapped_column(BigInteger, nullable=False, default=0)
+
+    __mapper_args__ = {"version_id_col": version}
+
+    __table_args__ = (
+        Index("ix_user_memories_user_id", "user_id"),
+        Index("ix_user_memories_user_agent", "user_id", "agent_id"),
+        Index("ix_user_memories_memory_id", "memory_id", unique=True),
+        Index("ix_user_memories_updated_at", "updated_at"),
+    )
diff --git a/src/ii_agent/memory/repository.py b/src/ii_agent/memory/repository.py
new file mode 100644
index 000000000..e1d76261d
--- /dev/null
+++ b/src/ii_agent/memory/repository.py
@@ -0,0 +1,184 @@
+"""Data access layer for memory domain."""
+
+import uuid
+
+from sqlalchemy import cast, delete, func, or_, select
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ii_agent.core.db.base import BaseRepository
+from ii_agent.memory.models import UserMemory
+
+
+class MemoryRepository(BaseRepository[UserMemory]):
+    """Repository for user memory CRUD operations."""
+
+    model = UserMemory
+
+    async def get_user_memories(
+        self,
+        db: AsyncSession,
+        user_id: uuid.UUID,
+        *,
+        agent_id: str | None = None,
+        limit: int | None = None,
+    ) -> list[UserMemory]:
+        """Retrieve all memories for a user, newest first."""
+        stmt = (
+            select(UserMemory)
+            .where(UserMemory.user_id == user_id)
+            .order_by(UserMemory.updated_at.desc())
+        )
+        if agent_id is not None:
+            stmt = stmt.where(UserMemory.agent_id == agent_id)
+        if limit is not None and limit > 0:
+            stmt = stmt.limit(limit)
+
+        result = await db.execute(stmt)
+        return list(result.scalars().all())
+
+    async def get_by_memory_id(
+        self,
+        db: AsyncSession,
+        memory_id: str,
+        user_id: uuid.UUID,
+    ) -> UserMemory | None:
+        """Retrieve a single memory by its logical memory_id."""
+        stmt = select(UserMemory).where(
+            UserMemory.memory_id == memory_id,
+            UserMemory.user_id == user_id,
+        )
+        result = await db.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def get_user_memories_paginated(
+        self,
+        db: AsyncSession,
+        user_id: uuid.UUID,
+        *,
+        page: int = 1,
+        per_page: int = 10,
+        search: str | None = None,
+        topics: list[str] | None = None,
+        sort_by: str = "updated_at",
+        sort_order: str = "desc",
+    ) -> tuple[list[UserMemory], int]:
+        """Paginated query for the dashboard UI. Returns (items, total_count)."""
+        base = select(UserMemory).where(UserMemory.user_id == user_id)
+
+        if search:
+            base = base.where(UserMemory.memory.ilike(f"%{search}%"))
+        if topics:
+            base = base.where(
+                or_(
+                    *[
+                        UserMemory.topics.op("@>")(cast([t], JSONB))
+                        for t in topics
+                    ]
+                )
+            )
+
+        # Count
+        count_stmt = select(func.count()).select_from(base.subquery())
+        total = (await db.execute(count_stmt)).scalar_one()
+
+        # Sort
+        if sort_by == "memory":
+            order_col = UserMemory.memory
+        elif sort_by == "topics_count":
+            order_col = func.jsonb_array_length(
+                func.coalesce(UserMemory.topics, cast("[]", JSONB))
+            )
+        else:
+            order_col = UserMemory.updated_at
+
+        base = base.order_by(order_col.asc() if sort_order == "asc" else order_col.desc())
+
+        # Paginate
+        offset = (page - 1) * per_page
+        base = base.offset(offset).limit(per_page)
+
+        result = await db.execute(base)
+        rows = list(result.scalars().all())
+        return rows, total
+
+    async def get_distinct_topics(
+        self,
+        db: AsyncSession,
+        user_id: uuid.UUID,
+    ) -> list[str]:
+        """Return all distinct topics across user memories."""
+        subq = (
+            select(
+                func.jsonb_array_elements_text(UserMemory.topics).label("topic")
+            )
+            .where(UserMemory.user_id == user_id)
+            .where(UserMemory.topics.is_not(None))
+            .where(func.jsonb_array_length(UserMemory.topics) > 0)
+        ).subquery()
+        stmt = select(func.distinct(subq.c.topic))
+        result = await db.execute(stmt)
+        return sorted([row[0] for row in result.all()])
+
+    async def upsert(
+        self,
+        db: AsyncSession,
+        memory: UserMemory,
+    ) -> UserMemory:
+        """Insert or update a single memory."""
+        existing = await db.execute(
+            select(UserMemory).where(UserMemory.memory_id == memory.memory_id)
+        )
+        row = existing.scalar_one_or_none()
+
+        if row is not None:
+            row.memory = memory.memory
+            row.topics = memory.topics
+            row.input = memory.input
+            if memory.agent_id is not None:
+                row.agent_id = memory.agent_id
+            await db.flush()
+            await db.refresh(row)
+            return row
+        else:
+            db.add(memory)
+            await db.flush()
+            await db.refresh(memory)
+            return memory
+
+    async def delete_by_memory_id(
+        self,
+        db: AsyncSession,
+        memory_id: str,
+        user_id: uuid.UUID,
+    ) -> None:
+        """Delete a single memory by its logical memory_id."""
+        stmt = delete(UserMemory).where(
+            UserMemory.memory_id == memory_id,
+            UserMemory.user_id == user_id,
+        )
+        await db.execute(stmt)
+
+    async def delete_by_memory_ids(
+        self,
+        db: AsyncSession,
+        memory_ids: list[str],
+        user_id: uuid.UUID,
+    ) -> None:
+        """Batch-delete memories."""
+        if not memory_ids:
+            return
+        stmt = delete(UserMemory).where(
+            UserMemory.memory_id.in_(memory_ids),
+            UserMemory.user_id == user_id,
+        )
+        await db.execute(stmt)
+
+    async def clear_user_memories(
+        self,
+        db: AsyncSession,
+        user_id: uuid.UUID,
+    ) -> None:
+        """Delete all memories for a user."""
+        stmt = delete(UserMemory).where(UserMemory.user_id == user_id)
+        await db.execute(stmt)
diff --git a/src/ii_agent/memory/router.py b/src/ii_agent/memory/router.py
new file mode 100644
index 000000000..6e47581ff
--- /dev/null
+++ b/src/ii_agent/memory/router.py
@@ -0,0 +1,143 @@
+"""Memory dashboard API endpoints."""
+
+from typing import Any, Optional
+
+from fastapi import APIRouter, HTTPException, Query, status
+
+from ii_agent.auth.dependencies import CurrentUser, DBSession
+from ii_agent.memory.dependencies import MemoryServiceDep
+from ii_agent.memory.schemas import (
+    MemoryBulkDeleteRequest,
+    MemoryCreateRequest,
+    MemoryListResponse,
+    MemoryResponse,
+    MemoryUpdateRequest,
+)
+
+router = APIRouter(prefix="/memories", tags=["Memories"])
+
+
+@router.get("", response_model=MemoryListResponse)
+async def list_memories(
+    current_user: CurrentUser,
+    db: DBSession,
+    memory_service: MemoryServiceDep,
+    page: int = Query(1, ge=1),
+    per_page: int = Query(10, ge=1, le=100),
+    search: Optional[str] = Query(None, max_length=200),
+    topics: Optional[str] = Query(None, description="Comma-separated topic filters"),
+    sort_by: str = Query("updated_at"),
+    sort_order: str = Query("desc"),
+) -> Any:
+    """List user memories with pagination, search, filter, and sort."""
+    if sort_by not in ("updated_at", "memory", "topics_count"):
+        sort_by = "updated_at"
+    if sort_order not in ("asc", "desc"):
+        sort_order = "desc"
+
+    topic_list = [t.strip() for t in topics.split(",") if t.strip()] if topics else None
+
+    memories, total = await memory_service.get_memories_paginated(
+        db,
+        current_user.id,
+        page=page,
+        per_page=per_page,
+        search=search,
+        topics=topic_list,
+        sort_by=sort_by,
+        sort_order=sort_order,
+    )
+
+    return MemoryListResponse(
+        memories=memories,
+        total=total,
+        page=page,
+        per_page=per_page,
+    )
+
+
+@router.get("/topics", response_model=list[str])
+async def list_topics(
+    current_user: CurrentUser,
+    db: DBSession,
+    memory_service: MemoryServiceDep,
+) -> Any:
+    """Get all distinct topics for the current user."""
+    return await memory_service.get_distinct_topics(db, current_user.id)
+
+
+@router.get("/{memory_id}", response_model=MemoryResponse)
+async def get_memory(
+    memory_id: str,
+    current_user: CurrentUser,
+    db: DBSession,
+    memory_service: MemoryServiceDep,
+) -> Any:
+    """Get a single memory by ID."""
+    memory = await memory_service.get_memory(db, memory_id, current_user.id)
+    if not memory:
+        raise HTTPException(status_code=404, detail="Memory not found")
+    return memory
+
+
+@router.post("", response_model=MemoryResponse, status_code=status.HTTP_201_CREATED)
+async def create_memory(
+    body: MemoryCreateRequest,
+    current_user: CurrentUser,
+    db: DBSession,
+    memory_service: MemoryServiceDep,
+) -> Any:
+    """Create a new memory."""
+    import uuid
+
+    return await memory_service.upsert_memory(
+        db,
+        memory_id=str(uuid.uuid4()),
+        user_id=current_user.id,
+        memory_text=body.memory,
+        topics=body.topics or [],
+    )
+
+
+@router.put("/{memory_id}", response_model=MemoryResponse)
+async def update_memory(
+    memory_id: str,
+    body: MemoryUpdateRequest,
+    current_user: CurrentUser,
+    db: DBSession,
+    memory_service: MemoryServiceDep,
+) -> Any:
+    """Update an existing memory."""
+    existing = await memory_service.get_memory(db, memory_id, current_user.id)
+    if not existing:
+        raise HTTPException(status_code=404, detail="Memory not found")
+
+    return await memory_service.upsert_memory(
+        db,
+        memory_id=memory_id,
+        user_id=current_user.id,
+        memory_text=body.memory if body.memory is not None else existing.memory,
+        topics=body.topics if body.topics is not None else existing.topics,
+    )
+
+
+@router.delete("/{memory_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_memory(
+    memory_id: str,
+    current_user: CurrentUser,
+    db: DBSession,
+    memory_service: MemoryServiceDep,
+) -> None:
+    """Delete a single memory."""
+    await memory_service.delete_memory(db, memory_id, current_user.id)
+
+
+@router.post("/bulk-delete", status_code=status.HTTP_204_NO_CONTENT)
+async def bulk_delete_memories(
+    body: MemoryBulkDeleteRequest,
+    current_user: CurrentUser,
+    db: DBSession,
+    memory_service: MemoryServiceDep,
+) -> None:
+    """Delete multiple memories at once."""
+    await memory_service.delete_memories(db, body.memory_ids, current_user.id)
diff --git a/src/ii_agent/memory/schemas.py b/src/ii_agent/memory/schemas.py
new file mode 100644
index 000000000..81e1cd31b
--- /dev/null
+++ b/src/ii_agent/memory/schemas.py
@@ -0,0 +1,90 @@
+"""Pydantic schemas (DTOs) for memory domain."""
+
+from datetime import datetime
+from typing import Optional
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+# ---------------------------------------------------------------------------
+# Domain DTO (used internally by service/manager)
+# ---------------------------------------------------------------------------
+
+
+class MemoryData(BaseModel):
+    """Domain model for a single user memory record."""
+
+    model_config = ConfigDict(from_attributes=True)
+
+    memory_id: str
+    memory: str
+    topics: list[str] | None = None
+    user_id: UUID | None = None
+    input: str | None = None
+    agent_id: str | None = None
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+
+# ---------------------------------------------------------------------------
+# API request/response DTOs
+# ---------------------------------------------------------------------------
+
+
+class MemoryResponse(BaseModel):
+    memory_id: str
+    memory: str
+    topics: list[str] | None = None
+    input: str | None = None
+    agent_id: str | None = None
+    created_at: int | None = None
+    updated_at: int | None = None
+
+
+class MemoryListResponse(BaseModel):
+    memories: list[MemoryResponse]
+    total: int
+    page: int
+    per_page: int
+
+
+class MemoryCreateRequest(BaseModel):
+    memory: str = Field(..., min_length=1, max_length=5000)
+    topics: list[str] | None = None
+
+
+class MemoryUpdateRequest(BaseModel):
+    memory: str | None = Field(None, min_length=1, max_length=5000)
+    topics: list[str] | None = None
+
+
+class MemoryBulkDeleteRequest(BaseModel):
+    memory_ids: list[str]
+
+
+# ---------------------------------------------------------------------------
+# User preferences
+# ---------------------------------------------------------------------------
+
+
+class UserPreferences(BaseModel):
+    has_memory: bool = True
+
+
+class UpdatePreferencesRequest(BaseModel):
+    has_memory: Optional[bool] = None
+
+
+# ---------------------------------------------------------------------------
+# Agentic search response
+# ---------------------------------------------------------------------------
+
+
+class MemorySearchResponse(BaseModel):
+    """Model for agentic memory search results."""
+
+    memory_ids: list[str] = Field(
+        ...,
+        description="The IDs of the memories that are most semantically similar to the query.",
+    )
diff --git a/src/ii_agent/memory/service.py b/src/ii_agent/memory/service.py
new file mode 100644
index 000000000..68c4686ff
--- /dev/null
+++ b/src/ii_agent/memory/service.py
@@ -0,0 +1,258 @@
+"""Business logic for memory domain.
+
+Combines DB access via MemoryRepository with Redis caching via MemoryCacheService.
+Follows the project's service pattern: takes db: AsyncSession as first parameter.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+import uuid
+from typing import Any
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ii_agent.memory.cache_service import MemoryCacheService
+from ii_agent.memory.models import UserMemory
+from ii_agent.memory.repository import MemoryRepository
+from ii_agent.memory.schemas import MemoryData, MemoryResponse
+
+logger = logging.getLogger(__name__)
+
+
+def _to_response(record: UserMemory) -> MemoryResponse:
+    """Convert ORM record to API response DTO."""
+    return MemoryResponse(
+        memory_id=record.memory_id,
+        memory=record.memory,
+        topics=record.topics,
+        input=record.input,
+        agent_id=record.agent_id,
+        created_at=int(record.created_at.timestamp()) if record.created_at else None,
+        updated_at=int(record.updated_at.timestamp()) if record.updated_at else None,
+    )
+
+
+def _to_data(record: UserMemory) -> MemoryData:
+    """Convert ORM record to domain DTO."""
+    return MemoryData(
+        memory_id=record.memory_id,
+        memory=record.memory,
+        topics=record.topics,
+        user_id=record.user_id,
+        input=record.input,
+        agent_id=record.agent_id,
+        created_at=record.created_at,
+        updated_at=record.updated_at,
+    )
+
+
+class MemoryService:
+    """Service for user memory operations."""
+
+    def __init__(
+        self,
+        *,
+        memory_repo: MemoryRepository,
+        cache: MemoryCacheService,
+    ) -> None:
+        self._repo = memory_repo
+        self._cache = cache
+
+    # ------------------------------------------------------------------
+    # Reads
+    # ------------------------------------------------------------------
+
+    async def get_user_memories(
+        self,
+        db: AsyncSession,
+        user_id: uuid.UUID,
+        *,
+        agent_id: str | None = None,
+        limit: int | None = None,
+    ) -> list[MemoryData]:
+        """Retrieve all memories for a user, newest first.
+
+        Uses cache for the unfiltered case (agent context injection).
+        """
+        use_cache = agent_id is None and limit is None
+        user_id_str = str(user_id)
+
+        if use_cache:
+            cached = await self._cache.get_user_memories(user_id_str)
+            if cached is not None:
+                return [MemoryData.model_validate(d) for d in cached]
+
+        rows = await self._repo.get_user_memories(
+            db, user_id, agent_id=agent_id, limit=limit
+        )
+        memories = [_to_data(row) for row in rows]
+
+        if use_cache:
+            await self._cache.set_user_memories(
+                user_id_str, [m.model_dump(mode="json") for m in memories]
+            )
+
+        return memories
+
+    async def get_memory(
+        self,
+        db: AsyncSession,
+        memory_id: str,
+        user_id: uuid.UUID,
+    ) -> MemoryResponse | None:
+        row = await self._repo.get_by_memory_id(db, memory_id, user_id)
+        return _to_response(row) if row else None
+
+    async def get_memories_paginated(
+        self,
+        db: AsyncSession,
+        user_id: uuid.UUID,
+        *,
+        page: int = 1,
+        per_page: int = 10,
+        search: str | None = None,
+        topics: list[str] | None = None,
+        sort_by: str = "updated_at",
+        sort_order: str = "desc",
+    ) -> tuple[list[MemoryResponse], int]:
+        """Paginated query with Redis cache."""
+        user_id_str = str(user_id)
+        params_str = (
+            f"{page}:{per_page}:{search}:"
+            f"{sorted(topics) if topics else ''}:{sort_by}:{sort_order}"
+        )
+        params_hash = hashlib.md5(params_str.encode()).hexdigest()[:12]
+
+        cached = await self._cache.get_paginated_memories(user_id_str, params_hash)
+        if cached is not None:
+            memories = [MemoryResponse.model_validate(d) for d in cached["memories"]]
+            return memories, cached["total"]
+
+        rows, total = await self._repo.get_user_memories_paginated(
+            db,
+            user_id,
+            page=page,
+            per_page=per_page,
+            search=search,
+            topics=topics,
+            sort_by=sort_by,
+            sort_order=sort_order,
+        )
+        memories = [_to_response(row) for row in rows]
+
+        await self._cache.set_paginated_memories(
+            user_id_str,
+            params_hash,
+            {"memories": [m.model_dump(mode="json") for m in memories], "total": total},
+        )
+
+        return memories, total
+
+    async def get_distinct_topics(
+        self,
+        db: AsyncSession,
+        user_id: uuid.UUID,
+    ) -> list[str]:
+        user_id_str = str(user_id)
+        cached = await self._cache.get_user_topics(user_id_str)
+        if cached is not None:
+            return cached
+
+        topics = await self._repo.get_distinct_topics(db, user_id)
+        await self._cache.set_user_topics(user_id_str, topics)
+        return topics
+
+    # ------------------------------------------------------------------
+    # Writes
+    # ------------------------------------------------------------------
+
+    async def upsert_memory(
+        self,
+        db: AsyncSession,
+        *,
+        memory_id: str,
+        user_id: uuid.UUID,
+        memory_text: str,
+        topics: list[str] | None = None,
+        input_text: str | None = None,
+        agent_id: str | None = None,
+    ) -> MemoryResponse:
+        """Insert or update a single memory."""
+        record = UserMemory(
+            memory_id=memory_id,
+            user_id=user_id,
+            agent_id=agent_id,
+            memory=memory_text,
+            topics=topics,
+            input=input_text,
+        )
+        saved = await self._repo.upsert(db, record)
+        await self._cache.evict_user_memory_data(str(user_id))
+        return _to_response(saved)
+
+    async def delete_memory(
+        self,
+        db: AsyncSession,
+        memory_id: str,
+        user_id: uuid.UUID,
+    ) -> None:
+        await self._repo.delete_by_memory_id(db, memory_id, user_id)
+        await self._cache.evict_user_memory_data(str(user_id))
+
+    async def delete_memories(
+        self,
+        db: AsyncSession,
+        memory_ids: list[str],
+        user_id: uuid.UUID,
+    ) -> None:
+        await self._repo.delete_by_memory_ids(db, memory_ids, user_id)
+        await self._cache.evict_user_memory_data(str(user_id))
+
+    async def clear_user_memories(
+        self,
+        db: AsyncSession,
+        user_id: uuid.UUID,
+    ) -> None:
+        await self._repo.clear_user_memories(db, user_id)
+        await self._cache.evict_user_memory_data(str(user_id))
+
+    # ------------------------------------------------------------------
+    # User preferences
+    # ------------------------------------------------------------------
+
+    async def load_user_memory_preferences(
+        self,
+        db: AsyncSession,
+        user_id: uuid.UUID,
+    ) -> dict[str, Any]:
+        """Load memory preferences from user metadata.
+
+        Returns dict with 'has_memory' key, defaulting to True.
+        """
+        from ii_agent.users.models import User
+        from sqlalchemy import select
+
+        user_id_str = str(user_id)
+
+        cached = await self._cache.get_user_prefs(user_id_str)
+        if cached is not None:
+            return cached
+
+        try:
+            result = await db.execute(
+                select(User.user_metadata).where(User.id == user_id)
+            )
+            row = result.scalar_one_or_none()
+            if row and isinstance(row, dict):
+                prefs = row.get("preferences", {})
+                data = {"has_memory": prefs.get("has_memory", True)}
+            else:
+                data = {"has_memory": True}
+        except Exception as e:
+            logger.warning(f"Failed to load user memory preferences: {e}")
+            data = {"has_memory": True}
+
+        await self._cache.set_user_prefs(user_id_str, data)
+        return data
diff --git a/src/ii_agent/memory/strategies/__init__.py b/src/ii_agent/memory/strategies/__init__.py
new file mode 100644
index 000000000..581e20b2c
--- /dev/null
+++ b/src/ii_agent/memory/strategies/__init__.py
@@ -0,0 +1,7 @@
+from ii_agent.memory.strategies.base import MemoryOptimizationStrategy
+from ii_agent.memory.strategies.summarize import SummarizeStrategy
+
+__all__ = [
+    "MemoryOptimizationStrategy",
+    "SummarizeStrategy",
+]
diff --git a/src/ii_agent/memory/strategies/base.py b/src/ii_agent/memory/strategies/base.py
new file mode 100644
index 000000000..fe15d9ddd
--- /dev/null
+++ b/src/ii_agent/memory/strategies/base.py
@@ -0,0 +1,23 @@
+"""Base class for memory optimization strategies."""
+
+from abc import ABC, abstractmethod
+
+from ii_agent.agents.models.base import Model
+from ii_agent.memory.schemas import MemoryData
+
+
+class MemoryOptimizationStrategy(ABC):
+    """Abstract base class for memory optimization strategies."""
+
+    @abstractmethod
+    async def aoptimize(
+        self,
+        memories: list[MemoryData],
+        model: Model,
+    ) -> list[MemoryData]:
+        """Optimize memories asynchronously."""
+        raise NotImplementedError
+
+    def count_tokens(self, memories: list[MemoryData]) -> int:
+        """Approximate token count across all memories (4 chars ~ 1 token)."""
+        return sum(len(m.memory or "") // 4 for m in memories)
diff --git a/src/ii_agent/memory/strategies/summarize.py b/src/ii_agent/memory/strategies/summarize.py
new file mode 100644
index 000000000..55786fc49
--- /dev/null
+++ b/src/ii_agent/memory/strategies/summarize.py
@@ -0,0 +1,87 @@
+"""Summarize strategy: combine all memories into a single comprehensive summary."""
+
+import logging
+from textwrap import dedent
+from uuid import uuid4
+
+from ii_agent.agents.models.base import Model
+from ii_agent.agents.models.message import Message
+from ii_agent.memory.schemas import MemoryData
+from ii_agent.memory.strategies.base import MemoryOptimizationStrategy
+
+logger = logging.getLogger(__name__)
+
+
+class SummarizeStrategy(MemoryOptimizationStrategy):
+    """Combine all memories into a single comprehensive summary.
+
+    Achieves maximum compression by eliminating redundancy.
+    """
+
+    def _get_system_prompt(self) -> str:
+        return dedent("""\
+            You are a memory compression assistant. Your task is to summarize multiple memories about a user
+            into a single comprehensive summary while preserving all key facts.
+
+            Requirements:
+            - Combine related information from all memories
+            - Preserve all factual information
+            - Remove redundancy and consolidate repeated facts
+            - Create a coherent narrative about the user
+            - Maintain third-person perspective
+            - Do not add information not present in the original memories
+
+            Return only the summarized memory text, nothing else.\
+        """)
+
+    async def aoptimize(
+        self,
+        memories: list[MemoryData],
+        model: Model,
+    ) -> list[MemoryData]:
+        if not memories:
+            raise ValueError("No memories to optimize")
+
+        user_id = memories[0].user_id
+        if user_id is None:
+            raise ValueError("Cannot determine user_id from first memory")
+
+        memory_contents = [m.memory for m in memories if m.memory]
+        all_topics: list[str] = []
+        for m in memories:
+            if m.topics:
+                all_topics.extend(m.topics)
+        summarized_topics = list(set(all_topics)) if all_topics else None
+
+        agent_ids = {m.agent_id for m in memories if m.agent_id}
+        summarized_agent_id = list(agent_ids)[0] if len(agent_ids) == 1 else None
+
+        combined_content = "\n\n".join(
+            [f"Memory {i + 1}: {content}" for i, content in enumerate(memory_contents)]
+        )
+
+        messages_for_model = [
+            Message(role="system", content=self._get_system_prompt()),
+            Message(
+                role="user",
+                content=f"Summarize these memories into a single summary:\n\n{combined_content}",
+            ),
+        ]
+
+        response = await model.aresponse(messages=messages_for_model)
+        summarized_content = response.content or " ".join(memory_contents)
+
+        summarized_memory = MemoryData(
+            memory_id=str(uuid4()),
+            memory=summarized_content.strip(),
+            topics=summarized_topics,
+            user_id=user_id,
+            agent_id=summarized_agent_id,
+        )
+
+        logger.debug(
+            f"Summarized {len(memories)} memories into 1: "
+            f"{self.count_tokens(memories)} -> {self.count_tokens([summarized_memory])} tokens"
+        )
+
+        return [summarized_memory]
diff --git a/src/ii_agent/memory/types.py b/src/ii_agent/memory/types.py
new file mode 100644
index 000000000..5b0c51684
--- /dev/null
+++ b/src/ii_agent/memory/types.py
@@ -0,0 +1,14 @@
+"""Enum types for memory domain."""
+
+from enum import StrEnum
+
+
+class MemorySortField(StrEnum):
+    UPDATED_AT = "updated_at"
+    MEMORY = "memory"
+    TOPICS_COUNT = "topics_count"
+
+
+class MemorySortOrder(StrEnum):
+    ASC = "asc"
+    DESC = "desc"
diff --git a/src/ii_agent/realtime/handlers/query.py b/src/ii_agent/realtime/handlers/query.py
index 6dbf2707d..026896df8 100644
--- a/src/ii_agent/realtime/handlers/query.py
+++ b/src/ii_agent/realtime/handlers/query.py
@@ -89,6 +89,20 @@ async def _handle_query(
         final_status = RunStatus.FAILED
         try:
             session_store = AgentSessionStore(session_maker=get_session_factory())
+
+            # Merge DB-backed user preferences as base, with request tool_args as override
+            from ii_agent.memory.service import MemoryService
+            tool_args = query_command.tool_args or {}
+            try:
+                memory_service: MemoryService = self._container.memory_service
+                async with get_db_session_local() as prefs_db:
+                    user_prefs = await memory_service.load_user_memory_preferences(
+                        prefs_db, session_info.user_id
+                    )
+                tool_args = {**user_prefs, **tool_args}
+            except Exception as e:
+                logger.warning(f"Failed to load user memory preferences: {e}")
+
             agent = await agent_factory.create_agent(
                 user_id=str(session_info.user_id),
                 session_id=str(session_info.id),
@@ -97,7 +111,7 @@ async def _handle_query(
                 if session_info.agent_type
                 else AgentType.GENERAL,
                 session_store=session_store,
-                tool_args=query_command.tool_args,
+                tool_args=tool_args,
                 metadata=query_command.metadata,
                 skill_creator=self._create_skill_creator(session_info.user_id),
             )
diff --git a/src/ii_agent/users/models.py b/src/ii_agent/users/models.py
index c752f8494..34a2f5c1d 100644
--- a/src/ii_agent/users/models.py
+++ b/src/ii_agent/users/models.py
@@ -100,6 +100,14 @@ class User(Base):
         "Skill", back_populates="user", cascade="all, delete-orphan"
     )
 
+    @property
+    def preferences(self) -> dict:
+        md = self.user_metadata if isinstance(self.user_metadata, dict) else {}
+        prefs = md.get("preferences", {})
+        return {
+            "has_memory": prefs.get("has_memory", True),
+        }
+
     # Add index for email lookup
     __table_args__ = (Index("idx_users_email", "email"),)
 
diff --git a/src/ii_agent/users/router.py b/src/ii_agent/users/router.py
index 61b38f5f5..73a7b763d 100644
--- a/src/ii_agent/users/router.py
+++ b/src/ii_agent/users/router.py
@@ -1,6 +1,10 @@
 """API routes for users domain."""
 
+import copy
+from typing import Any, Optional
+
 from fastapi import APIRouter
+from pydantic import BaseModel
 
 from ii_agent.auth.dependencies import CurrentUser, DBSession
 from ii_agent.users.dependencies import UserServiceDep
@@ -20,6 +24,37 @@ async def update_user_language(
     return {"message": "Language updated successfully", "language": language}
 
 
+class UpdatePreferencesRequest(BaseModel):
+    has_memory: Optional[bool] = None
+
+
+@router.patch("/me/preferences")
+async def update_user_preferences(
+    current_user: CurrentUser,
+    db: DBSession,
+    body: UpdatePreferencesRequest,
+) -> dict[str, Any]:
+    """Update user preference settings (memory, personalization)."""
+    metadata = copy.deepcopy(current_user.user_metadata) if isinstance(current_user.user_metadata, dict) else {}
+    old_prefs = metadata.get("preferences", {})
+    updates = body.model_dump(exclude_none=True)
+    metadata["preferences"] = {**old_prefs, **updates}
+
+    current_user.user_metadata = metadata
+    await db.commit()
+
+    # Evict cached memory preferences so the next agent run sees the new value
+    try:
+        from ii_agent.core.container import get_app_container
+
+        container = get_app_container()
+        await container.memory_service._cache.evict_user_prefs(str(current_user.id))
+    except Exception:
+        pass  # cache eviction is best-effort
+
+    return {"message": "Preferences updated successfully", "preferences": current_user.preferences}
+
+
 @router.delete("/me")
 async def delete_user_account(
     current_user: CurrentUser,
diff --git a/src/ii_agent/users/schemas.py b/src/ii_agent/users/schemas.py
index 2379bd881..5984e6f06 100644
--- a/src/ii_agent/users/schemas.py
+++ b/src/ii_agent/users/schemas.py
@@ -6,6 +6,10 @@
 from pydantic import BaseModel, ConfigDict, field_serializer
 
 
+class UserPreferences(BaseModel):
+    has_memory: bool = True
+
+
 class UserPublic(BaseModel):
     model_config = ConfigDict(from_attributes=True)
 
@@ -20,6 +24,7 @@ class UserPublic(BaseModel):
     subscription_billing_cycle: str | None = None
     subscription_current_period_end: datetime | None = None
     language: str = "en"
+    preferences: UserPreferences = UserPreferences()
 
     @field_serializer("subscription_current_period_end", when_used="json", mode="plain")
     def serialize_period_end(self, value: datetime | None, _info) -> str | None: