AgentScope 1.0：智能体城市的建造者

"如果你不能把智能体框架讲给六岁小孩听，你自己也没真懂。" —— 费曼式的理解

开篇：从单兵作战到城市文明

想象一下，如果你要教机器人做三件事：做饭、写代码、查资料。

第一代方案，你写死每一步指令——这是"脚本化时代"，机器人只会按部就班。

第二代方案，你给机器人一个大语言模型大脑——这是"LLM时代"，机器人能理解指令，但脑子里的知识随时会过时，手边也没工具可用。

第三代方案，你给机器人大脑配上了"手脚"（工具）、"记忆宫殿"（内存）、"交通规则"（消息协议）——这是 AgentScope 时代。

AgentScope 1.0，本质上是一座为智能体建造的城市。在这座城市里，每个智能体都有统一的身份证格式、共享的记忆系统、丰富的工具箱，以及高效的城市规划。它不再是单打独斗的孤岛，而是一个互相协作、自我演化的复杂适应系统。

┌─────────────────────────────────────────┐
│         智能体城市 AgentScope          │
├─────────────────────────────────────────┤
│  表层：模块化组件（消息、模型、工具）   │
├─────────────────────────────────────────┤
│  中层：ReAct 范式（推理→行动循环）    │
├─────────────────────────────────────────┤
│  底层：系统涌现（多智能体协作进化）    │
└─────────────────────────────────────────┘

一、城市基础设施：四大基石

1.1 消息协议：统一的"身份证系统"

如果把智能体城市比作一个社区，那么每个智能体就是居民，消息就是居民之间的交流。但不同语言、不同方言，交流就会出问题。

AgentScope 设计了一套通用的消息格式——Msg 对象，就像给每个居民发了一张标准化身份证：

Msg = {
    "name": "Jarvis",           # 谁发的消息
    "role": "assistant",        # 身份角色
    "content": [...],           # 说的内容（可以是文字、图片、工具调用...）
    "metadata": {...},          # 附加信息
    "timestamp": 1700000000,   # 时间戳
    "id": "msg_123456"         # 唯一编号
}

费曼式理解：想象你在火车站问路，不同工作人员说的方言不一样，多麻烦！现在所有人都说普通话（统一协议），效率自然就高了。

ContentBlock 的多样性：

TextBlock：普通文字，像口头对话
ImageBlock/AudioBlock/VideoBlock：多媒体内容，像展示照片、录音带
ToolUseBlock：工具调用记录，像操作手册
ThinkingBlock：推理过程，像内心独白

这就好比一个人说话时，不仅说出话，还能同时展示图片、拿出工具、说出自己的思考过程——全方位的表达。

1.2 模型抽象：多供应商的"翻译官"

城市里有多种交通工具：汽车、地铁、公交。但如果你要写一套导航系统，难道要针对每种交通工具单独写代码吗？

AgentScope 的Model 模块就是"通用翻译官"，它屏蔽了不同 LLM 提供商（OpenAI、Anthropic、Gemini 等）的差异，让你用同一套代码调用任何模型。

统一接口的四重境界：

格式化器（Formatter）：把 AgentScope 的消息翻译成各模型能懂的格式

- ChatFormatter：一对一对话 - MultiAgentFormatter：多人群聊

异步调用：就像发消息不等对方回复就继续工作

``python # 不阻塞的流式响应 async for chunk in model.generate(...): print(chunk) # 实时输出``

统一响应：无论模型返回什么格式，都包装成标准的 ChatResponse

``python ChatResponse = { "content": [TextBlock(...), ToolUseBlock(...), ThinkingBlock(...)], "usage": {"inputtokens": 1000, "outputtokens": 500}, "timestamp": 1700000000 }``

追踪与钩子：就像给每辆车装上 GPS，全程监控

- 记录每个模型的调用次数、消耗 Token - 支持企业级可观测性（OpenTelemetry）

伏笔：这为后续的"Studio 可视化"埋下基础——因为你有了统一的数据格式，才能画得出漂亮的追踪图。

1.3 内存系统：短期缓冲与长期归档

记忆，是智能体的灵魂。没有记忆的智能体，就像得了阿尔茨海默症——每次对话都是陌生人。

