一个 AI 助手同时推进十个项目:Dots 的多任务调度和长期记忆是怎么工作的?

作者注:多项目 Agent 需要独立上下文、持久状态、任务调度和恢复机制,并行工作才能做到可追踪、互不干扰。

一个 AI 助手能否同时推进多个项目,关键在四件事:每项工作有独立上下文,执行状态持久保存,调度器统一安排优先级和并发,中断后可以从检查点恢复。同时调用多个模型并不难,难的是让这些调用各自记得自己在做什么。OpenAI 于 2026 年 9 月 29 日发布的 Dots 采用了这套模式。官方文档说明,一个 Dot 可以维护多个责任事项,把工作拆给后台 Agent 并行处理。每个新任务拥有自己的对话上下文,不会自动获得用户与 Dot 的全部历史对话。开发者可以用 Checkpointer、Store、任务队列和状态机搭建类似的多项目管理系统。

下文先根据官方资料拆解 Dots 的多任务和记忆机制,再用一个贯穿全文的项目管理示例,依次设计四层任务结构、并行调度、中断恢复、执行追踪和成本边界。标题中的“十个项目”只是对工作模式的示例表达,Dots 和自建系统都没有固定的十路并发,也不能无限并行。文中的自建 Agent 代码属于设计方案,没有附带虚构的运行结果。

dots-multi-task-scheduling-long-term-memory-image-0


To Know:Dots 多任务调度相关术语

术语 解释
Workspace 组织项目与权限的工作空间,通常对应一个用户或一个团队。
Project 项目单元,包含目标、资料和相关任务。
Task 一项有明确目标的工作,例如“检索今日 OpenAI 新闻”。
Run 任务的一次实际执行记录,同一个 Task 可以执行很多次。
后台 Agent Dot 派出去并行处理子任务的执行者,完成后向 Dot 汇报。
Checkpointer 保存任务执行检查点的组件,负责中断后恢复。
Store 保存跨任务长期信息的存储组件,负责延续项目背景。
状态机 按规则管理任务各阶段转换的机制,如待执行、执行中、等待审批。
并发限制 同时执行任务的数量上限,受 API 额度、服务器资源和成本约束。
Tracing 记录模型调用、工具调用和交接过程的追踪能力。
Proactive Research Dots 在没有新消息时对已授权资料源做的只读后台研究。

1 Dots 多任务调度:一个 Dot 为什么能同时承担多个责任

1.1 Dots 官方披露的多项目能力

按照官方定位,Dots 是一个常驻型个人 Agent。它拥有自己的云端计算机和浏览器,用户离开后仍能继续推进已委派的工作。在多任务方面,Tasks and memory 文档列出了以下能力:

  • 同时保留多个工作事项的状态,并在同一对话中切换任务;
  • 用户可以随时补充信息、调整优先级;
  • 把复杂任务拆成若干部分,交给后台 Agent 并行处理;
  • 创建独立的可见任务线程,再收集各任务结果并汇总;
  • 工作出现阻塞时请求用户介入,后台任务运行期间用户仍可继续发消息。

这些能力合起来,让 Dot 承担的角色更接近项目协调者。它负责决定哪件事先做、哪件事拆出去、哪件事交还用户,单个任务的具体执行可以由后台 Agent、ChatGPT Work 任务或 Codex 任务完成。

1.2 多对话、多任务与多 Agent 的区别

这三个概念经常被混用,它们解决的问题各不相同。用统一的示例来看:假设用户的工作空间里有 AI Radar(AI 新闻日报)、Website(网站改版)、Research(竞品研究)三个项目。

模式 运作方式 在示例中的表现 解决的问题
多对话 用户为每个项目开一个聊天窗口 用户自己记住 Research 做到了哪一步 隔离聊天内容,进度仍由人管理
多任务 一个协调者维护多个任务的状态 Dot 记录三个项目各自的进度和优先级 统一调度和状态追踪
多 Agent 协调者把子任务派给多个执行者 后台 Agent 收集资料,另一个执行者写报告 并行执行与专业分工

Dots 把三者叠加在一起:用户在一个入口与 Dot 沟通,Dot 维护多项任务,并按需派出后台 Agent。自建系统要复刻这种效果,三层能力都要实现,只开多个聊天窗口远远不够。

