diff --git a/AGENTS.md b/AGENTS.md
index ba51135..7b529e0 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -15,6 +15,12 @@ Xianren Studio（仙人工作室）：Tauri 2 + React 的 Windows 本地大模
 2. 涉及代码结构、模块职责、数据流、事件通道、数据库表/字段 → 更新 `docs/ARCHITECTURE.md` 对应章节。
 3. 涉及技术栈、目录结构、构建方式 → 同步更新 `README.md`。
 
+**每次代码改动后，必须提交并推送到远程仓库，且每次推送都打一个新的 tag：**
+
+1. 完成一轮代码改动（含文档同步）后，`git add -A` 并提交，提交信息用中文简要描述本次改动。
+2. 推送到远程 `origin/main`。
+3. 以现有最新 tag 为基准递增版本号（如 `v1.0.0` → `v1.1.0`），创建带注释的新 tag 并推送 tag。
+
 ## 构建命令
 
 ```powershell
diff --git a/README.md b/README.md
index 4bde102..f7f4b9d 100644
--- a/README.md
+++ b/README.md
@@ -7,6 +7,8 @@
 - **模型管理**：启动时自动扫描模型目录（可手动重新扫描），支持导入本地 GGUF、添加 OpenAI 兼容在线 API 模型（需「启用」后才会出现在对话页可选列表）；本地模型可一键「部署」后台加载并查看进度
 - **模型广场**：搜索 Hugging Face / ModelScope 上的 GGUF 模型，按量化版本一键下载（ModelScope 文件自动附带 SHA256 校验），下载进度实时显示
 - **聊天**：流式输出、Markdown/代码高亮、采样参数调节、多会话管理；右侧栏「可选大模型服务」只列出有部署状态的大模型（运行中/启动中/出错，彩色状态点）与已启用的在线 API 模型，模型名不显示 `.gguf` 后缀；每条回答下方显示所用模型名；回答完成后自动预测用户可能说的话（可点击填入输入框，条数与开关可在设置调整）；切换选项卡后保持会话与大模型等状态
+- **智能体**：内置预制智能体（通用助手、代码专家、写作助手、翻译官、数据分析师、提示词优化师）并支持自定义，每个智能体拥有独立人设（系统提示词）与专属会话区，可单独对话干活；支持本地与在线大模型，可恢复被删除的预制智能体
+- **工作流**：画布式可视化编排（开始 → 大模型/文本 → 输出，节点连线传参），内置翻译、总结、两步润色、写作助手等预制工作流并支持自定义；一键运行，支持本地与在线大模型，可在画布上实时查看每个节点的输出
 - **对话细节**：空会话复用（已有无消息的新建对话时不再新建）、回答重新生成/版本历史/编辑重提、思考过程展示、会话置顶收藏与导入导出
 - **本地 API 服务**：OpenAI 兼容端点（/v1/models、/v1/chat/completions、/v1/embeddings），仅本机监听，可选 API Key
 
diff --git a/apps/desktop/src/commands.rs b/apps/desktop/src/commands.rs
index 424170e..dd4a51a 100644
--- a/apps/desktop/src/commands.rs
+++ b/apps/desktop/src/commands.rs
@@ -9,11 +9,13 @@ use std::time::Instant;
 use tauri::{AppHandle, Emitter, State};
 use tokio::sync::RwLock;
 use xianren_api::ApiState;
+use xianren_core::agents as agents_db;
 use xianren_core::models as models_db;
 use xianren_core::mcp_servers as mcp_db;
 use xianren_core::sessions as sessions_db;
 use xianren_core::settings as settings_db;
 use xianren_core::skills as skills_db;
+use xianren_core::workflows as workflows_db;
 use xianren_core::{CoreApp, ModelInfo, Message};
 use xianren_engine::{ChatMessage, ChatRequest, EngineConfig, EngineManager};
 use xianren_engine::remote::RemoteConfig;
@@ -83,6 +85,15 @@ pub struct ChatToolStatusEvent {
     pub status: String,
 }
 
+#[derive(Serialize, Clone)]
+pub struct WorkflowNodeStatusEvent {
+    pub workflow_id: String,
+    pub node_id: String,
+    pub label: String,
+    pub status: String,
+    pub text: Option<String>,
+}
+
 #[derive(Serialize, Clone)]
 pub struct ChatTitleUpdatedEvent {
     pub conversation_id: String,
@@ -427,10 +438,468 @@ fn read_json_files(dir: &PathBuf) -> Result<Vec<PathBuf>, String> {
     Ok(files)
 }
 
+/// 内置预制智能体列表（随应用发布，首次启动写入数据库，可随时恢复）。
+const DEFAULT_AGENTS_JSON: &str = include_str!("default_agents.json");
+
+#[derive(Deserialize)]
+pub struct AgentInput {
+    pub name: String,
+    #[serde(default)]
+    pub icon: String,
+    #[serde(default)]
+    pub description: String,
+    #[serde(default)]
+    pub system_prompt: String,
+    #[serde(default)]
+    pub model_id: Option<String>,
+    #[serde(default = "default_true")]
+    pub enabled: bool,
+}
+
+fn default_true() -> bool {
+    true
+}
+
 #[tauri::command]
-pub fn list_conversations(state: State<'_, App>) -> Result<Vec<xianren_core::Conversation>, String> {
+pub fn list_agents(state: State<'_, App>) -> Result<Vec<xianren_core::Agent>, String> {
     let db = state.core.db.lock().unwrap();
-    sessions_db::list_conversations(&db).map_err(|e| e.to_string())
+    agents_db::list(&db).map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub fn add_agent(
+    state: State<'_, App>,
+    input: AgentInput,
+) -> Result<xianren_core::Agent, String> {
+    let db = state.core.db.lock().unwrap();
+    let id = uuid::Uuid::new_v4().to_string();
+    let agent = xianren_core::Agent {
+        id,
+        kind: "custom".to_string(),
+        name: input.name.trim().to_string(),
+        icon: if input.icon.trim().is_empty() {
+            "🤖".to_string()
+        } else {
+            input.icon.trim().to_string()
+        },
+        description: input.description.trim().to_string(),
+        system_prompt: input.system_prompt.trim().to_string(),
+        model_id: input.model_id,
+        enabled: input.enabled,
+        created_at: String::new(),
+        updated_at: String::new(),
+    };
+    if agent.name.is_empty() {
+        return Err("智能体名称不能为空".into());
+    }
+    agents_db::insert(&db, &agent).map_err(|e| e.to_string())?;
+    agents_db::get(&db, &agent.id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| "agent not found".to_string())
+}
+
+#[tauri::command]
+pub fn update_agent(
+    state: State<'_, App>,
+    id: String,
+    input: AgentInput,
+) -> Result<(), String> {
+    let db = state.core.db.lock().unwrap();
+    let existing = agents_db::get(&db, &id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| "智能体不存在".to_string())?;
+    let name = input.name.trim().to_string();
+    if name.is_empty() {
+        return Err("智能体名称不能为空".into());
+    }
+    let agent = xianren_core::Agent {
+        id,
+        kind: existing.kind,
+        name,
+        icon: if input.icon.trim().is_empty() {
+            existing.icon
+        } else {
+            input.icon.trim().to_string()
+        },
+        description: input.description.trim().to_string(),
+        system_prompt: input.system_prompt.trim().to_string(),
+        model_id: input.model_id,
+        enabled: input.enabled,
+        created_at: existing.created_at,
+        updated_at: String::new(),
+    };
+    agents_db::update(&db, &agent).map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub fn remove_agent(state: State<'_, App>, id: String) -> Result<(), String> {
+    let db = state.core.db.lock().unwrap();
+    // 删除智能体时一并清理它名下的所有会话（消息随外键级联删除）
+    let conversations = sessions_db::list_conversations(&db, Some(&id)).map_err(|e| e.to_string())?;
+    for c in conversations {
+        sessions_db::delete_conversation(&db, &c.id).map_err(|e| e.to_string())?;
+    }
+    agents_db::delete(&db, &id).map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub fn set_agent_enabled(
+    state: State<'_, App>,
+    id: String,
+    enabled: bool,
+) -> Result<(), String> {
+    let db = state.core.db.lock().unwrap();
+    agents_db::set_enabled(&db, &id, enabled).map_err(|e| e.to_string())
+}
+
+/// 恢复缺失的预制智能体（已存在或已被用户删除的同名预制体不会重复写入）。
+#[tauri::command]
+pub fn restore_preset_agents(state: State<'_, App>) -> Result<usize, String> {
+    let db = state.core.db.lock().unwrap();
+    let presets: Vec<xianren_core::Agent> =
+        serde_json::from_str(DEFAULT_AGENTS_JSON).unwrap_or_default();
+    agents_db::insert_presets_if_missing(&db, &presets).map_err(|e| e.to_string())
+}
+
+/// 首次启动时写入预制智能体（只执行一次，之后尊重用户删除）。
+pub fn seed_preset_agents(db: &rusqlite::Connection) -> usize {
+    let seeded = settings_db::get(db, "preset_agents_seeded")
+        .ok()
+        .flatten()
+        .map(|v| v == "1")
+        .unwrap_or(false);
+    if seeded {
+        return 0;
+    }
+    let presets: Vec<xianren_core::Agent> =
+        serde_json::from_str(DEFAULT_AGENTS_JSON).unwrap_or_default();
+    let inserted = agents_db::insert_presets_if_missing(db, &presets).unwrap_or(0);
+    let _ = settings_db::set(db, "preset_agents_seeded", "1");
+    inserted
+}
+
+/// 内置预制工作流（随应用发布，首次启动写入数据库，可随时恢复）。
+const DEFAULT_WORKFLOWS_JSON: &str = include_str!("default_workflows.json");
+
+#[derive(Deserialize)]
+pub struct WorkflowInput {
+    pub name: String,
+    #[serde(default)]
+    pub icon: String,
+    #[serde(default)]
+    pub description: String,
+    #[serde(default)]
+    pub nodes: Vec<xianren_core::workflows::WorkflowNode>,
+    #[serde(default)]
+    pub edges: Vec<xianren_core::workflows::WorkflowEdge>,
+    #[serde(default)]
+    pub model_id: Option<String>,
+    #[serde(default = "default_true")]
+    pub enabled: bool,
+}
+
+#[tauri::command]
+pub fn list_workflows(state: State<'_, App>) -> Result<Vec<xianren_core::Workflow>, String> {
+    let db = state.core.db.lock().unwrap();
+    workflows_db::list(&db).map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub fn add_workflow(
+    state: State<'_, App>,
+    input: WorkflowInput,
+) -> Result<xianren_core::Workflow, String> {
+    let db = state.core.db.lock().unwrap();
+    let name = input.name.trim().to_string();
+    if name.is_empty() {
+        return Err("工作流名称不能为空".into());
+    }
+    let id = uuid::Uuid::new_v4().to_string();
+    let workflow = xianren_core::Workflow {
+        id,
+        kind: "custom".to_string(),
+        name,
+        icon: if input.icon.trim().is_empty() {
+            "🔀".to_string()
+        } else {
+            input.icon.trim().to_string()
+        },
+        description: input.description.trim().to_string(),
+        nodes: input.nodes,
+        edges: input.edges,
+        model_id: input.model_id,
+        enabled: input.enabled,
+        created_at: String::new(),
+        updated_at: String::new(),
+    };
+    workflows_db::insert(&db, &workflow).map_err(|e| e.to_string())?;
+    workflows_db::get(&db, &workflow.id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| "workflow not found".to_string())
+}
+
+#[tauri::command]
+pub fn update_workflow(
+    state: State<'_, App>,
+    id: String,
+    input: WorkflowInput,
+) -> Result<(), String> {
+    let db = state.core.db.lock().unwrap();
+    let existing = workflows_db::get(&db, &id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| "工作流不存在".to_string())?;
+    let name = input.name.trim().to_string();
+    if name.is_empty() {
+        return Err("工作流名称不能为空".into());
+    }
+    let workflow = xianren_core::Workflow {
+        id,
+        kind: existing.kind,
+        name,
+        icon: if input.icon.trim().is_empty() {
+            existing.icon
+        } else {
+            input.icon.trim().to_string()
+        },
+        description: input.description.trim().to_string(),
+        nodes: input.nodes,
+        edges: input.edges,
+        model_id: input.model_id,
+        enabled: input.enabled,
+        created_at: existing.created_at,
+        updated_at: String::new(),
+    };
+    workflows_db::update(&db, &workflow).map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub fn remove_workflow(state: State<'_, App>, id: String) -> Result<(), String> {
+    let db = state.core.db.lock().unwrap();
+    workflows_db::delete(&db, &id).map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub fn set_workflow_enabled(
+    state: State<'_, App>,
+    id: String,
+    enabled: bool,
+) -> Result<(), String> {
+    let db = state.core.db.lock().unwrap();
+    workflows_db::set_enabled(&db, &id, enabled).map_err(|e| e.to_string())
+}
+
+/// 恢复缺失的预制工作流（已存在或已被用户删除的同名预制体不会重复写入）。
+#[tauri::command]
+pub fn restore_preset_workflows(state: State<'_, App>) -> Result<usize, String> {
+    let db = state.core.db.lock().unwrap();
+    let presets: Vec<xianren_core::Workflow> =
+        serde_json::from_str(DEFAULT_WORKFLOWS_JSON).unwrap_or_default();
+    workflows_db::insert_presets_if_missing(&db, &presets).map_err(|e| e.to_string())
+}
+
+/// 首次启动时写入预制工作流（只执行一次，之后尊重用户删除）。
+pub fn seed_preset_workflows(db: &rusqlite::Connection) -> usize {
+    let seeded = settings_db::get(db, "preset_workflows_seeded")
+        .ok()
+        .flatten()
+        .map(|v| v == "1")
+        .unwrap_or(false);
+    if seeded {
+        return 0;
+    }
+    let presets: Vec<xianren_core::Workflow> =
+        serde_json::from_str(DEFAULT_WORKFLOWS_JSON).unwrap_or_default();
+    let inserted = workflows_db::insert_presets_if_missing(db, &presets).unwrap_or(0);
+    let _ = settings_db::set(db, "preset_workflows_seeded", "1");
+    inserted
+}
+
+#[derive(Deserialize)]
+pub struct RunWorkflowPayload {
+    pub workflow_id: String,
+    #[serde(default)]
+    pub input: String,
+    #[serde(default)]
+    pub model_id: Option<String>,
+}
+
+/// 运行工作流：按拓扑顺序执行节点，LLM 节点调用本地/在线大模型，逐步推送节点状态事件。
+#[tauri::command]
+pub async fn run_workflow(
+    app: AppHandle,
+    state: State<'_, App>,
+    payload: RunWorkflowPayload,
+) -> Result<serde_json::Value, String> {
+    let core = state.core.clone();
+    let engine = state.engine.clone();
+    let (nodes, edges, wf_model_id) = {
+        let db = core.db.lock().unwrap();
+        let wf = workflows_db::get(&db, &payload.workflow_id)
+            .map_err(|e| e.to_string())?
+            .ok_or_else(|| "工作流不存在".to_string())?;
+        (wf.nodes, wf.edges, wf.model_id)
+    };
+
+    let result = crate::workflow::execute_workflow(
+        &nodes,
+        &edges,
+        &payload.input,
+        |node, prompt| {
+            let app = app.clone();
+            let core = core.clone();
+            let engine = engine.clone();
+            let workflow_id = payload.workflow_id.clone();
+            let wf_model_id = wf_model_id.clone();
+            let payload_model_id = payload.model_id.clone();
+            let node = node.clone();
+            let prompt = prompt.to_string();
+            async move {
+                let model = {
+                    let db = core.db.lock().unwrap();
+                    resolve_workflow_node_model(&db, &node, &wf_model_id, &payload_model_id)?
+                };
+                call_workflow_node_model(
+                    &app,
+                    &engine,
+                    &node,
+                    &prompt,
+                    &workflow_id,
+                    &model,
+                )
+                .await
+            }
+        },
+    )
+    .await?;
+
+    Ok(serde_json::json!({
+        "workflow_id": payload.workflow_id,
+        "results": result.results,
+        "final": result.final_text,
+    }))
+}
+
+/// 解析 LLM 节点使用的大模型：节点配置 → 工作流默认 → 运行参数 → 第一个本地/已启用在线模型。
+fn resolve_workflow_node_model(
+    db: &rusqlite::Connection,
+    node: &xianren_core::workflows::WorkflowNode,
+    wf_model_id: &Option<String>,
+    payload_model_id: &Option<String>,
+) -> Result<ModelInfo, String> {
+    let node_model = node
+        .data
+        .get("model_id")
+        .and_then(|v| v.as_str())
+        .filter(|s| !s.is_empty())
+        .map(str::to_string);
+    for candidate in [node_model, wf_model_id.clone(), payload_model_id.clone()]
+        .into_iter()
+        .flatten()
+    {
+        if let Some(m) = models_db::get(db, &candidate).map_err(|e| e.to_string())? {
+            return Ok(m);
+        }
+    }
+    let all = models_db::list(db).map_err(|e| e.to_string())?;
+    if let Some(m) = all.iter().find(|m| m.kind == "local") {
+        return Ok(m.clone());
+    }
+    if let Some(m) = all.iter().find(|m| m.kind == "remote" && m.enabled) {
+        return Ok(m.clone());
+    }
+    Err("没有可用的大模型：请先在模型管理部署本地模型或启用在线 API 模型".into())
+}
+
+/// 调用模型执行一个 LLM 节点（非流式），前后推送节点状态事件。
+async fn call_workflow_node_model(
+    app: &AppHandle,
+    engine: &EngineManager,
+    node: &xianren_core::workflows::WorkflowNode,
+    prompt: &str,
+    workflow_id: &str,
+    model: &ModelInfo,
+) -> Result<String, String> {
+    let _ = app.emit(
+        "workflow://node-status",
+        WorkflowNodeStatusEvent {
+            workflow_id: workflow_id.to_string(),
+            node_id: node.id.clone(),
+            label: node.label.clone(),
+            status: "running".to_string(),
+            text: None,
+        },
+    );
+    let temperature = node
+        .data
+        .get("temperature")
+        .and_then(|v| v.as_f64())
+        .unwrap_or(0.7) as f32;
+    let max_tokens = node
+        .data
+        .get("max_tokens")
+        .and_then(|v| v.as_u64())
+        .unwrap_or(2048)
+        .clamp(64, 8192) as u32;
+    let text = call_model_text(engine, model, prompt, temperature, max_tokens)
+        .await
+        .map_err(|e| format!("节点「{}」调用大模型失败：{e}", node.label))?;
+    let _ = app.emit(
+        "workflow://node-status",
+        WorkflowNodeStatusEvent {
+            workflow_id: workflow_id.to_string(),
+            node_id: node.id.clone(),
+            label: node.label.clone(),
+            status: "done".to_string(),
+            text: Some(text.clone()),
+        },
+    );
+    Ok(text)
+}
+
+/// 调用本地引擎或远程 OpenAI 兼容 API 完成一次非流式对话（工作流 LLM 节点复用）。
+pub async fn call_model_text(
+    engine: &EngineManager,
+    model: &ModelInfo,
+    prompt: &str,
+    temperature: f32,
+    max_tokens: u32,
+) -> Result<String, String> {
+    let upstream_model = if model.kind == "remote" {
+        model
+            .api_model
+            .clone()
+            .unwrap_or_else(|| model.repo_id.clone())
+    } else {
+        model.repo_id.clone()
+    };
+    let req = ChatRequest {
+        model: upstream_model.clone(),
+        messages: vec![ChatMessage::new("user", prompt)],
+        temperature: Some(temperature),
+        top_p: None,
+        max_tokens: Some(max_tokens),
+        stream: false,
+    };
+    let result = if model.kind == "remote" {
+        let cfg = RemoteConfig {
+            base_url: model.base_url.clone().unwrap_or_default(),
+            api_key: model.api_key.clone(),
+            model: upstream_model,
+        };
+        xianren_engine::chat_remote(&cfg, req).await
+    } else {
+        engine.chat(req).await
+    };
+    result.map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub fn list_conversations(
+    state: State<'_, App>,
+    agent_id: Option<String>,
+) -> Result<Vec<xianren_core::Conversation>, String> {
+    let db = state.core.db.lock().unwrap();
+    sessions_db::list_conversations(&db, agent_id.as_deref()).map_err(|e| e.to_string())
 }
 
 #[tauri::command]
@@ -438,10 +907,13 @@ pub fn create_conversation(
     state: State<'_, App>,
     title: String,
     model_id: Option<String>,
+    agent_id: Option<String>,
 ) -> Result<xianren_core::Conversation, String> {
     let db = state.core.db.lock().unwrap();
-    // 若已存在还没有任何消息的空会话，直接复用，不再新建
-    if let Some(existing) = sessions_db::find_empty_conversation(&db).map_err(|e| e.to_string())? {
+    // 若该作用域（普通对话或某个智能体）下已存在还没有任何消息的空会话，直接复用
+    if let Some(existing) = sessions_db::find_empty_conversation(&db, agent_id.as_deref())
+        .map_err(|e| e.to_string())?
+    {
         if let Some(mid) = &model_id {
             let _ = sessions_db::update_conversation_model(&db, &existing.id, mid);
         }
@@ -449,9 +921,30 @@ pub fn create_conversation(
             .map_err(|e| e.to_string())?
             .ok_or_else(|| "conversation not found".to_string());
     }
+    // 智能体会话：继承智能体的系统提示词，未指定模型时回退到智能体默认模型
+    let agent = match &agent_id {
+        Some(aid) => agents_db::get(&db, aid).map_err(|e| e.to_string())?,
+        None => None,
+    };
+    let effective_model = model_id.or_else(|| {
+        agent
+            .as_ref()
+            .and_then(|a| a.model_id.clone())
+    });
+    let system_prompt = agent
+        .as_ref()
+        .map(|a| a.system_prompt.trim().to_string())
+        .filter(|s| !s.is_empty());
     let id = uuid::Uuid::new_v4().to_string();
-    sessions_db::create_conversation(&db, &id, &title, model_id.as_deref(), None)
-        .map_err(|e| e.to_string())?;
+    sessions_db::create_conversation(
+        &db,
+        &id,
+        &title,
+        effective_model.as_deref(),
+        system_prompt.as_deref(),
+        agent_id.as_deref(),
+    )
+    .map_err(|e| e.to_string())?;
     sessions_db::get_conversation(&db, &id)
         .map_err(|e| e.to_string())?
         .ok_or_else(|| "conversation not found".to_string())
@@ -518,7 +1011,7 @@ pub fn import_conversation(
         payload.title.trim().to_string()
     };
     let db = state.core.db.lock().unwrap();
-    sessions_db::create_conversation(&db, &id, &title, payload.model_id.as_deref(), None)
+    sessions_db::create_conversation(&db, &id, &title, payload.model_id.as_deref(), None, None)
         .map_err(|e| e.to_string())?;
     for m in &payload.messages {
         sessions_db::import_message(
@@ -781,6 +1274,7 @@ pub async fn chat_send(
         engine_bin,
         user_message_id,
         conversation_tools,
+        system_prompt,
         tavily_key,
         search_enabled,
         tool_defs,
@@ -797,6 +1291,7 @@ pub async fn chat_send(
                 &title,
                 Some(&payload.model_id),
                 None,
+                None,
             )
             .map_err(|e| e.to_string())?;
         }
@@ -852,6 +1347,7 @@ pub async fn chat_send(
             bin,
             user_message_id,
             conversation.tools.clone(),
+            conversation.system_prompt.clone(),
             tavily_key,
             search_enabled,
             tool_defs,
@@ -865,13 +1361,8 @@ pub async fn chat_send(
         history
     };
 
-    // 注入可用工具说明（技能 / MCP）
-    if !tool_defs.is_empty() {
-        let sys = tools::build_tools_system_prompt(&tool_defs);
-        if !sys.is_empty() {
-            history.insert(0, ChatMessage::new("system", sys));
-        }
-    }
+    // 注入智能体/会话系统提示词与可用工具说明（技能 / MCP）
+    history = inject_system_prompts(history, system_prompt.as_deref(), &tool_defs);
 
     // 联网搜索工具：会话启用了 web_search、全局开关开启且已配置 API Key 时，自动搜索并注入上下文
     if conversation_tools.iter().any(|t| t == "web_search")
@@ -1366,6 +1857,25 @@ fn sanitize_history_for_local(mut history: Vec<ChatMessage>) -> Vec<ChatMessage>
     history
 }
 
+/// 把会话/智能体的系统提示词与工具说明注入消息历史：
+/// 系统提示词在最前，工具说明紧随其后，其余历史消息保持原顺序。
+fn inject_system_prompts(
+    mut history: Vec<ChatMessage>,
+    system_prompt: Option<&str>,
+    tool_defs: &[ToolDef],
+) -> Vec<ChatMessage> {
+    let mut index = 0;
+    if let Some(prompt) = system_prompt.map(str::trim).filter(|s| !s.is_empty()) {
+        history.insert(0, ChatMessage::new("system", prompt));
+        index = 1;
+    }
+    let tools_prompt = tools::build_tools_system_prompt(tool_defs);
+    if !tools_prompt.is_empty() {
+        history.insert(index, ChatMessage::new("system", &tools_prompt));
+    }
+    history
+}
+
 /// 自动生成会话标题：设置开启且为首轮对话时，调用当前模型生成简短标题并覆盖。
 async fn maybe_generate_conversation_title(
     app: AppHandle,
@@ -1824,7 +2334,7 @@ pub async fn regenerate_message(
     let engine = state.engine.clone();
     let base = state.engine_base.clone();
 
-    let (history, model, engine_bin, conversation_id, tool_defs) = {
+    let (history, model, engine_bin, conversation_id, system_prompt, tool_defs) = {
         let db = core.db.lock().unwrap();
         let conversation = sessions_db::get_conversation(&db, &payload.conversation_id)
             .map_err(|e| e.to_string())?
@@ -1865,7 +2375,14 @@ pub async fn regenerate_message(
             .map_err(|e| e.to_string())?
             .unwrap_or_default();
         let tool_defs = resolve_conversation_tool_defs(&db, &conversation.tools);
-        (history, model, bin, payload.conversation_id.clone(), tool_defs)
+        (
+            history,
+            model,
+            bin,
+            payload.conversation_id.clone(),
+            conversation.system_prompt.clone(),
+            tool_defs,
+        )
     };
 
     let mut history = if model.kind == "local" {
@@ -1873,12 +2390,7 @@ pub async fn regenerate_message(
     } else {
         history
     };
-    if !tool_defs.is_empty() {
-        let sys = tools::build_tools_system_prompt(&tool_defs);
-        if !sys.is_empty() {
-            history.insert(0, ChatMessage::new("system", sys));
-        }
-    }
+    history = inject_system_prompts(history, system_prompt.as_deref(), &tool_defs);
     let (cancel_tx, cancel_rx) = tokio::sync::watch::channel(false);
     let cancel_flags = state.cancel_flags.clone();
     let flag_conv = conversation_id.clone();
@@ -1914,7 +2426,7 @@ pub async fn edit_message(
     let engine = state.engine.clone();
     let base = state.engine_base.clone();
 
-    let (history, model, engine_bin, conversation_id, tool_defs) = {
+    let (history, model, engine_bin, conversation_id, system_prompt, tool_defs) = {
         let db = core.db.lock().unwrap();
         let conversation = sessions_db::get_conversation(&db, &payload.conversation_id)
             .map_err(|e| e.to_string())?
@@ -1947,7 +2459,14 @@ pub async fn edit_message(
             .map_err(|e| e.to_string())?
             .unwrap_or_default();
         let tool_defs = resolve_conversation_tool_defs(&db, &conversation.tools);
-        (history, model, bin, payload.conversation_id.clone(), tool_defs)
+        (
+            history,
+            model,
+            bin,
+            payload.conversation_id.clone(),
+            conversation.system_prompt.clone(),
+            tool_defs,
+        )
     };
 
     let mut history = if model.kind == "local" {
@@ -1955,12 +2474,7 @@ pub async fn edit_message(
     } else {
         history
     };
-    if !tool_defs.is_empty() {
-        let sys = tools::build_tools_system_prompt(&tool_defs);
-        if !sys.is_empty() {
-            history.insert(0, ChatMessage::new("system", sys));
-        }
-    }
+    history = inject_system_prompts(history, system_prompt.as_deref(), &tool_defs);
     let (cancel_tx, cancel_rx) = tokio::sync::watch::channel(false);
     let cancel_flags = state.cancel_flags.clone();
     let flag_conv = conversation_id.clone();
diff --git a/apps/desktop/src/default_agents.json b/apps/desktop/src/default_agents.json
new file mode 100644
index 0000000..f023692
--- /dev/null
+++ b/apps/desktop/src/default_agents.json
@@ -0,0 +1,62 @@
+[
+  {
+    "id": "preset-general-assistant",
+    "kind": "preset",
+    "name": "通用助手",
+    "icon": "🤖",
+    "description": "全能型智能体，回答问题、分析信息、处理日常任务",
+    "system_prompt": "你是一个全能型 AI 助手「仙人工作室 · 通用助手」。你的目标是准确、清晰、友好地帮助用户解决各种问题。回答时：\n1. 先理解用户意图，必要时主动询问关键信息；\n2. 用简洁有条理的中文回答，重要结论放前面；\n3. 涉及代码时给出可直接运行的完整示例；\n4. 不确定的信息要明确说明，不要编造。",
+    "model_id": null,
+    "enabled": true
+  },
+  {
+    "id": "preset-code-expert",
+    "kind": "preset",
+    "name": "代码专家",
+    "icon": "💻",
+    "description": "资深软件工程师，擅长编程、调试、架构与代码评审",
+    "system_prompt": "你是一位资深软件工程师，精通 Rust、TypeScript/React、Python、C++ 等语言，熟悉 Tauri、Web 开发、数据库设计与系统编程。请用中文回答，注重工程实践：\n1. 先给出思路与关键取舍，再贴可运行的代码；\n2. 代码包含必要的注释与错误处理；\n3. 指出潜在的性能、安全与可维护性问题；\n4. 不确定的 API 行为请标注需验证，不要凭空杜撰。",
+    "model_id": null,
+    "enabled": true
+  },
+  {
+    "id": "preset-writing-assistant",
+    "kind": "preset",
+    "name": "写作助手",
+    "icon": "✍️",
+    "description": "中文写作与润色专家，覆盖报告、邮件、文章、演讲稿等",
+    "system_prompt": "你是一位专业的中文写作与编辑专家，擅长各类文体：报告、方案、邮件、公众号文章、演讲稿、小说等。\n1. 输出前先简要说明结构安排；\n2. 语言流畅自然、逻辑清晰，符合中文表达习惯；\n3. 根据用户需求调整正式度与篇幅；\n4. 主动给出润色前后的对比，方便用户理解改动。",
+    "model_id": null,
+    "enabled": true
+  },
+  {
+    "id": "preset-translator",
+    "kind": "preset",
+    "name": "翻译官",
+    "icon": "🌐",
+    "description": "多语言互译，擅长技术、商务与学术文本",
+    "system_prompt": "你是一名专业翻译，支持中英日韩等多语言互译，尤其擅长技术、商务与学术文本。\n1. 保持原文意思、语气与格式，术语翻译准确；\n2. 中文译成英文时使用地道表达，英文译成中文时符合中文习惯；\n3. 对歧义处给出两种译法并说明；\n4. 如用户要求，可附术语表或注释。",
+    "model_id": null,
+    "enabled": true
+  },
+  {
+    "id": "preset-data-analyst",
+    "kind": "preset",
+    "name": "数据分析师",
+    "icon": "📊",
+    "description": "精通统计、SQL 与 Python 数据分析的可视化专家",
+    "system_prompt": "你是一名资深数据分析师，精通统计学、SQL 与 Python 数据分析（pandas、matplotlib 等）。\n1. 回答以分析结论为先，再展示方法与依据；\n2. 涉及数据时给出可运行的 SQL/Python 代码与结果解读；\n3. 指出数据质量风险与常见陷阱；\n4. 可视化建议要具体（图表类型、X/Y 轴含义）。",
+    "model_id": null,
+    "enabled": true
+  },
+  {
+    "id": "preset-prompt-engineer",
+    "kind": "preset",
+    "name": "提示词优化师",
+    "icon": "🎯",
+    "description": "提示词工程专家，设计并优化 system prompt 与 few-shot 示例",
+    "system_prompt": "你是提示词工程专家，帮助用户设计、优化大模型提示词（system prompt / few-shot / 思维链）。\n1. 先明确目标、受众与约束条件；\n2. 给出结构化、可直接复制的完整提示词；\n3. 解释每一步设计意图与潜在改进点；\n4. 提供多版本对比（简洁版 / 详细版）与评测建议。",
+    "model_id": null,
+    "enabled": true
+  }
+]
diff --git a/apps/desktop/src/default_workflows.json b/apps/desktop/src/default_workflows.json
new file mode 100644
index 0000000..d0dbaab
--- /dev/null
+++ b/apps/desktop/src/default_workflows.json
@@ -0,0 +1,187 @@
+[
+  {
+    "id": "preset-wf-translator",
+    "kind": "preset",
+    "name": "翻译助手",
+    "icon": "🌐",
+    "description": "输入原文，调用大模型翻译成英文（单模型节点案例）",
+    "nodes": [
+      {
+        "id": "n_start",
+        "type": "start",
+        "label": "开始",
+        "position": { "x": 70, "y": 190 },
+        "data": {}
+      },
+      {
+        "id": "n_llm",
+        "type": "llm",
+        "label": "翻译为英文",
+        "position": { "x": 350, "y": 170 },
+        "data": {
+          "prompt": "你是一名专业翻译。请把下面的内容翻译成英文，保持原意与语气：\n\n{{input}}",
+          "model_id": null,
+          "temperature": 0.4,
+          "max_tokens": 2048
+        }
+      },
+      {
+        "id": "n_end",
+        "type": "end",
+        "label": "输出",
+        "position": { "x": 650, "y": 190 },
+        "data": { "template": "{{n_llm}}" }
+      }
+    ],
+    "edges": [
+      { "id": "e1", "from": "n_start", "to": "n_llm" },
+      { "id": "e2", "from": "n_llm", "to": "n_end" }
+    ],
+    "model_id": null,
+    "enabled": true
+  },
+  {
+    "id": "preset-wf-summarizer",
+    "kind": "preset",
+    "name": "内容总结",
+    "icon": "📝",
+    "description": "输入长文本，输出要点总结（单模型节点案例）",
+    "nodes": [
+      {
+        "id": "n_start",
+        "type": "start",
+        "label": "开始",
+        "position": { "x": 70, "y": 190 },
+        "data": {}
+      },
+      {
+        "id": "n_llm",
+        "type": "llm",
+        "label": "提炼要点",
+        "position": { "x": 350, "y": 170 },
+        "data": {
+          "prompt": "请总结下面内容的要点，用中文分条列出，每条不超过 30 字：\n\n{{input}}",
+          "model_id": null,
+          "temperature": 0.3,
+          "max_tokens": 1024
+        }
+      },
+      {
+        "id": "n_end",
+        "type": "end",
+        "label": "输出",
+        "position": { "x": 650, "y": 190 },
+        "data": { "template": "{{n_llm}}" }
+      }
+    ],
+    "edges": [
+      { "id": "e1", "from": "n_start", "to": "n_llm" },
+      { "id": "e2", "from": "n_llm", "to": "n_end" }
+    ],
+    "model_id": null,
+    "enabled": true
+  },
+  {
+    "id": "preset-wf-polish-chain",
+    "kind": "preset",
+    "name": "两步润色",
+    "icon": "✨",
+    "description": "先润色再校对，两个大模型节点串联执行（链式案例）",
+    "nodes": [
+      {
+        "id": "n_start",
+        "type": "start",
+        "label": "开始",
+        "position": { "x": 70, "y": 190 },
+        "data": {}
+      },
+      {
+        "id": "n_llm1",
+        "type": "llm",
+        "label": "润色",
+        "position": { "x": 340, "y": 150 },
+        "data": {
+          "prompt": "请润色下面的文字，使表达更流畅、正式：\n\n{{input}}",
+          "model_id": null,
+          "temperature": 0.5,
+          "max_tokens": 2048
+        }
+      },
+      {
+        "id": "n_llm2",
+        "type": "llm",
+        "label": "校对精简",
+        "position": { "x": 610, "y": 150 },
+        "data": {
+          "prompt": "请校对并精简下面这段文字，修正语病，删除冗余，保持原意：\n\n{{n_llm1}}",
+          "model_id": null,
+          "temperature": 0.3,
+          "max_tokens": 2048
+        }
+      },
+      {
+        "id": "n_end",
+        "type": "end",
+        "label": "输出",
+        "position": { "x": 880, "y": 190 },
+        "data": { "template": "{{n_llm2}}" }
+      }
+    ],
+    "edges": [
+      { "id": "e1", "from": "n_start", "to": "n_llm1" },
+      { "id": "e2", "from": "n_llm1", "to": "n_llm2" },
+      { "id": "e3", "from": "n_llm2", "to": "n_end" }
+    ],
+    "model_id": null,
+    "enabled": true
+  },
+  {
+    "id": "preset-wf-writer",
+    "kind": "preset",
+    "name": "写作助手",
+    "icon": "✍️",
+    "description": "文本节点注入风格要求，再交给大模型改写（文本节点案例）",
+    "nodes": [
+      {
+        "id": "n_start",
+        "type": "start",
+        "label": "开始",
+        "position": { "x": 70, "y": 150 },
+        "data": {}
+      },
+      {
+        "id": "n_text",
+        "type": "text",
+        "label": "风格要求",
+        "position": { "x": 70, "y": 380 },
+        "data": { "content": "风格要求：面向技术读者，语言简洁准确，使用短句，避免空话套话。" }
+      },
+      {
+        "id": "n_llm",
+        "type": "llm",
+        "label": "按风格改写",
+        "position": { "x": 350, "y": 170 },
+        "data": {
+          "prompt": "请结合下面的风格要求，改写原文：\n{{n_text}}\n\n原文：\n{{input}}",
+          "model_id": null,
+          "temperature": 0.5,
+          "max_tokens": 2048
+        }
+      },
+      {
+        "id": "n_end",
+        "type": "end",
+        "label": "输出",
+        "position": { "x": 650, "y": 190 },
+        "data": { "template": "{{n_llm}}" }
+      }
+    ],
+    "edges": [
+      { "id": "e1", "from": "n_start", "to": "n_llm" },
+      { "id": "e2", "from": "n_text", "to": "n_llm" },
+      { "id": "e3", "from": "n_llm", "to": "n_end" }
+    ],
+    "model_id": null,
+    "enabled": true
+  }
+]
diff --git a/apps/desktop/src/lib.rs b/apps/desktop/src/lib.rs
index 960982c..a89c2ba 100644
--- a/apps/desktop/src/lib.rs
+++ b/apps/desktop/src/lib.rs
@@ -1,6 +1,7 @@
 mod commands;
 mod mcp_client;
 mod tools;
+mod workflow;
 
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -124,11 +125,32 @@ pub fn run() {
                     tracing::warn!(error = %e, "auto scan failed");
                 }
             }
+            let seeded_agents = commands::seed_preset_agents(&db);
+            if seeded_agents > 0 {
+                tracing::info!(seeded = seeded_agents, "preset agents seeded");
+            }
+            let seeded_workflows = commands::seed_preset_workflows(&db);
+            if seeded_workflows > 0 {
+                tracing::info!(seeded = seeded_workflows, "preset workflows seeded");
+            }
             let _ = app.emit("models://updated", ());
             Ok(())
         })
         .invoke_handler(tauri::generate_handler![
             commands::app_info,
+            commands::list_agents,
+            commands::add_agent,
+            commands::update_agent,
+            commands::remove_agent,
+            commands::set_agent_enabled,
+            commands::restore_preset_agents,
+            commands::list_workflows,
+            commands::add_workflow,
+            commands::update_workflow,
+            commands::remove_workflow,
+            commands::set_workflow_enabled,
+            commands::restore_preset_workflows,
+            commands::run_workflow,
             commands::list_models,
             commands::import_model,
             commands::remove_model,
diff --git a/apps/desktop/src/workflow.rs b/apps/desktop/src/workflow.rs
new file mode 100644
index 0000000..6cbfaa0
--- /dev/null
+++ b/apps/desktop/src/workflow.rs
@@ -0,0 +1,455 @@
+//! 工作流执行引擎：节点图（DAG）的拓扑执行、模板变量解析与结果收集。
+//!
+//! 设计上不依赖具体模型/网络：`execute_workflow` 通过传入的 `call_model`
+//! 闭包调用大模型，因此可在单元测试里用假模型把「图执行逻辑」完整跑通。
+
+use std::collections::{HashMap, HashSet};
+use std::future::Future;
+
+use xianren_core::workflows::{WorkflowEdge, WorkflowNode};
+
+/// 解析模板：支持 `{{input}}`（工作流输入）与 `{{节点id}}`（上游节点输出）。
+pub fn resolve_template(
+    template: &str,
+    input: &str,
+    outputs: &HashMap<String, String>,
+) -> Result<String, String> {
+    let mut out = String::new();
+    let mut rest = template;
+    while let Some(start) = rest.find("{{") {
+        out.push_str(&rest[..start]);
+        let after = &rest[start + 2..];
+        match after.find("}}") {
+            Some(end) => {
+                let key = after[..end].trim();
+                if key == "input" {
+                    out.push_str(input);
+                } else if let Some(value) = outputs.get(key) {
+                    out.push_str(value);
+                } else {
+                    let mut msg = "模板引用了不存在的变量 {{".to_string();
+                    msg.push_str(key);
+                    msg.push_str("}}（该节点可能尚未执行或不存在）");
+                    return Err(msg);
+                }
+                rest = &after[end + 2..];
+            }
+            None => {
+                out.push_str("{{");
+                rest = after;
+            }
+        }
+    }
+    out.push_str(rest);
+    Ok(out)
+}
+
+/// Kahn 拓扑排序，返回节点 id 执行顺序；存在环或引用未知节点时报错。
+pub fn topo_order(
+    nodes: &[WorkflowNode],
+    edges: &[WorkflowEdge],
+) -> Result<Vec<String>, String> {
+    let ids: HashSet<&str> = nodes.iter().map(|n| n.id.as_str()).collect();
+    let mut indegree: HashMap<&str, usize> = nodes.iter().map(|n| (n.id.as_str(), 0)).collect();
+    let mut adj: HashMap<&str, Vec<&str>> = HashMap::new();
+    for edge in edges {
+        if !ids.contains(edge.from_node.as_str()) {
+            return Err(format!("连线引用了不存在的节点：{}", edge.from_node));
+        }
+        if !ids.contains(edge.to_node.as_str()) {
+            return Err(format!("连线引用了不存在的节点：{}", edge.to_node));
+        }
+        if edge.from_node == edge.to_node {
+            return Err("节点不能连接自身".into());
+        }
+        *indegree.entry(edge.to_node.as_str()).or_default() += 1;
+        adj.entry(edge.from_node.as_str())
+            .or_default()
+            .push(edge.to_node.as_str());
+    }
+    let mut queue: Vec<&str> = indegree
+        .iter()
+        .filter(|(_, d)| **d == 0)
+        .map(|(k, _)| *k)
+        .collect();
+    queue.sort_unstable();
+    let mut order = Vec::new();
+    while let Some(id) = queue.pop() {
+        order.push(id.to_string());
+        if let Some(nexts) = adj.get(id) {
+            for next in nexts {
+                let d = indegree.get_mut(next).expect("known node");
+                *d -= 1;
+                if *d == 0 {
+                    queue.push(next);
+                }
+            }
+            queue.sort_unstable();
+        }
+    }
+    if order.len() != nodes.len() {
+        return Err("工作流存在循环依赖，无法执行".into());
+    }
+    Ok(order)
+}
+
+#[derive(Debug)]
+pub struct WorkflowResult {
+    pub results: HashMap<String, String>,
+    pub final_text: String,
+}
+
+/// 按拓扑顺序执行整个工作流图。
+///
+/// 节点语义：
+/// - `start`：输出即工作流输入（可通过 `{{input}}` 引用）；
+/// - `text`：输出为其 `data.content` 静态文本；
+/// - `llm`：把 `data.prompt` 模板解析后交给 `call_model`，输出为模型返回文本；
+/// - `end`：把 `data.template` 解析后作为最终输出（模板为空时取上游输出）。
+pub async fn execute_workflow<F, Fut>(
+    nodes: &[WorkflowNode],
+    edges: &[WorkflowEdge],
+    input: &str,
+    mut call_model: F,
+) -> Result<WorkflowResult, String>
+where
+    F: FnMut(&WorkflowNode, &str) -> Fut,
+    Fut: Future<Output = Result<String, String>>,
+{
+    let order = topo_order(nodes, edges)?;
+    let by_id: HashMap<&str, &WorkflowNode> = nodes.iter().map(|n| (n.id.as_str(), n)).collect();
+    let mut outputs: HashMap<String, String> = HashMap::new();
+    let mut work_outputs: Vec<String> = Vec::new();
+    let mut end_outputs: Vec<String> = Vec::new();
+
+    for id in &order {
+        let node: &WorkflowNode = by_id.get(id.as_str()).copied().expect("ordered node exists");
+        match node.kind.as_str() {
+            "start" => {
+                outputs.insert(id.clone(), input.to_string());
+            }
+            "text" => {
+                let content = node
+                    .data
+                    .get("content")
+                    .and_then(|v| v.as_str())
+                    .unwrap_or("");
+                outputs.insert(id.clone(), content.to_string());
+                work_outputs.push(content.to_string());
+            }
+            "llm" => {
+                let raw_prompt = node
+                    .data
+                    .get("prompt")
+                    .and_then(|v| v.as_str())
+                    .unwrap_or("");
+                let prompt = resolve_template(raw_prompt, input, &outputs)?;
+                if prompt.trim().is_empty() {
+                    return Err(format!("节点「{}」的提示词为空", node.label));
+                }
+                let text = call_model(node, &prompt).await?;
+                outputs.insert(id.clone(), text.clone());
+                work_outputs.push(text);
+            }
+            "end" => {
+                let raw_template = node
+                    .data
+                    .get("template")
+                    .and_then(|v| v.as_str())
+                    .unwrap_or("");
+                let resolved = if raw_template.trim().is_empty() {
+                    upstream_output(edges, id, &outputs)?
+                } else {
+                    resolve_template(raw_template, input, &outputs)?
+                };
+                outputs.insert(id.clone(), resolved.clone());
+                end_outputs.push(resolved);
+            }
+            other => return Err(format!("未知节点类型：{other}")),
+        }
+    }
+
+    let final_text = if !end_outputs.is_empty() {
+        end_outputs.join("\n\n")
+    } else {
+        work_outputs.last().cloned().unwrap_or_default()
+    };
+    Ok(WorkflowResult {
+        results: outputs,
+        final_text,
+    })
+}
+
+/// 结束节点模板为空时，取直接上游节点的输出（多个时按连线顺序拼接）。
+fn upstream_output(
+    edges: &[WorkflowEdge],
+    node_id: &str,
+    outputs: &HashMap<String, String>,
+) -> Result<String, String> {
+    let upstreams: Vec<&str> = edges
+        .iter()
+        .filter(|e| e.to_node == node_id)
+        .map(|e| e.from_node.as_str())
+        .collect();
+    if upstreams.is_empty() {
+        return Err("结束节点没有上游输入，请连接上游节点或在模板中引用 {{input}}".into());
+    }
+    let mut parts = Vec::new();
+    for id in upstreams {
+        if let Some(value) = outputs.get(id) {
+            parts.push(value.clone());
+        }
+    }
+    if parts.is_empty() {
+        return Err("结束节点的上游节点尚未产生输出".into());
+    }
+    Ok(parts.join("\n\n"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    };
+    use xianren_core::workflows::{NodePosition, WorkflowNode};
+    use xianren_core::workflows::WorkflowEdge;
+
+    fn node(id: &str, kind: &str, label: &str, data: serde_json::Value) -> WorkflowNode {
+        WorkflowNode {
+            id: id.to_string(),
+            kind: kind.to_string(),
+            label: label.to_string(),
+            position: NodePosition { x: 0.0, y: 0.0 },
+            data,
+        }
+    }
+
+    fn edge(id: &str, from: &str, to: &str) -> WorkflowEdge {
+        WorkflowEdge {
+            id: id.to_string(),
+            from_node: from.to_string(),
+            to_node: to.to_string(),
+        }
+    }
+
+    fn llm_data(prompt: &str) -> serde_json::Value {
+        serde_json::json!({ "prompt": prompt })
+    }
+
+    fn end_data(template: &str) -> serde_json::Value {
+        serde_json::json!({ "template": template })
+    }
+
+    #[tokio::test]
+    async fn single_llm_workflow_runs() {
+        let nodes = vec![
+            node("n_start", "start", "开始", serde_json::json!({})),
+            node("n_llm", "llm", "翻译", llm_data("把下面内容翻译成英文：\n{{input}}")),
+            node("n_end", "end", "输出", end_data("{{n_llm}}")),
+        ];
+        let edges = vec![edge("e1", "n_start", "n_llm"), edge("e2", "n_llm", "n_end")];
+        let calls = Arc::new(AtomicUsize::new(0));
+        let calls2 = calls.clone();
+        let result = execute_workflow(&nodes, &edges, "你好世界", |_node, prompt| {
+            calls2.fetch_add(1, Ordering::SeqCst);
+            let prompt = prompt.to_string();
+            async move { Ok(format!("[EN] {prompt}")) }
+        })
+        .await
+        .unwrap();
+        assert_eq!(calls.load(Ordering::SeqCst), 1);
+        assert!(result.final_text.contains("[EN] 把下面内容翻译成英文："));
+        assert!(result.final_text.contains("你好世界"));
+    }
+
+    #[tokio::test]
+    async fn two_step_chain_passes_output_forward() {
+        let nodes = vec![
+            node("n_start", "start", "开始", serde_json::json!({})),
+            node("n_llm1", "llm", "润色", llm_data("润色：\n{{input}}")),
+            node("n_llm2", "llm", "校对", llm_data("校对以下内容：\n{{n_llm1}}")),
+            node("n_end", "end", "输出", end_data("{{n_llm2}}")),
+        ];
+        let edges = vec![
+            edge("e1", "n_start", "n_llm1"),
+            edge("e2", "n_llm1", "n_llm2"),
+            edge("e3", "n_llm2", "n_end"),
+        ];
+        let seen = Arc::new(tokio::sync::Mutex::new(Vec::new()));
+        let seen2 = seen.clone();
+        let result = execute_workflow(&nodes, &edges, "原稿", |node, prompt| {
+            let seen = seen2.clone();
+            let label = node.label.clone();
+            let prompt = prompt.to_string();
+            async move {
+                seen.lock().await.push(format!("{label}|{prompt}"));
+                Ok(format!("[{label}处理完成]"))
+            }
+        })
+        .await
+        .unwrap();
+        let seen = seen.lock().await;
+        assert_eq!(seen.len(), 2);
+        // 第二个节点的提示词必须包含第一个节点的输出
+        assert!(seen[1].contains("[润色处理完成]"));
+        assert!(seen[1].contains("校对以下内容"));
+        assert_eq!(result.final_text, "[校对处理完成]");
+    }
+
+    #[tokio::test]
+    async fn text_node_combines_with_input() {
+        let nodes = vec![
+            node("n_start", "start", "开始", serde_json::json!({})),
+            node(
+                "n_text",
+                "text",
+                "风格",
+                serde_json::json!({ "content": "风格要求：面向技术读者，简洁。" }),
+            ),
+            node(
+                "n_llm",
+                "llm",
+                "改写",
+                llm_data("结合以下风格改写原文：\n{{n_text}}\n\n原文：\n{{input}}"),
+            ),
+            node("n_end", "end", "输出", end_data("{{n_llm}}")),
+        ];
+        let edges = vec![
+            edge("e1", "n_start", "n_llm"),
+            edge("e2", "n_text", "n_llm"),
+            edge("e3", "n_llm", "n_end"),
+        ];
+        let prompt_seen = Arc::new(tokio::sync::Mutex::new(String::new()));
+        let prompt_seen2 = prompt_seen.clone();
+        execute_workflow(&nodes, &edges, "原文内容", |_node, prompt| {
+            let prompt_seen = prompt_seen2.clone();
+            let prompt = prompt.to_string();
+            async move {
+                *prompt_seen.lock().await = prompt.clone();
+                Ok("改写完成".to_string())
+            }
+        })
+        .await
+        .unwrap();
+        let seen = prompt_seen.lock().await;
+        assert!(seen.contains("风格要求：面向技术读者，简洁。"));
+        assert!(seen.contains("原文内容"));
+    }
+
+    #[tokio::test]
+    async fn cycle_is_rejected() {
+        let nodes = vec![
+            node("a", "llm", "A", llm_data("{{b}}")),
+            node("b", "llm", "B", llm_data("{{a}}")),
+        ];
+        let edges = vec![edge("e1", "a", "b"), edge("e2", "b", "a")];
+        let err = execute_workflow(&nodes, &edges, "x", |_, _| async move {
+            Ok("unused".to_string())
+        })
+        .await
+        .unwrap_err();
+        assert!(err.contains("循环"));
+    }
+
+    #[tokio::test]
+    async fn missing_variable_is_rejected() {
+        let nodes = vec![
+            node("a", "llm", "A", llm_data("{{nope}}")),
+            node("b", "end", "输出", end_data("{{a}}")),
+        ];
+        let edges = vec![edge("e1", "a", "b")];
+        let err = execute_workflow(&nodes, &edges, "x", |_, _| async move {
+            Ok("unused".to_string())
+        })
+        .await
+        .unwrap_err();
+        assert!(err.contains("不存在的变量"));
+    }
+
+    /// 端到端冒烟：读取真实数据目录中已配置/启用的大模型（优先在线 API），
+    /// 用真实模型调用跑通一个「翻译」工作流。默认忽略，需要联网与已配置模型：
+    /// cargo test -p xianren-desktop --lib -- --ignored --nocapture workflow::tests::real_model_translation_workflow_e2e
+    #[tokio::test]
+    #[ignore = "需要真实大模型（读取用户数据目录配置并联网调用）"]
+    async fn real_model_translation_workflow_e2e() {
+        let core = xianren_core::CoreApp::init(None).expect("open app db");
+        let model = {
+            let db = core.db.lock().unwrap();
+            let all = xianren_core::models::list(&db).expect("list models");
+            all.iter()
+                .find(|m| m.kind == "remote" && m.enabled)
+                .or_else(|| all.iter().find(|m| m.kind == "local"))
+                .cloned()
+        };
+        let Some(model) = model else {
+            eprintln!("SKIP: 数据目录没有可用模型，跳过真实模型端到端测试");
+            return;
+        };
+        eprintln!("使用模型：{}（kind={}）", model.file_name, model.kind);
+
+        let nodes = vec![
+            WorkflowNode {
+                id: "n_start".into(),
+                kind: "start".into(),
+                label: "开始".into(),
+                position: NodePosition { x: 0.0, y: 0.0 },
+                data: serde_json::json!({}),
+            },
+            WorkflowNode {
+                id: "n_llm".into(),
+                kind: "llm".into(),
+                label: "翻译为英文".into(),
+                position: NodePosition { x: 0.0, y: 0.0 },
+                data: serde_json::json!({
+                    "prompt": "你是一名专业翻译。请把下面的内容翻译成英文，只输出译文：\n\n{{input}}",
+                    "temperature": 0.4,
+                    "max_tokens": 1024,
+                }),
+            },
+            WorkflowNode {
+                id: "n_end".into(),
+                kind: "end".into(),
+                label: "输出".into(),
+                position: NodePosition { x: 0.0, y: 0.0 },
+                data: serde_json::json!({ "template": "{{n_llm}}" }),
+            },
+        ];
+        let edges = vec![
+            WorkflowEdge {
+                id: "e1".into(),
+                from_node: "n_start".into(),
+                to_node: "n_llm".into(),
+            },
+            WorkflowEdge {
+                id: "e2".into(),
+                from_node: "n_llm".into(),
+                to_node: "n_end".into(),
+            },
+        ];
+        let engine = xianren_engine::EngineManager::new();
+        let result = execute_workflow(&nodes, &edges, "仙人工作室是一款本地大模型桌面应用", |_node, prompt| {
+            let engine = engine.clone();
+            let model = model.clone();
+            let prompt = prompt.to_string();
+            async move {
+                crate::commands::call_model_text(&engine, &model, &prompt, 0.4, 1024).await
+            }
+        })
+        .await
+        .expect("workflow runs");
+
+        eprintln!("最终输出：\n{}", result.final_text);
+        assert!(!result.final_text.trim().is_empty(), "模型输出不能为空");
+        // 英文翻译结果应包含关键英文词
+        assert!(
+            result.final_text.to_lowercase().contains("desktop")
+                || result.final_text.to_lowercase().contains("studio")
+                || result.final_text.to_lowercase().contains("local")
+                || result.final_text.to_lowercase().contains("model"),
+            "翻译结果不符合预期：{}",
+            result.final_text
+        );
+    }
+}
diff --git a/crates/core/src/agents.rs b/crates/core/src/agents.rs
new file mode 100644
index 0000000..5e3a1d1
--- /dev/null
+++ b/crates/core/src/agents.rs
@@ -0,0 +1,128 @@
+use crate::error::Result;
+use rusqlite::{params, Connection};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Agent {
+    pub id: String,
+    pub kind: String,
+    pub name: String,
+    pub icon: String,
+    pub description: String,
+    pub system_prompt: String,
+    pub model_id: Option<String>,
+    pub enabled: bool,
+    #[serde(default)]
+    pub created_at: String,
+    #[serde(default)]
+    pub updated_at: String,
+}
+
+const SELECT_COLUMNS: &str = "id, kind, name, icon, description, system_prompt, model_id, enabled, created_at, updated_at";
+
+pub fn list(db: &Connection) -> Result<Vec<Agent>> {
+    let mut stmt = db.prepare(&format!(
+        "SELECT {SELECT_COLUMNS} FROM agents
+         ORDER BY (kind = 'preset') DESC, updated_at DESC, created_at DESC"
+    ))?;
+    let rows = stmt.query_map([], row_to_agent)?;
+    let mut out = Vec::new();
+    for row in rows {
+        out.push(row?);
+    }
+    Ok(out)
+}
+
+pub fn get(db: &Connection, id: &str) -> Result<Option<Agent>> {
+    let mut stmt = db.prepare(&format!(
+        "SELECT {SELECT_COLUMNS} FROM agents WHERE id = ?1"
+    ))?;
+    let mut rows = stmt.query_map(params![id], row_to_agent)?;
+    match rows.next() {
+        Some(row) => Ok(Some(row?)),
+        None => Ok(None),
+    }
+}
+
+pub fn insert(db: &Connection, agent: &Agent) -> Result<()> {
+    db.execute(
+        "INSERT INTO agents (id, kind, name, icon, description, system_prompt, model_id, enabled, created_at, updated_at)
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, datetime('now'), datetime('now'))",
+        params![
+            agent.id,
+            agent.kind,
+            agent.name,
+            agent.icon,
+            agent.description,
+            agent.system_prompt,
+            agent.model_id,
+            agent.enabled as i32,
+        ],
+    )?;
+    Ok(())
+}
+
+pub fn update(db: &Connection, agent: &Agent) -> Result<()> {
+    db.execute(
+        "UPDATE agents SET kind = ?1, name = ?2, icon = ?3, description = ?4,
+         system_prompt = ?5, model_id = ?6, enabled = ?7, updated_at = datetime('now')
+         WHERE id = ?8",
+        params![
+            agent.kind,
+            agent.name,
+            agent.icon,
+            agent.description,
+            agent.system_prompt,
+            agent.model_id,
+            agent.enabled as i32,
+            agent.id,
+        ],
+    )?;
+    Ok(())
+}
+
+pub fn delete(db: &Connection, id: &str) -> Result<()> {
+    db.execute("DELETE FROM agents WHERE id = ?1", params![id])?;
+    Ok(())
+}
+
+pub fn set_enabled(db: &Connection, id: &str, enabled: bool) -> Result<()> {
+    db.execute(
+        "UPDATE agents SET enabled = ?1, updated_at = datetime('now') WHERE id = ?2",
+        params![enabled as i32, id],
+    )?;
+    Ok(())
+}
+
+/// 批量写入预制智能体（按 id 忽略已存在的，方便“恢复预制智能体”重复调用）。
+pub fn insert_presets_if_missing(db: &Connection, presets: &[Agent]) -> Result<usize> {
+    let mut inserted = 0;
+    for p in presets {
+        let exists: bool = db.query_row(
+            "SELECT EXISTS(SELECT 1 FROM agents WHERE id = ?1)",
+            params![p.id],
+            |row| row.get(0),
+        )?;
+        if !exists {
+            insert(db, p)?;
+            inserted += 1;
+        }
+    }
+    Ok(inserted)
+}
+
+fn row_to_agent(row: &rusqlite::Row<'_>) -> rusqlite::Result<Agent> {
+    let enabled: i32 = row.get(7)?;
+    Ok(Agent {
+        id: row.get(0)?,
+        kind: row.get(1)?,
+        name: row.get(2)?,
+        icon: row.get(3)?,
+        description: row.get(4)?,
+        system_prompt: row.get(5)?,
+        model_id: row.get(6)?,
+        enabled: enabled != 0,
+        created_at: row.get(8)?,
+        updated_at: row.get(9)?,
+    })
+}
diff --git a/crates/core/src/app.rs b/crates/core/src/app.rs
index 34f7221..4ab728f 100644
--- a/crates/core/src/app.rs
+++ b/crates/core/src/app.rs
@@ -109,6 +109,7 @@ fn open_db(path: &Path) -> Result<Connection> {
     ensure_column(&conn, "conversations", "pinned", "INTEGER NOT NULL DEFAULT 0")?;
     ensure_column(&conn, "conversations", "favorite", "INTEGER NOT NULL DEFAULT 0")?;
     ensure_column(&conn, "conversations", "tools_json", "TEXT NOT NULL DEFAULT '[]'")?;
+    ensure_column(&conn, "conversations", "agent_id", "TEXT")?;
     Ok(conn)
 }
 
diff --git a/crates/core/src/lib.rs b/crates/core/src/lib.rs
index d399810..96e7f8c 100644
--- a/crates/core/src/lib.rs
+++ b/crates/core/src/lib.rs
@@ -1,3 +1,4 @@
+pub mod agents;
 pub mod app;
 pub mod error;
 pub mod mcp_servers;
@@ -5,8 +6,11 @@ pub mod models;
 pub mod sessions;
 pub mod settings;
 pub mod skills;
+pub mod workflows;
 
 pub use app::CoreApp;
 pub use error::{CoreError, Result};
 pub use models::ModelInfo;
+pub use agents::Agent;
 pub use sessions::{Conversation, Message};
+pub use workflows::Workflow;
diff --git a/crates/core/src/schema.sql b/crates/core/src/schema.sql
index 58d37dd..b4ab62d 100644
--- a/crates/core/src/schema.sql
+++ b/crates/core/src/schema.sql
@@ -28,6 +28,7 @@ CREATE TABLE IF NOT EXISTS conversations (
     title         TEXT NOT NULL DEFAULT '新会话',
     model_id      TEXT,
     system_prompt TEXT,
+    agent_id      TEXT,
     pinned        INTEGER NOT NULL DEFAULT 0,
     favorite      INTEGER NOT NULL DEFAULT 0,
     tools_json    TEXT NOT NULL DEFAULT '[]',
@@ -35,6 +36,33 @@ CREATE TABLE IF NOT EXISTS conversations (
     updated_at    TEXT NOT NULL DEFAULT (datetime('now'))
 );
 
+CREATE TABLE IF NOT EXISTS agents (
+    id            TEXT PRIMARY KEY,
+    kind          TEXT NOT NULL DEFAULT 'custom',
+    name          TEXT NOT NULL,
+    icon          TEXT NOT NULL DEFAULT '🤖',
+    description   TEXT NOT NULL DEFAULT '',
+    system_prompt TEXT NOT NULL DEFAULT '',
+    model_id      TEXT,
+    enabled       INTEGER NOT NULL DEFAULT 1,
+    created_at    TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at    TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS workflows (
+    id            TEXT PRIMARY KEY,
+    kind          TEXT NOT NULL DEFAULT 'custom',
+    name          TEXT NOT NULL,
+    icon          TEXT NOT NULL DEFAULT '🔀',
+    description   TEXT NOT NULL DEFAULT '',
+    nodes_json    TEXT NOT NULL DEFAULT '[]',
+    edges_json    TEXT NOT NULL DEFAULT '[]',
+    model_id      TEXT,
+    enabled       INTEGER NOT NULL DEFAULT 1,
+    created_at    TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at    TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
 CREATE TABLE IF NOT EXISTS messages (
     id              TEXT PRIMARY KEY,
     conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
diff --git a/crates/core/src/sessions.rs b/crates/core/src/sessions.rs
index bc21b4a..6664c17 100644
--- a/crates/core/src/sessions.rs
+++ b/crates/core/src/sessions.rs
@@ -8,6 +8,7 @@ pub struct Conversation {
     pub title: String,
     pub model_id: Option<String>,
     pub system_prompt: Option<String>,
+    pub agent_id: Option<String>,
     pub pinned: bool,
     pub favorite: bool,
     pub tools: Vec<String>,
@@ -48,20 +49,25 @@ pub fn create_conversation(
     title: &str,
     model_id: Option<&str>,
     system_prompt: Option<&str>,
+    agent_id: Option<&str>,
 ) -> Result<()> {
     db.execute(
-        "INSERT INTO conversations (id, title, model_id, system_prompt) VALUES (?1, ?2, ?3, ?4)",
-        params![id, title, model_id, system_prompt],
+        "INSERT INTO conversations (id, title, model_id, system_prompt, agent_id) VALUES (?1, ?2, ?3, ?4, ?5)",
+        params![id, title, model_id, system_prompt, agent_id],
     )?;
     Ok(())
 }
 
-pub fn list_conversations(db: &Connection) -> Result<Vec<Conversation>> {
+/// 列出指定作用域的会话：`agent_id = None` 时只返回普通对话（agent_id 为空），
+/// `Some(id)` 时只返回该智能体的对话。
+pub fn list_conversations(db: &Connection, agent_id: Option<&str>) -> Result<Vec<Conversation>> {
     let mut stmt = db.prepare(
-        "SELECT id, title, model_id, system_prompt, pinned, favorite, tools_json, created_at, updated_at
-         FROM conversations ORDER BY pinned DESC, updated_at DESC",
+        "SELECT id, title, model_id, system_prompt, agent_id, pinned, favorite, tools_json, created_at, updated_at
+         FROM conversations
+         WHERE (?1 IS NULL AND agent_id IS NULL) OR agent_id = ?1
+         ORDER BY pinned DESC, updated_at DESC",
     )?;
-    let rows = stmt.query_map([], row_to_conversation)?;
+    let rows = stmt.query_map(params![agent_id], row_to_conversation)?;
     let mut out = Vec::new();
     for row in rows {
         out.push(row?);
@@ -71,7 +77,7 @@ pub fn list_conversations(db: &Connection) -> Result<Vec<Conversation>> {
 
 pub fn get_conversation(db: &Connection, id: &str) -> Result<Option<Conversation>> {
     let mut stmt = db.prepare(
-        "SELECT id, title, model_id, system_prompt, pinned, favorite, tools_json, created_at, updated_at
+        "SELECT id, title, model_id, system_prompt, agent_id, pinned, favorite, tools_json, created_at, updated_at
          FROM conversations WHERE id = ?1",
     )?;
     let mut rows = stmt.query_map(params![id], row_to_conversation)?;
@@ -81,16 +87,21 @@ pub fn get_conversation(db: &Connection, id: &str) -> Result<Option<Conversation
     }
 }
 
-/// 查找最近一个还没有任何消息的空会话（用于“新建对话”时复用，避免产生多个空会话）。
-pub fn find_empty_conversation(db: &Connection) -> Result<Option<Conversation>> {
+/// 查找指定作用域（普通对话或某个智能体）下最近一个还没有任何消息的空会话，
+/// 用于“新建对话”时复用，避免产生多个空会话。
+pub fn find_empty_conversation(
+    db: &Connection,
+    agent_id: Option<&str>,
+) -> Result<Option<Conversation>> {
     let mut stmt = db.prepare(
-        "SELECT c.id, c.title, c.model_id, c.system_prompt, c.pinned, c.favorite, c.tools_json, c.created_at, c.updated_at
+        "SELECT c.id, c.title, c.model_id, c.system_prompt, c.agent_id, c.pinned, c.favorite, c.tools_json, c.created_at, c.updated_at
          FROM conversations c
          WHERE NOT EXISTS (SELECT 1 FROM messages m WHERE m.conversation_id = c.id)
+           AND ((?1 IS NULL AND c.agent_id IS NULL) OR c.agent_id = ?1)
          ORDER BY c.updated_at DESC
          LIMIT 1",
     )?;
-    let mut rows = stmt.query_map([], row_to_conversation)?;
+    let mut rows = stmt.query_map(params![agent_id], row_to_conversation)?;
     match rows.next() {
         Some(row) => Ok(Some(row?)),
         None => Ok(None),
@@ -351,19 +362,20 @@ pub fn apply_message_version(
 }
 
 fn row_to_conversation(row: &rusqlite::Row<'_>) -> rusqlite::Result<Conversation> {
-    let pinned: i32 = row.get(4)?;
-    let favorite: i32 = row.get(5)?;
-    let tools_json: String = row.get(6)?;
+    let pinned: i32 = row.get(5)?;
+    let favorite: i32 = row.get(6)?;
+    let tools_json: String = row.get(7)?;
     Ok(Conversation {
         id: row.get(0)?,
         title: row.get(1)?,
         model_id: row.get(2)?,
         system_prompt: row.get(3)?,
+        agent_id: row.get(4)?,
         pinned: pinned != 0,
         favorite: favorite != 0,
         tools: serde_json::from_str(&tools_json).unwrap_or_default(),
-        created_at: row.get(7)?,
-        updated_at: row.get(8)?,
+        created_at: row.get(8)?,
+        updated_at: row.get(9)?,
     })
 }
 
diff --git a/crates/core/src/workflows.rs b/crates/core/src/workflows.rs
new file mode 100644
index 0000000..24143e8
--- /dev/null
+++ b/crates/core/src/workflows.rs
@@ -0,0 +1,162 @@
+use crate::error::Result;
+use rusqlite::{params, Connection};
+use serde::{Deserialize, Serialize};
+
+/// 画布节点位置（前端画布坐标）。
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct NodePosition {
+    pub x: f64,
+    pub y: f64,
+}
+
+/// 节点类型：start=开始（提供 {{input}}）、llm=大模型调用、text=静态文本、end=结束输出。
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WorkflowNode {
+    pub id: String,
+    #[serde(rename = "type")]
+    pub kind: String,
+    pub label: String,
+    pub position: NodePosition,
+    #[serde(default)]
+    pub data: serde_json::Value,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WorkflowEdge {
+    pub id: String,
+    #[serde(rename = "from")]
+    pub from_node: String,
+    #[serde(rename = "to")]
+    pub to_node: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Workflow {
+    pub id: String,
+    pub kind: String,
+    pub name: String,
+    pub icon: String,
+    pub description: String,
+    pub nodes: Vec<WorkflowNode>,
+    pub edges: Vec<WorkflowEdge>,
+    pub model_id: Option<String>,
+    pub enabled: bool,
+    #[serde(default)]
+    pub created_at: String,
+    #[serde(default)]
+    pub updated_at: String,
+}
+
+const SELECT_COLUMNS: &str =
+    "id, kind, name, icon, description, nodes_json, edges_json, model_id, enabled, created_at, updated_at";
+
+pub fn list(db: &Connection) -> Result<Vec<Workflow>> {
+    let mut stmt = db.prepare(&format!(
+        "SELECT {SELECT_COLUMNS} FROM workflows
+         ORDER BY (kind = 'preset') DESC, updated_at DESC, created_at DESC"
+    ))?;
+    let rows = stmt.query_map([], row_to_workflow)?;
+    let mut out = Vec::new();
+    for row in rows {
+        out.push(row?);
+    }
+    Ok(out)
+}
+
+pub fn get(db: &Connection, id: &str) -> Result<Option<Workflow>> {
+    let mut stmt = db.prepare(&format!(
+        "SELECT {SELECT_COLUMNS} FROM workflows WHERE id = ?1"
+    ))?;
+    let mut rows = stmt.query_map(params![id], row_to_workflow)?;
+    match rows.next() {
+        Some(row) => Ok(Some(row?)),
+        None => Ok(None),
+    }
+}
+
+pub fn insert(db: &Connection, workflow: &Workflow) -> Result<()> {
+    db.execute(
+        "INSERT INTO workflows (id, kind, name, icon, description, nodes_json, edges_json, model_id, enabled, created_at, updated_at)
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, datetime('now'), datetime('now'))",
+        params![
+            workflow.id,
+            workflow.kind,
+            workflow.name,
+            workflow.icon,
+            workflow.description,
+            serde_json::to_string(&workflow.nodes).unwrap_or_else(|_| "[]".to_string()),
+            serde_json::to_string(&workflow.edges).unwrap_or_else(|_| "[]".to_string()),
+            workflow.model_id,
+            workflow.enabled as i32,
+        ],
+    )?;
+    Ok(())
+}
+
+pub fn update(db: &Connection, workflow: &Workflow) -> Result<()> {
+    db.execute(
+        "UPDATE workflows SET kind = ?1, name = ?2, icon = ?3, description = ?4,
+         nodes_json = ?5, edges_json = ?6, model_id = ?7, enabled = ?8, updated_at = datetime('now')
+         WHERE id = ?9",
+        params![
+            workflow.kind,
+            workflow.name,
+            workflow.icon,
+            workflow.description,
+            serde_json::to_string(&workflow.nodes).unwrap_or_else(|_| "[]".to_string()),
+            serde_json::to_string(&workflow.edges).unwrap_or_else(|_| "[]".to_string()),
+            workflow.model_id,
+            workflow.enabled as i32,
+            workflow.id,
+        ],
+    )?;
+    Ok(())
+}
+
+pub fn delete(db: &Connection, id: &str) -> Result<()> {
+    db.execute("DELETE FROM workflows WHERE id = ?1", params![id])?;
+    Ok(())
+}
+
+pub fn set_enabled(db: &Connection, id: &str, enabled: bool) -> Result<()> {
+    db.execute(
+        "UPDATE workflows SET enabled = ?1, updated_at = datetime('now') WHERE id = ?2",
+        params![enabled as i32, id],
+    )?;
+    Ok(())
+}
+
+pub fn insert_presets_if_missing(db: &Connection, presets: &[Workflow]) -> Result<usize> {
+    let mut inserted = 0;
+    for p in presets {
+        let exists: bool = db.query_row(
+            "SELECT EXISTS(SELECT 1 FROM workflows WHERE id = ?1)",
+            params![p.id],
+            |row| row.get(0),
+        )?;
+        if !exists {
+            insert(db, p)?;
+            inserted += 1;
+        }
+    }
+    Ok(inserted)
+}
+
+fn row_to_workflow(row: &rusqlite::Row<'_>) -> rusqlite::Result<Workflow> {
+    let nodes_json: String = row.get(5)?;
+    let edges_json: String = row.get(6)?;
+    let enabled: i32 = row.get(8)?;
+    Ok(Workflow {
+        id: row.get(0)?,
+        kind: row.get(1)?,
+        name: row.get(2)?,
+        icon: row.get(3)?,
+        description: row.get(4)?,
+        nodes: serde_json::from_str(&nodes_json).unwrap_or_default(),
+        edges: serde_json::from_str(&edges_json).unwrap_or_default(),
+        model_id: row.get(7)?,
+        enabled: enabled != 0,
+        created_at: row.get(9)?,
+        updated_at: row.get(10)?,
+    })
+}
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index 465931d..8718315 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -12,8 +12,8 @@
 
 ```
 xianren_studio/