AgentScope 的内存系统分为两层：

短期内存：工作台上的便利贴

InMemoryMemory 就像你桌上的便利贴，快速记录最近发生的事：

memory = InMemoryMemory()
memory.add(msg)           # 贴一张便利贴
memory.get(5)             # 看最近 5 张
memory.delete(2)          # 撕掉第 2 张
memory.clear()            # 全部清理

智能体对话时，自动把新消息贴上去，把工具调用的结果也记录下来——这就是"工作记忆"，保证连续对话的连贯性。

长期内存：档案馆里的索引卡

LongTermMemory 是抽象基类，具体实现可以用任何后端（SQL、向量数据库、mem0 等）。它有两种操作模式：

开发者控制（像管理员归档）：

record(messages)：在特定时间点（如对话结束）保存信息
retrieve(query)：根据查询词找出相关记忆

智能体自主（像人类自己记笔记）：

recordtomemory()：智能体自己觉得重要的，就存下来
retrievefrommemory(keyword)：智能体需要时，主动查资料

双范式设计的隐喻：

┌────────────────────────────────────┐
│      记忆的两种控制模式            │
├────────────────────────────────────┤
│  开发者控制 = 期末考试归档笔记    │
│  智能体自主 = 日常听课记随笔      │
├────────────────────────────────────┤
│  系统性 vs. 机会性               │
│  可靠性 vs. 灵活性               │
└────────────────────────────────────┘

这种设计让记忆既系统化（确保关键信息不丢），又灵活（智能体能记住意外学到的东西）。

1.4 工具箱：瑞士军刀的模块化管理

智能体的手脚——工具，是连接虚拟大脑和现实世界的桥梁。但工具有一千种，全塞给智能体，它会"选择瘫痪"（Too Many Choices Paradox）。

AgentScope 的 Toolkit 提供了三层管理：

基础层：工具注册与执行

toolkit = Toolkit()
toolkit.register_tool_function(search_weather)  # 注册工具
toolkit.register_tool_function(calculate_tax)
result = toolkit.execute_tool_function("search_weather", location="Beijing")

自动生成 JSON Schema：工具注册时，自动从函数文档生成描述，LLM 就能理解这个工具是干什么的。

进阶层：MCP 细粒度管理

MCP（Model Context Protocol）是 Anthropic 提出的工具协议标准。AgentScope 提供两种客户端：

有状态客户端：像打持久电话

# 建立连接，全程保持会话
client = StatefulMCPClient(...)
client.connect()  # 开始通话
client.call_tool("browser_navigate", url="...")
client.call_tool("browser_click", element="...")
client.close()  # 结束通话

适合：浏览器会话（保持 cookies）、数据库连接等需要状态的服务。

无状态客户端：像发一次性短信

# 每次调用独立连接
client = StatelessMCPClient(...)
client.call_tool("search", query="...")  # 自动建连、自动断开

适合：搜索 API、计算服务等无状态的服务。

客户端侧抽象：远程工具被包装成"本地代理"对象，智能体根本不知道它是远程的——就像你用快递 APP，根本不知道包裹在哪个仓库。

高阶层：组级工具管理

解决"工具爆炸"问题的创新设计：

# 创建工具组
toolkit.create_tool_group("browser", ["navigate", "click", "screenshot"])
toolkit.create_tool_group("file", ["read", "write", "delete"])

# 激活/停用
toolkit.update_tool_groups(["browser"])      # 只启用浏览器工具
toolkit.update_tool_groups(["file"])       # 切换到文件工具

费曼式理解：就像厨师做饭，备菜时拿菜刀、砧板，炒菜时拿锅铲、调料——工具跟着任务走，而不是所有工具堆在台面上。

二、智能体行为：ReAct 的循环演化

2.1 ReAct 范式：思考与行动的螺旋

ReAct（Reasoning + Acting）是 AgentScope 的核心设计哲学。它的本质是一个反馈循环：

推理 → 行动 → 观察 → 再推理 → 再行动 → ...
  ↑                                ↓
  └───────── 闭环形成 ─────────────┘

智能体的三大功能：

