铃阅时讯
❌

阅读视图

WAIC 2026开幕式主论坛 | 印奇:当智能体走进物理世界

阶跃StepFun 2026-07-17 21:50 北京

当智能体进入物理世界,每个人的可能,都将被十倍放大

2026 世界人工智能大会(WAIC 2026)今日开幕。作为全球人工智能领域的顶级盛会,本届大会以“智能伙伴 共创未来”为主题。

阶跃星辰董事长、千里科技董事长印奇作为特邀嘉宾出席大会开幕式并在大会主论坛(上午场)发表主题演讲《当智能体进入物理世界》。

以下为演讲全文——

各位嘉宾、各位朋友:

非常高兴在 WAIC 的开幕式上,和大家一起探讨人工智能技术和产业发展的下个阶段。过去 5 年,AI 快速发展,回看每一次 AI 爆发,都离不开两股力量的结合:超级模型与超级应用。Transformer 大语言模型和 chatbot 聊天机器人的结合,带来了 ChatGPT 时刻;强化学习、推理模型与辅助编程的结合,打开了 AI 编程的巨大机遇。那么,下一波爆发点会是什么?我们看到的一个巨大的可能,就是智能体模型和下一代终端产品的结合。

所以,今天我想分享的主题是:当智能体走进物理世界。

15 年前,我刚刚大学毕业,选择的第一份工作就是成为一名 AI 创业者。15 年后,AI 创业从一个小众赛道变成这个时代全球最大的共识之一。我深感能在这个时代成为一名 AI 创业者,无比幸运。

当今的每一位 AI 研究者和 AI 创业者,都是站在历史巨人的肩膀上。

一边是 70 年来几代 AI 科学家孜孜不倦的探索。不管是符号学派还是连接学派,再到深度学习和大模型。细看整个 AI 技术的发展脉络,都呈现出高度的连续性,同时又具备从量变到质变、如阶跃函数般的跳变性。

另一边,沿着产业和应用的角度,IT 行业、PC 互联网、移动互联网、云计算、半导体、新能源,共同构成了 AI 爆发不可或缺的序章。

2026 年,模型能力跨越了能力的临界点。可以说,我们已经站在 AGI 高峰的山脚下。

5 年前,AI 能连续执行的任务时长仅仅是几秒钟,今天它已经能够独立工作数十小时,而且进步的斜率还在不断增大。我发现其中一个有趣的规律,AI 发展的里程碑似乎总和一个词紧密相关,那就是“语言”。

从早期的图灵测试,机器能否如人类一般掌握自然语言,是衡量智能最重要的标准;后来大语言模型 predict next token 的模式出现,一开始大家认为这不是智能,到后面惊讶的发现这恰恰开启了通往智能的真正大门。

再到 2026 年的关口,AI 已经不光掌握了人类交流的语言,还在人类最重要的智力劳动——编程上快速追赶甚至超越人类。

这可能会成为图灵测试的 2.0 版本:在最重要的语言框架下,机器是否能超越人?下一阶段更关键的问题也将变成,我们如何为 AI 进入物理世界设计一套新的语言体系?哲学家维特根斯坦曾说:“语言的边界,就是世界的边界。”在 AI 的世界里,也似乎遵循这个规律。

无论是从模型技术演进还是产业发展的角度,“智能体”都变成 AI 下一阶段最重要的关键词。回看历史,所有的产品都是某种服务的载体。在信息革命 80 年的时间里,最重要的产品形态,从大型计算机、个人计算机,再到软件、网站、移动应用,接下来可能快速转变成“智能体”这样一种新载体。

智能体,将不仅是一个聊天的机器人,它能感知外部物理世界,理解用户深度记忆和偏好,综合决策和执行,完成用户交予的各项任务。

智能体,正在成为生产力的最小单元。

未来,每个人身边都会有专业智能体:工程师有代码智能体,设计师有创意智能体,研究员有分析智能体……这些智能体,会让一个人拥有一支团队的能力,也让屏幕里的智能真正走进我们的工作和生活。

因此,智能体带来的不是一个单点应用机会,而是三个结构性变化:新系统、新载体、新网络。

第一,是新系统。

过去四十年,每一次计算平台的变化,都伴随着操作系统的变化。PC 时代管理软件,移动时代管理应用,智能体时代则要管理很多能够理解目标、规划路径、调用工具并执行任务的智能体。因此,智能体能做什么,不只取决于模型有多聪明,也取决于操作系统为它打开了多大的能力边界。

因此我提出一个公式:智能体能力 = 模型能力 × 智能体操作系统能力。

如果说模型决定智能体能“想多远”,那么 Agentic OS 决定智能体“走多远”——它连接模型与数据、工具、接口和设备,让智能体不仅能够理解世界,也能够采取行动。这就是智能体原生操作系统,它将成为未来人机交互和产业生态的重要基础设施。

第二,是新载体。

移动互联网时代,终端连接人与数字世界;智能体时代,终端将带着智能走进物理世界。它不再只是等待人的操作,而是能够感知环境、理解情境并采取行动。

这意味着,终端的设计逻辑正在改变:过去,我们围绕人的操作方式设计机器;未来,我们将围绕人与智能的协作方式重新定义终端。

终端的设计理念也将从“以人为本”,进一步走向“人机共生”。

电脑将成为 Agent 工作站,手机将成为随身智能中枢,汽车将成为移动智能空间,机器人将成为人类身边的智能伙伴。更重要的是,这些终端不再彼此孤立。电脑、手机、汽车和机器人,将成为同一个智能体在不同场景下的不同身体。智能可以在多个终端之间连续存在、自由迁移、协同完成任务。

