diff --git a/interface/src/api/client.ts b/interface/src/api/client.ts
index 837861d77..857282435 100644
--- a/interface/src/api/client.ts
+++ b/interface/src/api/client.ts
@@ -378,6 +378,32 @@ export interface MemoriesSearchParams {
 	memory_type?: MemoryType;
 }
 
+export interface MemoryCreateRequest {
+	agent_id: string;
+	content: string;
+	memory_type?: MemoryType;
+	importance?: number;
+}
+
+export interface MemoryUpdateRequest {
+	agent_id: string;
+	memory_id: string;
+	content?: string;
+	memory_type?: MemoryType;
+	importance?: number;
+}
+
+export interface MemoryWriteResponse {
+	success: boolean;
+	memory: MemoryItem;
+}
+
+export interface MemoryDeleteResponse {
+	success: boolean;
+	forgotten: boolean;
+	message: string;
+}
+
 export type CortexEventType =
 	| "bulletin_generated"
 	| "bulletin_failed"
@@ -961,6 +987,38 @@ export const api = {
 		if (params.sort) search.set("sort", params.sort);
 		return fetchJson<MemoriesListResponse>(`/agents/memories?${search}`);
 	},
+	createMemory: async (request: MemoryCreateRequest) => {
+		const response = await fetch(`${API_BASE}/agents/memories`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(request),
+		});
+		if (!response.ok) {
+			throw new Error(`API error: ${response.status}`);
+		}
+		return response.json() as Promise<MemoryWriteResponse>;
+	},
+	updateMemory: async (request: MemoryUpdateRequest) => {
+		const response = await fetch(`${API_BASE}/agents/memories`, {
+			method: "PUT",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(request),
+		});
+		if (!response.ok) {
+			throw new Error(`API error: ${response.status}`);
+		}
+		return response.json() as Promise<MemoryWriteResponse>;
+	},
+	deleteMemory: async (agentId: string, memoryId: string) => {
+		const search = new URLSearchParams({ agent_id: agentId, memory_id: memoryId });
+		const response = await fetch(`${API_BASE}/agents/memories?${search}`, {
+			method: "DELETE",
+		});
+		if (!response.ok) {
+			throw new Error(`API error: ${response.status}`);
+		}
+		return response.json() as Promise<MemoryDeleteResponse>;
+	},
 	searchMemories: (agentId: string, query: string, params: MemoriesSearchParams = {}) => {
 		const search = new URLSearchParams({ agent_id: agentId, q: query });
 		if (params.limit) search.set("limit", String(params.limit));
diff --git a/interface/src/routes/AgentMemories.tsx b/interface/src/routes/AgentMemories.tsx
index 3aba1ec27..dd4f69dde 100644
--- a/interface/src/routes/AgentMemories.tsx
+++ b/interface/src/routes/AgentMemories.tsx
@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useRef, useState } from "react";
-import { useQuery } from "@tanstack/react-query";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { useVirtualizer } from "@tanstack/react-virtual";
 import { AnimatePresence, motion } from "framer-motion";
 import {
@@ -13,10 +13,23 @@ import { CortexChatPanel } from "@/components/CortexChatPanel";
 import { MemoryGraph } from "@/components/MemoryGraph";
 import {
 	Button,
+	Dialog,
+	DialogContent,
+	DialogHeader,
+	DialogTitle,
 	DropdownMenu,
 	DropdownMenuContent,
 	DropdownMenuItem,
 	DropdownMenuTrigger,
+	Input,
+	Label,
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+	Slider,
+	TextArea,
 	ToggleGroup,
 	SearchInput,
 	FilterButton,
@@ -27,6 +40,28 @@ import { HugeiconsIcon } from "@hugeicons/react";
 
 type ViewMode = "list" | "graph";
 
+interface MemoryFormData {
+	content: string;
+	memory_type: MemoryType;
+	importance: number;
+}
+
+function emptyFormData(): MemoryFormData {
+	return {
+		content: "",
+		memory_type: "fact",
+		importance: 0.6,
+	};
+}
+
+function memoryToFormData(memory: MemoryItem): MemoryFormData {
+	return {
+		content: memory.content,
+		memory_type: memory.memory_type,
+		importance: memory.importance,
+	};
+}
+
 const SORT_OPTIONS: { value: MemorySort; label: string }[] = [
 	{ value: "recent", label: "Recent" },
 	{ value: "importance", label: "Importance" },
@@ -71,6 +106,7 @@ interface AgentMemoriesProps {
 }
 
 export function AgentMemories({ agentId }: AgentMemoriesProps) {
+	const queryClient = useQueryClient();
 	const [viewMode, setViewMode] = useState<ViewMode>("list");
 	const [searchQuery, setSearchQuery] = useState("");
 	const [debouncedQuery, setDebouncedQuery] = useState("");
@@ -78,6 +114,11 @@ export function AgentMemories({ agentId }: AgentMemoriesProps) {
 	const [typeFilter, setTypeFilter] = useState<MemoryType | null>(null);
 	const [expandedId, setExpandedId] = useState<string | null>(null);
 	const [chatOpen, setChatOpen] = useState(true);
+	const [editorOpen, setEditorOpen] = useState(false);
+	const [editingMemory, setEditingMemory] = useState<MemoryItem | null>(null);
+	const [formData, setFormData] = useState<MemoryFormData>(emptyFormData());
+	const [formError, setFormError] = useState<string | null>(null);
+	const [deleteConfirmMemoryId, setDeleteConfirmMemoryId] = useState<string | null>(null);
 
 	const parentRef = useRef<HTMLDivElement>(null);
 
@@ -128,15 +169,110 @@ export function AgentMemories({ agentId }: AgentMemoriesProps) {
 	const isLoading = isSearching ? searchQueryResult.isLoading : listQuery.isLoading;
 	const isError = isSearching ? searchQueryResult.isError : listQuery.isError;
 
+	const refreshMemories = () => {
+		queryClient.invalidateQueries({ queryKey: ["memories", agentId] });
+		queryClient.invalidateQueries({ queryKey: ["memories-search", agentId] });
+	};
+
+	const createMutation = useMutation({
+		mutationFn: () => {
+			return api.createMemory({
+				agent_id: agentId,
+				content: formData.content,
+				memory_type: formData.memory_type,
+				importance: formData.importance,
+			});
+		},
+		onSuccess: () => {
+			refreshMemories();
+			setEditorOpen(false);
+			setEditingMemory(null);
+			setFormData(emptyFormData());
+			setFormError(null);
+		},
+		onError: () => setFormError("Failed to create memory"),
+	});
+
+	const updateMutation = useMutation({
+		mutationFn: () => {
+			if (!editingMemory) throw new Error("No memory selected");
+			return api.updateMemory({
+				agent_id: agentId,
+				memory_id: editingMemory.id,
+				content: formData.content,
+				memory_type: formData.memory_type,
+				importance: formData.importance,
+			});
+		},
+		onSuccess: () => {
+			refreshMemories();
+			setEditorOpen(false);
+			setEditingMemory(null);
+			setFormData(emptyFormData());
+			setFormError(null);
+		},
+		onError: () => setFormError("Failed to update memory"),
+	});
+
+	const deleteMutation = useMutation({
+		mutationFn: (memoryId: string) => api.deleteMemory(agentId, memoryId),
+		onSuccess: (_response, memoryId) => {
+			refreshMemories();
+			if (expandedId === memoryId) {
+				setExpandedId(null);
+			}
+			setDeleteConfirmMemoryId(null);
+		},
+	});
+
+	const openCreateDialog = () => {
+		setEditingMemory(null);
+		setFormData(emptyFormData());
+		setFormError(null);
+		setEditorOpen(true);
+	};
+
+	const openEditDialog = (memory: MemoryItem) => {
+		setEditingMemory(memory);
+		setFormData(memoryToFormData(memory));
+		setFormError(null);
+		setEditorOpen(true);
+	};
+
+	const saveMemory = () => {
+		const trimmedContent = formData.content.trim();
+		if (!trimmedContent) {
+			setFormError("Content is required");
+			return;
+		}
+
+		if (formData.importance < 0 || formData.importance > 1) {
+			setFormError("Importance must be between 0 and 1");
+			return;
+		}
+
+		setFormError(null);
+		if (editingMemory) {
+			updateMutation.mutate();
+		} else {
+			createMutation.mutate();
+		}
+	};
+
 	const virtualizer = useVirtualizer({
 		count: memories.length,
 		getScrollElement: () => parentRef.current,
+		getItemKey: (index) => memories[index]?.id ?? index,
 		estimateSize: useCallback((index: number) => {
 			return expandedId === memories[index]?.id ? 200 : 48;
 		}, [expandedId, memories]),
 		overscan: 10,
 	});
 
+	useEffect(() => {
+		virtualizer.measure();
+	}, [memories.length, expandedId, virtualizer]);
+
 	// Reset expanded when data changes
 	useEffect(() => {
 		setExpandedId(null);
@@ -174,6 +310,10 @@ export function AgentMemories({ agentId }: AgentMemoriesProps) {
 					</DropdownMenuContent>
 				</DropdownMenu>
 
+				<Button size="sm" variant="secondary" onClick={openCreateDialog}>
+					+ Add memory
+				</Button>
+
 			{/* View mode toggle */}
 			<ToggleGroup
 				value={viewMode}
@@ -228,11 +368,10 @@ export function AgentMemories({ agentId }: AgentMemoriesProps) {
 			) : (
 				<>
 					{/* Table header */}
-					<div className="grid grid-cols-[80px_1fr_100px_120px_100px] gap-3 border-b border-app-line/50 px-6 py-2 text-tiny font-medium uppercase tracking-wider text-ink-faint">
+					<div className="grid grid-cols-[80px_1fr_100px_120px] gap-3 border-b border-app-line/50 px-6 py-2 text-tiny font-medium uppercase tracking-wider text-ink-faint">
 						<span>Type</span>
 						<span>{isSearching ? "Content / Score" : "Content"}</span>
 						<span>Importance</span>
-						<span>Source</span>
 						<span>Created</span>
 					</div>
 
@@ -277,7 +416,7 @@ export function AgentMemories({ agentId }: AgentMemoriesProps) {
 										<Button
 											onClick={() => setExpandedId(isExpanded ? null : memory.id)}
 											variant="ghost"
-											className="grid h-auto w-full grid-cols-[80px_1fr_100px_120px_100px] items-center gap-3 rounded-none px-6 py-3 text-left hover:bg-app-darkBox/30"
+											className="grid h-auto w-full grid-cols-[80px_1fr_100px_120px] items-center gap-3 rounded-none px-6 py-3 text-left hover:bg-app-darkBox/30"
 										>
 												<TypeBadge type={memory.memory_type} />
 												<div className="min-w-0">
@@ -291,9 +430,6 @@ export function AgentMemories({ agentId }: AgentMemoriesProps) {
 													)}
 												</div>
 												<ImportanceBar value={memory.importance} />
-												<span className="truncate text-tiny text-ink-faint">
-													{memory.source ?? "-"}
-												</span>
 												<span className="text-tiny text-ink-faint">
 													{formatTimeAgo(memory.created_at)}
 												</span>
@@ -309,18 +445,27 @@ export function AgentMemories({ agentId }: AgentMemoriesProps) {
 														transition={{ type: "spring", stiffness: 500, damping: 35 }}
 														className="overflow-hidden border-t border-app-line/30 bg-app-darkBox/20 px-6"
 													>
-														<div className="py-4">
-															<p className="whitespace-pre-wrap text-sm leading-relaxed text-ink-dull">
-																{memory.content}
-															</p>
-															<div className="mt-3 flex flex-wrap gap-x-6 gap-y-1 text-tiny text-ink-faint">
+													<div className="py-4">
+														<p className="whitespace-pre-wrap text-sm leading-relaxed text-ink-dull">
+															{memory.content}
+														</p>
+														<div className="mt-3 flex items-center gap-2">
+															<Button size="sm" variant="secondary" onClick={() => openEditDialog(memory)}>
+																Edit
+															</Button>
+															<Button
+																size="sm"
+																variant="destructive"
+																onClick={() => setDeleteConfirmMemoryId(memory.id)}
+															>
+																Remove
+															</Button>
+														</div>
+														<div className="mt-3 flex flex-wrap gap-x-6 gap-y-1 text-tiny text-ink-faint">
 																<span>ID: {memory.id}</span>
 																<span>Accessed: {memory.access_count}x</span>
 																<span>Last accessed: {formatTimeAgo(memory.last_accessed_at)}</span>
 																<span>Updated: {formatTimeAgo(memory.updated_at)}</span>
-																{memory.channel_id && (
-																	<span>Channel: {memory.channel_id}</span>
-																)}
 															</div>
 														</div>
 													</motion.div>
@@ -355,6 +500,119 @@ export function AgentMemories({ agentId }: AgentMemoriesProps) {
 					</motion.div>
 				)}
 			</AnimatePresence>
+
+			<Dialog open={editorOpen} onOpenChange={(open) => !open && setEditorOpen(false)}>
+				<DialogContent>
+					<DialogHeader>
+						<DialogTitle>{editingMemory ? "Edit memory" : "Add memory"}</DialogTitle>
+					</DialogHeader>
+					<div className="space-y-3">
+						<div className="space-y-1.5">
+							<Label>Content</Label>
+							<TextArea
+								value={formData.content}
+								onChange={(event) =>
+									setFormData((prev) => ({ ...prev, content: event.target.value }))
+								}
+								rows={4}
+							/>
+						</div>
+						<div className="grid grid-cols-2 gap-3">
+							<div className="space-y-1.5">
+								<Label>Type</Label>
+								<Select
+									value={formData.memory_type}
+									onValueChange={(value) =>
+										setFormData((prev) => ({ ...prev, memory_type: value as MemoryType }))
+									}
+								>
+									<SelectTrigger>
+										<SelectValue />
+									</SelectTrigger>
+									<SelectContent>
+										{MEMORY_TYPES.map((type_) => (
+											<SelectItem key={type_} value={type_}>
+												{type_}
+											</SelectItem>
+										))}
+									</SelectContent>
+								</Select>
+							</div>
+							<div className="space-y-1.5">
+								<Label>Importance (0-1)</Label>
+								<div className="flex items-center gap-3">
+									<Slider
+										value={[formData.importance]}
+										onValueChange={(value) =>
+											setFormData((prev) => ({ ...prev, importance: value[0] ?? prev.importance }))
+										}
+										min={0}
+										max={1}
+										step={0.01}
+										className="flex-1"
+									/>
+									<Input
+										type="number"
+										min={0}
+										max={1}
+										step={0.01}
+										value={formData.importance.toFixed(2)}
+										onChange={(event) => {
+											const parsed = Number.parseFloat(event.target.value);
+											if (Number.isNaN(parsed)) return;
+											setFormData((prev) => ({
+												...prev,
+												importance: Math.min(1, Math.max(0, parsed)),
+											}));
+										}}
+										className="w-24"
+									/>
+								</div>
+							</div>
+						</div>
+						{formError && <p className="text-sm text-red-400">{formError}</p>}
+						<div className="flex justify-end gap-2">
+							<Button variant="ghost" size="sm" onClick={() => setEditorOpen(false)}>
+								Cancel
+							</Button>
+							<Button
+								size="sm"
+								onClick={saveMemory}
+								loading={createMutation.isPending || updateMutation.isPending}
+							>
+								{editingMemory ? "Save changes" : "Create memory"}
+							</Button>
+						</div>
+					</div>
+				</DialogContent>
+			</Dialog>
+
+			<Dialog
+				open={deleteConfirmMemoryId !== null}
+				onOpenChange={(open) => !open && setDeleteConfirmMemoryId(null)}
+			>
+				<DialogContent>
+					<DialogHeader>
+						<DialogTitle>Remove memory?</DialogTitle>
+					</DialogHeader>
+					<p className="text-sm text-ink-dull">
+						This forgets the memory and removes it from active recall.
+					</p>
+					<div className="flex justify-end gap-2">
+						<Button variant="ghost" size="sm" onClick={() => setDeleteConfirmMemoryId(null)}>
+							Cancel
+						</Button>
+						<Button
+							variant="destructive"
+							size="sm"
+							onClick={() => deleteConfirmMemoryId && deleteMutation.mutate(deleteConfirmMemoryId)}
+							loading={deleteMutation.isPending}
+						>
+							Remove
+						</Button>
+					</div>
+				</DialogContent>
+			</Dialog>
 		</div>
 	);
 }
diff --git a/src/api/memories.rs b/src/api/memories.rs
index e3e50e286..02f785c65 100644
--- a/src/api/memories.rs
+++ b/src/api/memories.rs
@@ -9,6 +9,51 @@ use axum::http::StatusCode;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 
+#[derive(Deserialize)]
+pub(super) struct CreateMemoryRequest {
+    agent_id: String,
+    content: String,
+    #[serde(default = "default_memory_type")]
+    memory_type: String,
+    #[serde(default)]
+    importance: Option<f32>,
+}
+
+fn default_memory_type() -> String {
+    "fact".to_string()
+}
+
+#[derive(Deserialize)]
+pub(super) struct UpdateMemoryRequest {
+    agent_id: String,
+    memory_id: String,
+    #[serde(default)]
+    content: Option<String>,
+    #[serde(default)]
+    memory_type: Option<String>,
+    #[serde(default)]
+    importance: Option<f32>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct DeleteMemoryRequest {
+    agent_id: String,
+    memory_id: String,
+}
+
+#[derive(Serialize)]
+pub(super) struct MemoryWriteResponse {
+    success: bool,
+    memory: Memory,
+}
+
+#[derive(Serialize)]
+pub(super) struct MemoryDeleteResponse {
+    success: bool,
+    forgotten: bool,
+    message: String,
+}
+
 #[derive(Serialize)]
 pub(super) struct MemoriesListResponse {
     memories: Vec<Memory>,
@@ -122,6 +167,187 @@ fn default_neighbor_depth() -> u32 {
     1
 }
 
+fn parse_required_memory_type(type_str: &str) -> Result<MemoryType, StatusCode> {
+    parse_memory_type(type_str).ok_or(StatusCode::BAD_REQUEST)
+}
+
+/// Create a new memory for an agent.
+pub(super) async fn create_memory(
+    State(state): State<Arc<ApiState>>,
+    Json(request): Json<CreateMemoryRequest>,
+) -> Result<Json<MemoryWriteResponse>, StatusCode> {
+    let content = request.content.trim().to_string();
+    if content.is_empty() {
+        return Err(StatusCode::BAD_REQUEST);
+    }
+
+    let memory_type = parse_required_memory_type(&request.memory_type)?;
+
+    let searches = state.memory_searches.load();
+    let memory_search = searches.get(&request.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+    let store = memory_search.store();
+
+    let mut memory = Memory::new(content.clone(), memory_type);
+    if let Some(importance) = request.importance {
+        memory.importance = importance.clamp(0.0, 1.0);
+    }
+
+    store.save(&memory).await.map_err(|error| {
+        tracing::warn!(%error, agent_id = %request.agent_id, "failed to create memory");
+        StatusCode::INTERNAL_SERVER_ERROR
+    })?;
+
+    let embedding = memory_search
+        .embedding_model_arc()
+        .embed_one(&memory.content)
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, agent_id = %request.agent_id, memory_id = %memory.id, "failed to embed memory content");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+    memory_search
+        .embedding_table()
+        .store(&memory.id, &memory.content, &embedding)
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, agent_id = %request.agent_id, memory_id = %memory.id, "failed to store memory embedding");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+    if let Err(error) = memory_search.embedding_table().ensure_fts_index().await {
+        tracing::warn!(%error, "failed to ensure FTS index after memory create");
+    }
+
+    Ok(Json(MemoryWriteResponse {
+        success: true,
+        memory,
+    }))
+}
+
+/// Update an existing memory for an agent.
+pub(super) async fn update_memory(
+    State(state): State<Arc<ApiState>>,
+    Json(request): Json<UpdateMemoryRequest>,
+) -> Result<Json<MemoryWriteResponse>, StatusCode> {
+    let searches = state.memory_searches.load();
+    let memory_search = searches.get(&request.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+    let store = memory_search.store();
+
+    let mut memory = store.load(&request.memory_id).await.map_err(|error| {
+        tracing::warn!(%error, agent_id = %request.agent_id, memory_id = %request.memory_id, "failed to load memory for update");
+        StatusCode::INTERNAL_SERVER_ERROR
+    })?
+    .ok_or(StatusCode::NOT_FOUND)?;
+
+    let mut content_updated = false;
+
+    if let Some(content) = request.content {
+        let trimmed = content.trim();
+        if trimmed.is_empty() {
+            return Err(StatusCode::BAD_REQUEST);
+        }
+        if memory.content != trimmed {
+            memory.content = trimmed.to_string();
+            content_updated = true;
+        }
+    }
+
+    if let Some(memory_type) = request.memory_type {
+        memory.memory_type = parse_required_memory_type(&memory_type)?;
+    }
+
+    if let Some(importance) = request.importance {
+        memory.importance = importance.clamp(0.0, 1.0);
+    }
+
+    memory.updated_at = chrono::Utc::now();
+
+    store.update(&memory).await.map_err(|error| {
+        tracing::warn!(%error, agent_id = %request.agent_id, memory_id = %request.memory_id, "failed to update memory");
+        StatusCode::INTERNAL_SERVER_ERROR
+    })?;
+
+    if content_updated {
+        if let Err(error) = memory_search.embedding_table().delete(&memory.id).await {
+            tracing::warn!(%error, memory_id = %memory.id, "failed to delete previous embedding during memory update");
+        }
+
+        let embedding = memory_search
+            .embedding_model_arc()
+            .embed_one(&memory.content)
+            .await
+            .map_err(|error| {
+                tracing::warn!(%error, agent_id = %request.agent_id, memory_id = %memory.id, "failed to embed updated memory content");
+                StatusCode::INTERNAL_SERVER_ERROR
+            })?;
+
+        memory_search
+            .embedding_table()
+            .store(&memory.id, &memory.content, &embedding)
+            .await
+            .map_err(|error| {
+                tracing::warn!(%error, agent_id = %request.agent_id, memory_id = %memory.id, "failed to store updated memory embedding");
+                StatusCode::INTERNAL_SERVER_ERROR
+            })?;
+
+        if let Err(error) = memory_search.embedding_table().ensure_fts_index().await {
+            tracing::warn!(%error, "failed to ensure FTS index after memory update");
+        }
+    }
+
+    Ok(Json(MemoryWriteResponse {
+        success: true,
+        memory,
+    }))
+}
+
+/// Soft-delete a memory for an agent (sets forgotten = true).
+pub(super) async fn delete_memory(
+    State(state): State<Arc<ApiState>>,
+    Query(query): Query<DeleteMemoryRequest>,
+) -> Result<Json<MemoryDeleteResponse>, StatusCode> {
+    let searches = state.memory_searches.load();
+    let memory_search = searches.get(&query.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+    let store = memory_search.store();
+
+    let Some(memory) = store.load(&query.memory_id).await.map_err(|error| {
+        tracing::warn!(%error, agent_id = %query.agent_id, memory_id = %query.memory_id, "failed to load memory for deletion");
+        StatusCode::INTERNAL_SERVER_ERROR
+    })? else {
+        return Err(StatusCode::NOT_FOUND);
+    };
+
+    if memory.forgotten {
+        return Ok(Json(MemoryDeleteResponse {
+            success: true,
+            forgotten: false,
+            message: "Memory is already forgotten".to_string(),
+        }));
+    }
+
+    let forgotten = store.forget(&query.memory_id).await.map_err(|error| {
+        tracing::warn!(%error, agent_id = %query.agent_id, memory_id = %query.memory_id, "failed to forget memory");
+        StatusCode::INTERNAL_SERVER_ERROR
+    })?;
+
+    if forgotten
+        && let Err(error) = memory_search.embedding_table().delete(&query.memory_id).await
+    {
+        tracing::warn!(%error, memory_id = %query.memory_id, "failed to delete memory embedding after forget");
+    }
+
+    Ok(Json(MemoryDeleteResponse {
+        success: forgotten,
+        forgotten,
+        message: if forgotten {
+            "Memory forgotten".to_string()
+        } else {
+            "Memory was not forgotten".to_string()
+        },
+    }))
+}
+
 /// List memories for an agent with sorting, filtering, and pagination.
 pub(super) async fn list_memories(
     State(state): State<Arc<ApiState>>,
diff --git a/src/api/server.rs b/src/api/server.rs
index 39dcc9d64..6120f83c5 100644
--- a/src/api/server.rs
+++ b/src/api/server.rs
@@ -73,7 +73,13 @@ pub async fn start_http_server(
         .route("/channels", get(channels::list_channels))
         .route("/channels/messages", get(channels::channel_messages))
         .route("/channels/status", get(channels::channel_status))
-        .route("/agents/memories", get(memories::list_memories))
+        .route(
+            "/agents/memories",
+            get(memories::list_memories)
+                .post(memories::create_memory)
+                .put(memories::update_memory)
+                .delete(memories::delete_memory),
+        )
         .route("/agents/memories/search", get(memories::search_memories))
         .route("/agents/memories/graph", get(memories::memory_graph))
         .route(