Reply（回复）：主动响应用户

``用户问："帮我查北京天气" ↓ 智能体推理：需要调用天气工具 ↓ 智能体行动：调用工具 ↓ 智能体观察：工具返回"晴，25℃" ↓ 智能体推理：任务完成 ↓ 智能体回复："北京今天晴，25℃"``

Observe（观察）：被动接收环境信息

- 其他智能体发来广播消息 - 外部系统推送通知 - 不产生回复，只更新内部状态

Handle Interrupt（处理中断）：人机协作的关键

- 用户在智能体执行过程中喊"停！" - 智能体优雅暂停当前操作 - 可以快速响应，或调用 LLM 生成上下文感知反应

创新的"中断即事件"设计：传统系统把中断当作"异常信号"，AgentScope 把中断当作可观察事件——保留部分 LLM 响应、标记用户中断点，智能体能感知"我在哪里被打断"，并基于此调整后续行动。

2.2 实时转向：方向盘握在谁手里？

想象自动驾驶汽车突然遇到障碍物。是死板地按原计划撞上去，还是灵活变道？

AgentScope 的实时转向让智能体能像人类一样灵活：

# 用户发送中断信号
agent.interrupt("先别执行任务，帮我查一下股票")

# 智能体在 handle_interrupt 中处理
async def handle_interrupt(interrupt_msg):
    if interrupt_msg.content.startswith("先别执行"):
        # 保存当前状态
        self.memory.add(interrupt_msg)
        # 快速响应
        return "收到，已暂停当前任务"

CAS 涌现视角：中断不是系统"故障"，而是系统与环境交互的一部分——智能体的适应性体现在对不可预测事件的反应上。

2.3 并行工具调用：多线程的智慧

如果智能体要查三个网站的信息，是串行（查完 A 查 B 再查 C）还是并行（同时查 A、B、C）？

AgentScope 原生支持并行调用：

# 智能体在单次推理中生成多个工具调用
tools_to_call = [
    {"name": "search", "query": "site:A.com ..."},
    {"name": "search", "query": "site:B.com ..."},
    {"name": "search", "query": "site:C.com ..."},
]

# 异步并行执行
results = await asyncio.gather(*[
    toolkit.execute_tool_call(t) for t in tools_to_call
])

性能提升：三个网站各耗时 1 秒，串行需要 3 秒，并行只需 1 秒（接近）。

2.4 动态工具提供：按需加载的武器库

智能体执行多阶段任务（先调研、再编码、再测试），每个阶段需要的工具不同。

resetequippedtools 让智能体能自主切换工具集：

# 阶段 1：调研，激活搜索工具
agent.reset_equipped_tools(tool_groups=["search"])

# 阶段 2：编码，激活文件和代码工具
agent.reset_equipped_tools(tool_groups=["file", "code"])

# 阶段 3：测试，激活测试工具
agent.reset_equipped_tools(tool_groups=["test"])

CAS 自组织原理：智能体的"能力边界"不是固定的，而是根据任务动态调整——就像人根据工作需要换衣服、换工具。

2.5 状态持久化：系统的记忆胶水

长时间运行的智能体（如 Meta Planner 处理复杂项目）需要保存中间状态，否则中断后一切重来。

AgentScope 的 StateModule 基类提供自动化的状态管理：

class Agent(StateModule):
    def __init__(self):
        self.memory = InMemoryMemory()      # StateModule 自动纳入
        self.tools = Toolkit()              # StateModule 自动纳入
        self.register_state("counter", 0)    # 手动注册非 StateModule 属性

# 保存整个智能体
state_dict = agent.state_dict()

# 恢复智能体
agent.load_state_dict(state_dict)

嵌套结构支持：智能体里包含子智能体，子智能体包含工具，整个层次结构都能保存和恢复——这就像"存盘"功能，随时可以接着玩。

2.6 非侵入式定制：钩子系统的魔法

你想要：

记录所有工具调用日志？
验证每个响应的格式？
把控制台输出重定向到 Web 界面？

不用修改 AgentScope 核心代码，用钩子系统即可：

# 添加前置钩子：在推理前检查
@agent.hooks.pre_reasoning
async def check_reasoning_input(agent, input_msg):
    print(f"准备推理：{input_msg}")