未来的终端竞争,不再只是设备之争,而是谁能让智能体更好地感知环境、采取行动,真正进入物理世界。

第三,是新网络。

互联网时代,连接的是人、信息和服务;智能体时代,我们将还将连接能够理解目标、调度资源、协同工作的智能体。这就是 A2A 网络。

从产业视角看,这不仅一种通信协议,更是一张由 Agent 和人类共同构成的人机共生价值网络。未来,数十亿人、数百亿设备和智能体,都可能成为其中的节点,形成一个规模更大、协作效率更高的新型网络。

对创业者而言,这意味着新的产业机会:智能体会有自己的身份和信用。人们可以找到它、了解它擅长什么、把任务交给它,也可以根据它的表现付费、评价,以及与它合作。

当智能体能够自主寻找伙伴、组织协作、完成交易,A2A 就不再只是技术协议,而将成为智能体经济的基础设施。

但也正因为智能体正在进入组织、网络、设备和真实世界,我们必须看到:人机共生带来的,不只是能力跃迁,更是秩序重构。

当智能体开始代表人行动,我们必须回答三个问题:

    • 它可以代表谁行动?

    • 行动产生后果,谁来负责?

    • 当它连接数据、设备和真实环境,怎样确保身份可信、权限可控、行为可追溯?

过去,我们更多是在科幻作品中思考这些命题。今天,随着智能体走进现实,它们正成为必须真正面对的问题。

为此,阶跃正与图灵奖得主姚期智先生领衔的上海期智研究院开展前沿研究。我们也期待与全球专家学者一道,探索智能体时代新的技术体系、治理机制与社会契约。作为年轻一代 AI 创业者,我们既是这场技术浪潮的参与者和受益者,也是下一阶段秩序的共同建设者。我们有机会把智能从屏幕带入真实世界,也有责任让它更可信、更安全、更普惠,成为人类长期的伙伴。

Agent 时代最大的意义,不是替代人,而是放大人。它正在孕育新一代 AI Native 建设者,也催生新一代 AI Native 组织。

AI Native,不只是会用 AI,而是从第一天起,就把 AI 写进产品、系统和组织的基因里。对个人,它让一个人拥有一支团队的能力;对创业者,它意味着创造新产品、新组织,甚至一个全新的产业。

每一次技术革命,都会催生新一代伟大的企业。我们相信,人工智能时代的超级建设者,也一定会从 AI Native 组织中诞生,并由他们参与书写下一段产业历史。

最后,我想回到阶跃最朴素的使命:智能阶跃,十倍每个人的可能。

我相信,未来不是机器替代人的世界,而是人与智能共同进化的世界。

在 AI 行业的 15 年里,我觉得最有意思的地方是:技术还年轻,产业还年轻,很多问题还没有标准答案。大家不是在一条已经铺好的路上竞速,而是在一起把这条路修出来。

因此,我们这一代 AI 创业者要做的不只是创造更强的模型,更要让智能走进真实世界,成为每个人都能使用、都能信任的力量。

当智能体进入物理世界,每个人的可能,都将被十倍放大。

谢谢大家。

跳转微信打开

  •  

Wan-Streamer v0.2:响应延迟仅550ms,让 AI 真正与你"面对面"

原创 通义实验室 2026-07-17 15:14 浙江

实时互动,丝滑连麦~

和 AI 打视频电话,卡顿、延迟、声画不同步,是常态。

这本质上就是“语音识别 ➡️ 大模型 ➡️ 语音合成 ➡️ 动画驱动”的流水线拼装。环节越多,延迟越高,割裂感越强。

但真正的自然交流,应该像和朋友打视频一样自然:没有卡顿,没有等待。

它能实时读懂你的微表情,像真人一样点头、做手势,让声音、唇形与神态在毫秒间完美同步。

最新发布的 Wan-Streamer v0.2 让这成为现实。

一分钟认识 Wan-Streamer

它是面向实时双工交互的端到端全模态理解与生成模型,把“听、看、说、演”统一进单个 Transformer 中,让 AI 像真人一样边听、边看、边回应。

  • 极致低延迟:端到端响应延迟 550ms(200ms模型延迟 + 350ms网络延迟),

  • 画质增强:输出分辨率从 v0.1 的 192×336 提升至 640×368 @ 25FPS,微表情场景细节清晰可见;

  • 全模态端到端:原生支持文本、音频、视频的实时理解与同步生成,无需外部模块拼装。

我们对比了市面上主流的实时交互系统。在响应延迟上,Wan-Streamer 的端到端交互延迟在 0.55s 左右(含网络传输),显著快于常见的实时语音对话模型。

在功能覆盖上,Wan-Streamer 同时具备了视频感知、视频输出、全双工交互、端到端架构且响应延迟控制在1秒内。

架构重构:从“流水线”到“原生因果流”

传统的实时数字人系统,底层通常是级联流水线。

“

举个例子:当你说一句话,系统需要等语音转成文字,大模型生成文本回复,再合成语音,最后驱动数字人张嘴。这个过程不仅要等待,而且各个模块独立运行,容易出现声音和嘴型对不上、表情僵硬的问题。

”

Wan-Streamer 将用户的文本、音频、视频输入,与智能体的输出,统一映射到同一条因果时间线(Causal Timeline) 上。

模型无需等待“一整段话”说完,而是引入了流式单元(Streaming Unit) 的概念。大约每160ms就会完成一次完整的闭环:

  • 感知当前 160ms 的用户音视频输入;

  • 更新共享的交互状态与上下文;

  • 生成同步的语音和视频 Latent(潜变量);

  • 解码并输出上一单元的音视频响应。

