会话并行

一句话定义:会话并行是 DriFox 提供的多实例并发执行能力,允许用户同时打开多个独立的对话窗口,每个窗口拥有独立的上下文、工具和智能体配置,实现多任务并行探索与处理。

DriFox 会话并行界面

功能概览

  • 分支会话 — 从当前对话分叉,创建独立的新窗口,继承上下文或全新开始

  • 会话管理 — 查看最近会话和最活跃会话,方便任务切换

  • 并行探索 — 多个窗口同时运行,互不干扰,各自持有独立的状态

  • 待办追踪 — 内置待办清单功能,跟踪任务进度

技术定位对比

特性

会话并行 (DriFox)

多标签页 (传统IDE)

多进程模式

上下文隔离

✓ 完全独立

✗ 共享全局状态

✓ 完全独立

资源占用

轻量(线程级)

轻量

较重(进程级)

状态同步

手动(可选)

共享文件系统

IPC通信

适用场景

多方案探索

文件浏览切换

独立任务执行

启动开销

即时

即时

秒级

特性

会话并行 (DriFox)

SubAgent DAG

传统单会话

并发模型

用户手动多窗口

自动拓扑并行

单一顺序

上下文关系

完全独立或分支

上游→下游传递

单一连续

控制粒度

全局窗口级

节点级任务级

消息级

适用任务类型

人机交互探索

自动化流水线

简单问答

架构设计

数据流架构图

┌─────────────────────────────────────────────────────────────────────┐
│                         DriFox 主进程                                │
│  ┌─────────────────────────────────────────────────────────────────┐ │
│  │                     会话管理器 (SessionManager)                 │ │
│  │  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐           │ │
│  │  │ 会话 A   │ │ 会话 B   │ │ 会话 C   │ │ 会话 D   │  ...      │ │
│  │  │(主窗口)  │ │(分支窗口)│ │(分支窗口)│ │(分支窗口)│           │ │
│  │  └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘           │ │
│  │       │            │            │            │                  │ │
│  │  ┌────▼─────┐ ┌────▼─────┐ ┌────▼─────┐ ┌────▼─────┐           │ │
│  │  │上下文A-1 │ │上下文B-1 │ │上下文C-1 │ │上下文D-1 │           │ │
│  │  │工具集A   │ │工具集B   │ │工具集C   │ │工具集D   │           │ │
│  │  │记忆A     │ │记忆B     │ │记忆C     │ │记忆D     │           │ │
│  │  │待办A     │ │待办B     │ │待办C     │ │待办D     │           │ │
│  │  └─────────┘ └─────────┘ └─────────┘ └─────────┘           │ │
│  └─────────────────────────────────────────────────────────────────┘ │
│                                    │                                  │
│              ┌─────────────────────┼─────────────────────┐          │
│              ▼                     ▼                     ▼          │
│  ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐  │
│  │    LLM 实例 A    │  │    LLM 实例 B    │  │    LLM 实例 C    │  │
│  │  (独立线程)      │  │  (独立线程)      │  │  (独立线程)      │  │
│  └────────┬─────────┘  └────────┬─────────┘  └────────┬─────────┘  │
│           │                     │                     │            │
└───────────┼─────────────────────┼─────────────────────┼────────────┘
            │                     │                     │
            ▼                     ▼                     ▼
    ┌──────────────┐      ┌──────────────┐      ┌──────────────┐
    │ 外部API服务   │      │ 外部API服务   │      │ 外部API服务   │
    │ (OpenAI/      │      │ (OpenAI/     │      │ (OpenAI/     │
    │  Claude等)    │      │  Claude等)    │      │  Claude等)   │
    └──────────────┘      └──────────────┘      └──────────────┘

核心组件说明

组件

职责

SessionManager

会话生命周期管理、窗口创建/销毁、会话列表维护

ContextContainer

独立存储每个会话的对话历史、用户偏好、临时状态

Toolset

每个会话独立的工具集配置,工具调用隔离

MemoryStore

会话级记忆存储,不与其他会话共享

TodoTracker

待办事项追踪,按会话维度隔离

LLMDispatcher

为每个会话分配独立的 LLM 调用线程

使用场景与示例

场景一:多方案并行探索

当需要同时探索多个解决方案时,会话并行让你每个方案在独立窗口中展开。

场景描述:你正在开发一个功能,面临 A/B 两种实现方案,想同时评估两者的优缺点。

操作流程

  1. 在主会话中描述需求和方案 A

  2. 点击「分支会话」,创建新窗口探索方案 A

  3. 回到主会话,点击「分支会话」,创建另一个窗口探索方案 B

  4. 两个窗口并行运行,分别与 AI 讨论不同方案