# 添加后置钩子：在工具调用后处理结果
@agent.hooks.post_acting
async def log_tool_result(agent, tool_result):
    logger.info(f"工具结果：{tool_result}")

# 添加 print 钩子：拦截所有控制台输出
@agent.hooks.pre_print
def redirect_to_web(agent, msg):
    web_interface.send(msg)
    return None  # 不打印到控制台

伏笔与照应：这个钩子系统为后续的"Friday 副驾驶"埋下基础——Friday 就是通过钩子访问 AgentScope 的内部资源的。

三、内置智能体：从原型到实用的桥梁

3.1 深度研究智能体：图书馆里的侦探

想象你要写一篇关于"量子计算最新进展"的深度报告。单靠一次搜索不够，需要：

查询扩展：把"量子计算"拆解成"量子纠缠"、"量子纠错"、"量子算法"等子问题
广泛阅读：用多个查询词搜索，收集广泛素材
深度挖掘：对重要文章精读，提取关键信息
反思修正：如果信息不足，调整搜索策略

这就是 Deep Research Agent 的核心逻辑。

树状结构 vs 线性结构：

传统 ReAct（线性）：
查询A → 查询B → 查询C → 总结

深度研究（树状）：
    查询A（量子计算总览）
    ├─ 查询A1（量子纠缠）
    │  └─ 查询A1a（实验进展）
    ├─ 查询A2（量子纠错）
    └─ 查询A3（量子算法）

反思的层次：

低级反思：工具调用失败，换个参数重试
高级反思：方向不对，重新规划子任务

费曼式理解：就像老中医看病，先望闻问切收集信息，遇到疑点再追问，最后开处方——不是机械地执行流程，而是动态调整。

3.2 浏览器使用智能体：网页世界的游牧者

Web 世界是智能体的重要战场。Browser-use Agent 让智能体能：

导航网页：打开 URL、点击按钮、输入文字
理解网页：读 HTML、看截图（视觉模型）
多标签页管理：同时打开多个网页，交叉比对信息
长页面处理：网页太长？分块读，保持上下文

应用场景：

"帮我查一下特斯拉的股价"
"在 GitHub 上找最火的 Python 项目"
"订一张从北京到上海的机票"

Playwright MCP 集成：

# 建立有状态连接
client = StdIOStatefulClient(cmd=["npx", "-y", "@playwright/mcp"])
client.connect()

# 注册浏览器工具
toolkit.register_mcp_client(client)

# 智能体就能像人类一样操作浏览器

伏笔：长页面处理技术为后续的"内容总结能力"埋下基础——因为能处理长内容，才能做好总结。

3.3 元规划器：项目经理的大脑

单智能体适合简单任务，但复杂项目（如"开发一个数据分析平台"）需要：

任务分解：拆解成数据采集、清洗、分析、可视化等阶段
资源分配：每个阶段用什么工具？
进度跟踪：哪步完成了？哪步失败了？
动态调整：遇到阻碍，怎么改计划？

Meta Planner 就是这样的项目经理。

双模式架构：

简单任务 → 直接用 ReAct（轻量级）
复杂任务 → 用 Meta Planner（规划-执行模式）

三大核心组件：

RoadmapManager：路线图管理器

``json { "roadmap": { "originaltask": "开发数据分析平台", "decomposedtasks": [ {"description": "数据采集", "status": "completed"}, {"description": "数据清洗", "status": "in_progress"}, {"description": "数据分析", "status": "pending"} ] } }``

WorkerManager：工作智能体管理器

- 为每个子任务创建专门的 Worker Agent - 分配适当的工具（搜索工具、文件工具、代码工具...）

会话持久化：保存整个规划状态，中断后能恢复

CAS 涌现：项目经理本身是个 Agent，它管理的 Workers 也是 Agent——这是"Agent 包含 Agent"的递归结构，涌现出单 Agent 无法具备的复杂能力。

四、多智能体协作：从独行侠到社群进化

4.1 智能体作为工具：专家的联合作战

想象一个医学诊断团队：