1.3 一位用户自述的并行观察

Reddit 上一位用户自述了一天的测试。他把数百份 PDF、数千页文档交给 Dot 审查,同时运行法律研究任务。他观察到三个执行过程同时存在:Dot 自己的云端计算机处理任务 A,他连接的一台 Linux 电脑处理任务 B,另一个后台研究 Agent 处理任务 C。他还提到,启动独立法律研究任务时曾遇到执行环境不可用,连接本地电脑后才派发成功。

这份个人观察说明,Dot 的云端计算机、本地电脑和 Work/Codex 环境是不同的执行资源。作者本人也指出,他没有验证这些路径是否拥有独立且无限的额度。所以这次测试只能说明 Dots 能把工作分派到不同环境,不能据此推断每位 Pro 用户都能获得同样的并行规模。


2 Dots 长期记忆:一个任务为什么需要独立记忆

2.1 新任务的上下文边界

官方文档明确写道:每个新任务有自己的对话上下文,不会自动获得 Dot 与用户之间的全部历史对话。Dot 可以检索过去的 ChatGPT 对话来寻找背景,检索到的内容只作为当前工作的上下文使用。

这个设计很实际。如果每个任务都载入全部历史,Research 项目的竞品报告就可能混入 Website 项目的改版讨论,上下文也会越来越长、越来越贵。长期项目需要显式管理“这个任务该知道什么”,单靠一条越拉越长的聊天记录做不到这一点。

2.2 Dots 记忆的四个数据层

根据官方资料,Dot 的上下文来自四个不同来源:

  1. ChatGPT Memory:Dot 可以读取 ChatGPT 的相关记忆和近期对话;
  2. Dot 自身的笔记:积累用户偏好、工作习惯、项目决策和长期责任事项;
  3. 当前任务上下文:本次对话中的指令、文件、检索结果和工具执行结果;
  4. 已连接应用的数据:Dot 读取已授权应用的数据,并可通过主动研究形成记忆。

这几层的生命周期各不相同。ChatGPT Memory 和 Dot 笔记属于不同的数据层,关闭 ChatGPT Memory 共享不会自动删除 Dot 已获取的信息,断开插件也只会停止新的访问。截至 2026 年 11 月 16 日,用户还不能逐条查看、修改或删除 Dot 的独立记忆,删除 Dot 会启动对其自身上下文的删除。自建系统设计记忆层时,可以参考这套分层思路,同时补上可查看、可删除的管理界面。


3 Checkpointer 与 Store:多任务 Agent 的两种记忆

LangGraph 的持久化文档把 Agent 的记忆分成两类,这个划分正好对应 Dots 的“任务上下文”和“长期笔记”。下面仍以 Research 项目的月度竞品报告为例说明。

3.1 Checkpointer:记住工作做到哪一步

Checkpointer 保存单个任务线程的执行快照,内容包括当前步骤、已调用的工具、工具返回结果,以及哪一步在等待人工审批。在示例中,月度报告任务已经抓完 6 家竞品的价格页,正准备分析时服务重启了。有了检查点,任务可以从“分析”这一步继续,已经抓取的资料不必重抓。

存储介质决定了检查点能否撑过重启。内存型实现适合开发测试,进程重启后状态就会丢失;本地持久化可以用 SQLite,长期部署的服务更适合 PostgreSQL。检查点会持续增长,生产系统还要制定旧状态的清理策略。

3.2 Store:记住项目背景

Store 保存跨任务、跨会话的长期资料,例如用户偏好、项目背景、历史决策和多个任务共享的知识。在示例中,“报告读者是产品团队”“只跟踪 API 价格和功能更新”“上月已决定不再跟踪某家停更的竞品”都属于 Store 的内容。下个月新建报告任务时,它会读取这些决策,用户无需重新交代。

3.3 Checkpointer 与 Store 职责对比

维度 Checkpointer Store
作用范围 单个任务线程 多任务、跨线程
保存内容 执行状态快照 长期资料与事实
核心价值 中断后恢复工作 新任务延续项目背景
示例内容 “已抓取 6 家价格页,下一步分析” “报告读者是产品团队”
生命周期 跟随任务状态,完成后可清理 按长期记忆策略保留和更新