-├── apps/desktop/          Tauri 桌面壳（Rust 命令层、tauri.conf.json、推荐模型默认 JSON）
-├── crates/core/           领域核心：SQLite（模型注册表、会话、消息、设置）
+├── apps/desktop/          Tauri 桌面壳（Rust 命令层、tauri.conf.json、推荐模型/预制智能体/预制工作流默认 JSON、工作流执行引擎 workflow.rs）
+├── crates/core/           领域核心：SQLite（模型注册表、智能体、工作流、会话、消息、设置）
 ├── crates/engine/         llama-server 生命周期 + 流式/非流式聊天（本地与远程 OpenAI 兼容）
 ├── crates/download/       分片断点续传下载器
 ├── crates/api/            OpenAI 兼容本地 API 服务（axum）
@@ -33,7 +33,7 @@ React UI（ui/src）
    ▼
 apps/desktop/src/commands.rs  ← 所有 Tauri 命令（invoke_handler 注册于 lib.rs）
    │
-   ├── crates/core（SQLite：models / sessions / settings）
+   ├── crates/core（SQLite：models / agents / workflows / sessions / settings）
    ├── crates/engine（llama-server 子进程 / 远程 OpenAI API）
    ├── crates/download（下载任务）
    └── crates/api（本地 API 服务）