病毒学家：懂病毒
流行病学家：懂传播
临床医生：懂治疗

用户问"新冠的最新治疗方案是什么？"，主智能体（接待员）把问题分发给三个专家，汇总答案给用户。

Agent as a Tool 的实现：

# 创建专家智能体
virologist = ExpertAgent(name="病毒学家", knowledge_base="virology")
epidemiologist = ExpertAgent(name="流行病学家", knowledge_base="epidemiology")
clinician = ExpertAgent(name="临床医生", knowledge_base="clinical")

# 主智能体把专家当作工具注册
toolkit.register_tool_function(virologist.query)
toolkit.register_tool_function(epidemiologist.query)
toolkit.register_tool_function(clinician.query)

# 主智能体自主选择调用哪个专家

优势：

模块化：每个专家独立开发、测试
可扩展：新专家直接注册为工具
可替换：换一个病毒学家，不影响系统

4.2 智能体对话：社交化的工作流

多智能体协作的另一个范式是"对话式"——就像会议室讨论。

Pipeline 抽象：把常见的对话模式封装成管道

# 顺序管道：A 说完 B 说，B 说完 C 说
pipeline = SequentialPipeline(agents=[Alice, Bob, Charlie])
await pipeline()

# 条件分支：如果任务成功走 A，失败走 B
pipeline = ConditionalPipeline(
    condition=check_success,
    true_branch=agent_success,
    false_branch=agent_failure
)

# 循环管道：不断重复直到收敛
pipeline = WhilePipeline(
    condition=not_finished,
    agent=worker
)

MsgHub 抽象：广播消息的中央枢纽

async with MsgHub(
    participants=[Alice, Bob, Charlie],
    announcement=Msg("system", "大家好，现在开始会议", "system")
) as hub:
    # 任何人说话，所有人都能听到
    await Alice()  # Alice 说完，Bob 和 Charlie 自动收到
    await Bob()   # Bob 说完，Alice 和 Charlie 自动收到

    # 动态管理：Bob 中途离开
    hub.delete(Bob)
    await hub.broadcast(Msg("Bob", "我有事先走", "assistant"))

CAS 涌现：单个智能体的行为很简单（说话），但多个智能体通过 Hub 交互，会涌现出"讨论"、"辩论"、"协商"等复杂群体行为——这就像蚂蚁很笨，但蚁群能建造精妙的巢穴。

五、开发者友好体验：从实验室到生产线的桥梁

5.1 评估系统：科学的智能体考场

智能体好不好用，不能靠感觉，要靠科学评估。

分层评估架构：

┌───────────────────────────────────┐
│     Benchmark（考试卷）           │
│   包含多个 Task（题目）          │
└───────────────────────────────────┘
           ↓
┌───────────────────────────────────┐
│     Task（单道题）               │
│   输入 + 预期答案 + 度量标准    │
└───────────────────────────────────┘
           ↓
┌───────────────────────────────────┐
│     SolutionOutput（答题结果）     │
│   是否成功？最终答案？执行轨迹？   │
└───────────────────────────────────┘
           ↓
┌───────────────────────────────────┐
│     Metric（评分标准）            │
│   分类（对/错）或数值（0-100）   │
└───────────────────────────────────┘

两种评估器：

GeneralEvaluator：顺序执行，适合调试

``python evaluator = GeneralEvaluator() results = evaluator.run(benchmark) # 可以逐个检查每个任务的执行轨迹``

RayEvaluator：并行分布式执行，适合大规模测试

``python evaluator = RayEvaluator(num_workers=10) results = evaluator.run(benchmark) # 10 个 Worker 并行跑，速度快 10 倍``

存储与恢复：

# 保存评估结果
evaluator_storage.save(results, "run_2025-01-09")

# 中断后继续（只跑没完成的）
evaluator.resume("run_2025-01-09")

5.2 Studio：可视化的智能体 X 光机

如果你想知道智能体内部发生了什么，Studio 就是你的"透视镜"。

聊天机器人式对话追踪

from agentscope.studio import init_studio

# 一行代码连接到 Studio
init_studio()

# 之后所有对话、工具调用、推理过程都会实时显示在 Web 界面

界面展示：