两者分工明确,缺一不可。只有 Checkpointer,每个新任务都像新员工入职;只有 Store,任务一中断就要从头再来。

dots-multi-task-scheduling-long-term-memory-image-1

上图中的“读取背景—写入快照—回写决策”循环,可以直接映射到第 6 节的代码。示例代码通过 API易 apiyi.com 的 OpenAI 兼容接口调用模型,换模型时只需修改模型名。


4 多项目任务管理系统设计:Workspace、Project、Task、Run

4.1 四层结构与独立 ID

自建多项目 Agent 建议采用四层结构,每一层都有独立 ID:

层级 作用 示例
Workspace 管理一个用户的工作空间和权限 regulus
Project 管理独立项目的目标与资料 AI Radar、Website、Research
Task 管理具体任务 Daily News、Monthly Report
Run 记录某次实际执行 Daily News 在 2026-11-16 09:00 的执行

对应的树形结构如下:

Workspace: regulus
├── Project: AI Radar
│   ├── Task: Daily News
│   │   ├── Run: 2026-11-16
│   │   └── Run: 2026-11-17
│   └── Task: Topic Discovery
├── Project: Website
│   ├── Task: UI Improvement
│   └── Task: Bug Fix
└── Project: Research
    ├── Task: Competitor Analysis
    └── Task: Monthly Report

Task 和 Run 分开记录是关键。Daily News 每天运行一次,每次 Run 都有自己的输入、输出、耗时和状态,出了问题可以精确定位到某一天的某一次执行。

4.2 记忆访问范围与项目隔离

一个 Agent 管理多个项目时,各项目的文件默认不能互相读取。建议按层级划分记忆的访问范围:

  • 用户通用偏好(如报告用中文、结论先行):所有授权项目可读;
  • 项目背景(如 Research 的读者和跟踪范围):仅该项目的任务可读;
  • 单次任务记录:仅当前任务和明确授权的关联任务可读;
  • 企业客户资料:仅指定客户项目可读;
  • 敏感凭证:放在独立的安全存储中,永远不进入模型上下文。

跨项目共享资料时,要记录来源和授权范围。这与 Dots 的做法一致:官方说明 Dot 的上下文不保留凭证、图片和截图,权限边界由插件授权和 Custom Rules 共同控制。


5 多任务调度:如何让任务并行又互不干扰

5.1 调度器与 Agent 推理分离

建议把“什么时候做”和“怎么做”交给两个组件。调度器负责启动时机、项目选择、当前运行数、优先级、超时和重试;Agent 负责理解任务、制定步骤、选择工具、分析结果和提交成果。这样,调度规则可以确定性地执行,模型只处理需要推理的部分。

技术选型可以参考这套组合:APScheduler 管理周期性任务,Celery 做后台任务队列,Redis 负责消息和短期协调,PostgreSQL 保存项目与执行状态,LangGraph 这类框架管理 Agent 流程与持久化状态。小规模原型用 Python 的 asyncio 加 SQLite 也能跑通,第 6 节的代码就是这样设计的。

5.2 三种并行方式

多任务 Agent 至少有三种并行:

  1. 独立任务并行:AI Radar 的每日新闻和 Research 的月度报告互不依赖,可以同时运行;
  2. 子任务并行:一个项目拆成资料收集、事实核查等子任务分头进行;
  3. 模型角色并行:不同模型负责不同专业工作,最后汇总。

决定能否并行的约束包括 API 并发额度、服务器资源、任务依赖、数据库写入竞争、模型成本、结果冲突和重复执行。

5.3 示例:资料收集、数据分析、报告生成

Research 项目的月度报告拆成三个子任务。资料收集可以和 AI Radar 的每日新闻并行;数据分析依赖资料收集的结果,必须等它完成;报告生成依赖分析结论,完成后进入等待审批状态,由用户确认后才算交付。

dots-multi-task-scheduling-long-term-memory-image-2

把三个子任务一起启动看起来更快,数据分析却会因为拿不到资料而产生空结论,甚至自行编造数据。依赖关系决定了哪些任务必须串行,并发上限决定了能同时跑多少个,两者都应写进调度器,交给模型临场判断很容易出错。

5.4 模型角色分工