@@ -48,13 +48,17 @@ apps/desktop/src/commands.rs  ← 所有 Tauri 命令（invoke_handler 注册于
 ```
 ui/src/
 ├── main.tsx                入口
-├── App.tsx                 导航栏、路由（7 个页面）、全局事件订阅（引擎/下载/模型/建议）
+├── App.tsx                 导航栏、路由（9 个页面）、全局事件订阅（引擎/下载/模型/建议）
 ├── api.ts                  Tauri invoke 封装 + 全部请求/事件 TypeScript 类型
 ├── store.ts                zustand 全局状态（见下）
 ├── styles.css              全局样式
 ├── components/Icon.tsx     SVG 图标库
 └── pages/
     ├── ChatPage.tsx        对话页（最大的页面，含会话快照、消息气泡、模型下拉、建议标签）
+    ├── AgentsPage.tsx      智能体列表（预制/自定义分组、新建/编辑/删除/恢复预制）
+    ├── AgentChatPage.tsx   智能体会话页（按路由加载智能体并渲染 ChatPage 智能体模式）
+    ├── WorkflowsPage.tsx   工作流列表（预制/自定义分组、新建/删除/恢复预制）
+    ├── WorkflowCanvasPage.tsx 工作流画布（节点拖拽/连线、节点编辑、运行与结果展示）
     ├── ModelsPage.tsx      模型管理（本地部署 + 在线 API 启用开关）
     ├── ModelPlazaPage.tsx  模型广场（HF/ModelScope 搜索与下载）
     ├── TasksPage.tsx       任务（下载/部署进度）
@@ -69,6 +73,9 @@ ui/src/
 
 | 字段 | 说明 |
 | --- | --- |
+| `agents` / `agentsLoaded` | 智能体列表（预制 + 自定义）与加载标记 |
+| `agentConversations` | 智能体 id → 会话列表（各智能体会话隔离，key 为智能体 id） |
+| `workflows` / `workflowsLoaded` | 工作流列表（预制 + 自定义）与加载标记 |
 | `models` | 模型列表（含 `enabled`、`kind`、`file_name` 等） |
 | `engine` | 引擎状态（running / model / port） |
 | `deployStates` / `deployProgress` | 各模型部署状态（loading/ready/error）与进度 |
@@ -94,10 +101,12 @@ ui/src/
 
 | 分组 | 命令 |
 | --- | --- |
+| 智能体 | `list_agents`、`add_agent`、`update_agent`、`remove_agent`、`set_agent_enabled`、`restore_preset_agents` |
+| 工作流 | `list_workflows`、`add_workflow`、`update_workflow`、`remove_workflow`、`set_workflow_enabled`、`restore_preset_workflows`、`run_workflow` |
 | 应用/设置 | `app_info`、`settings_get`、`settings_set` |
 | 模型 | `list_models`、`import_model`、`remove_model`、`set_model_enabled`、`scan_models`、`add_remote_model` |
 | 模型广场 | `search_models`、`list_model_files`、`list_recommended_models`、`import_recommendations`、`fetch_model_page` |
-| 会话 | `list_conversations`、`create_conversation`、`rename_conversation`、`set_conversation_pinned`、`set_conversation_favorite`、`import_conversation`、`set_conversation_tools`、`delete_conversation`、`get_messages` |
+| 会话 | `list_conversations`（可按 `agent_id` 过滤）、`create_conversation`（可选 `agent_id`，自动继承智能体系统提示词与默认模型）、`rename_conversation`、`set_conversation_pinned`、`set_conversation_favorite`、`import_conversation`、`set_conversation_tools`、`delete_conversation`、`get_messages` |
 | 消息 | `chat_send`、`chat_stop`、`regenerate_message`、`edit_message`、`list_message_versions`、`apply_message_version` |
 | 引擎 | `engine_start`、`engine_stop`、`engine_status`、`deploy_model` |
 | 工具 | `web_search`（Tavily）、`list_skills`、`add_skill`、`update_skill`、`remove_skill`、`set_skill_enabled`、`test_skill`、`list_mcp_servers`、`add_mcp_server`、`update_mcp_server`、`remove_mcp_server`、`set_mcp_server_enabled`、`mcp_test_server`、`mcp_list_tools`、`mcp_call_tool` |
@@ -109,9 +118,19 @@ ui/src/
 
 - `chat_send`：写入用户消息 → 构建历史 → 拉起后台生成任务。
 - `run_generation_and_stream`：统一生成入口（本地引擎 / 远程 API），流式转发 token、统计用量、写库、发 `chat://done`，随后触发标题生成与建议生成。