这意味着,AI 不需要等你说完再想,而是在你说话的每一小段时间里,同步完成“感知 ➡️ 理解 ➡️ 生成 ➡️ 解码”。这种原生流式的建模方式,是实现极低延迟与全双工交互的基础。

从 v0.1 到 v0.2:画质跃升与“场景锚定”

v0.1 验证了端到端原生流式音视频对话的可行性,但 192×336 的分辨率在视觉上局限于近景特写(Close-up),主要聚焦于面部和嘴型。

v0.2 将输出分辨率大幅提升至640×368。这不仅仅是像素的增加,更带来了视觉构图与应用场景的质变。

AI 不再只是一个“悬浮的头部”。在 v0.2 的画面中,你可以清晰看到它的视线方向、身体姿态、自然的手势动作,甚至它面前的桌子和周围的房间布局。

技术解密:Thinker-Performer 双通路与 Ulysses 并行

分辨率的大幅提升,意味着视频 Latent 生成的计算量显著增加。如果将这些计算任务放在原有的低延迟通路中,200ms 的模型侧延迟底线将被突破。

如何在提升画质的同时,不增加用户可感知的延迟?

Wan-Streamer v0.2将模型拆分为两条并行通路,在物理硬件上进行解耦:

思考者:单卡快车道

Thinker 部署在单张 GPU上,负责所有对延迟敏感的任务:流式音视频感知、语言与状态更新、构建 K/V 缓存(让模型记住上下文),以及音频解码。 

它就像对话中的“大脑”,负责快速听懂你的话、记住上下文,并立刻组织语言,保证 200ms 的极低响应。

执行者:多卡 Ulysses 并行

640×368 的高分辨率视频生成计算量极大。在 Wan-Streamer v0.2 中,Performer 被扩展为一个多 GPU 的 Ulysses 式上下文并行集群,专门承担这部分重载计算。 

它就像幕后的“渲染团队”。因为高清画面计算量大,系统采用 Ulysses 序列并行机制,将长视频序列切分给多张显卡分工合作、并行去噪。(注:由于音频 Latent 序列较短,切分反而会增加通信开销,因此音频生成不进行序列切分,直接计算)。

时序重叠

更关键的设计在于时序调度。单卡 Thinker 的工作窗口与多卡 Performer 的计算窗口是重叠的。 当 Performer 集群在后台处理当前帧的高清视频 Latent 时,Thinker 已经在处理下一帧的用户输入,并解码上一帧的音频。

通过这种“快慢分工、时序重叠”的架构,v0.2 将额外的视觉生成成本从延迟敏感路径中剥离。在包含 350ms 双向网络预算的情况下,总远程交互延迟依然保持在约 550ms。

Wan-Streamer v0.2  延迟保持部署拓扑时序图

万物皆可对话:想象力才是唯一边界

只要能用自然语言描述,Wan-Streamer 就能在虚拟世界里把那个"角色"实时呈现出来,和你面对面交流。没有预设剧本,没有固定角色库——你的想象力就是唯一的边界。

你可以和秦始皇聊统一六国,听李白即兴吟诗、让蒙娜丽莎开口说话,和清明上河图里的路人聊聊宋朝生活,还能问问你家猫主子整天都在想什么......

基于这种高度自由的角色生成能力,Wan-Streamer 典型的应用场景包括:

  • 视频通话式 AI 助手:打开摄像头即可面对面交流,适用于口语陪练、面试模拟、心理咨询等需要“在场感”的场景。

  • 场景化陪伴与教育:AI 老师可以通过画面“看着”学生的表情判断理解程度;AI 可以在厨房里实时指导做菜的步骤。

  • 沉浸式游戏 NPC:游戏中的角色可以拥有表情、肢体语言和实时反应,与玩家进行真正的“面对面”对话。

  • 无障碍交互:为听障用户实时生成带精确唇语和手势的视频回应;为视障用户实时描述摄像头捕捉到的周围环境。

让 AI 能够自然地参与实时对话,需要它真正理解用户的话语、读懂表情,并在几百毫秒内给出综合反应。

Wan-Streamer v0.2 是我们在这一方向上的持续探索:通过原生流式架构与分布式推理拓扑,在单一模型的交互循环中同时完成理解与生成,让 AI 的沟通方式进一步逼近真人。

这是一条长期的研究路线,我们将持续迭代 Wan-Streamer,敬请期待。

推荐内容

Qwen-Audio-3.0-Realtime 如何让语音交互“懂倾听,更聪明”?

跳转微信打开

  •  

AI专栏 | Demo 跑通了,上线就翻车?Java Agent 生产的那些坑,我们帮你填了

原创 Cris/小蜗牛 2026-07-17 11:50 上海

一个 Harness,把 Java Agent 从 Demo 拉到生产

作者简介

Cris Yang,携程资深后端开发工程师,关注AI原理探索与Agent构建。

奋斗的小蜗牛,开源项目 SnailJob / SnailAi 作者。专注于系统架构、分布式设计、高性能系统与 AI Agent 技术探索。

导读:Java 团队做 Agent,不缺模型接入方案,缺的是让 Agent 稳定跑在生产里的运行时能力。记忆漂移、大报文击穿上下文、推理不可复盘、工具变更要发版——这些问题现有框架不兜底。Spring-Ai-Trip 在 Spring AI 上叠加了一层 Harness,用渐进压缩、Spill 溢出保护、认知可观测等机制,填平 Demo 到生产之间的鸿沟。如果你也在 Java 侧做 Agent,也在被这些“Demo 跑通了,上线就翻车”的问题反复折磨,这篇文章或许能帮你少踩几个坑。