子任务 推荐模型类型 选择理由 可用平台
资料收集与摘要 轻量快速模型 调用量大,对成本敏感 API易 apiyi.com、官方 API
数据分析 推理能力强的模型 需要多步比较和计算 API易 apiyi.com、官方 API
报告生成 长文写作能力强的模型 结构与表达质量要求高 API易 apiyi.com、官方 API
事实核查 与写作模型不同的模型 交叉验证,减少同源错误 API易 apiyi.com、官方 API

具体模型以平台当前的模型列表为准。一个 Key 对接多家模型时,角色分工可以通过配置调整,代码结构无需改动。


6 快速上手:用统一接口搭建多任务 Agent 原型

6.1 极简示例:给任务注入项目背景

下面的代码演示最核心的一点:任务执行前,从长期记忆中只取出所属项目的背景。

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # API易 OpenAI 兼容接口
)

# Store:按项目隔离的长期背景
project_memory = {
    "research": "读者:产品团队;只跟踪 API 价格与功能更新;报告结论先行",
    "ai-radar": "每日 09:00 汇总 OpenAI、Anthropic、Google 官方动态",
}

def run_task(project_id: str, goal: str) -> str:
    resp = client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[
            {"role": "system", "content": f"项目背景:{project_memory[project_id]}"},
            {"role": "user", "content": goal},
        ],
    )
    return resp.choices[0].message.content

print(run_task("research", "列出本月需要关注的竞品更新清单"))

6.2 完整设计方案:状态机、检查点、依赖与并发

以下代码是一个设计方案,覆盖 Store、Checkpoint、状态机、依赖调度、并发限制、重试、超时和执行记录,用于说明各组件如何协作。它没有经过生产环境验证,文中也不提供虚构的运行结果。

查看完整设计方案代码
import asyncio, json, sqlite3, time, uuid
from dataclasses import dataclass, field
from enum import Enum
from openai import AsyncOpenAI

client = AsyncOpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # API易统一接口,一个 Key 切换多家模型
)

class Status(str, Enum):
    PENDING = "pending"; RUNNING = "running"; WAITING = "waiting"
    APPROVAL = "approval"; COMPLETED = "completed"
    FAILED = "failed"; CANCELLED = "cancelled"; PAUSED = "paused"

db = sqlite3.connect("agent.db")
db.executescript("""
CREATE TABLE IF NOT EXISTS store(
  scope TEXT, key TEXT, value TEXT, source TEXT, PRIMARY KEY(scope, key));
CREATE TABLE IF NOT EXISTS checkpoint(
  run_id TEXT, task_id TEXT, step TEXT, state TEXT, ts REAL);
CREATE TABLE IF NOT EXISTS runs(
  run_id TEXT PRIMARY KEY, workspace_id TEXT, project_id TEXT, task_id TEXT,
  model_id TEXT, input_tokens INT, output_tokens INT,
  duration REAL, retry_count INT, final_status TEXT);
""")

def store_get(scopes: list[str]) -> str:
    """只读取被授权的作用域:user 与 project:<id>"""
    marks = ",".join("?" * len(scopes))
    rows = db.execute(f"SELECT key, value FROM store WHERE scope IN ({marks})", scopes)
    return "\n".join(f"- {k}: {v}" for k, v in rows)

def save_checkpoint(run_id, task_id, step, state):
    db.execute("INSERT INTO checkpoint VALUES (?,?,?,?,?)",
               (run_id, task_id, step, json.dumps(state, ensure_ascii=False), time.time()))
    db.commit()

def log_run(run_id, task, usage, duration, retries, status):
    db.execute("INSERT OR REPLACE INTO runs VALUES (?,?,?,?,?,?,?,?,?,?)",
               (run_id, "regulus", task.project_id, task.task_id, task.model,
                getattr(usage, "prompt_tokens", 0), getattr(usage, "completion_tokens", 0),
                duration, retries, status.value))
    db.commit()

@dataclass
class Task:
    task_id: str
    project_id: str
    goal: str
    model: str
    depends_on: list[str] = field(default_factory=list)
    needs_approval: bool = False