+- `inject_system_prompts`：把会话/智能体系统提示词（`conversations.system_prompt`）与工具说明统一注入消息历史最前；`chat_send` / `regenerate_message` / `edit_message` 三条链路共用。
 - `maybe_generate_suggestions` → `call_suggestion_model` → `parse_suggestions`：回答完成后预测用户接下来可能说的话。统一要求模型输出 JSON 数组；最多重试 3 次；过滤元信息行与回答原文片段；每条 ≤ 30 字。
 - `maybe_generate_conversation_title`：首轮对话自动生成标题。
-- `create_conversation`：先查找空会话（`find_empty_conversation`）复用，没有才新建。
+- `create_conversation`：先在指定作用域（普通对话或某智能体）查找空会话（`find_empty_conversation`）复用，没有才新建；智能体会话写入该智能体的系统提示词与默认模型。
+- `seed_preset_agents`：启动时首次写入 `default_agents.json` 中的预制智能体（`settings.preset_agents_seeded` 标记只执行一次）；`restore_preset_agents` 命令可随时补齐缺失预制体。
+- `run_workflow`：加载工作流节点/连线 → 交给 `workflow.rs` 执行引擎按拓扑顺序运行；LLM 节点经 `resolve_workflow_node_model` 解析模型（节点 → 工作流默认 → 运行参数 → 自动回退），`call_model_text` 非流式调用本地引擎或远程 API，逐节点推送 `workflow://node-status` 事件。
+- `seed_preset_workflows`：启动时首次写入 `default_workflows.json` 中的预制工作流（`settings.preset_workflows_seeded` 标记只执行一次）；`restore_preset_workflows` 命令可随时补齐缺失预制体。
+
+**工作流执行引擎（`apps/desktop/src/workflow.rs`）：**
+
+- `topo_order`：Kahn 拓扑排序，检测循环 / 未知节点 / 自连。
+- `resolve_template`：解析 `{{input}}` 与 `{{节点id}}` 变量。
+- `execute_workflow`：按拓扑顺序执行 start / text / llm / end 节点，收集各节点输出并汇总最终结果；通过注入的 `call_model` 闭包调用模型，与具体模型解耦（单元测试用假模型跑通 5 个案例，另有真实模型端到端测试 `real_model_translation_workflow_e2e`）。
 
 **工具协议（技能 / MCP）：**
 
@@ -135,13 +154,15 @@ ui/src/
 | --- | --- | --- |
 | `models` | `kind`（local/remote）、`enabled`、`file_name`、`file_path`、`status`、`base_url`、`api_key`、`api_model`、`meta_json` | 模型注册表；`enabled` 决定在线 API 模型是否出现在聊天页可选列表 |
 | `settings` | `key`/`value` | 键值设置 |
-| `conversations` | `title`、`model_id`、`pinned`、`favorite`、`tools_json` | 会话 |
+| `conversations` | `title`、`model_id`、`system_prompt`、`agent_id`、`pinned`、`favorite`、`tools_json` | 会话；`agent_id` 为空表示普通对话，否则属于对应智能体 |
+| `agents` | `kind`（preset/custom）、`name`、`icon`、`description`、`system_prompt`、`model_id`、`enabled` | 智能体（预制 + 自定义） |
+| `workflows` | `kind`（preset/custom）、`name`、`icon`、`description`、`nodes_json`、`edges_json`、`model_id`、`enabled` | 工作流（节点/连线以 JSON 存储，节点含 type/label/position/data） |
 | `messages` | `role`、`model_id`、`content`、`tokens_in/out`、`elapsed_ms`、`first_token_ms`、`images_json` | 消息；`model_id` 记录该回答所用模型（回答下方展示模型名） |
 | `message_versions` | `content`、`tokens_out`、`seq` | 重新生成前的旧版本 |
 | `skills` | `name`、`description`、`content`、`enabled` | 技能工具库 |
 | `mcp_servers` | `name`、`description`、`url`、`auth_token`、`enabled` | MCP 服务配置 |
 
-迁移清单（`ensure_column`）：`models.kind/base_url/api_key/api_model/enabled`、`messages.elapsed_ms/first_token_ms/images_json/model_id`、`conversations.pinned/favorite/tools_json`。
+迁移清单（`ensure_column`）：`models.kind/base_url/api_key/api_model/enabled`、`messages.elapsed_ms/first_token_ms/images_json/model_id`、`conversations.pinned/favorite/tools_json/agent_id`。
 
 ### 5.3 `models.rs`
 
@@ -151,10 +172,18 @@ ui/src/
 
 会话/消息/版本 CRUD；`find_empty_conversation`（新建对话复用空会话）；`import_message`（导入对话用，可指定创建时间）。
 
-### 5.5 `settings.rs`
+### 5.5 `agents.rs`
+
+智能体 CRUD（`list/get/insert/update/delete/set_enabled`）与预制体批量写入 `insert_presets_if_missing`（按 id 忽略已存在，供首次种子与「恢复预制智能体」复用）。
+
+### 5.6 `settings.rs`
 
 `get/set/insert_default/all`。
 
+### 5.7 `workflows.rs`
+
+工作流 CRUD（`list/get/insert/update/delete/set_enabled`）与预制体批量写入 `insert_presets_if_missing`（按 id 忽略已存在）；节点 `WorkflowNode`（type=start/llm/text/end、position、data）与连线 `WorkflowEdge` 以 JSON 列存储，序列化/反序列化在读写时完成。
+
 ---
 
 ## 6. 引擎与远程调用（`crates/engine`）
@@ -197,6 +226,7 @@ ui/src/
 | `models://updated` | 后端→前端 | 模型列表变化 |
 | `download://started/progress/done/error` | 后端→前端 | 下载任务进度 |
 | `server://status` | 后端→前端 | 本地 API 服务状态 |
+| `workflow://node-status` | 后端→前端 | 工作流节点运行状态（running/done/error）与输出文本 |
 
 ---
 
@@ -218,6 +248,8 @@ ui/src/
 | `tavily_api_key` | （内置演示值） | 联网搜索 API Key |
 | `tool_web_search_enabled` | true | 联网搜索工具开关 |
 | `recommend_dir` | 数据目录/recommendations | 推荐列表目录 |
+| `preset_agents_seeded` | 首次启动后为 `1` | 预制智能体是否已写入（内部标记，避免覆盖用户删除） |
+| `preset_workflows_seeded` | 首次启动后为 `1` | 预制工作流是否已写入（内部标记，避免覆盖用户删除） |
 
 ---
 
diff --git a/docs/FEATURES.md b/docs/FEATURES.md
index 44077d8..ef8428c 100644
--- a/docs/FEATURES.md
+++ b/docs/FEATURES.md
@@ -12,11 +12,13 @@
 
 ## 1. 页面总览
 