主窗口 (会话-主)
┌────────────────────────────────────────────────────┐
│ 用户: 我需要实现一个消息队列,考虑A方案用Redis...   │
│ AI:  好的,让我分析Redis实现方案的优缺点...        │
│                                                    │
│ [分支] → 创建新会话继续探讨                         │
└────────────────────────────────────────────────────┘
       ├──→ 窗口1 (会话-A)          ──→ 窗口2 (会话-B)
           ┌──────────────────┐      ┌──────────────────┐
           │ 用户: 深入分析    │      │ 用户: 考虑B方案   │
           │ Redis实现细节... │      │ 用RabbitMQ实现.. │
           │                  │      │                  │
           │ AI: Redis队列    │      │ AI: RabbitMQ     │
           │ 的Pub/Sub模式.. │      │ 的Confirm模式..  │
           └──────────────────┘      └──────────────────┘

输出结果:最终你可以对比两个窗口的讨论结果,做出更明智的决策。

场景二:长任务后台运行

当一个窗口执行耗时的代码分析或批量处理时,你可以在其他窗口继续其他工作。

场景描述:启动一个大规模代码重构任务,同时在另一个窗口进行 CodeGraph 分析。

后台任务窗口                      前台工作窗口
┌─────────────────────┐          ┌─────────────────────┐
│ 会话-代码重构        │          │ 会话-代码分析        │
│                     │          │                     │
│ [正在执行]          │          │ 用户: 分析这个模块   │
│ ████████░░ 80%      │  并行    │ 的调用链结构         │
│ 处理文件 800/1000   │ ──────→  │                     │
│                     │          │ AI: (立即响应)      │
│ 用户可以切换到       │          │ 这个模块的主要调用.. │
│ 其他窗口继续工作     │          │                     │
└─────────────────────┘          └─────────────────────┘

场景三:分支实验与回溯

通过分支会话创建实验性探索,保留主会话作为「基线」。

操作示例

时间线:

T0:  主会话 (v1.0基线)
     ├──→ T1: 分支会话A (实验: 尝试新算法)
     │         │
     │         └──→ T2: 评估效果,不满意则关闭
     └──→ T3: 分支会话B (实验: 另一种方案)
               └──→ T4: 效果良好,合并到主会话

分支会话的优势

  • 保留「干净」的基线会话

  • 多次实验互不干扰

  • 随时回溯到任意历史点

不是什么澄清

  • 不是多用户协作系统 — 会话并行是单用户多实例,不是多用户同时在线协作

  • 不是进程级隔离 — 共享同一进程,资源开销低于多进程方案

  • 不是自动并行任务 — 需要用户手动创建分支会话,DAG 是自动并行

  • 不是会话同步 — 各会话独立运行,不自动同步上下文(除非手动复制)

  • 不是标签页切换 — 每个窗口是完整的独立实例,而非简单的标签页

设计哲学

1. 上下文隔离是核心价值

每个会话拥有独立的上下文存储,这意味着:

  • 工具调用不会相互干扰

  • 记忆存储按会话维度隔离

  • 待办事项不会串门

  • 用户可以放心大胆地尝试各种方案

为什么这样设计:在复杂项目中,一次错误的工具调用或记忆污染可能导致整个任务失败。会话隔离让用户可以大胆探索,即使玩坏了也只要关闭那个窗口。

2. 轻量优先原则

DriFox 选择线程级并行而非进程级:

  • 启动开销几乎为零

  • 上下文切换成本极低

  • 资源占用远低于多进程方案

为什么这样设计:大多数探索性任务不需要进程级隔离,线程级足够且更高效。除非明确需要进程隔离的安全边界,否则不引入额外开销。

3. 用户控制优先于自动化

会话并行需要用户主动创建分支:

  • 用户决定何时分支

  • 用户决定分支的上下文继承方式

  • 用户决定是否合并或丢弃

为什么这样设计:自动化虽然方便,但探索性场景下用户需要清晰的控制感。显式的分支操作让用户始终清楚自己在哪个「时间线」上工作。

4. 分支即快照

分支会话本质上是一个「快照」:

  • 继承当前会话的状态

  • 创建后完全独立演进

  • 可随时关闭而不影响原会话

为什么这样设计:这模拟了版本控制的思想,让你可以「fork」一个会话去尝试,保留「主分支」的完整性。满意就合并,不满意就丢弃。

使用技巧

  1. 使用分支而非新建:从当前会话分支可以继承上下文,减少重复说明

  2. 命名会话:为重要会话命名,方便在会话列表中识别

  3. 定期清理:关闭不再需要的分支会话,避免资源浪费

  4. 善用待办:在独立会话中创建待办,保持任务焦点

总结

会话并行是 DriFox 为复杂任务处理而设计的多实例并发方案。它不是简单的「多标签页」,而是通过完整的上下文隔离、轻量级线程并行、用户可控的分支机制,让你在同一应用中并行探索多个解决方案、同时处理多个任务、或保留实验性分支而「不弄脏」主会话。

当 DAG 工作流为你自动化执行多节点任务时,会话并行为你提供同样灵活的手动并行能力——一切由你掌控。