async def run_task(task: Task, done: dict, sem: asyncio.Semaphore,
                   max_retry: int = 2, timeout: int = 120):
    run_id = f"run-{uuid.uuid4().hex[:8]}"
    background = store_get(["user", f"project:{task.project_id}"])
    upstream = "\n\n".join(done[d] for d in task.depends_on)
    messages = [
        {"role": "system", "content": f"长期背景:\n{background}"},
        {"role": "user", "content": f"{task.goal}\n\n上游结果:\n{upstream or '无'}"},
    ]
    async with sem:  # 并发限制
        for attempt in range(max_retry + 1):
            start = time.time()
            save_checkpoint(run_id, task.task_id, f"attempt-{attempt}", messages)
            try:
                resp = await asyncio.wait_for(
                    client.chat.completions.create(model=task.model, messages=messages),
                    timeout)
                output = resp.choices[0].message.content
                status = Status.APPROVAL if task.needs_approval else Status.COMPLETED
                log_run(run_id, task, resp.usage, time.time() - start, attempt, status)
                save_checkpoint(run_id, task.task_id, status.value, {"output": output})
                if status == Status.COMPLETED:
                    done[task.task_id] = output
                return
            except Exception as e:  # 超时或接口错误:指数退避后重试
                save_checkpoint(run_id, task.task_id, "error", {"error": str(e)})
                await asyncio.sleep(2 ** attempt)
        log_run(run_id, task, None, 0, max_retry, Status.FAILED)

async def schedule(tasks: list[Task], max_concurrency: int = 2) -> dict:
    sem = asyncio.Semaphore(max_concurrency)
    done: dict[str, str] = {}
    pending = {t.task_id: t for t in tasks}
    while pending:
        ready = [t for t in pending.values() if all(d in done for d in t.depends_on)]
        if not ready:  # 前置任务失败、待审批或存在循环依赖
            print("阻塞任务:", list(pending))
            break
        await asyncio.gather(*(run_task(t, done, sem) for t in ready))
        for t in ready:
            pending.pop(t.task_id)
    return done

tasks = [
    Task("daily-news", "ai-radar", "汇总今日 AI 官方动态", "gpt-4.1-mini"),
    Task("collect", "research", "收集本月竞品 API 价格与功能变更", "gpt-4.1-mini"),
    Task("analyze", "research", "对比变更并归纳趋势", "gpt-4.1", depends_on=["collect"]),
    Task("report", "research", "生成月度竞品报告", "gpt-4.1",
         depends_on=["analyze"], needs_approval=True),
]
asyncio.run(schedule(tasks))

代码里有几处对应前文的设计。store_get 只读取 user 和当前项目作用域,实现项目隔离;checkpoint 表按 run 记录每一步,配合 runs 表记录 Token 与最终状态;schedule 用依赖关系决定串行,用信号量限制并发。真实系统还需要补上工具调用、审批回调和恢复入口。

🚀 快速开始:搭建原型阶段,推荐通过 API易 apiyi.com 获取免费测试额度,用同一个 Key 分别给收集、分析、写作三个角色配置不同模型,对比效果和成本后再确定分工。


7 多任务 Agent 如何处理中断、失败和人工审批

7.1 任务状态机

任务进度应当由明确的状态记录,模型在聊天里描述的进度只能作参考。推荐的主流程是 Pending(待执行)→ Running(执行中)→ Waiting(等待外部条件)或 Approval(等待审批)→ Completed(完成),另设 Failed、Cancelled、Paused 三个终止或暂停状态。每次状态转换都写入数据库,调度器只依据数据库里的状态做决策。

7.2 重试、超时与暂停恢复

  • 重试:接口错误或超时后指数退避重试,并记录 retry_count,便于发现经常失败的步骤;
  • 超时:每个 Run 设置执行时限,超时转为 Failed 并告警,防止一个卡死的任务长期占用并发名额;
  • 暂停恢复:暂停时保存检查点,恢复时从最后一个检查点继续,已经完成的工具调用无需重复执行;
  • 幂等性:发邮件、写数据库这类有副作用的步骤,重试前先检查是否已执行,避免重复操作。

Dots 的官方资料里有一个相关细节:停止正在运行的任务和取消已创建的周期计划是两件事,暂停 Dot 时,独立的 Work、Codex 和计划任务也可能继续运行。自建系统应把“停止本次 Run”“暂停 Task”“取消周期计划”设计成三个独立操作。