-应用共 7 个选项卡（导航左侧栏）：
+应用共 9 个选项卡（导航左侧栏）：
 
 | 选项卡 | 路由 | 页面 |
 | --- | --- | --- |
 | 对话 | `/chat` | `ui/src/pages/ChatPage.tsx` |
+| 智能体 | `/agents`、`/agents/:agentId` | `ui/src/pages/AgentsPage.tsx`、`ui/src/pages/AgentChatPage.tsx` |
+| 工作流 | `/workflows`、`/workflows/:workflowId` | `ui/src/pages/WorkflowsPage.tsx`、`ui/src/pages/WorkflowCanvasPage.tsx` |
 | 模型管理 | `/` | `ui/src/pages/ModelsPage.tsx` |
 | 模型广场 | `/plaza` | `ui/src/pages/ModelPlazaPage.tsx` |
 | 任务 | `/tasks` | `ui/src/pages/TasksPage.tsx` |
@@ -77,7 +79,52 @@
 
 ---
 
-## 3. 模型管理页（`/`）
+## 3. 智能体页（`/agents`）
+
+### 3.1 智能体列表
+
+- 左侧导航新增「智能体」选项卡，页面分为「预制智能体」与「自定义智能体」两组。
+- **预制智能体**：随应用内置 6 个（通用助手、代码专家、写作助手、翻译官、数据分析师、提示词优化师），首次启动自动写入数据库（`settings` 键 `preset_agents_seeded` 标记，之后尊重用户删除）；可通过「恢复预制智能体」一键找回已删除的预制体。
+- **自定义智能体**：支持新增 / 编辑 / 删除 / 启用停用。字段：名称、图标（emoji）、描述、系统提示词、默认大模型（可选）、启用开关。
+- 删除智能体会同时删除其名下所有会话（消息随外键级联删除）。
+
+### 3.2 智能体会话
+
+- 点击智能体卡片「开始对话」进入 `/agents/:agentId`，该页面复用聊天页完整能力（流式输出、重新生成、版本历史、工具、预测建议等）。
+- **会话隔离**：`conversations` 表新增 `agent_id` 字段。普通对话页只显示 `agent_id` 为空的会话，每个智能体只显示属于自己的会话，互不干扰。
+- 新建智能体会话时自动写入该智能体的**系统提示词**（人设）与默认大模型；对话时仍可在右侧参数面板切换任意可用大模型（本地 / 在线 API 均可）。
+- 系统提示词在 `chat_send` / `regenerate_message` / `edit_message` 三条链路统一注入到消息历史最前（工具说明紧随其后），重新生成与编辑重提同样生效。
+
+---
+
+## 4. 工作流页（`/workflows`）
+
+### 4.1 工作流列表
+
+- 左侧导航新增「工作流」选项卡，页面分为「预制工作流」与「自定义工作流」两组，支持新建 / 删除 / 启用停用 / 恢复预制。
+- **预制工作流**：随应用内置 4 个（翻译助手、内容总结、两步润色、写作助手），首次启动自动写入数据库（`settings` 键 `preset_workflows_seeded` 标记，之后尊重用户删除）；「恢复预制工作流」可一键找回。
+- 新建工作流会生成「开始 → 大模型 → 输出」的默认画布，随后进入画布编辑器。
+
+### 4.2 画布编辑器（`/workflows/:workflowId`）
+
+- 左侧节点面板可添加 4 类节点：
+  - **开始**：工作流入口，提供运行输入（提示词中可用 `{{input}}` 引用）；
+  - **大模型**：配置提示词模板、节点级大模型（可选）、temperature、max_tokens，提示词可用 `{{input}}` 与 `{{节点id}}` 引用上游节点输出；
+  - **文本**：静态文本内容（如风格要求），可被其他节点引用；
+  - **输出**：决定最终输出（模板留空时自动取上游输出）。
+- 节点可拖动布局；点击节点右侧圆点拖到另一节点左侧圆点建立连线（数据流），点击连线删除；删除节点时自动清理相关连线。
+- 右侧面板：运行工作流（输入内容 + 可选大模型）、节点设置、工作流设置（图标/描述/默认大模型/启用）、各节点输出列表。
+- 运行前自动保存画布；后端按拓扑顺序执行，`workflow://node-status` 事件实时推送每个节点 running/done 状态与输出。
+
+### 4.3 执行引擎
+
+- `apps/desktop/src/workflow.rs`：DAG 拓扑排序（Kahn，检测循环/未知节点/自连）、模板变量解析（`{{input}}`、`{{节点id}}`）、逐节点执行与结果收集；不依赖具体模型，通过注入的 `call_model` 闭包调用模型，便于单元测试。
+- LLM 节点模型解析顺序：节点配置 → 工作流默认模型 → 运行参数模型 → 第一个本地模型 / 第一个已启用在线模型。
+- 已内置 5 个执行引擎单元测试（单节点、链式传参、文本节点组合、循环检测、缺失变量报错）与 1 个真实模型端到端测试（`real_model_translation_workflow_e2e`，用本机已配置的在线模型跑通「翻译」工作流，默认忽略、显式运行）。
+
+---
+
+## 5. 模型管理页（`/`）
 
 - **本地模型**：启动时自动扫描模型目录（可手动重新扫描）；支持导入本地 GGUF 文件；可「部署」（后台加载 llama-server 并显示进度）或「停止」；可打开所在目录、移除。
 - **在线 API 模型**（OpenAI 兼容）：添加时填写显示名称、Base URL、API Key（可选）、上游模型 ID。
@@ -86,7 +133,7 @@
 
 ---
 
-## 4. 模型广场页（`/plaza`）
+## 6. 模型广场页（`/plaza`）
 
 - 搜索 Hugging Face / ModelScope 上的 GGUF 模型，支持热门榜（空关键词）。
 - 查看仓库的 GGUF 量化版本文件列表，选择版本一键下载（ModelScope 文件自动附带 SHA256 校验）。
@@ -95,14 +142,14 @@
 
 ---
 
-## 5. 任务页（`/tasks`）
+## 7. 任务页（`/tasks`）
 
 - 展示下载任务与部署任务的实时进度、状态（进行中 / 完成 / 失败）。
 - 空状态提示：暂无任务时引导去模型广场下载或部署本地模型。
 
 ---
 
-## 6. 工具页（`/tools`）
+## 8. 工具页（`/tools`）
 
 - **联网搜索**：配置 Tavily API Key，支持手动测试搜索；对话中的「联网搜索」开关依赖该配置。
 - **技能（Skill）**：
@@ -116,14 +163,14 @@
 
 ---
 
-## 7. 服务管理页（`/server`）
+## 9. 服务管理页（`/server`）
 
 - OpenAI 兼容的本地 API 服务：`/v1/models`、`/v1/chat/completions`（SSE 流式）、`/v1/embeddings`。
 - 可设置端口与 API Key，仅本机监听；可启动/停止并查看状态。
 
 ---
 
-## 8. 设置页（`/settings`）
+## 10. 设置页（`/settings`）
 
 - **引擎与路径**：模型目录、llama-server 路径、模型下载源（hf-mirror / huggingface.co / modelscope.cn）、默认后端（auto/cpu/cuda/vulkan）、上传大小上限。
 - **对话**：
@@ -137,12 +184,14 @@
 
 ---
 
-## 9. 改动记录
+## 11. 改动记录
 
 > 按时间倒序追加；每次改动功能都要在此登记。
 
 ### 2026-08-16
 
+- 新增「工作流」选项卡：画布式节点编辑器（开始/大模型/文本/输出，节点连线传参、拖动布局），内置 4 个预制工作流（翻译助手、内容总结、两步润色、写作助手）并支持自定义与恢复；新增 `workflows` 表与 `run_workflow` 命令，后端 `apps/desktop/src/workflow.rs` 执行引擎支持拓扑排序、模板变量（`{{input}}`/`{{节点id}}`）、循环检测，LLM 节点支持本地/在线大模型（节点 → 工作流 → 运行参数 → 自动回退）；`workflow://node-status` 事件实时推送节点状态；5 个引擎单元测试 + 1 个真实模型端到端测试全部跑通。
+- 新增「智能体」选项卡：内置 6 个预制智能体 + 支持自定义智能体（名称/图标/描述/系统提示词/默认模型/启用开关）；每个智能体拥有独立会话区（`conversations.agent_id` 隔离），新建会话自动继承智能体系统提示词与默认模型；系统提示词统一注入 `chat_send` / `regenerate_message` / `edit_message` 链路；删除智能体时级联删除其会话；支持「恢复预制智能体」。
 - 工具页新增「技能（Skill）」与「MCP 服务」管理；对话工具协议上线：模型用 `[[skill:…]]` / `[[mcp:…]]` 标记调用技能与 MCP 工具，系统执行后回填结果（最多 3 轮）。新增本地 MCP 测试服务器 `scripts/test_mcp_server.py` 与 3 个示例技能。
 - 会话列表「更多操作」菜单：鼠标移出按钮/菜单所在区域时自动关闭，避免遮挡其他对话标题的查看与操作。
 - 新建对话时复用已有空会话（无消息的会话），避免堆积多个空的「新会话」。
diff --git a/ui/src/App.tsx b/ui/src/App.tsx
index f0ab80c..49dd8eb 100644
--- a/ui/src/App.tsx
+++ b/ui/src/App.tsx
@@ -16,9 +16,15 @@ import ToolsPage from "./pages/ToolsPage";
 import ServerPage from "./pages/ServerPage";
 import SettingsPage from "./pages/SettingsPage";
 import TasksPage from "./pages/TasksPage";