对话流：像聊天记录，清晰展示每一轮对话
结构化消息：区分"思考"（Thought）、"工具调用"（Tool Use）、"工具结果"（Tool Result）
多模态内容：图片、音频、视频都能直接预览

执行追踪：细粒度的性能剖析

Span（跨度）：每个离散计算步骤的记录

LLM 调用：耗时 1.2 秒，消耗 5000 Token
工具执行：耗时 0.5 秒，返回结果
异常发生：错误类型、堆栈跟踪

时间线视图：

[00:00] 用户输入
[00:00] └─ 智能体推理 (500ms)
[00:00]    └─ LLM 调用 (1200ms)
[00:01]       └─ 工具调用: search (500ms)
[00:02]    └─ 智能体推理 (600ms)
[00:02]       └─ LLM 调用 (800ms)
[00:03]    └─ 智能体回复

关联导航：点击对话中的"工具调用"，自动跳转到追踪中的对应 Span——就像看书时看到脚注编号，就能快速定位页末的详细解释。

评估结果可视化：统计分布 vs 单点数值

传统评估只给个"准确率 85%"，但这有误导性——也许 100 道题里，60 道全对，40 道全错，平均就是 60% 对（准确率 85% 暗示每题都对或错）。

AgentScope 的分布可视化：

准确率分布：
      ▆▆▆▆  (30 题，准确率 100%)
   ▅▅       (20 题，准确率 80%)
▇           (50 题，准确率 0%)
   0    50   100

分类统计：

"始终正确"：30 题
"始终错误"：50 题（主要问题！）
"不稳定"：20 题（需要改进鲁棒性）

轨迹对比：

点击"不稳定"组中的某个失败案例
看完整执行轨迹：在哪一步失败了？
对比成功案例的轨迹：差异在哪里？

Friday：内置的智能副驾驶

Studio 内置了一个叫 Friday 的智能体，它有两重身份：

助手：回答开发者的问题

- "怎么定义一个自定义工具？" - "AgentScope 的内存系统怎么用？" - Friday 搜索文档、代码，直接给出答案

展示：演示 AgentScope 的高级能力

- Friday 本身就用到了实时转向、长期记忆、动态工具提供等功能 - 开发者可以参考 Friday 的实现

费曼式理解：Friday 就像一个"活的文档"+"示范案例"——不是死板的说明书，而是能对话、能展示的智能导师。

六、运行时系统：从实验到生产

6.1 Runtime：智能体部署的双核引擎

如果 AgentScope 是智能体的"城市基础设施"，那么 Runtime 就是"市政管理系统"——负责把智能体部署到生产环境。

双核架构：

┌─────────────────────────────────┐
│         Runtime                 │
├─────────────────────────────────┤
│  Engine（引擎）：               │
│   - 生成 FastAPI 服务          │
│   - 会话管理                   │
│   - 生命周期控制               │
├─────────────────────────────────┤
│  Sandbox（沙箱）：             │
│   - 隔离环境                   │
│   - 安全执行                   │
│   - 资源限制                   │
└─────────────────────────────────┘

Engine：一键部署

from agentscope_runtime import Runner, ContextManager

# 创建智能体
agent = ReActAgent(name="Friday", model=model, toolkit=toolkit)

# 创建 Runner
runner = Runner(agent=agent, context_manager=ContextManager())

# 一键部署（自动生成 FastAPI 服务）
await runner.deploy(
    deploy_manager=LocalDeployManager(host="localhost", port=8090),
    protocol_adapters=A2AFastAPIDefaultAdapter(agent=agent)
)

部署后：

自动获得 /process 端点，可以接收请求
内置健康检查 (/health)
支持 Google A2A 协议（跨框架通信）

Sandbox：安全执行环境

智能体要执行代码、访问文件系统，但安全怎么保证？

Sandbox 提供隔离环境：

from agentscope_runtime.sandbox.tools.base import run_ipython_cell

# 自动沙箱管理（每次调用独立环境）
result = run_ipython_cell(code="import os; print(os.listdir())")