7.3 人工审批:参考 Dots 的 Custom Rules

Dots 用 Custom Rules 把行为分成四档:无需询问直接执行、预先授权后执行、执行前询问、交还用户。修改密码、转移资金等操作必须由用户接管,永久删除数据、安装软件可能要求每次批准。用户批准也无法覆盖核心安全限制。

自建系统可以照此给工具打标签。只读检索直接执行;起草报告完成后进入 Approval;对外发送、付款、删除一律交给人。示例中的报告任务设置了 needs_approval=True,生成后停在审批状态,用户确认后才写入 Completed。


8 多任务 Agent 的执行追踪:Tracing 与日志

多项目并行时,用户最常问的问题是“它到底做了什么”。OpenAI Agents SDK 的 Tracing 可以记录调用了哪个 Agent、使用了哪个模型、发生了哪些工具调用、哪里进行了 handoff、触发了哪些安全检查,以及任务最终如何结束。

Tracing 擅长还原单次执行过程,项目级的统计还需要业务日志补充。建议每个 Run 至少记录 project_id、task_id、run_id、model_id、input_tokens、output_tokens、tool_calls、duration、retry_count 和 final_status。有了这些字段,就能回答“Research 项目本月花了多少 Token”“哪个步骤重试最多”“哪个模型的分析任务最常超时”这类管理问题。第 6 节的 runs 表就是这套字段的最小实现。


9 多任务 Agent 的成本和管理边界

9.1 Dots 的费用结构

截至 2026 年 11 月 16 日,个人用户可通过 ChatGPT Pro 100、Pro 200、Pro 500 三档订阅使用 Dots,月费分别为 100、200、500 美元。官方没有在个人 Pro 的 Dots 说明中列出单独的 Dot 月费。Dot 委派出去的 ChatGPT Work 或 Codex 任务按对应产品的额度和规则计算,消耗取决于模型、上下文、推理、工具调用和检索。个人 Pro 的使用还有年龄(18 岁以上)和地区限制,不包括欧洲经济区、英国和瑞士。

企业工作区的计费方式不同。现行官方文档说明,符合条件的企业工作区可以选择按工作类型的固定费率,或者按用量计费;预览期免费,2026 年 11 月 18 日起对已启用的 Dots 开始计费;委派到 Work 或 Codex 的任务另行收费。具体金额以工作区实际适用的报价为准。

9.2 自建系统的成本来源

自建多任务 Agent 的成本主要来自四处:

  • 重复读取上下文:每个任务都注入项目背景,背景越长,每次调用的输入 Token 越多,Store 里的内容需要定期精简;
  • 重试与失败:一次失败的分析任务会把上游资料重新送入模型一遍;
  • 模型选择:所有子任务都用最强模型,成本会成倍上升;
  • 并发额度:API 的速率限制决定了实际可用的并行数。

9.3 并行数量与有效工作量

并行数量和有效工作量是两回事。依赖未满足的任务提前启动只会产出废结果,相互冲突的结论要花人工去合并,一个项目的错误数据经共享记忆传到另一个项目,返工成本会更高。合理的做法是先保证项目隔离和依赖正确,再根据监控数据逐步调高并发上限。


10 常见问题 FAQ

Q1:Dots 的多任务调度是什么?

一个 Dot 同时维护多个责任事项。用户可以切换任务、调整优先级,Dot 把复杂工作拆给后台 Agent 并行处理,汇总结果后在需要决策时交还用户。

Q2:Dots 的长期记忆会记住所有历史对话吗?

不会全部载入。新任务有自己的对话上下文,Dot 依靠 ChatGPT Memory、自身笔记、当前任务上下文和已连接应用的数据工作,需要时再检索过去的对话。

Q3:Checkpointer 和 Store 能互相替代吗?

两者职责不同。Checkpointer 保存单个任务的执行快照,用于中断恢复;Store 保存跨任务的项目背景和决策,用于让新任务延续上下文。长期项目两者都需要。

Q4:Dots 能同时并行多少个任务?

官方资料没有公布固定的并发数。Dots 支持并行,执行环境和使用额度都有边界。Reddit 用户自述观察到三个执行过程同时运行,这只是个人测试结果。