一、Java 侧做 Agent,我们到底缺什么

二、设计哲学:我们如何看待 Agent 运行时

三、系统架构:Spring-Ai-Trip 的全景视图

四、短期记忆:渐进式压缩

五、可观测性:Span + Event 树

六、Spill:大结果的溢出保护

七、能力供给:填平 Skill 的空白 + MCP 热插拔

八、并行工具调用:能同时做的事,别排队

九、端到端实战:一次排障会话,把所有机制串起来

十、Roadmap:我们还在往哪走

一、Java 侧做 Agent,我们到底缺什么

过去两年,Agent 生态的语言分布很偏——Python、TS 那边百花齐放,Java 这边一直不温不火。LangChain4j 和 Spring AI 把接入大模型这件事做得挺到位,后来的 Spring AI Alibaba、AgentScope Java 又在编排和多 Agent 协作方向补上了部分能力。但真正在生产里做过 Java 侧 Agent 的团队,大概率都踩过下面这三个问题:

  • 技术栈错配:国内后端团队的技术栈基本以 Java 为主,用 Python 独立搭建服务会带来跨语言 RPC 调用,同时需要维护两套可观测体系、两套配置中心,让整队人转去写 Python 也不现实。他们要的不是能用 Python 跑的 Agent,而是"能用 Java 写、能长在现有业务代码旁边"的 Agent。

  • 企业级治理断层:多数开源框架只做到能跑起来:调通模型、跑通工具。至于链路追踪、配置中心、限流熔断、审计合规、灰度发布——大多要业务方自己接。

  • 运行时空白:即便选了 Java 方案,现有框架也基本只做到能调通大模型。而生产化真正的难点在运行时:短期记忆怎么管、单次工具返回的 5 万字报文怎么处理、错误结论的推理过程怎么回溯、工具怎么在不重启的情况下加减、并发工具调用怎么保证一致性——这些几乎没有框架给你兜。

会调大模型,只是拿到了入场券;让 Agent 稳定、可控、可解释地跑在生产里,才是真正难的部分。

现有 Java 方案审视

Spring AI把接入大模型这件事做得很轻,统一的模型抽象、Advisor 拦截链、Tool Calling 注解对 Java 工程师很友好。但也就到接入这一步:ChatMemory 只有滑动窗口这类基础实现,工具返回值直接进上下文、没有溢出保护,Observation 只覆盖到"调用发生了"这一层,工具注册是启动期静态的,会话生命周期没有作用域概念。

Spring AI 是模型抽象层,不是Agent 运行时。它给你一辆能开的车,但生产化需要的变速箱、ABS、行车电脑,得自己造。

Spring AI Alibaba走得更远,Graph 编排、Nacos 集成、DashScope 生态、Studio 工具链。我们没选它:一来我们已经在用 QConfig、CAT、内部 MCP 网关,换 Nacos 这套等于把现有基建全部替掉;二来它的重点在编排,我们头疼的是单个 Agent 内部怎么更稳定的运行。

AgentScope Java出现得晚,但布局铺得比较全:不可变消息、@Tool 注解、A2A / MCP 双协议、Reactor 非阻塞,适合新起项目。它和我们的场景不一样:它是一站式开发平台,我们是往已有 Spring Boot 服务里嵌的一层。后文会把它拿来做对照。

Spring AI 之外这块空白,大到值得单独做一层。我们将该中间层叫做 Spring-Ai-Trip,作为挂载在 Spring AI 与业务 Agent 之间的Harness。

二、设计哲学:我们如何看待 Agent 运行时

在讲机制之前,先把心法交代清楚,后面所有具体设计,都是这四条原则的推论。

2.1 叠加,而不是替代(Additive over Replacement)

不重造 Spring AI 的轮子,所有能力以 Advisor / ToolCallback / Observation 的方式挂到它上面。业务方随时可以只用 Spring AI 原生能力,也随时可以按需开启我们的能力项。

2.2 读写分离,把复杂度推后(Lazy Compaction)

写入路径永远简单快速——毫秒级落库,零加工。所有 Agent 决策(压缩、预算判断、锚定、修复)都推迟到注入模型的那一刻再做。原始数据永远完整保留在库里,复盘、审计、回放随时可查。

2.3 信息不丢弃,只降级(Progressive Degradation)

面对上下文压力,信息从高精度原文渐进降级到高密度摘要,而不是断崖式截断,也不是被打散成检索碎片。我们要的是斜坡,即保留连续的、可读的、只是密度不同的一份历史。

2.4 默认安全,业务无感(Safe by Default)

异常路径的清理、并发下的一致性、工具下线的安全窗口、进程重启后的会话续接,这些脏活都由框架在业务背后处理干净。

三、系统架构:Spring-Ai-Trip 的全景视图

3.1 整体架构图

3.2 核心数据流

一次 agent调用穿过 Harness 的完整路径,大致是这样:

四、短期记忆:渐进式压缩

Agent 的短期记忆决定了它是能连续作战的助手,还是每轮从零开始的无状态函数。没有记忆的 Agent 本质上是 f(当前输入) → 输出,会在三个层面断裂:

  • 对话连续性断裂:第 1 轮说"处理订单 ORD-2024-001",第 5 轮问"进展怎样了"——Agent 已经不记得订单号

  • 决策链断裂:中间环节丢失,无法基于已有结论继续推进

  • 行动链断裂:早期工具返回消失,可能重复调用或跳过步骤