# 持久沙箱（跨调用保持状态）
with BaseSandbox() as sandbox:
    func = run_ipython_cell.bind(sandbox=sandbox)
    func(code="data = [1, 2, 3]")  # 第一次调用
    func(code="print(sum(data))")      # 第二次调用，data 还在

专用沙箱：

Filesystem Sandbox：限制文件访问范围
BrowserSandbox：隔离浏览器会话
TrainingSandbox：资源受限的训练环境

伏笔：沙箱的安全执行为后续的"浏览器智能体"和"代码执行智能体"提供了基础设施——没有沙箱，这些智能体根本不敢在生产环境运行。

七、应用场景：从原型到实践的跨越

7.1 用户-助手对话：最简单的起点

import asyncio
from agentscope.agent import ReActAgent, UserAgent

async def main():
    # 创建智能体
    agent = ReActAgent(
        name="Friday",
        sys_prompt="你是一个有用的助手",
        model=model,
        toolkit=toolkit,
        memory=InMemoryMemory()
    )
    user = UserAgent("Bob")

    # 轮流对话
    msg = None
    while True:
        msg = await user(msg)
        if msg.get_text_content() == "exit":
            break
        msg = await agent(msg)

asyncio.run(main())

费曼式理解：就像打电话——你说一句，智能体回一句，直到你挂机。

7.2 多智能体对话：模拟真实协作

from agentscope.pipeline import MsgHub, sequential_pipeline

# 创建三个角色
alice = ReActAgent(name="Alice", sys_prompt="你是教师，30岁")
bob = ReActAgent(name="Bob", sys_prompt="你是学生，14岁")
charlie = ReActAgent(name="Charlie", sys_prompt="你是医生，28岁")

# 在 MsgHub 中组织对话
async with MsgHub(
    participants=[alice, bob, charlie],
    announcement=Msg("system", "请自我介绍", "system")
) as hub:
    # 顺序发言
    await sequential_pipeline([alice, bob, charlie])

    # 动态调整：Bob 离开
    hub.delete(bob)
    await hub.broadcast(Msg("Bob", "我有事先走", "assistant"))
    await alice()  # Alice 对 Bob 离开的反应
    await charlie()  # Charlie 的反应

照应前文：这里用到了前面介绍的 Pipeline 和 MsgHub 抽象——伏笔在这一章得到回收。

7.3 深度研究智能体应用

初始化：

# 连接 Tavily 搜索服务
client = StdIOStatefulClient(cmd=["npx", "-y", "@tavily/mcp"])
client.connect()
toolkit.register_mcp_client(client)

# 创建研究智能体
research_agent = DeepResearchAgent(
    name="Researcher",
    model=model,
    toolkit=toolkit,
    memory=InMemoryMemory()
)

执行：

用户：帮我写一篇关于"量子计算最新进展"的报告

智能体（自动）：
1. 分解：量子纠错、量子算法、实验进展...
2. 广泛搜索：用多个查询词收集素材
3. 深度挖掘：精读关键文章
4. 反思：信息不足，补充搜索
5. 总结：生成结构化报告

7.4 浏览器智能体应用

# 用户：帮我查一下特斯拉的股价

智能体：
1. 子任务分解：
   - 打开浏览器
   - 导航到 finance.yahoo.com
   - 搜索 "TSLA"
   - 查看股价

2. 执行：
   - navigate("https://finance.yahoo.com")
   - search("TSLA")
   - screenshot()
   - extract_price()

7.5 元规划器应用

场景：开发一个数据分析平台

# 用户：帮我开发一个数据分析平台

Meta Planner：
1. 规划阶段：
   - 生成 Roadmap：
     [
       {"任务": "需求分析", "状态": "completed"},
       {"任务": "数据采集", "状态": "in_progress"},
       {"任务": "数据清洗", "状态": "pending"},
       {"任务": "数据分析", "状态": "pending"},
       {"任务": "可视化", "状态": "pending"}
     ]

2. 执行阶段：
   - 为"数据采集"创建 Worker Agent（分配搜索工具、API 工具）
   - Worker 完成，更新 Roadmap 状态
   - 为"数据清洗"创建 Worker Agent（分配文件工具、代码工具）
   - ...

3. 进度跟踪：
   - 定期保存 Roadmap 状态
   - 中断后可以恢复