+import AgentsPage from "./pages/AgentsPage";
+import AgentChatPage from "./pages/AgentChatPage";
+import WorkflowsPage from "./pages/WorkflowsPage";
+import WorkflowCanvasPage from "./pages/WorkflowCanvasPage";
 
 const navItems = [
   { to: "/chat", label: "对话", icon: "chat" },
+  { to: "/agents", label: "智能体", icon: "bot" },
+  { to: "/workflows", label: "工作流", icon: "workflow" },
   { to: "/", label: "模型管理", icon: "box", end: true },
   { to: "/plaza", label: "模型广场", icon: "plaza" },
   { to: "/tasks", label: "任务", icon: "tasks" },
@@ -35,6 +41,8 @@ export default function App() {
   const refreshEngine = useStore((s) => s.refreshEngine);
   const refreshServer = useStore((s) => s.refreshServer);
   const refreshConversations = useStore((s) => s.refreshConversations);
+  const refreshAgents = useStore((s) => s.refreshAgents);
+  const refreshWorkflows = useStore((s) => s.refreshWorkflows);
   const setDeployState = useStore((s) => s.setDeployState);
   const setDeployProgress = useStore((s) => s.setDeployProgress);
   const setChatSuggestions = useStore((s) => s.setChatSuggestions);
@@ -55,6 +63,8 @@ export default function App() {
     refreshEngine();
     refreshServer();
     refreshConversations();
+    refreshAgents();
+    refreshWorkflows();
     const un1 = onEvent("engine://status", () => refreshEngine());
     const un2 = onEvent("server://status", () => refreshServer());
     const un3start = onEvent<DownloadProgressEvent>("download://started", (e) => {
@@ -159,6 +169,8 @@ export default function App() {
     refreshEngine,
     refreshServer,
     refreshConversations,
+    refreshAgents,
+    refreshWorkflows,
     setDeployState,
     setDeployProgress,
     setChatSuggestions,
@@ -227,6 +239,10 @@ export default function App() {
         <Routes>
           <Route path="/" element={<ModelsPage />} />
           <Route path="/chat" element={<ChatPage />} />
+          <Route path="/agents" element={<AgentsPage />} />
+          <Route path="/agents/:agentId" element={<AgentChatPage />} />
+          <Route path="/workflows" element={<WorkflowsPage />} />
+          <Route path="/workflows/:workflowId" element={<WorkflowCanvasPage />} />
           <Route path="/plaza" element={<ModelPlazaPage />} />
           <Route path="/tasks" element={<TasksPage />} />
           <Route path="/tools" element={<ToolsPage />} />
diff --git a/ui/src/api.ts b/ui/src/api.ts
index 80a9ee1..0db2035 100644
--- a/ui/src/api.ts
+++ b/ui/src/api.ts
@@ -72,6 +72,92 @@ export interface Skill {
   created_at: string;
 }
 
+export interface Agent {
+  id: string;
+  kind: string;
+  name: string;
+  icon: string;
+  description: string;
+  system_prompt: string;
+  model_id: string | null;
+  enabled: boolean;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface AgentInput {
+  name: string;
+  icon: string;
+  description: string;
+  system_prompt: string;
+  model_id: string | null;
+  enabled: boolean;
+}
+
+export interface WorkflowNodePosition {
+  x: number;
+  y: number;
+}
+
+export interface WorkflowNode {
+  id: string;
+  type: string;
+  label: string;
+  position: WorkflowNodePosition;
+  data: {
+    prompt?: string;
+    content?: string;
+    template?: string;
+    model_id?: string | null;
+    temperature?: number;
+    max_tokens?: number;
+  };
+}
+
+export interface WorkflowEdge {
+  id: string;
+  from: string;
+  to: string;
+}
+
+export interface Workflow {
+  id: string;
+  kind: string;
+  name: string;
+  icon: string;
+  description: string;
+  nodes: WorkflowNode[];
+  edges: WorkflowEdge[];
+  model_id: string | null;
+  enabled: boolean;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface WorkflowInput {
+  name: string;
+  icon: string;
+  description: string;
+  nodes: WorkflowNode[];
+  edges: WorkflowEdge[];
+  model_id: string | null;
+  enabled: boolean;
+}
+
+export interface WorkflowRunResult {
+  workflow_id: string;
+  results: Record<string, string>;
+  final: string;
+}
+
+export interface WorkflowNodeStatusEvent {
+  workflow_id: string;
+  node_id: string;
+  label: string;
+  status: string;
+  text: string | null;
+}
+
 export interface McpServer {
   id: string;
   name: string;
@@ -122,6 +208,7 @@ export interface Conversation {
   title: string;
   model_id: string | null;
   system_prompt: string | null;
+  agent_id: string | null;
   pinned: boolean;
   favorite: boolean;
   tools: string[];
@@ -253,6 +340,27 @@ export interface ServerStatus {
 
 export const api = {
   appInfo: () => invoke<AppInfo>("app_info"),
+  listAgents: () => invoke<Agent[]>("list_agents"),
+  addAgent: (input: AgentInput) => invoke<Agent>("add_agent", { input }),
+  updateAgent: (id: string, input: AgentInput) =>
+    invoke<void>("update_agent", { id, input }),
+  removeAgent: (id: string) => invoke<void>("remove_agent", { id }),
+  setAgentEnabled: (id: string, enabled: boolean) =>
+    invoke<void>("set_agent_enabled", { id, enabled }),
+  restorePresetAgents: () => invoke<number>("restore_preset_agents"),
+  listWorkflows: () => invoke<Workflow[]>("list_workflows"),
+  addWorkflow: (input: WorkflowInput) => invoke<Workflow>("add_workflow", { input }),
+  updateWorkflow: (id: string, input: WorkflowInput) =>
+    invoke<void>("update_workflow", { id, input }),
+  removeWorkflow: (id: string) => invoke<void>("remove_workflow", { id }),
+  setWorkflowEnabled: (id: string, enabled: boolean) =>
+    invoke<void>("set_workflow_enabled", { id, enabled }),
+  restorePresetWorkflows: () => invoke<number>("restore_preset_workflows"),
+  runWorkflow: (payload: {
+    workflow_id: string;
+    input: string;
+    model_id: string | null;
+  }) => invoke<WorkflowRunResult>("run_workflow", { payload }),
   listModels: () => invoke<ModelInfo[]>("list_models"),
   importModel: (path: string) => invoke<ModelInfo>("import_model", { path }),
   removeModel: (id: string) => invoke<void>("remove_model", { id }),
@@ -310,9 +418,14 @@ export const api = {
   settingsGet: () => invoke<Record<string, string>>("settings_get"),
   settingsSet: (key: string, value: string) =>
     invoke<void>("settings_set", { key, value }),
-  listConversations: () => invoke<Conversation[]>("list_conversations"),
-  createConversation: (title: string, modelId?: string) =>
-    invoke<Conversation>("create_conversation", { title, modelId: modelId ?? null }),
+  listConversations: (agentId?: string) =>
+    invoke<Conversation[]>("list_conversations", { agentId: agentId ?? null }),
+  createConversation: (title: string, modelId?: string, agentId?: string) =>
+    invoke<Conversation>("create_conversation", {
+      title,
+      modelId: modelId ?? null,
+      agentId: agentId ?? null,
+    }),
   renameConversation: (id: string, title: string) =>
     invoke<void>("rename_conversation", { id, title }),
   setConversationPinned: (id: string, pinned: boolean) =>
diff --git a/ui/src/components/Icon.tsx b/ui/src/components/Icon.tsx
index fc78c25..b55cc83 100644
--- a/ui/src/components/Icon.tsx
+++ b/ui/src/components/Icon.tsx
@@ -2,6 +2,24 @@ import type { ReactNode } from "react";
 
 const paths: Record<string, ReactNode> = {
   chat: <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" />,
+  bot: (
+    <>
+      <rect x="4" y="7" width="16" height="13" rx="2.5" />
+      <path d="M12 7V3M9.5 3h5" />
+      <circle cx="9" cy="13" r="1" />
+      <circle cx="15" cy="13" r="1" />
+      <path d="M9.5 17h5" />
+    </>
+  ),
+  workflow: (
+    <>
+      <circle cx="6" cy="5" r="2" />
+      <circle cx="18" cy="12" r="2" />
+      <circle cx="6" cy="19" r="2" />
+      <path d="M6 7v2a3 3 0 0 0 3 3h7a3 3 0 0 1 3 3v1" />
+      <path d="M6 17v-1" />
+    </>
+  ),
   box: (
     <>
       <path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z" />
diff --git a/ui/src/pages/AgentChatPage.tsx b/ui/src/pages/AgentChatPage.tsx
new file mode 100644
index 0000000..e8a816c
--- /dev/null
+++ b/ui/src/pages/AgentChatPage.tsx
@@ -0,0 +1,38 @@
+import { useEffect } from "react";
+import { Link, useParams } from "react-router-dom";
+import { useStore } from "../store";
+import ChatPage from "./ChatPage";
+
+export default function AgentChatPage() {
+  const { agentId } = useParams<{ agentId: string }>();
+  const agents = useStore((s) => s.agents);
+  const agentsLoaded = useStore((s) => s.agentsLoaded);
+  const refreshAgents = useStore((s) => s.refreshAgents);
+
+  useEffect(() => {
+    refreshAgents();
+  }, [refreshAgents]);
+
+  if (!agentsLoaded) {
+    return (
+      <div className="flex h-full items-center justify-center text-sm text-slate-400">
+        正在加载智能体…
+      </div>
+    );
+  }
+
+  const agent = agents.find((a) => a.id === agentId);
+  if (!agent) {
+    return (
+      <div className="flex h-full flex-col items-center justify-center gap-3 text-sm text-slate-400">
+        <div className="text-4xl">🤖</div>
+        智能体不存在或已被删除
+        <Link to="/agents" className="btn-secondary">
+          返回智能体列表
+        </Link>
+      </div>
+    );
+  }
+
+  return <ChatPage key={agent.id} agent={agent} />;
+}
diff --git a/ui/src/pages/AgentsPage.tsx b/ui/src/pages/AgentsPage.tsx
new file mode 100644
index 0000000..7bd5800
--- /dev/null
+++ b/ui/src/pages/AgentsPage.tsx
@@ -0,0 +1,385 @@
+import { useEffect, useMemo, useState } from "react";
+import { useNavigate } from "react-router-dom";
+import { api, Agent, AgentInput } from "../api";
+import { useStore } from "../store";
+import Icon from "../components/Icon";
+
+interface EditorState {
+  editing: Agent | null;
+  name: string;
+  icon: string;
+  description: string;
+  system_prompt: string;
+  model_id: string | null;
+  enabled: boolean;
+}
+
+function emptyEditor(): EditorState {
+  return {
+    editing: null,
+    name: "",
+    icon: "🤖",
+    description: "",
+    system_prompt: "",
+    model_id: null,
+    enabled: true,
+  };
+}
+
+export default function AgentsPage() {
+  const agents = useStore((s) => s.agents);
+  const refreshAgents = useStore((s) => s.refreshAgents);
+  const refreshModels = useStore((s) => s.refreshModels);
+  const models = useStore((s) => s.models);
+  const navigate = useNavigate();
+  const [editor, setEditor] = useState<EditorState | null>(null);
+  const [msg, setMsg] = useState<string | null>(null);
+  const [busy, setBusy] = useState(false);
+
+  useEffect(() => {
+    refreshAgents();
+    refreshModels();
+  }, [refreshAgents, refreshModels]);
+
+  const presets = useMemo(() => agents.filter((a) => a.kind === "preset"), [agents]);
+  const customs = useMemo(() => agents.filter((a) => a.kind === "custom"), [agents]);
+
+  const modelNameById = useMemo(() => {
+    const map = new Map<string, string>();
+    for (const m of models) {
+      map.set(m.id, m.file_name.replace(/\.gguf$/i, ""));
+    }
+    return map;
+  }, [models]);
+
+  function startEdit(agent: Agent) {
+    setEditor({
+      editing: agent,
+      name: agent.name,
+      icon: agent.icon,
+      description: agent.description,
+      system_prompt: agent.system_prompt,
+      model_id: agent.model_id,
+      enabled: agent.enabled,
+    });
+  }
+
+  async function handleSave() {
+    if (!editor) return;
+    if (!editor.name.trim()) {
+      setMsg("请填写智能体名称");
+      return;
+    }
+    const input: AgentInput = {
+      name: editor.name.trim(),
+      icon: editor.icon.trim() || "🤖",
+      description: editor.description.trim(),
+      system_prompt: editor.system_prompt.trim(),
+      model_id: editor.model_id || null,
+      enabled: editor.enabled,
+    };
+    setBusy(true);
+    try {
+      if (editor.editing) {
+        await api.updateAgent(editor.editing.id, input);
+        setMsg("智能体已保存");
+      } else {
+        await api.addAgent(input);
+        setMsg("智能体已创建");
+      }
+      setEditor(null);
+      await refreshAgents();
+    } catch (e) {
+      setMsg(`保存失败：${String(e)}`);
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  async function handleToggle(agent: Agent) {
+    try {
+      await api.setAgentEnabled(agent.id, !agent.enabled);
+      await refreshAgents();
+    } catch (e) {
+      setMsg(`操作失败：${String(e)}`);
+    }
+  }
+
+  async function handleDelete(agent: Agent) {
+    if (!confirm(`确定删除智能体「${agent.name}」吗？\n其名下所有会话将一并删除。`)) return;
+    try {
+      await api.removeAgent(agent.id);
+      setMsg("智能体已删除");
+      await refreshAgents();
+    } catch (e) {
+      setMsg(`删除失败：${String(e)}`);
+    }
+  }
+
+  async function handleRestorePresets() {
+    setBusy(true);
+    try {
+      const n = await api.restorePresetAgents();
+      setMsg(n > 0 ? `已恢复 ${n} 个预制智能体` : "预制智能体已齐全，无需恢复");
+      await refreshAgents();
+    } catch (e) {
+      setMsg(`恢复失败：${String(e)}`);
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  return (
+    <div className="h-full overflow-auto p-6">
+      <div className="mb-4 flex items-start justify-between gap-4">
+        <div>
+          <h1 className="text-xl font-semibold">智能体</h1>
+          <p className="mt-1 text-sm text-slate-400">
+            每个智能体拥有独立的人设与系统提示词，可单独开始完整对话；支持本地与在线大模型，对话时可按会话启用工具
+          </p>
+        </div>
+        <div className="flex shrink-0 gap-2">
+          <button className="btn-secondary" onClick={handleRestorePresets} disabled={busy}>
+            恢复预制智能体
+          </button>
+          <button className="btn-primary" onClick={() => setEditor(emptyEditor())}>
+            + 新建智能体
+          </button>
+        </div>
+      </div>
+
+      {msg ? (
+        <div className="mb-4 flex items-center justify-between rounded-lg border border-border bg-panel px-4 py-2 text-xs text-slate-300">
+          <span>{msg}</span>
+          <button className="text-slate-500 hover:text-slate-200" onClick={() => setMsg(null)}>
+            ×
+          </button>
+        </div>
+      ) : null}
+
+      {editor ? (
+        <div className="mb-6 space-y-3 rounded-xl border border-border bg-panel p-5">
+          <div className="text-sm font-medium">
+            {editor.editing ? "编辑智能体" : "新建智能体"}
+          </div>
+          <div className="grid grid-cols-3 gap-3">
+            <label className="block text-sm">
+              <span className="text-xs text-slate-400">名称</span>
+              <input
+                className="input mt-1"
+                value={editor.name}
+                onChange={(e) => setEditor({ ...editor, name: e.target.value })}
+                placeholder="例如：翻译官"
+              />
+            </label>
+            <label className="block text-sm">
+              <span className="text-xs text-slate-400">图标（emoji）</span>
+              <input
+                className="input mt-1"
+                value={editor.icon}
+                onChange={(e) => setEditor({ ...editor, icon: e.target.value })}
+                placeholder="例如：🌐"
+                maxLength={8}
+              />
+            </label>
+            <label className="block text-sm">
+              <span className="text-xs text-slate-400">默认大模型（可选）</span>
+              <select
+                className="input mt-1"
+                value={editor.model_id ?? ""}
+                onChange={(e) =>
+                  setEditor({ ...editor, model_id: e.target.value || null })
+                }
+              >
+                <option value="">不指定（对话时选择）</option>
+                {models.map((m) => (
+                  <option key={m.id} value={m.id}>
+                    {m.file_name.replace(/\.gguf$/i, "")}
+                    {m.kind === "remote" ? "（在线 API）" : "（本地）"}
+                  </option>
+                ))}
+              </select>
+            </label>
+          </div>
+          <label className="block text-sm">
+            <span className="text-xs text-slate-400">描述（展示给用户）</span>
+            <input
+              className="input mt-1"
+              value={editor.description}
+              onChange={(e) => setEditor({ ...editor, description: e.target.value })}
+              placeholder="例如：多语言互译，擅长技术、商务与学术文本"
+            />
+          </label>
+          <label className="block text-sm">
+            <span className="text-xs text-slate-400">系统提示词（人设与能力，每次对话都会注入给模型）</span>
+            <textarea
+              className="input mt-1 min-h-[140px] resize-y"
+              value={editor.system_prompt}
+              onChange={(e) => setEditor({ ...editor, system_prompt: e.target.value })}
+              placeholder="例如：你是一名专业翻译，支持中英日韩等多语言互译……"
+            />
+          </label>
+          <div className="flex items-center gap-3">
+            <label className="flex cursor-pointer items-center gap-2 text-xs text-slate-300">
+              <input
+                type="checkbox"
+                checked={editor.enabled}
+                onChange={(e) => setEditor({ ...editor, enabled: e.target.checked })}
+                className="accent-indigo-500"
+              />
+              启用
+            </label>
+            <button className="btn-primary" onClick={handleSave} disabled={busy}>
+              保存
+            </button>
+            <button className="btn-secondary" onClick={() => setEditor(null)}>
+              取消
+            </button>
+          </div>
+        </div>
+      ) : null}
+
+      {presets.length > 0 ? (
+        <section className="mb-6">
+          <div className="mb-2 text-xs uppercase text-slate-500">预制智能体</div>
+          <div className="grid grid-cols-2 gap-3 xl:grid-cols-3">
+            {presets.map((a) => (
+              <AgentCard
+                key={a.id}
+                agent={a}
+                modelNameById={modelNameById}
+                onChat={() => navigate(`/agents/${a.id}`)}
+                onEdit={() => startEdit(a)}
+                onToggle={() => handleToggle(a)}
+                onDelete={() => handleDelete(a)}
+              />
+            ))}
+          </div>
+        </section>
+      ) : null}
+
+      <section>
+        <div className="mb-2 text-xs uppercase text-slate-500">自定义智能体</div>
+        {customs.length === 0 ? (
+          <div className="rounded-xl border border-dashed border-border bg-panel/50 px-4 py-8 text-center text-sm text-slate-500">
+            还没有自定义智能体，点击右上角「新建智能体」创建
+          </div>
+        ) : (
+          <div className="grid grid-cols-2 gap-3 xl:grid-cols-3">
+            {customs.map((a) => (
+              <AgentCard
+                key={a.id}
+                agent={a}
+                modelNameById={modelNameById}
+                onChat={() => navigate(`/agents/${a.id}`)}
+                onEdit={() => startEdit(a)}
+                onToggle={() => handleToggle(a)}
+                onDelete={() => handleDelete(a)}
+              />
+            ))}
+          </div>
+        )}
+      </section>
+
+      <div className="mt-8 rounded-xl border border-border bg-panel p-4 text-xs leading-relaxed text-slate-400">
+        <div className="mb-1 font-medium text-slate-300">使用说明</div>
+        <ul className="list-inside list-disc space-y-1">
+          <li>点击「开始对话」进入该智能体的专属会话区，普通对话与各智能体的会话互不干扰；</li>
+          <li>智能体的人设来自「系统提示词」，新建会话时自动写入，之后可随时返回本页调整；</li>
+          <li>支持本地模型与在线 API 模型（需在模型管理启用），对话时可在右侧参数面板切换；</li>
+          <li>删除自定义智能体会同时删除其名下所有会话；删除预制智能体后可用「恢复预制智能体」找回。</li>
+        </ul>
+      </div>
+    </div>
+  );
+}
+
+function AgentCard({
+  agent,
+  modelNameById,
+  onChat,
+  onEdit,
+  onToggle,
+  onDelete,
+}: {
+  agent: Agent;
+  modelNameById: Map<string, string>;
+  onChat: () => void;
+  onEdit: () => void;
+  onToggle: () => void;
+  onDelete: () => void;
+}) {
+  return (
+    <div
+      className={`flex flex-col rounded-xl border border-border bg-panel p-4 ${
+        agent.enabled ? "" : "opacity-60"
+      }`}
+    >
+      <div className="flex items-start gap-3">
+        <div className="flex h-11 w-11 shrink-0 items-center justify-center rounded-xl bg-panel-2 text-2xl">
+          {agent.icon || "🤖"}
+        </div>
+        <div className="min-w-0 flex-1">
+          <div className="flex items-center gap-2">
+            <span className="truncate text-sm font-semibold">{agent.name}</span>
+            <span className="shrink-0 rounded bg-panel-2 px-1.5 py-0.5 text-[10px] text-slate-400">
+              {agent.kind === "preset" ? "预制" : "自定义"}
+            </span>
+          </div>
+          <div className="mt-0.5 line-clamp-2 text-xs text-slate-400">{agent.description}</div>
+        </div>
+        <Toggle checked={agent.enabled} onChange={onToggle} />
+      </div>
+      {agent.model_id && modelNameById.has(agent.model_id) ? (
+        <div className="mt-2 truncate text-[11px] text-slate-500">
+          默认模型：{modelNameById.get(agent.model_id)}
+        </div>
+      ) : null}
+      <div className="mt-3 flex items-center gap-2">
+        <button className="btn-primary flex-1 px-2 py-1.5 text-xs" onClick={onChat}>
+          开始对话
+        </button>
+        <button
+          className="rounded-lg border border-border bg-panel-2 px-2.5 py-1.5 text-xs text-slate-300 hover:text-white"
+          onClick={onEdit}
+          title="编辑"
+        >
+          <Icon name="edit" className="h-3.5 w-3.5" />
+        </button>
+        <button
+          className="rounded-lg border border-border bg-panel-2 px-2.5 py-1.5 text-xs text-slate-400 hover:text-red-400"
+          onClick={onDelete}
+          title="删除"
+        >
+          <Icon name="trash" className="h-3.5 w-3.5" />
+        </button>
+      </div>
+    </div>
+  );
+}
+
+function Toggle({
+  checked,
+  onChange,
+}: {
+  checked: boolean;
+  onChange: (v: boolean) => void;
+}) {
+  return (
+    <button
+      type="button"
+      role="switch"
+      aria-checked={checked}
+      onClick={() => onChange(!checked)}
+      className={`relative h-6 w-11 shrink-0 rounded-full transition-colors ${
+        checked ? "bg-accent" : "bg-panel-2"
+      }`}
+    >
+      <span
+        className={`absolute top-0.5 h-5 w-5 rounded-full bg-white shadow transition-all ${
+          checked ? "left-[22px]" : "left-0.5"
+        }`}
+      />
+    </button>
+  );
+}
diff --git a/ui/src/pages/ChatPage.tsx b/ui/src/pages/ChatPage.tsx
index 05ac4fc..f63e336 100644
--- a/ui/src/pages/ChatPage.tsx
+++ b/ui/src/pages/ChatPage.tsx
@@ -1,8 +1,10 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Link } from "react-router-dom";
 import ReactMarkdown from "react-markdown";
 import remarkGfm from "remark-gfm";
 import {
   api,
+  Agent,
   ChatDoneEvent,
   ChatErrorEvent,
   ChatMessageUpdatedEvent,
@@ -57,6 +59,7 @@ const defaultParams: ChatParams = {
 };
 
 // 会话快照：切换选项卡时 ChatPage 会卸载，通过模块级缓存保持对话/模型等状态的连续性。
+// 普通对话（key=""）与每个智能体（key=智能体 id）各自独立一份快照，互不串扰。
 interface ChatSessionSnapshot {
   activeConvId: string | null;
   selectedModelId: string;
@@ -69,17 +72,28 @@ interface ChatSessionSnapshot {
   attachments: Attachment[];
 }
 
-const chatSession: ChatSessionSnapshot = {
-  activeConvId: null,
-  selectedModelId: "",
-  messages: [],
-  input: "",
-  params: defaultParams,
-  rightOpen: localStorage.getItem("xianren-right-open") !== "0",
-  selectedTools: [],
-  versionsFor: {},
-  attachments: [],
-};
+const EMPTY_AGENT_CONVERSATIONS: Conversation[] = [];
+
+const chatSessions: Record<string, ChatSessionSnapshot> = {};
+
+function defaultSnapshot(): ChatSessionSnapshot {
+  return {
+    activeConvId: null,
+    selectedModelId: "",
+    messages: [],
+    input: "",
+    params: { ...defaultParams },
+    rightOpen: localStorage.getItem("xianren-right-open") !== "0",
+    selectedTools: [],
+    versionsFor: {},
+    attachments: [],
+  };
+}
+
+function snapshotFor(scope: string): ChatSessionSnapshot {
+  if (!chatSessions[scope]) chatSessions[scope] = defaultSnapshot();
+  return chatSessions[scope];
+}
 
 const TEXT_EXTENSIONS = new Set([
   "txt", "md", "markdown", "json", "csv", "log", "py", "js", "ts", "tsx", "jsx",
@@ -93,30 +107,38 @@ function displayModelName(name: string) {
 
 type ModelRuntimeState = "ready" | "loading" | "error";
 
-export default function ChatPage() {
+export default function ChatPage({ agent }: { agent?: Agent | null } = {}) {
+  const scopeKey = agent?.id ?? "";
+  const snap = snapshotFor(scopeKey);
   const models = useStore((s) => s.models);
   const engine = useStore((s) => s.engine);
   const deployStates = useStore((s) => s.deployStates);
   const suggestionsByMessage = useStore((s) => s.chatSuggestionsByMessage);
-  const conversations = useStore((s) => s.conversations);
+  const mainConversations = useStore((s) => s.conversations);
+  const agentConversations = useStore((s) =>
+    agent?.id ? s.agentConversations[agent.id] : undefined,
+  );
+  const conversations = agent
+    ? agentConversations ?? EMPTY_AGENT_CONVERSATIONS
+    : mainConversations;
   const refreshConversations = useStore((s) => s.refreshConversations);
 
-  const [activeConvId, setActiveConvId] = useState<string | null>(chatSession.activeConvId);
-  const [messages, setMessages] = useState<LocalMessage[]>(chatSession.messages);
-  const [input, setInput] = useState(chatSession.input);
+  const [activeConvId, setActiveConvId] = useState<string | null>(snap.activeConvId);
+  const [messages, setMessages] = useState<LocalMessage[]>(snap.messages);
+  const [input, setInput] = useState(snap.input);
   const [streaming, setStreaming] = useState(false);
   const [error, setError] = useState<string | null>(null);
-  const [params, setParams] = useState<ChatParams>(chatSession.params);
-  const [selectedModelId, setSelectedModelId] = useState(chatSession.selectedModelId);
-  const [rightOpen, setRightOpen] = useState(chatSession.rightOpen);
+  const [params, setParams] = useState<ChatParams>(snap.params);
+  const [selectedModelId, setSelectedModelId] = useState(snap.selectedModelId);
+  const [rightOpen, setRightOpen] = useState(snap.rightOpen);
   const [editingId, setEditingId] = useState<string | null>(null);
   const [editingDraft, setEditingDraft] = useState("");
   const [versionsFor, setVersionsFor] = useState<Record<string, MessageVersion[]>>(
-    chatSession.versionsFor,
+    snap.versionsFor,
   );
-  const [attachments, setAttachments] = useState<Attachment[]>(chatSession.attachments);
+  const [attachments, setAttachments] = useState<Attachment[]>(snap.attachments);
   const [uploadLimitMb, setUploadLimitMb] = useState(10);
-  const [selectedTools, setSelectedTools] = useState<string[]>(chatSession.selectedTools);
+  const [selectedTools, setSelectedTools] = useState<string[]>(snap.selectedTools);
   const [webSearchEnabled, setWebSearchEnabled] = useState(true);
   const [toolStatus, setToolStatus] = useState<string | null>(null);
   const [toolSkills, setToolSkills] = useState<Skill[]>([]);
@@ -189,24 +211,31 @@ export default function ChatPage() {
 
   // 每次渲染后把当前状态写回快照，确保切走选项卡再回来时保持连续性
   useEffect(() => {
-    chatSession.activeConvId = activeConvId;
-    chatSession.selectedModelId = selectedModelId;
-    chatSession.messages = messages;
-    chatSession.input = input;
-    chatSession.params = params;
-    chatSession.rightOpen = rightOpen;
-    chatSession.selectedTools = selectedTools;
-    chatSession.versionsFor = versionsFor;
-    chatSession.attachments = attachments;
+    const s = snapshotFor(scopeKey);
+    s.activeConvId = activeConvId;
+    s.selectedModelId = selectedModelId;
+    s.messages = messages;
+    s.input = input;
+    s.params = params;
+    s.rightOpen = rightOpen;
+    s.selectedTools = selectedTools;
+    s.versionsFor = versionsFor;
+    s.attachments = attachments;
   });
 
+  // 拉取当前作用域（普通对话或所选智能体）的会话列表
+  useEffect(() => {
+    refreshConversations(agent?.id);
+  }, [agent?.id, refreshConversations]);
+
   // 若上次离开时回答还在生成中（快照里有流式占位），回到对话页后从数据库拉取最终结果
   const restoredRef = useRef(false);
   useEffect(() => {
     if (restoredRef.current) return;
     restoredRef.current = true;
     if (!activeConvId) return;
-    const last = chatSession.messages[chatSession.messages.length - 1];
+    const snapMessages = snapshotFor(scopeKey).messages;
+    const last = snapMessages[snapMessages.length - 1];
     if (!last || !last.streaming) return;
     api
       .getMessages(activeConvId)
@@ -225,6 +254,11 @@ export default function ChatPage() {
   useEffect(() => {
     // 上次选择的大模型仍存在时保持不动，避免切换选项卡/状态刷新后被自动换掉
     if (selectedModelId && models.some((m) => m.id === selectedModelId)) return;
+    // 智能体指定了默认大模型且可用时，优先使用
+    if (agent?.model_id && models.some((m) => m.id === agent.model_id)) {
+      setSelectedModelId(agent.model_id);
+      return;
+    }
     if (availableModels.length === 0) {
       if (selectedModelId) setSelectedModelId("");
       return;
@@ -232,7 +266,7 @@ export default function ChatPage() {
     if (!availableModels.some((x) => x.model.id === selectedModelId)) {
       setSelectedModelId(availableModels[0].model.id);
     }
-  }, [models, availableModels, selectedModelId]);
+  }, [models, availableModels, selectedModelId, agent?.model_id]);
 
   useEffect(() => {
     function onMouseDown(e: MouseEvent) {
@@ -342,7 +376,7 @@ export default function ChatPage() {
       });
       setStreaming(false);
       setToolStatus(null);
-      refreshConversations();
+      refreshConversations(agent?.id);
     });
     const un3 = onEvent<ChatErrorEvent>("chat://error", (e) => {
       if (e.conversation_id !== activeConvId) return;
@@ -370,7 +404,7 @@ export default function ChatPage() {
       );
     });
     const un5 = onEvent<ChatTitleUpdatedEvent>("chat://title-updated", () => {
-      refreshConversations();
+      refreshConversations(agent?.id);
     });
     const un6 = onEvent<ChatToolStatusEvent>("chat://tool-status", (e) => {
       if (e.conversation_id !== activeConvId) return;
@@ -387,7 +421,7 @@ export default function ChatPage() {
       un5.then((f) => f());
       un6.then((f) => f());
     };
-  }, [activeConvId, refreshConversations, resolveModelName]);
+  }, [activeConvId, refreshConversations, resolveModelName, agent?.id]);
 
   function appendStreamingPlaceholder(modelName?: string) {
     setMessages((prev) => [
@@ -426,13 +460,17 @@ export default function ChatPage() {
 
     let convId = activeConvId;
     if (!convId) {
-      const conv = await api.createConversation(content.slice(0, 30) || "新会话");
+      const conv = await api.createConversation(
+        content.slice(0, 30) || "新会话",
+        undefined,
+        agent?.id,
+      );
       convId = conv.id;
       if (selectedTools.length > 0) {
         await api.setConversationTools(convId, selectedTools);
       }
       setActiveConvId(convId);
-      await refreshConversations();
+      await refreshConversations(agent?.id);
     }
 
     const tempUserId = `user-${Date.now()}`;
@@ -570,7 +608,11 @@ export default function ChatPage() {
   }
 
   async function handleNewConversation() {
-    const conv = await api.createConversation("新会话", selectedModelId || undefined);
+    const conv = await api.createConversation(
+      "新会话",
+      selectedModelId || undefined,
+      agent?.id,
+    );
     if (selectedTools.length > 0) {
       await api.setConversationTools(conv.id, selectedTools);
     }
@@ -578,7 +620,7 @@ export default function ChatPage() {
     setMessages([]);
     setError(null);
     setVersionsFor({});
-    await refreshConversations();
+    await refreshConversations(agent?.id);
   }
 
   async function handleLoadConversation(id: string) {
@@ -599,7 +641,7 @@ export default function ChatPage() {
     if (activeConvId) {
       try {
         await api.setConversationTools(activeConvId, next);
-        await refreshConversations();
+        await refreshConversations(agent?.id);
       } catch (e) {
         alert(String(e));
       }
@@ -612,7 +654,7 @@ export default function ChatPage() {
       setActiveConvId(null);
       setMessages([]);
     }
-    await refreshConversations();
+    await refreshConversations(agent?.id);
   }
 
   async function handleRenameConversation(c: Conversation) {
@@ -620,7 +662,7 @@ export default function ChatPage() {
     if (!title || !title.trim()) return;
     try {
       await api.renameConversation(c.id, title.trim());
-      await refreshConversations();
+      await refreshConversations(agent?.id);
     } catch (e) {
       alert(String(e));
     }
@@ -629,7 +671,7 @@ export default function ChatPage() {
   async function handleTogglePin(c: Conversation) {
     try {
       await api.setConversationPinned(c.id, !c.pinned);
-      await refreshConversations();
+      await refreshConversations(agent?.id);
     } catch (e) {
       alert(String(e));
     }
@@ -638,7 +680,7 @@ export default function ChatPage() {
   async function handleToggleFavorite(c: Conversation) {
     try {
       await api.setConversationFavorite(c.id, !c.favorite);
-      await refreshConversations();
+      await refreshConversations(agent?.id);
     } catch (e) {
       alert(String(e));
     }
@@ -690,7 +732,7 @@ export default function ChatPage() {
         model_id: typeof data.model_id === "string" ? data.model_id : null,
         messages,
       });
-      await refreshConversations();
+      await refreshConversations(agent?.id);
       alert("导入成功");
     } catch (e) {
       alert(`导入失败：${String(e)}`);
@@ -851,11 +893,35 @@ export default function ChatPage() {
       </div>
 
       <div className="flex flex-1 flex-col">
+        {agent ? (
+          <div className="flex items-center gap-3 border-b border-border bg-panel px-5 py-3">
+            <div className="flex h-10 w-10 shrink-0 items-center justify-center rounded-xl bg-panel-2 text-2xl">
+              {agent.icon || "🤖"}
+            </div>
+            <div className="min-w-0 flex-1">
+              <div className="flex items-center gap-2 text-sm font-semibold">
+                <span className="truncate">{agent.name}</span>
+                <span className="shrink-0 rounded bg-panel-2 px-1.5 py-0.5 text-[10px] text-slate-400">
+                  {agent.kind === "preset" ? "预制" : "自定义"}
+                </span>
+              </div>
+              <div className="truncate text-xs text-slate-400">{agent.description}</div>
+            </div>
+            <Link
+              to="/agents"
+              className="shrink-0 rounded-lg border border-border bg-panel-2 px-3 py-1.5 text-xs text-slate-300 hover:text-white"
+            >
+              ← 返回智能体
+            </Link>
+          </div>
+        ) : null}
         <div className="flex-1 space-y-4 overflow-auto p-6">
           {messages.length === 0 && !error ? (
             <div className="mt-24 text-center text-sm text-slate-500">
-              <div className="mb-2 text-3xl">💬</div>
-              选择左侧会话，或直接开始新的对话。
+              <div className="mb-2 text-3xl">{agent ? agent.icon || "🤖" : "💬"}</div>
+              {agent
+                ? `与「${agent.name}」开始对话吧，它的人设与能力已通过系统提示词生效。`
+                : "选择左侧会话，或直接开始新的对话。"}
               <div className="mt-1 text-xs text-slate-600">
                 支持上传/粘贴图片与文本文件（本地文本模型仅支持文本文件）
               </div>
diff --git a/ui/src/pages/WorkflowCanvasPage.tsx b/ui/src/pages/WorkflowCanvasPage.tsx
new file mode 100644
index 0000000..38a15e7
--- /dev/null
+++ b/ui/src/pages/WorkflowCanvasPage.tsx
@@ -0,0 +1,807 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import type { PointerEvent as ReactPointerEvent } from "react";
+import { Link, useParams } from "react-router-dom";
+import {
+  api,
+  ModelInfo,
+  onEvent,
+  WorkflowEdge,
+  WorkflowNode,
+  WorkflowNodeStatusEvent,
+  WorkflowRunResult,
+} from "../api";
+import { useStore } from "../store";
+import Icon from "../components/Icon";
+
+const NODE_W = 230;
+const PORT_Y = 18;
+
+const NODE_META: Record<
+  string,
+  { label: string; icon: string; color: string; desc: string }
+> = {
+  start: { label: "开始", icon: "▶", color: "text-emerald-300", desc: "工作流入口，提供 {{input}}" },
+  llm: { label: "大模型", icon: "✦", color: "text-sky-300", desc: "调用大模型执行提示词" },
+  text: { label: "文本", icon: "T", color: "text-amber-300", desc: "静态文本内容，可被引用" },
+  end: { label: "输出", icon: "■", color: "text-rose-300", desc: "决定最终输出" },
+};
+
+interface NodeRunState {
+  status: string;
+  text: string | null;
+}
+
+function defaultData(type: string): WorkflowNode["data"] {
+  if (type === "llm") {
+    return { prompt: "", model_id: null, temperature: 0.7, max_tokens: 2048 };
+  }
+  if (type === "text") return { content: "" };
+  if (type === "end") return { template: "" };
+  return {};
+}
+
+export default function WorkflowCanvasPage() {
+  const { workflowId } = useParams<{ workflowId: string }>();
+  const workflows = useStore((s) => s.workflows);
+  const workflowsLoaded = useStore((s) => s.workflowsLoaded);
+  const refreshWorkflows = useStore((s) => s.refreshWorkflows);
+  const models = useStore((s) => s.models);
+  const refreshModels = useStore((s) => s.refreshModels);
+
+  const workflow = workflows.find((w) => w.id === workflowId);
+
+  const [name, setName] = useState("");
+  const [icon, setIcon] = useState("🔀");
+  const [description, setDescription] = useState("");
+  const [modelId, setModelId] = useState<string | null>(null);
+  const [enabled, setEnabled] = useState(true);
+  const [nodes, setNodes] = useState<WorkflowNode[]>([]);
+  const [edges, setEdges] = useState<WorkflowEdge[]>([]);
+  const [selectedNodeId, setSelectedNodeId] = useState<string | null>(null);
+
+  const [dragNode, setDragNode] = useState<{
+    id: string;
+    startX: number;
+    startY: number;
+    origX: number;
+    origY: number;
+  } | null>(null);
+  const [tempEdge, setTempEdge] = useState<{
+    from: string;
+    x: number;
+    y: number;
+  } | null>(null);
+
+  const [runInput, setRunInput] = useState("");
+  const [runModelId, setRunModelId] = useState<string | null>(null);
+  const [running, setRunning] = useState(false);
+  const [nodeStatus, setNodeStatus] = useState<Record<string, NodeRunState>>({});
+  const [runResult, setRunResult] = useState<WorkflowRunResult | null>(null);
+  const [runError, setRunError] = useState<string | null>(null);
+  const [msg, setMsg] = useState<string | null>(null);
+
+  const canvasRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    refreshWorkflows();
+    refreshModels();
+  }, [refreshWorkflows, refreshModels]);
+
+  // 工作流加载/切换时同步本地编辑状态
+  useEffect(() => {
+    if (!workflow) return;
+    setName(workflow.name);
+    setIcon(workflow.icon);
+    setDescription(workflow.description);
+    setModelId(workflow.model_id);
+    setEnabled(workflow.enabled);
+    setNodes(workflow.nodes);
+    setEdges(workflow.edges);
+    setSelectedNodeId(null);
+    setNodeStatus({});
+    setRunResult(null);
+    setRunError(null);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [workflow?.id]);
+
+  // 订阅节点运行状态事件
+  useEffect(() => {
+    if (!workflow?.id) return;
+    const un = onEvent<WorkflowNodeStatusEvent>("workflow://node-status", (e) => {
+      if (e.workflow_id !== workflow.id) return;
+      setNodeStatus((prev) => ({
+        ...prev,
+        [e.node_id]: {
+          status: e.status,
+          text: e.text ?? prev[e.node_id]?.text ?? null,
+        },
+      }));
+    });
+    return () => {
+      un.then((f) => f());
+    };
+  }, [workflow?.id]);
+
+  const selectedNode = useMemo(
+    () => nodes.find((n) => n.id === selectedNodeId) ?? null,
+    [nodes, selectedNodeId],
+  );
+
+  const modelNameById = useMemo(() => {
+    const map = new Map<string, string>();
+    for (const m of models) map.set(m.id, m.file_name.replace(/\.gguf$/i, ""));
+    return map;
+  }, [models]);
+
+  function canvasPoint(clientX: number, clientY: number) {
+    const rect = canvasRef.current?.getBoundingClientRect();
+    return { x: clientX - (rect?.left ?? 0), y: clientY - (rect?.top ?? 0) };
+  }
+
+  function updateNode(id: string, patch: Partial<WorkflowNode>) {
+    setNodes((prev) => prev.map((n) => (n.id === id ? { ...n, ...patch } : n)));
+  }
+
+  function updateNodeData(id: string, patch: Partial<WorkflowNode["data"]>) {
+    setNodes((prev) =>
+      prev.map((n) => (n.id === id ? { ...n, data: { ...n.data, ...patch } } : n)),
+    );
+  }
+
+  function addNode(type: string) {
+    const count = nodes.length;
+    const id = `n_${Date.now().toString(36)}${Math.floor(Math.random() * 1000)}`;
+    const meta = NODE_META[type] ?? { label: type, icon: "?", desc: "" };
+    const node: WorkflowNode = {
+      id,
+      type,
+      label: meta.label,
+      position: { x: 320 + (count % 3) * 40, y: 160 + (count % 4) * 50 },
+      data: defaultData(type),
+    };
+    setNodes((prev) => [...prev, node]);
+    setSelectedNodeId(id);
+  }
+
+  function startNodeDrag(e: ReactPointerEvent, node: WorkflowNode) {
+    e.stopPropagation();
+    setSelectedNodeId(node.id);
+    const p = canvasPoint(e.clientX, e.clientY);
+    setDragNode({
+      id: node.id,
+      startX: p.x,
+      startY: p.y,
+      origX: node.position.x,
+      origY: node.position.y,
+    });
+  }
+
+  function startTempEdge(nodeId: string, e: ReactPointerEvent) {
+    e.stopPropagation();
+    const p = canvasPoint(e.clientX, e.clientY);
+    setTempEdge({ from: nodeId, x: p.x, y: p.y });
+  }
+
+  useEffect(() => {
+    if (!dragNode && !tempEdge) return;
+    function onMove(e: PointerEvent) {
+      const p = canvasPoint(e.clientX, e.clientY);
+      if (dragNode) {
+        setNodes((prev) =>
+          prev.map((n) =>
+            n.id === dragNode.id
+              ? {
+                  ...n,
+                  position: {
+                    x: dragNode.origX + (p.x - dragNode.startX),
+                    y: dragNode.origY + (p.y - dragNode.startY),
+                  },
+                }
+              : n,
+          ),
+        );
+      }
+      if (tempEdge) {
+        setTempEdge((prev) => (prev ? { ...prev, x: p.x, y: p.y } : prev));
+      }
+    }
+    function onUp(e: PointerEvent) {
+      if (tempEdge) {
+        const el = document.elementFromPoint(e.clientX, e.clientY) as HTMLElement | null;
+        const targetNode = el?.closest("[data-port='input']")?.getAttribute("data-node");
+        if (targetNode && targetNode !== tempEdge.from) {
+          setEdges((prev) => {
+            const rest = prev.filter(
+              (ed) => !(ed.from === tempEdge.from && ed.to === targetNode),
+            );
+            return [
+              ...rest,
+              { id: `e_${Date.now().toString(36)}${Math.floor(Math.random() * 1000)}`, from: tempEdge.from, to: targetNode },
+            ];
+          });
+        }
+        setTempEdge(null);
+      }
+      setDragNode(null);
+    }
+    window.addEventListener("pointermove", onMove);
+    window.addEventListener("pointerup", onUp);
+    return () => {
+      window.removeEventListener("pointermove", onMove);
+      window.removeEventListener("pointerup", onUp);
+    };
+  }, [dragNode, tempEdge]);
+
+  function deleteEdge(id: string) {
+    setEdges((prev) => prev.filter((e) => e.id !== id));
+  }
+
+  function deleteNode(id: string) {
+    setNodes((prev) => prev.filter((n) => n.id !== id));
+    setEdges((prev) => prev.filter((e) => e.from !== id && e.to !== id));
+    if (selectedNodeId === id) setSelectedNodeId(null);
+  }
+
+  async function saveWorkflow(): Promise<boolean> {
+    if (!workflow) return false;
+    try {
+      await api.updateWorkflow(workflow.id, {
+        name: name.trim() || "未命名工作流",
+        icon: icon.trim() || "🔀",
+        description,
+        nodes,
+        edges,
+        model_id: modelId,
+        enabled,
+      });
+      await refreshWorkflows();
+      setMsg("已保存");
+      return true;
+    } catch (e) {
+      setRunError(`保存失败：${String(e)}`);
+      return false;
+    }
+  }
+
+  async function handleRun() {
+    if (!workflow || running) return;
+    if (nodes.length === 0) {
+      setRunError("画布为空，请先添加节点");
+      return;
+    }
+    const ok = await saveWorkflow();
+    if (!ok) return;
+    setRunning(true);
+    setRunError(null);
+    setRunResult(null);
+    setNodeStatus({});
+    try {
+      const result = await api.runWorkflow({
+        workflow_id: workflow.id,
+        input: runInput,
+        model_id: runModelId,
+      });
+      setRunResult(result);
+      const completed: Record<string, NodeRunState> = {};
+      for (const [nid, text] of Object.entries(result.results)) {
+        completed[nid] = { status: "done", text };
+      }
+      setNodeStatus((prev) => ({ ...prev, ...completed }));
+    } catch (e) {
+      setRunError(String(e));
+    } finally {
+      setRunning(false);
+    }
+  }
+
+  if (!workflowsLoaded) {
+    return (
+      <div className="flex h-full items-center justify-center text-sm text-slate-400">
+        正在加载工作流…
+      </div>
+    );
+  }
+  if (!workflow) {
+    return (
+      <div className="flex h-full flex-col items-center justify-center gap-3 text-sm text-slate-400">
+        <div className="text-4xl">🔀</div>
+        工作流不存在或已被删除
+        <Link to="/workflows" className="btn-secondary">
+          返回工作流列表
+        </Link>
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex h-full flex-col">
+      <div className="flex items-center gap-3 border-b border-border bg-panel px-4 py-2.5">
+        <Link
+          to="/workflows"
+          className="flex items-center gap-1 rounded-lg px-2 py-1 text-xs text-slate-400 hover:bg-panel-2 hover:text-slate-200"
+        >
+          <Icon name="chevron-left" className="h-3.5 w-3.5" />
+          工作流
+        </Link>
+        <input
+          className="input w-52 px-2 py-1 text-sm"
+          value={name}
+          onChange={(e) => setName(e.target.value)}
+          placeholder="工作流名称"
+        />
+        <span
+          className="shrink-0 rounded bg-panel-2 px-1.5 py-0.5 text-[10px] text-slate-400"
+          title="预制工作流可编辑后保存为自定义版本"
+        >
+          {workflow.kind === "preset" ? "预制" : "自定义"}
+        </span>
+        <span className="text-xs text-slate-500">
+          {nodes.length} 节点 · {edges.length} 连线
+        </span>
+        {msg ? <span className="text-xs text-emerald-400">{msg}</span> : null}
+        <div className="ml-auto flex items-center gap-2">
+          <button className="btn-secondary" onClick={() => saveWorkflow()}>
+            保存
+          </button>
+          <button className="btn-primary" onClick={handleRun} disabled={running}>
+            {running ? "运行中…" : "▶ 运行"}
+          </button>
+        </div>
+      </div>
+
+      <div className="flex min-h-0 flex-1">
+        {/* 节点面板 */}
+        <div className="flex w-44 shrink-0 flex-col gap-2 overflow-y-auto border-r border-border bg-panel p-3">
+          <div className="text-xs uppercase text-slate-500">节点</div>
+          {Object.entries(NODE_META).map(([type, meta]) => (
+            <button
+              key={type}
+              className="flex items-center gap-2 rounded-lg border border-border bg-panel-2 px-3 py-2 text-left text-xs text-slate-300 hover:border-accent/50 hover:text-white"
+              onClick={() => addNode(type)}
+              title={meta.desc}
+            >
+              <span className={`text-base ${meta.color}`}>{meta.icon}</span>
+              <span className="flex-1">
+                <span className="block font-medium">{meta.label}</span>
+                <span className="block truncate text-[10px] text-slate-500">{meta.desc}</span>
+              </span>
+              <span className="text-slate-500">＋</span>
+            </button>
+          ))}
+          <div className="mt-2 rounded-lg border border-dashed border-border p-2 text-[10px] leading-relaxed text-slate-500">
+            提示词中可用 <code className="text-slate-300">{"{{input}}"}</code> 与{" "}
+            <code className="text-slate-300">{"{{节点id}}"}</code> 引用上游输出。
+          </div>
+        </div>
+
+        {/* 画布 */}
+        <div className="min-w-0 flex-1 overflow-auto bg-[#0a0d13]">
+          <div ref={canvasRef} className="relative" style={{ width: 1200, height: 720 }}>
+            <svg
+              className="pointer-events-none absolute inset-0"
+              width={1200}
+              height={720}
+            >
+              {edges.map((edge) => {
+                const from = nodes.find((n) => n.id === edge.from);
+                const to = nodes.find((n) => n.id === edge.to);
+                if (!from || !to) return null;
+                const x1 = from.position.x + NODE_W;
+                const y1 = from.position.y + PORT_Y;
+                const x2 = to.position.x;
+                const y2 = to.position.y + PORT_Y;
+                const d = `M ${x1} ${y1} C ${x1 + 80} ${y1}, ${x2 - 80} ${y2}, ${x2} ${y2}`;
+                return (
+                  <g key={edge.id}>
+                    <path
+                      d={d}
+                      fill="none"
+                      stroke="transparent"
+                      strokeWidth={16}
+                      style={{ pointerEvents: "stroke", cursor: "pointer" }}
+                      onClick={() => deleteEdge(edge.id)}
+                    />
+                    <path
+                      d={d}
+                      fill="none"
+                      stroke="#64748b"
+                      strokeWidth={2}
+                      style={{ pointerEvents: "none" }}
+                    />
+                  </g>
+                );
+              })}
+              {tempEdge ? (
+                <path
+                  d={`M ${tempEdge.x} ${tempEdge.y} L ${tempEdge.x} ${tempEdge.y}`}
+                  fill="none"
+                  stroke="#a78bfa"
+                  strokeWidth={2}
+                  strokeDasharray="6 4"
+                />
+              ) : null}
+            </svg>
+            {nodes.map((node) => (
+              <CanvasNode
+                key={node.id}
+                node={node}
+                selected={selectedNodeId === node.id}
+                runState={nodeStatus[node.id] ?? null}
+                onSelect={() => setSelectedNodeId(node.id)}
+                onDragStart={(e) => startNodeDrag(e, node)}
+                onOutputPointerDown={(e) => startTempEdge(node.id, e)}
+              />
+            ))}
+            {nodes.length === 0 ? (
+              <div className="absolute inset-0 flex items-center justify-center text-sm text-slate-600">
+                从左侧添加节点，开始编排工作流
+              </div>
+            ) : null}
+          </div>
+        </div>
+
+        {/* 右侧面板 */}
+        <div className="flex w-80 shrink-0 flex-col gap-4 overflow-y-auto border-l border-border bg-panel p-3">
+          <section>
+            <div className="mb-2 text-xs uppercase text-slate-500">运行工作流</div>
+            <label className="block text-sm">
+              <span className="text-xs text-slate-400">输入内容（{"{{input}}"}）</span>
+              <textarea
+                className="input mt-1 min-h-[80px] resize-y text-xs"
+                value={runInput}
+                onChange={(e) => setRunInput(e.target.value)}
+                placeholder="输入要交给工作流处理的文本…"
+              />
+            </label>
+            <label className="mt-2 block text-sm">
+              <span className="text-xs text-slate-400">大模型（节点未指定时使用）</span>
+              <select
+                className="input mt-1 text-xs"
+                value={runModelId ?? ""}
+                onChange={(e) => setRunModelId(e.target.value || null)}
+              >
+                <option value="">自动选择</option>
+                {models.map((m) => (
+                  <option key={m.id} value={m.id}>
+                    {modelNameById.get(m.id)}
+                    {m.kind === "remote" ? "（API）" : "（本地）"}
+                  </option>
+                ))}
+              </select>
+            </label>
+            {running ? (
+              <div className="mt-2 flex items-center gap-2 text-xs text-amber-300">
+                <span className="h-2 w-2 animate-pulse rounded-full bg-amber-400" />
+                正在执行…
+              </div>
+            ) : null}
+            {runError ? (
+              <div className="mt-2 rounded-lg border border-red-500/40 bg-red-500/10 px-3 py-2 text-xs text-red-300">
+                {runError}
+              </div>
+            ) : null}
+            {runResult ? (
+              <div className="mt-2 rounded-lg border border-emerald-500/40 bg-emerald-500/10 px-3 py-2">
+                <div className="text-xs text-emerald-300">最终输出</div>
+                <div className="mt-1 max-h-40 overflow-y-auto whitespace-pre-wrap text-xs leading-relaxed text-slate-200">
+                  {runResult.final || "（空）"}
+                </div>
+              </div>
+            ) : null}
+          </section>
+
+          <section>
+            <div className="mb-2 text-xs uppercase text-slate-500">节点设置</div>
+            {selectedNode ? (
+              <NodeEditor
+                node={selectedNode}
+                models={models}
+                modelNameById={modelNameById}
+                onChange={(patch) => updateNode(selectedNode.id, patch)}
+                onDataChange={(patch) => updateNodeData(selectedNode.id, patch)}
+                onDelete={() => deleteNode(selectedNode.id)}
+              />
+            ) : (
+              <div className="text-xs text-slate-600">点击画布中的节点进行设置</div>
+            )}
+          </section>
+
+          <section>
+            <div className="mb-2 text-xs uppercase text-slate-500">工作流设置</div>
+            <label className="block text-sm">
+              <span className="text-xs text-slate-400">图标（emoji）</span>
+              <input
+                className="input mt-1 text-xs"
+                value={icon}
+                maxLength={8}
+                onChange={(e) => setIcon(e.target.value)}
+              />
+            </label>
+            <label className="mt-2 block text-sm">
+              <span className="text-xs text-slate-400">描述</span>
+              <input
+                className="input mt-1 text-xs"
+                value={description}
+                onChange={(e) => setDescription(e.target.value)}
+                placeholder="工作流用途说明"
+              />
+            </label>
+            <label className="mt-2 block text-sm">
+              <span className="text-xs text-slate-400">默认大模型（可选）</span>
+              <select
+                className="input mt-1 text-xs"
+                value={modelId ?? ""}
+                onChange={(e) => setModelId(e.target.value || null)}
+              >
+                <option value="">不指定</option>
+                {models.map((m) => (
+                  <option key={m.id} value={m.id}>
+                    {modelNameById.get(m.id)}
+                    {m.kind === "remote" ? "（API）" : "（本地）"}
+                  </option>
+                ))}
+              </select>
+            </label>
+            <label className="mt-3 flex cursor-pointer items-center gap-2 text-xs text-slate-300">
+              <input
+                type="checkbox"
+                checked={enabled}
+                onChange={(e) => setEnabled(e.target.checked)}
+                className="accent-indigo-500"
+              />
+              启用
+            </label>
+          </section>
+
+          <section>
+            <div className="mb-2 text-xs uppercase text-slate-500">各节点输出</div>
+            {Object.keys(nodeStatus).length === 0 ? (
+              <div className="text-xs text-slate-600">运行工作流后在此查看每个节点的输出</div>
+            ) : (
+              <div className="space-y-2">
+                {nodes.map((n) => {
+                  const st = nodeStatus[n.id];
+                  if (!st) return null;
+                  return (
+                    <div key={n.id} className="rounded-lg border border-border bg-panel-2 px-2.5 py-2">
+                      <div className="flex items-center gap-1.5 text-xs text-slate-300">
+                        <span
+                          className={`h-1.5 w-1.5 rounded-full ${
+                            st.status === "done"
+                              ? "bg-emerald-400"
+                              : st.status === "running"
+                                ? "animate-pulse bg-amber-400"
+                                : "bg-red-400"
+                          }`}
+                        />
+                        {n.label}
+                      </div>
+                      {st.text != null ? (
+                        <div className="mt-1 line-clamp-3 whitespace-pre-wrap text-[11px] text-slate-500">
+                          {st.text}
+                        </div>
+                      ) : null}
+                    </div>
+                  );
+                })}
+              </div>
+            )}
+          </section>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function CanvasNode({
+  node,
+  selected,
+  runState,
+  onSelect,
+  onDragStart,
+  onOutputPointerDown,
+}: {
+  node: WorkflowNode;
+  selected: boolean;
+  runState: NodeRunState | null;
+  onSelect: () => void;
+  onDragStart: (e: ReactPointerEvent) => void;
+  onOutputPointerDown: (e: ReactPointerEvent) => void;
+}) {
+  const meta = NODE_META[node.type] ?? { label: node.type, icon: "?", color: "text-slate-300", desc: "" };
+  const statusColor =
+    runState?.status === "done"
+      ? "border-emerald-500/60"
+      : runState?.status === "running"
+        ? "border-amber-500/70"
+        : runState?.status === "error"
+          ? "border-red-500/70"
+          : "border-border";
+  const preview =
+    node.type === "llm"
+      ? node.data.prompt
+      : node.type === "text"
+        ? node.data.content
+        : node.type === "end"
+          ? node.data.template
+          : "输入 → {{input}}";
+
+  return (
+    <div
+      className={`absolute rounded-xl border bg-panel shadow-lg transition-colors ${statusColor} ${
+        selected ? "ring-2 ring-accent/70" : ""
+      }`}
+      style={{ left: node.position.x, top: node.position.y, width: NODE_W }}
+      onClick={(e) => {
+        e.stopPropagation();
+        onSelect();
+      }}
+    >
+      <div
+        className="flex cursor-grab items-center gap-2 rounded-t-xl border-b border-border/60 bg-panel-2 px-3 py-1.5 active:cursor-grabbing"
+        onPointerDown={onDragStart}
+        title="拖动调整位置"
+      >
+        <span className={`text-sm ${meta.color}`}>{meta.icon}</span>
+        <span className="min-w-0 flex-1 truncate text-xs font-medium text-slate-200">
+          {node.label}
+        </span>
+        <span className="truncate text-[10px] text-slate-500">{node.id}</span>
+      </div>
+      <div className="px-3 py-2">
+        <div className="line-clamp-2 whitespace-pre-wrap text-[11px] text-slate-400">
+          {preview || "（空）"}
+        </div>
+        {runState?.text != null ? (
+          <div className="mt-1.5 rounded bg-panel-2 px-2 py-1 line-clamp-2 whitespace-pre-wrap text-[10px] text-emerald-300/90">
+            {runState.text}
+          </div>
+        ) : null}
+        {runState?.status === "running" ? (
+          <div className="mt-1.5 flex items-center gap-1.5 text-[10px] text-amber-300">
+            <span className="h-1.5 w-1.5 animate-pulse rounded-full bg-amber-400" />
+            运行中…
+          </div>
+        ) : null}
+      </div>
+      <div
+        data-port="input"
+        data-node={node.id}
+        className="absolute -left-1.5 top-[18px] h-3 w-3 cursor-crosshair rounded-full border-2 border-border bg-slate-500 hover:bg-accent"
+        title="输入端口"
+        onPointerDown={(e) => e.stopPropagation()}
+      />
+      <div
+        data-port="output"
+        data-node={node.id}
+        className="absolute -right-1.5 top-[18px] h-3 w-3 cursor-crosshair rounded-full border-2 border-border bg-accent hover:bg-accent-2"
+        title="拖动到其他节点的输入端口建立连线"
+        onPointerDown={onOutputPointerDown}
+      />
+    </div>
+  );
+}
+
+function NodeEditor({
+  node,
+  models,
+  modelNameById,
+  onChange,
+  onDataChange,
+  onDelete,
+}: {
+  node: WorkflowNode;
+  models: ModelInfo[];
+  modelNameById: Map<string, string>;
+  onChange: (patch: Partial<WorkflowNode>) => void;
+  onDataChange: (patch: Partial<WorkflowNode["data"]>) => void;
+  onDelete: () => void;
+}) {
+  return (
+    <div className="space-y-2">
+      <label className="block text-sm">
+        <span className="text-xs text-slate-400">节点名称</span>
+        <input
+          className="input mt-1 text-xs"
+          value={node.label}
+          onChange={(e) => onChange({ label: e.target.value })}
+        />
+      </label>
+      {node.type === "start" ? (
+        <div className="text-xs leading-relaxed text-slate-500">
+          开始节点提供工作流输入，其他节点可用{" "}
+          <code className="rounded bg-panel-2 px-1">{"{{input}}"}</code> 引用。
+        </div>
+      ) : null}
+      {node.type === "llm" ? (
+        <>
+          <label className="block text-sm">
+            <span className="text-xs text-slate-400">提示词模板</span>
+            <textarea
+              className="input mt-1 min-h-[110px] resize-y text-xs"
+              value={node.data.prompt ?? ""}
+              onChange={(e) => onDataChange({ prompt: e.target.value })}
+              placeholder={"例如：请翻译以下内容：\n{{input}}"}
+            />
+            <span className="mt-0.5 block text-[10px] text-slate-600">
+              可用 {"{{input}}"} 与 {"{{节点id}}"} 引用上游节点输出
+            </span>
+          </label>
+          <label className="block text-sm">
+            <span className="text-xs text-slate-400">大模型（留空则自动选择）</span>
+            <select
+              className="input mt-1 text-xs"
+              value={node.data.model_id ?? ""}
+              onChange={(e) => onDataChange({ model_id: e.target.value || null })}
+            >
+              <option value="">自动选择</option>
+              {models.map((m) => (
+                <option key={m.id} value={m.id}>
+                  {modelNameById.get(m.id)}
+                  {m.kind === "remote" ? "（API）" : "（本地）"}
+                </option>
+              ))}
+            </select>
+          </label>
+          <div className="grid grid-cols-2 gap-2">
+            <label className="block text-sm">
+              <span className="text-xs text-slate-400">temperature</span>
+              <input
+                type="number"
+                step={0.05}
+                min={0}
+                max={2}
+                className="input mt-1 text-xs"
+                value={node.data.temperature ?? 0.7}
+                onChange={(e) => onDataChange({ temperature: Number(e.target.value) })}
+              />
+            </label>
+            <label className="block text-sm">
+              <span className="text-xs text-slate-400">max_tokens</span>
+              <input
+                type="number"
+                step={64}
+                min={64}
+                max={8192}
+                className="input mt-1 text-xs"
+                value={node.data.max_tokens ?? 2048}
+                onChange={(e) => onDataChange({ max_tokens: Number(e.target.value) })}
+              />
+            </label>
+          </div>
+        </>
+      ) : null}
+      {node.type === "text" ? (
+        <label className="block text-sm">
+          <span className="text-xs text-slate-400">文本内容</span>
+          <textarea
+            className="input mt-1 min-h-[110px] resize-y text-xs"
+            value={node.data.content ?? ""}
+            onChange={(e) => onDataChange({ content: e.target.value })}
+            placeholder="例如：风格要求：面向技术读者，简洁……"
+          />
+          <span className="mt-0.5 block text-[10px] text-slate-600">
+            其他节点可用 <code>{"{{节点id}}"}</code> 引用本内容
+          </span>
+        </label>
+      ) : null}
+      {node.type === "end" ? (
+        <label className="block text-sm">
+          <span className="text-xs text-slate-400">输出模板（留空自动取上游输出）</span>
+          <textarea
+            className="input mt-1 min-h-[80px] resize-y text-xs"
+            value={node.data.template ?? ""}
+            onChange={(e) => onDataChange({ template: e.target.value })}
+            placeholder='例如：{{n_llm}}'
+          />
+        </label>
+      ) : null}
+      <button
+        className="mt-1 w-full rounded-lg border border-red-500/40 bg-red-500/10 px-3 py-1.5 text-xs text-red-300 hover:bg-red-500/20"
+        onClick={onDelete}
+      >
+        删除节点（含相关连线）
+      </button>
+    </div>
+  );
+}
diff --git a/ui/src/pages/WorkflowsPage.tsx b/ui/src/pages/WorkflowsPage.tsx
new file mode 100644
index 0000000..cf18b7b
--- /dev/null
+++ b/ui/src/pages/WorkflowsPage.tsx
@@ -0,0 +1,289 @@
+import { useEffect, useMemo, useState } from "react";
+import { useNavigate } from "react-router-dom";
+import { api, Workflow, WorkflowInput, WorkflowNode } from "../api";
+import { useStore } from "../store";
+import Icon from "../components/Icon";
+
+function defaultGraph(): { nodes: WorkflowNode[]; edges: Workflow["edges"] } {
+  return {
+    nodes: [
+      {
+        id: "n_start",
+        type: "start",
+        label: "开始",
+        position: { x: 70, y: 190 },
+        data: {},
+      },
+      {
+        id: "n_llm",
+        type: "llm",
+        label: "大模型",
+        position: { x: 340, y: 170 },
+        data: { prompt: "", model_id: null, temperature: 0.7, max_tokens: 2048 },
+      },
+      {
+        id: "n_end",
+        type: "end",
+        label: "输出",
+        position: { x: 620, y: 190 },
+        data: { template: "{{n_llm}}" },
+      },
+    ],
+    edges: [
+      { id: "e1", from: "n_start", to: "n_llm" },
+      { id: "e2", from: "n_llm", to: "n_end" },
+    ],
+  };
+}
+
+export default function WorkflowsPage() {
+  const workflows = useStore((s) => s.workflows);
+  const refreshWorkflows = useStore((s) => s.refreshWorkflows);
+  const refreshModels = useStore((s) => s.refreshModels);
+  const models = useStore((s) => s.models);
+  const navigate = useNavigate();
+  const [msg, setMsg] = useState<string | null>(null);
+  const [busy, setBusy] = useState(false);
+
+  useEffect(() => {
+    refreshWorkflows();
+    refreshModels();
+  }, [refreshWorkflows, refreshModels]);
+
+  const presets = useMemo(
+    () => workflows.filter((w) => w.kind === "preset"),
+    [workflows],
+  );
+  const customs = useMemo(
+    () => workflows.filter((w) => w.kind === "custom"),
+    [workflows],
+  );
+
+  const modelNameById = useMemo(() => {
+    const map = new Map<string, string>();
+    for (const m of models) map.set(m.id, m.file_name.replace(/\.gguf$/i, ""));
+    return map;
+  }, [models]);
+
+  async function handleNewWorkflow() {
+    setBusy(true);
+    try {
+      const graph = defaultGraph();
+      const input: WorkflowInput = {
+        name: "未命名工作流",
+        icon: "🔀",
+        description: "",
+        nodes: graph.nodes,
+        edges: graph.edges,
+        model_id: null,
+        enabled: true,
+      };
+      const wf = await api.addWorkflow(input);
+      await refreshWorkflows();
+      navigate(`/workflows/${wf.id}`);
+    } catch (e) {
+      setMsg(`新建失败：${String(e)}`);
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  async function handleToggle(wf: Workflow) {
+    try {
+      await api.setWorkflowEnabled(wf.id, !wf.enabled);
+      await refreshWorkflows();
+    } catch (e) {
+      setMsg(`操作失败：${String(e)}`);
+    }
+  }
+
+  async function handleDelete(wf: Workflow) {
+    if (!confirm(`确定删除工作流「${wf.name}」吗？`)) return;
+    try {
+      await api.removeWorkflow(wf.id);
+      setMsg("工作流已删除");
+      await refreshWorkflows();
+    } catch (e) {
+      setMsg(`删除失败：${String(e)}`);
+    }
+  }
+
+  async function handleRestorePresets() {
+    setBusy(true);
+    try {
+      const n = await api.restorePresetWorkflows();
+      setMsg(n > 0 ? `已恢复 ${n} 个预制工作流` : "预制工作流已齐全，无需恢复");
+      await refreshWorkflows();
+    } catch (e) {
+      setMsg(`恢复失败：${String(e)}`);
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  return (
+    <div className="h-full overflow-auto p-6">
+      <div className="mb-4 flex items-start justify-between gap-4">
+        <div>
+          <h1 className="text-xl font-semibold">工作流</h1>
+          <p className="mt-1 text-sm text-slate-400">
+            在画布上编排「开始 → 大模型 / 文本 → 输出」节点，节点之间连线传参，一键运行；支持本地与在线大模型
+          </p>
+        </div>
+        <div className="flex shrink-0 gap-2">
+          <button className="btn-secondary" onClick={handleRestorePresets} disabled={busy}>
+            恢复预制工作流
+          </button>
+          <button className="btn-primary" onClick={handleNewWorkflow} disabled={busy}>
+            + 新建工作流
+          </button>
+        </div>
+      </div>
+
+      {msg ? (
+        <div className="mb-4 flex items-center justify-between rounded-lg border border-border bg-panel px-4 py-2 text-xs text-slate-300">
+          <span>{msg}</span>
+          <button className="text-slate-500 hover:text-slate-200" onClick={() => setMsg(null)}>
+            ×
+          </button>
+        </div>
+      ) : null}
+
+      {presets.length > 0 ? (
+        <section className="mb-6">
+          <div className="mb-2 text-xs uppercase text-slate-500">预制工作流</div>
+          <div className="grid grid-cols-2 gap-3 xl:grid-cols-3">
+            {presets.map((wf) => (
+              <WorkflowCard
+                key={wf.id}
+                workflow={wf}
+                modelNameById={modelNameById}
+                onOpen={() => navigate(`/workflows/${wf.id}`)}
+                onToggle={() => handleToggle(wf)}
+                onDelete={() => handleDelete(wf)}
+              />
+            ))}
+          </div>
+        </section>
+      ) : null}
+
+      <section>
+        <div className="mb-2 text-xs uppercase text-slate-500">自定义工作流</div>
+        {customs.length === 0 ? (
+          <div className="rounded-xl border border-dashed border-border bg-panel/50 px-4 py-8 text-center text-sm text-slate-500">
+            还没有自定义工作流，点击右上角「新建工作流」在画布上创建
+          </div>
+        ) : (
+          <div className="grid grid-cols-2 gap-3 xl:grid-cols-3">
+            {customs.map((wf) => (
+              <WorkflowCard
+                key={wf.id}
+                workflow={wf}
+                modelNameById={modelNameById}
+                onOpen={() => navigate(`/workflows/${wf.id}`)}
+                onToggle={() => handleToggle(wf)}
+                onDelete={() => handleDelete(wf)}
+              />
+            ))}
+          </div>
+        )}
+      </section>
+
+      <div className="mt-8 rounded-xl border border-border bg-panel p-4 text-xs leading-relaxed text-slate-400">
+        <div className="mb-1 font-medium text-slate-300">使用说明</div>
+        <ul className="list-inside list-disc space-y-1">
+          <li>画布上节点从上到下/从左到右执行，连线表示数据流：LLM 节点的提示词里用{" "}
+            <code className="rounded bg-panel-2 px-1">{"{{input}}"}</code> 引用运行输入，用{" "}
+            <code className="rounded bg-panel-2 px-1">{"{{节点id}}"}</code> 引用上游节点输出；</li>
+          <li>「文本」节点提供静态内容（如风格要求），「结束」节点决定最终输出内容；</li>
+          <li>点击节点右侧圆点拖到另一节点左侧圆点可连线，点击连线可删除；运行前会自动保存画布。</li>
+        </ul>
+      </div>
+    </div>
+  );
+}
+
+function WorkflowCard({
+  workflow,
+  modelNameById,
+  onOpen,
+  onToggle,
+  onDelete,
+}: {
+  workflow: Workflow;
+  modelNameById: Map<string, string>;
+  onOpen: () => void;
+  onToggle: () => void;
+  onDelete: () => void;
+}) {
+  return (
+    <div
+      className={`flex flex-col rounded-xl border border-border bg-panel p-4 ${
+        workflow.enabled ? "" : "opacity-60"
+      }`}
+    >
+      <div className="flex items-start gap-3">
+        <div className="flex h-11 w-11 shrink-0 items-center justify-center rounded-xl bg-panel-2 text-2xl">
+          {workflow.icon || "🔀"}
+        </div>
+        <div className="min-w-0 flex-1">
+          <div className="flex items-center gap-2">
+            <span className="truncate text-sm font-semibold">{workflow.name}</span>
+            <span className="shrink-0 rounded bg-panel-2 px-1.5 py-0.5 text-[10px] text-slate-400">
+              {workflow.kind === "preset" ? "预制" : "自定义"}
+            </span>
+          </div>
+          <div className="mt-0.5 line-clamp-2 text-xs text-slate-400">
+            {workflow.description || "（无描述）"}
+          </div>
+        </div>
+        <Toggle checked={workflow.enabled} onChange={onToggle} />
+      </div>
+      <div className="mt-2 truncate text-[11px] text-slate-500">
+        {workflow.nodes.length} 个节点 · {workflow.edges.length} 条连线
+        {workflow.model_id && modelNameById.has(workflow.model_id)
+          ? ` · 默认模型：${modelNameById.get(workflow.model_id)}`
+          : ""}
+      </div>
+      <div className="mt-3 flex items-center gap-2">
+        <button className="btn-primary flex-1 px-2 py-1.5 text-xs" onClick={onOpen}>
+          <Icon name="workflow" className="mr-1 inline h-3.5 w-3.5" />
+          打开画布
+        </button>
+        <button
+          className="rounded-lg border border-border bg-panel-2 px-2.5 py-1.5 text-xs text-slate-400 hover:text-red-400"
+          onClick={onDelete}
+          title="删除"
+        >
+          <Icon name="trash" className="h-3.5 w-3.5" />
+        </button>
+      </div>
+    </div>
+  );
+}
+
+function Toggle({
+  checked,
+  onChange,
+}: {
+  checked: boolean;
+  onChange: (v: boolean) => void;
+}) {
+  return (
+    <button
+      type="button"
+      role="switch"
+      aria-checked={checked}
+      onClick={() => onChange(!checked)}
+      className={`relative h-6 w-11 shrink-0 rounded-full transition-colors ${
+        checked ? "bg-accent" : "bg-panel-2"
+      }`}
+    >
+      <span
+        className={`absolute top-0.5 h-5 w-5 rounded-full bg-white shadow transition-all ${
+          checked ? "left-[22px]" : "left-0.5"
+        }`}
+      />
+    </button>
+  );
+}
diff --git a/ui/src/store.ts b/ui/src/store.ts
index 07388c1..ec61f09 100644
--- a/ui/src/store.ts
+++ b/ui/src/store.ts
@@ -1,7 +1,20 @@
 import { create } from "zustand";
-import { api, Conversation, EngineStatus, ModelInfo, ServerStatus } from "./api";
+import {
+  api,
+  Agent,
+  Conversation,
+  EngineStatus,
+  ModelInfo,
+  ServerStatus,
+  Workflow,
+} from "./api";
 
 interface Store {
+  agents: Agent[];
+  agentsLoaded: boolean;
+  agentConversations: Record<string, Conversation[]>;
+  workflows: Workflow[];
+  workflowsLoaded: boolean;
   models: ModelInfo[];
   engine: EngineStatus | null;
   server: ServerStatus | null;
@@ -15,10 +28,12 @@ interface Store {
   setChatSuggestions: (messageId: string, suggestions: string[]) => void;
   upsertTask: (task: TaskItem) => void;
   clearFinishedTasks: () => void;
+  refreshAgents: () => Promise<void>;
+  refreshWorkflows: () => Promise<void>;
   refreshModels: () => Promise<void>;
   refreshEngine: () => Promise<void>;
   refreshServer: () => Promise<void>;
-  refreshConversations: () => Promise<void>;
+  refreshConversations: (agentId?: string) => Promise<void>;
 }
 
 export interface TaskItem {
@@ -33,6 +48,11 @@ export interface TaskItem {
 }
 
 export const useStore = create<Store>((set) => ({
+  agents: [],
+  agentsLoaded: false,
+  agentConversations: {},
+  workflows: [],
+  workflowsLoaded: false,
   models: [],
   engine: null,
   server: null,
@@ -60,9 +80,25 @@ export const useStore = create<Store>((set) => ({
     }),
   clearFinishedTasks: () =>
     set((s) => ({ tasks: s.tasks.filter((t) => t.status === "running") })),
+  refreshAgents: async () => {
+    const agents = await api.listAgents();
+    set({ agents, agentsLoaded: true });
+  },
+  refreshWorkflows: async () => {
+    const workflows = await api.listWorkflows();
+    set({ workflows, workflowsLoaded: true });
+  },
   refreshModels: async () => set({ models: await api.listModels() }),
   refreshEngine: async () => set({ engine: await api.engineStatus() }),
   refreshServer: async () => set({ server: await api.serverStatus() }),
-  refreshConversations: async () =>
-    set({ conversations: await api.listConversations() }),
+  refreshConversations: async (agentId) => {
+    const list = await api.listConversations(agentId);
+    if (agentId) {
+      set((s) => ({
+        agentConversations: { ...s.agentConversations, [agentId]: list },
+      }));
+    } else {
+      set({ conversations: list });
+    }
+  },
 }));