记忆不是 Agent 的附加功能,而是 Agent 区别于 API wrapper 的本质特征。

4.1 通行做法的结构性缺陷

上下文窗口是固定的,对话越长越满,必须淘汰一些内容。核心问题是淘汰标准:按什么规则丢、丢完之后关键信息还在不在。

滑动窗口——Spring AI 的 MessageWindowChatMemory、LangChain 的 ConversationBufferWindowMemory 都是这个路子:保留最近 N 条消息,超出从队头丢。它用位置作为唯一淘汰标准,可信息的价值根本不由时间决定——用户第 1 轮说的"帮我处理订单 ORD-2024-001 的退款",可能比第 19 轮那句"嗯"重要一万倍。到第 21 轮,窗口一滑,最初的目标被无声丢弃,于是 Agent 开始目标漂移:越聊越偏,或者每一轮都在重新猜用户到底想要啥。

RAG 检索——把历史向量化,用时再捞。它擅长跨文档知识检索,但用作会话记忆有个硬伤:它按语义相似度捞相关片段,却感知不到时序,也拼不出对话的整体画像——Agent 知道自己某次查过订单,却不知道整个任务进展到哪一步了。

看清了这些,我们的设计哲学其实就一句话:

永远不丢弃任何信息;注入模型时,按信息价值的衰减曲线,渐进地压缩。

"渐进"是关键词。信息不是在某个边界突然消失,也不是被打散成碎片,而是连续、分级地从高精度原文过渡到高密度摘要。

在思考这套渐进压缩具体怎么做时,Claude Code 的四层上下文管理机制给了我们很大启发——我们借鉴了其中三条核心思想:信息不应被断崖式截断、摘要应该结构化而不是"总结一下"、压缩之后需要显式恢复。但不能直接照搬:Claude Code 是单机 CLI,单进程持有会话状态、SM 文件写本地磁盘;我们是分布式服务端,多实例无粘性会话、要跨实例续接、要接多家模型厂商——这些差异决定了我们最终落地的形态和它不同。

4.2 三层防御体系

第一层:完整持久化。所有消息逐条落库,只追加、不删除。

这一层还带来一个容易被忽视、却极其关键的设计——读写分离。写入永远只是简单的一次落库,毫秒级,零压缩开销;所有压缩都只发生在读取、注入模型的那一刻。原始数据一条都不少地躺在库里,复盘、审计、回放随时可查。这一步还顺带解决了服务端才需要面对的跨实例会话续接:任何实例接过 sessionId,都能从库里拿到完整历史 + 摘要,不依赖任何本地状态。