八、总结：智能体的城市文明

AgentScope 1.0 的本质，是为智能体建造一座城市。

这座城市的设计哲学：

8.1 费曼式的简单

复杂的技术，被拆解成简单的模块：

消息 = 统一身份证
模型 = 通用翻译官
内存 = 便利贴 + 档案馆
工具 = 瑞士军刀

每个模块都能独立理解，组合在一起又涌现出复杂能力。

8.2 红楼梦式的层次

表层：清晰的技术文档中层：系统设计的隐喻（城市、协作、涌现）底层：智能体本质的思考（推理与行动的螺旋、记忆与遗忘的平衡、个体与集体的关系）

8.3 CAS 的涌现

简单的 ReAct 循环，产生复杂行为
独立的智能体，通过 MsgHub 交互，涌现出群体智慧
工具、模型、内存的组合，涌现出意想不到的新能力

8.4 钱学森的系统观

整体把握：AgentScope 不是工具集合，而是一个系统——各组件相互作用、相互依赖。

局部回归：每个模块（消息、模型、内存、工具）的设计都服务于整体目标（构建可用的智能体应用）。

九、未来：智能体文明的演进

AgentScope 1.0 奠定了基础，但智能体的城市还在不断演化：

短期方向：

更多内置智能体（代码审查、内容创作、数据分析...）
更强大的评估基准（行业标准测试集）
更丰富的可视化功能（3D 追踪、热力图...）

中期方向：

跨框架协作（与 LangChain、AutoGPT 等互操作）
自主智能体市场（智能体像 App 一样可以买卖）
智能体联邦（多个智能体城市之间的联盟）

长期愿景：

想象一个世界，智能体像人类一样：

有专业分工（医生智能体、律师智能体、工程师智能体...）
有社交网络（智能体之间互相推荐、协作）
有经济系统（用 Token 购买智能体服务）
有文化（智能体的"价值观"和"风格"会演化）

AgentScope，就是这座城市的基础设施提供商。

十、结语：从城市到文明

AgentScope 1.0 的发布，标志着智能体开发从"实验室原型"迈向"生产级应用"的关键一步。

但更重要的是，它体现了一种哲学：

智能体不是工具，而是协作的伙伴。

它们有记忆，能记住你的偏好
它们有推理，能理解你的意图
它们有协作，能和其他智能体一起工作
它们有演化，能从经验中学习

AgentScope 提供的不是一套代码库，而是一个生态系统——就像城市不只是建筑物的集合，而是人与人之间复杂交互的系统。

在这个系统里，开发者专注于创造有"灵魂"的智能体，而 AgentScope 负责提供基础设施——交通、通信、记忆、工具。

从单体智能，到群体协作；从孤岛工具，到城市文明。

这就是 AgentScope 1.0 的使命。

"简单是终极的复杂。"——达·芬奇

AgentScope 把复杂的智能体系统，简化为可组合、可扩展、可理解的模块。

但在简单的表象下，隐藏着涌现的复杂性——这是智能体的城市，也是未来的文明。

附录：快速开始

# 安装
pip install agentscope

# 最简单的例子
import asyncio
from agentscope.agent import ReActAgent, UserAgent
from agentscope.model import OpenAIChatModel
from agentscope.memory import InMemoryMemory

async def main():
    # 创建智能体
    agent = ReActAgent(
        name="Jarvis",
        sys_prompt="你是一个有用的 AI 助手",
        model=OpenAIChatModel("gpt-4"),
        memory=InMemoryMemory()
    )
    user = UserAgent("Tony")

    # 对话
    msg = None
    while True:
        msg = await user(msg)
        if msg.get_text_content() == "exit":
            break
        msg = await agent(msg)

asyncio.run(main())

一行代码，连接 Studio：

from agentscope.studio import init_studio
init_studio()

打开浏览器，访问 http://localhost:5000，你就能看到智能体的内心世界。

本文基于 arXiv:2508.16279 论文撰写，采用费曼式比喻、红楼式隐喻、CAS 涌现思维和钱学森系统观，以通俗易懂的方式讲解 AgentScope 1.0 的设计与实践。