Q5:自建多项目 Agent 如何快速调用多种模型?

可以使用 OpenAI 兼容的聚合接口。在 API易 apiyi.com 注册获取 API Key 和免费测试额度后,把本文代码的 base_url 设为 `https://api.apiyi.com/v1`,即可用同一套代码给不同子任务配置 GPT、Claude、Gemini 等模型。

Q6:如何控制多任务 Agent 的模型成本?

按角色分配模型:资料收集用轻量模型,分析和写作再用强模型;精简 Store 中的项目背景;用 runs 表统计每个项目的 Token。通过 API易 apiyi.com 按量计费调用,便于先小规模测试再决定配额。

Q7:Dots 和自建系统在安全上要注意什么?

Agent 可能误解任务、误判资料或遭遇 Prompt Injection,官方也表示现有防护措施无法消除全部风险。涉及账户、资金、对外发送的操作应设置人工审批,敏感凭证不进入模型上下文。


11 Dots 多任务调度与长期记忆 Key Takeaways

  • 核心难点:多任务 Agent 的关键在独立上下文、持久状态、调度与恢复。
  • Dots 机制:一个 Dot 协调多个事项,后台 Agent 并行执行,新任务上下文相互独立。
  • 两种记忆:Checkpointer 负责恢复执行,Store 负责延续项目背景。
  • 四层结构:Workspace、Project、Task、Run 各有独立 ID,项目之间互相隔离。
  • 调度原则:依赖决定串行,并发上限决定规模,规则写进调度器。
  • 可追踪性:每个 Run 记录模型、Token、耗时、重试次数和最终状态。
  • 上手方式:通过 API易 apiyi.com 统一接口给不同子任务配置不同模型。

12 总结

Dots 展示了个人 Agent 管理多个长期项目的产品形态:常驻运行,任务上下文相互独立,记忆分层保存,后台 Agent 并行执行,高风险操作交还用户。它的多项目能力建立在状态管理之上,单纯增加并行数量做不到这一点。

自建类似系统时,可以按本文的顺序落地:先用四层结构和作用域划分实现项目隔离,再用 Store 与 Checkpointer 分别解决“记得背景”和“能够恢复”,然后用调度器管理依赖与并发,最后用状态机、审批和执行日志让每一步可控、可查。原型阶段推荐通过 API易 apiyi.com 快速验证不同模型在各个角色上的效果,再根据日志数据调整分工和并发。


参考资料

  1. OpenAI:Introducing dots:产品发布公告
  2. 链接: openai.com/index/introducing-dots
  3. 说明: 产品定位、云端计算机与多项目执行
  4. ChatGPT Learn:Tasks and memory:Dots 任务与记忆文档
  5. 链接: learn.chatgpt.com/docs/dots/tasks-and-memory
  6. 说明: 后台 Agent、任务独立上下文、主动研究
  7. OpenAI Help Center:Dots privacy, security, and safety FAQs:隐私与安全说明
  8. 链接: help.openai.com/en/articles/20001529-dots-privacy-security-and-safety-faqs
  9. 说明: 权限、审批、记忆删除与数据保留
  10. ChatGPT Learn:Dots admin guide:企业版管理与计费
  11. 链接: learn.chatgpt.com/docs/enterprise/dots-admin-guide
  12. 说明: 企业工作区计费方式与开始计费日期
  13. About ChatGPT Pro tiers:Pro 订阅档位说明
  14. 链接: help.openai.com/en/articles/9793128-about-chatgpt-pro-tiers
  15. 说明: Pro 100、200、500 的价格与额度规则
  16. LangGraph Persistence 文档:Checkpointer 与 Store
  17. 链接: github.com/langchain-ai/docs/blob/main/src/oss/langgraph/persistence.mdx
  18. 说明: 短期执行状态与长期记忆的划分
  19. OpenAI Agents SDK:Tracing 与工作流
  20. 链接: developers.openai.com/api/docs/guides/agents/sdk
  21. 说明: Agent 执行过程的追踪与调试

作者:APIYI 技术团队
技术交流:欢迎在 API易 apiyi.com 首页联系我们,更多接入资料可访问 docs.apiyi.com 文档中心

发表评论