第二层:工具结果微压缩。这是一个纯内存计算、完全不调用大模型的轻量回收。它的核心洞察是:一次工具调用的返回值,价值衰减得极快。一个 3000 token 的订单查询结果,在 Agent 已经据此告诉用户"订单已发货"之后,那 3000 token 的原始 JSON 就不再需要了——留下"我查过了,已发货"这个事实就够了。

    压缩前(约 3000 tokens):

      [工具] query_order → {"status":200,"body":{"orderId":"...","items":[...大量数据...]}}




    压缩后(约 10 tokens):

      [工具] query_order → "[旧工具结果已清理,可按 evidence-id=e7f3a 回查]"


    一些打磨得比较细的点: 以完结轮次为原子单位——工具调用链可能横跨好几条消息,只有当整轮真正结束了其中的结果才有资格被回收,绝不切断正在进行的调用链;按工具分策略——不同工具挂不同压缩规则,关键操作永不压缩、查询结果过期即清

    替换文本带证据指针——清理后的占位符里带一个指向持久化层的 evidence-id,排障时需要还原当时看到了什么,直接按指针回查即可,和后面讲的可观测性打通,原始工具返回并没有真的消失,只是从注入模型的上下文里退场。一次 20 轮工具调用的对话,光微压缩就能释放约 5 万 token。

    第三层:LLM 结构化摘要。 当微压缩之后仍然超预算,才动用大模型,把早期对话折叠成一份结构化摘要。注意,这不是让模型随便总结一下,而是按一个固定的九段式模板来写,并且给每一段排了优先级:

    这个设计直接命中前面说的目标漂移:User Intent 和 Current State 被显式地、结构化地锚定在摘要里,无论压缩多少轮,Agent 始终清楚"用户要什么"和"我做到哪了"。token 实在不够时,先从 P3 往下砍,P0 段落死保。摘要以 <system-reminder> 标签包住、作为一条历史消息注入,插在近期原文之前,既压缩了信息量,又最大限度保住了会话连贯。

    对话再长呢?摘要之上还能再做摘要。当已有一份摘要、又积累了一批新对话,框架会以合并更新的方式做增量摘要——在旧摘要基础上更新各段,而不是从头重写。于是摘要的质量随对话深度线性提升,而不是反复推倒重来。

    顺带对照一下 AgentScope Java 的思路:它的短期记忆走标准的消息容器

    ( InMemoryMemory ),长期记忆则通过 LongTermMemory 接口委托给 ReMe / Mem0 /阿里百炼等外部服务——重心是"记忆服务的对接"。回到"单会话内不忘事"这个问题上,它的重心不在这里;我们更像在做"记忆的注入形态"。两种取向没有对错,解决的是不同层次的问题,甚至可以叠加。

    4.3 悬空调用修复:服务端才会踩到的坑

    还有一个真实生产才会踩到的坑:服务中断。假如一轮工具调用刚发出、结果还没回来,进程就重启了,库里就留下了一个悬空的工具调用——这违反了大模型 API 的消息协议,下次直接报错。框架在加载历史时会自动检测并修复这种残缺,把违规的悬空消息剔除干净,让会话能安全地接着跑。这类"脏活",正是分布式 Harness 该替业务扛下来的。

    4.4 动态预算:为什么固定配额会翻车

    那么,超不超预算这条线,到底谁来划?

    给历史消息分配固定配额(比如窗口的 80% 留给历史)这个想法,建立在一个错误假设上——prompt 里除历史之外的部分是稳定的。它一点都不稳定:系统提示词(从几十到三千多 token)、工具 Schema(20 个工具轻松过万)、当前用户输入(一句"好"是 1 token,粘贴一份日志是几千 token)——固定比例要么太保守、要么一遇工具增多就溢出。

    正确的算法不是"取窗口的某个比例",而是"窗口减去所有已知固定开销之后,剩下多少给历史"

      有效窗口   = 上下文窗口 − 预留输出(默认 8000) − 安全缓冲(默认 3000)

      固定开销   = 系统提示词 + 工具 Schema + 当前输入

      历史预算   = 有效窗口 − 固定开销

      预估总量   = 固定开销 + 摘要 tokens + 历史 tokens

      触发压缩   ⇔  预估总量 > 有效窗口 × 阈值(默认 0.90)


      关键在"先扣后算":不可压缩的输出预留和安全余量先扣掉,固定开销再扣掉,剩下的才是历史的真实空间;判断是否压缩时,摘要本身也占地方,必须算进去。所有 token 数由一个本地近似估算器算出——英文约 4 字符 1 token、中文约 2 字符 1 token、JSON 上浮 15%——不调用远程 tokenizer,靠 10% 的阈值余量兜住估算误差。

      五、可观测性:Span + Event 树

      Agent 的故障模式和传统服务根本不同:没有异常堆栈,没有错误码,服务运行一切正常——只是推理方向偏了。传统 APM 能覆盖调用链路和耗时分布,但覆盖不到推理层:模型在哪一步、基于什么证据、做出了什么判断,这些信息在现有监控体系里是缺失的。

      5.1 一个真实的排障案例

      用户问:"帮我看看为什么昨天下午订单转化率跌了。"Agent 调了几个工具,最后回答:"经查,是支付网关超时率上升导致的转化率下跌,建议排查支付链路。"

      结论有零有整,业务方信了,排查支付链路一整天,结果发现支付一切正常。

      问题到底出在哪?如果没有可观测性,你只能靠猜。而当你能把这次会话完整回放出来,真相一目了然:

      真相浮出水面:那个查超时率的工具,数据只覆盖到中午 12 点,而下跌发生在下午两点后。模型拿到的是一份残缺数据,却把"上午的上升趋势"错误外推成了"下午的根因"。

      错误不在模型笨,而在于它拿到的证据本身有问题,且没人能看见这个断裂。有了完整的 Span + Event 回放,你一眼就能锁定:不是模型的锅,是那个工具的数据覆盖范围有问题,去修工具,而不是去调提示词。

      5.2 认知可观测 vs 传统监控

      这就是认知可观测性和传统监控的根本区别:它记录的不只是调用发生了,而是模型基于什么证据、做出了什么推理、得到了什么结论。

      我们把一次 Agent 执行,建模成一棵由Span和 Event 组成的树:

      • Span 是有始有终、可嵌套的执行区间:一次会话套着多轮对话,每轮里有模型调用和工具调用。它天然还原了 Agent "思考—行动—再思考"的递归结构。

      • Event是 Span 内部的关键瞬间:模型的思维链、最终回复、工具的入参与出参、以及错误。

      尤其是 Thinking 事件——模型的思维链被显式捕获下来。上面那个例子里,正是第 3 轮那句"有上升趋势 → 大概率是它导致的",暴露了模型的推理跳跃。没有它,你永远只能对着一个错误结论干瞪眼。

      5.3 可观测性后台

      那么,如何让这些认知层的可观测事件——思维链、证据链、工具入参出参、token 消耗、错误现场——被开发者直观地感受到呢?一个好用的可视化后台同样必不可少。为此,我们把整棵 Span + Event 树做成了一个专门服务于 Agent 开发的可视化平台。

      通过它,开发者可以按会话回放 Agent 的每一次执行,把模型看到的"有效上下文""每一步的思维链""工具的入参与出参""token 与耗时的分布""异常事件的现场"一并摊在同一个视图里。最终答案只是结果,Trace 才是调优入口——写完一版提示词、加了一个工具、换了一个模型之后,改动到底让 Agent 变好了还是变差了,不再靠肉眼比对输出去猜,而是能落到一条条可对照的证据上

      六、Spill:大结果的溢出保护

      短期记忆管的是随时间累积的膨胀,但还有一类膨胀是瞬间的——单次工具调用就能返回 5 万字。我们踩过这个坑:一个 BAT 生态的 MCP 工具,某次调用甩回将近 5 万字的报文。这份报文一旦原样进入上下文,三件事同时发生:

        预算瞬间击穿——单条消息就吃掉大半个窗口,其它历史被迫大规模压缩甚至丢弃;

        注意力被稀释——模型淹没在海量它根本不关心的字段里,真正该看的那几行反而被忽略,输出质量肉眼可见地下滑;

        成本被引爆——这份报文会跟着后续每一轮对话反复重新发送,token 一次次翻倍计费。

        而模型绝大多数时候只需要其中某个字段,或者只需要知道这个接口调通了、数据拿到了。

        6.1 思路:类比操作系统的内存交换

        我们的应对,叫 Spill(溢出保护)。思路和操作系统的内存交换如出一辙:内存(上下文)放不下的大块数据,落到磁盘去,在内存里只留一个指针。

        具体来说,任何工具的返回值,一旦超过阈值(默认 32000 字符),框架会自动接管:

        • 把完整原文落盘持久化,一个字节都不丢;

        • 给模型的上下文里,只留一段预览(默认前 2048 字符)+ 一句明确的说明 + 一个可回读的路径。

        模型看到的,从一堵 5 万字的墙变成了这样:

          [工具结果过大,已溢出到磁盘]

          预览(前 2048 字符):

          {"code":0,"data":{"list":[{"id":"...","name":"..."} ...

          完整内容已保存至:spill://order-assistant/conv-abc/tool-7f3a.json

          如需完整数据,可使用读取工具按该路径获取。


          这个设计的巧妙之处在于,它把要不要看全文的决策权,交还给了模型自己。绝大多数情况下,预览里的信息已经足够它继续推理;万一真需要全文里的某个细节,它可以主动拿着路径去回读——甚至只读其中一段。

          信息一点没少,但它从"强行灌进大脑"变成了"需要时再查阅的档案"。

          6.2 几个我们打磨过的细节

          按 tool 粒度可配置。哪些工具触发、阈值多少、预览多长、要不要落盘,都能挂到策略上按工具定制。有些工具的输出天然结构化(比如 JSON List),可以在预览时智能截取前若干项 + 计数摘要;有些工具的输出是纯文本报告,直接截前 N 个字符就够了。

          回读工具支持范围读取。回读接口不是要么给你全文、要么什么都没有,而是允许按字节区间、按 JSON path、按分页游标读取——避免回读又把上下文爆一次。模型看到一个 5 万字的 spill 文件路径时,它可以只回读第 3 到第 5 条 list 项,而不是被迫拿全文。

          命名空间和会话生命周期绑定。Spill 文件按 agentName/sessionId/toolId 组织,天然属于一次会话的资源。会话结束(无论成功、失败、取消、超时),这批文件跟着会话作用域一起被清理,不会在磁盘上留下孤儿。

          并发一致性。多个工具在同一轮里并发返回、并发触发 Spill 时,文件命名要不冲突、回注消息要顺序对齐、可观测 Span 要各挂各的——这些一致性细节在虚拟线程环境下都经过了针对性测试。

          "大工具返回值该往哪放"这个问题,不是我们独家看到的坑。Spring AI 目前还没有这一层的原生抽象,工具返回值直接进上下文;LangChain 一侧靠调用方手动 truncate——信息就直接丢了。有意思的对照来自 AgentScope Java,它的 ToolResultEvictionMiddleware 思路和我们的 Spill 几乎撞在一起:超过阈值自动接管、原文落盘、上下文里换成预览占位符、模型按需回读。它甚至在设计文档里明确区分了两件事——eviction 解决"上下文的宽度"(单条消息太大)、compaction 解决"上下文的深度"(消息太多),和我们把 Spill 与短期记忆压缩分成两层的思路完全一致。不同团队独立收敛到相近的方案,这本身就说明"大工具返回值该落盘 + 预留回读入口"是这类问题现阶段的合理解。差异更多在细节和归属——阈值、预览方式、挂载层次、命名空间——来自各自场景的具体约束,而不是设计思路的分歧。

          七、能力供给:填平 Skill 的空白 + MCP 热插拔

          Agent 的能力边界,由它手里的工具决定。这里有一对天生的矛盾:

          • 工具给少了——Agent 啥也干不成;

          • 工具给多了——每个工具的名字、描述、参数 Schema 都要塞进上下文,20 个工具轻松吃掉上万 token,不但烧钱,还稀释模型注意力。

          更别提工具还会变:今天上线一个新数据源,明天下线一个旧接口。难道每次都要改代码、发版?

          7.1 拆解一:填平 Spring AI 在 Skill 上的空白

          Skill 按需加载的思路早已是业界共识:上下文里只放技能清单(name + description),模型判断需要时,再调工具捞正文。这一层机制本身不新——新的是 Spring AI 在这件事上是一片空白,业务方要么自己拼加载器,要么把指令全塞进 system prompt。

          我们把 Skill 作为一等公民补齐,做了两个来源的实现:

          • 内置 Skill(classpath 加载):团队沉淀的通用能力——日志排查、大工具输出处理、ClickHouse 查询等——以 jar 内置形式随框架下发,引依赖即得。

          • DB 动态 Skill(后台可配):每次 spawn() 拉取当前 (appId, agentName) 绑定的技能清单,后台上架、编辑、绑定,下一次 spawn 即生效——不改代码、不发版。

          同名 DB Skill 覆盖内置 Skill。平台方提供默认能力池,业务方按需扩展或覆盖。

          7.2 拆解二:让工具能"热插拔"——MCP 动态工具注册

          工具集本身可由配置中心(如 QConfig)驱动、运行时热更新:改一份配置即时生效,全程不重启、不发版。

          热更新的难点在"安全":更新的瞬间,可能正有请求在用旧工具。两个机制兜底:

          • 差量刷新:只动真正变化的部分,避免"配置一变就全量重连"的雪崩。

          • 引用计数 + 延迟关闭:要下线的工具连接,等它身上所有在途调用都结束才真正释放——绝不会在请求执行到一半时把连接抽走。

          7.3 内置原子工具

          框架还内置了一批开箱即用的原子工具:文件读写、命令执行、任务清单、HTTP 调用等——都是我们在多个业务场景里反复用到、抽象出来的最小可复用能力集。

          八、并行工具调用:能同时做的事,别排队

          还有一个体感极强的痛点:慢。

          模型常常一次性决定调好几个相互独立的工具——查订单、查物流、查用户等级。串行执行意味着耗时累加,但这几个调用之间根本没有依赖,没必要排队。

          8.1 虚拟线程:契合"大部分时间在等网络"的场景

          框架的做法很直接:当模型在一轮里请求了多个独立的工具调用,用Java 虚拟线程把它们并发执行——总耗时从各段相加变成取最长的那段。虚拟线程极其轻量,成百上千个并发的 IO 等待也扛得住,契合工具调用这种"大部分时间在等网络"的场景。

          8.2 并发了,但不能乱

          • 结果顺序对齐:并发返回的工具结果回注 Prompt 时,要和模型请求顺序严格对齐——不能因为查物流比查订单快 200ms 就颠倒。

          • 观测 Span 不串味:每个工具调用挂在自己那条 Span 子树上,Thinking / ToolInput / ToolOutput 归属不错乱。

          • Spill 和微压缩在并发下照常工作:多工具并发触发 Spill 时文件命名不冲突;微压缩"完结轮次"的判定依然正确。

          这些一致性细节,框架都在底层处理干净——业务侧感知不到并发的复杂,只感知到变快了。

          九、端到端实战:一次排障会话,把所有机制串起来

          单看每个机制,都像一个独立的补丁。但它们真正的威力,在于协同。我们用一个贯穿始终的场景,把它们串成一条线。

          用户:"帮我排查下为什么订单 ORD-2024-0117 一直卡在'支付中'。"

          第 1 步——技能与工具就位。 收到问题,Agent 扫一眼上下文里的技能清单,判断这是支付排障,用内置工具把"支付状态机排查"这份技能的正文加载进来。同时,配置中心早已把这个环境该有的查询工具热插拔就绪。

          第 2 步——并行取证。 模型一次性决定:查订单主表、查支付流水、查网关回调日志。三个调用互不依赖,框架用虚拟线程并发执行,耗时取最长的一段,而不是三段相加。

          第 3 步——大报文不炸场。 网关回调日志甩回来一份 4 万字的报文。它没有污染上下文——超过阈值的部分被自动落盘,模型只拿到预览和一个回读路径。模型瞄一眼预览,发现关键信息不在里头,于是拿着路径只回读了它需要的那一段。上面这几步,都发生在响应这同一个问题的过程里,即模型内部"思考—取证—再思考"地递归推进,整个过程被记录成一棵 Span/Event 树。

          聊到后面几轮——记忆不漂移。 排障很少一问一答就结束:给出初步结论后,用户往往接着追问——"那网关重试过没有""换昨天同一时段再看看"。这样一来一回,就成了多轮对话。压缩正是在这里发挥作用:它不发生在某一轮的内部推理中,而是当新一轮对话到来、框架把历史加载进来准备注入模型的那一刻才触发。此时,前几轮里那些完整的工具返回值,被微压缩成"查过了、结果如何"的事实条目;更早的几轮被折叠成结构化摘要,而"用户要排查 ORD-2024-0117 的支付卡单"这个目标,始终被稳稳锚定在摘要的 P0 段落里——哪怕聊到第 20 轮,Agent 依然清楚自己在查什么。

          结论给出后——一切可回放。 整个过程被完整记录成一棵 Span + Event 树。万一结论有问题,你能一眼看到模型在哪一步、基于哪份证据、想岔了。

          会话结束——干净收场。 无论这次是顺利结案还是中途被取消,会话谢幕的那一刻,spill 文件、内存缓存、临时工具连接被成套释放,不留一点残渣。

          而这一整套协同,业务方几乎一行都不用写。 你只管把对话喂进去,把业务工具接上去;压缩、预算、锚定、修复、观测、清理,全在后台悄悄运转。业务代码里,剩下的就是那件你本该专注的事:把这个领域的问题解决好。

          十、Roadmap:我们还在往哪走

          Spring-Ai-Trip 解决的,是"让 Agent 稳稳跑在生产里"这一层的问题。往前看,还有更大的图景:

          • 更强的 Agentic Loop: 让 Agent 的自主规划、反思、纠错能力更成熟,并支持Plan Mode、Sub Agent,从"能完成任务"走向"能把任务完成得更好"。

          • 长期记忆: 短期记忆解决一次会话内不忘事,长期记忆要解决跨会话地积累经验、认识用户。

          • 自愈与容错: 把"悬空调用修复"这类点状能力,扩展成一套系统化的故障自恢复机制。

          • 提示词治理: 让提示词像代码一样,可版本化、可评测、可灰度。

          写在最后

          回头看,Spring-Ai-Trip 做的所有事情,其实都围绕一句话:

          把"会调大模型"和"能在生产里跑好一个 Agent"之间那道鸿沟,用一层 Harness 填掉。

          它不替代 Spring AI,而是叠在上面;它也不去和 Spring AI Alibaba、AgentScope 抢编排层的位置,而是专心把单个 Agent 内部怎么活下去这件事做好——记忆、Spill、可观测、能力供给、并行工具调用,每一层都是我们在业务里被问题绊过一次之后,补上的一块。它们对业务方大多只是一行配置,但每一行背后,都是从 Demo 到生产之间必须过的一道坎。

          如果你也在 Java 这边做 Agent,也在被这些问题反复折磨,希望文章里的思路对你有用。

          【推荐阅读】

           “携程技术”公众号

            分享,交流,成长

          跳转微信打开

          •  
          ❌