铃阅时讯
❌

阅读视图

端侧 AI 提速 80%?如何让 Qwen3-VL 在手机起飞

原创 王召德、潘逢治 2026-06-11 19:44 浙江

当我们谈论“把大模型跑在手机上”时,速度始终是绕不开的核心问题。模型越大、参数越多,推理时的矩阵乘法运算量就越大。

随着 Arm 第二代可伸缩矩阵扩展 (SME2) 技术的普及,以及 MNN 推理引擎的深度适配,我们找到了一把打开端侧性能天花板的钥匙。只需在编译时开启一个开关,就能让 Qwen3-VL-4B 这样强大的多模态模型,在支持 SME2 的旗舰手机(如 vivo X300 等)上实现实时流畅推理。

本文,我们直接从工程落地的角度,手把手带你完成从引擎编译、模型部署到 APP 构建的完整流程,并用实测数据告诉你:为什么这套组合拳能让 Qwen 在端侧起飞。

什么是 SME2?

SME2 是 Armv9 架构中的一组高级 CPU 指令,它基于 SME 升级,核心突破在于引入了 ZA 矩阵累加器寄存器和流式模式。传统 Neon 做矩阵乘需要手工将外积拆成向量乘再累加,而 SME2 中的 FMOPA 等指令可以一条指令完成一个矩阵 tile 的外积累加。

通过引入 SME2 指令集,Armv9 架构 CPU 能够在 AI 异构计算框架下,高效支持大语言模型推理、图像处理、自然语言处理、语音生成等实时移动端推理任务。

认识我们的工具箱

在开始实战前,我们先了解一下本次部署的核心组件:

MNN:阿里巴巴开源的端侧推理引擎,具备高性能、轻量级、高通用性的特点。支持 CNN、Transformer、LLM、扩散模型等多种架构。

MNN-LLM:MNN 中专为大语言模型设计的模块,提供了从模型转换、量化到推理部署的全链路工具。

Qwen 模型:本文以 Qwen3-VL-4B-Instruct 为例——一个 4B 参数的视觉语言模型,支持图文理解和对话,体积适中,模型能力较强。

MNN 模型仓库:MNN 官方已经为大家转换和量化了多款 Qwen 模型,可直接下载使用。

MNN 的 SME2 适配:MNN 对 SME2 的支持采用编译时内建 + 运行时自动检测的设计,用户无需手动配置:

  • 编译时:通过 MNN_SME2 开关(默认 ON)控制是否编译 SME2 优化内核

  • 运行时:启动时自动检测硬件是否支持 SME2,支持则走 SME2 加速路径,不支持则回退到 i8mm → Neon,不会崩溃

  • 三精度覆盖:FP32、FP16、INT8/INT4 量化均有手写 SME2 汇编内核

  • 大小核调度:感知 SoC 大小核拓扑,SME2 大核用大 tile 处理主体计算,Neon 小核处理剩余部分,并行工作

  • KleidiAI 集成:集成 Arm 官方 KleidiAI 加速库,提供更多 SME2 微内核

实战演练:从零构建 SME2 加速的端侧大模型

接下来我们从源码开始,手把手走一遍开启 SME2 加速的完整端侧大模型部署流程。

前置准备

请确保以下环境已就绪:

  • Android NDK:推荐 r27+,需设置 $ANDROID_NDK 环境变量

  • ADB:用于与手机通信,adb devices 可正常发现设备

  • JDK 17:Gradle 编译 APP 所需

  • 手机:开启开发者模式和 USB 调试,通过 USB 连接电脑

Step 1:编译推理引擎

🟣 为 Android 编译 MNN 引擎的动态库(.so 文件)和命令行推理工具。 

SME2 功能默认开启,可以通过 -DMNN_SME2=ON/OFF 显式控制开关。

    # 1. 进入 MNN 的 Android 工程目录
    cd MNN/project/android


    # 2. 创建编译目录
    mkdir build_64 && cd build_64


    # 3. 执行编译(SME2 默认开启,可通过 -DMNN_SME2 控制)
    ../build_64.sh "-DMNN_SME2=ON -DMNN_KLEIDIAI=ON -DMNN_LOW_MEMORY=true -DMNN_CPU_WEIGHT_DEQUANT_GEMM=true -DMNN_BUILD_LLM=true -DMNN_SUPPORT_TRANSFORMER_FUSE=true -DMNN_ARM82=true -DMNN_USE_LOGCAT=true -DMNN_OPENCL=true -DLLM_SUPPORT_VISION=true -DMNN_BUILD_OPENCV=true -DMNN_IMGCODECS=true -DLLM_SUPPORT_AUDIO=true -DMNN_BUILD_AUDIO=true -DMNN_BUILD_DIFFUSION=ON -DMNN_SEP_BUILD=OFF -DCMAKE_SHARED_LINKER_FLAGS='-Wl,-z,max-page-size=16384' -DCMAKE_INSTALL_PREFIX=."


    # 4. 整理编译产出
    make install

    💡 make install 是必要的——它会将 libMNN.so 拷贝到 build_64/lib/ 目录,后续 APP 编译时会从这个路径引用动态库。

    编译完成后,build_64/ 目录下会生成以下关键文件:

    • libMNN.so:MNN 核心引擎库

    • llm_demo:命令行推理工具

    • llm_bench:性能基准测试工具

    Step 2:准备模型

    🟣 方案一:直接下载 MNN 格式的模型(推荐) 

    MNN 官方已提供转换和量化好的模型,可一步到位:

      cd MNN/transformers/llm/export
      pip install modelscope
      modelscope download --model MNN/Qwen3-VL-4B-Instruct-MNN --local_dir Qwen3-VL-4B-Instruct-MNN

      🟣 方案二:使用 MNN 的模型转换工具自行转换 

      如果需要自定义量化参数或使用其他模型,可以手动转换:

        # 1. 进入 MNN-LLM 的 export 目录
        cd MNN/transformers/llm/export


        # 2. 安装 Python 依赖
        pip install -r requirements.txt


        # 3. 从 ModelScope 下载原始模型
        modelscope download Qwen/Qwen3-VL-4B-Instruct --local_dir Qwen3-VL-4B-Instruct


        # 4. 执行转换(HQQ 量化)
        python llmexport.py --path Qwen3-VL-4B-Instruct --dst_path Qwen3-VL-4B-Instruct-MNN --export mnn --hqq

        💡 提示:--export mnn 代表导出为 MNN 格式,--hqq 是推荐的量化选项,可以有效提升模型精度。

        Step 3:推送到手机,命令行验证

        🟣 将引擎和模型推送到手机,通过命令行快速验证推理是否正常。

          # 1. 推送引擎文件到手机
          adb push project/android/build_64/llm_demo /data/local/tmp/
          adb push project/android/build_64/llm_bench /data/local/tmp/
          adb push project/android/build_64/libMNN.so /data/local/tmp/


          # 2. 推送模型到手机
          adb shell mkdir -p /data/local/tmp/mnn_models
          adb push Qwen3-VL-4B-Instruct-MNN /data/local/tmp/mnn_models/


          # 3. 进入手机 shell
          adb shell


          # 4. 赋予执行权限
          chmod +x /data/local/tmp/llm_demo /data/local/tmp/llm_bench


          # 5. 创建 prompt 文件
          echo "你好" > /data/local/tmp/prompt.txt


          # 6. 设置动态库路径并运行推理
          cd /data/local/tmp
          export LD_LIBRARY_PATH=/data/local/tmp:$LD_LIBRARY_PATH
          ./llm_demo /data/local/tmp/mnn_models/Qwen3-VL-4B-Instruct-MNN/config.json /data/local/tmp/prompt.txt

          💡 知识点:为什么要设置 LD_LIBRARY_PATH?llm_demo 动态链接了 libMNN.so,Android 系统默认只在 /system/lib64 等系统目录搜索动态库,不会搜索 /data/local/tmp/。设置此变量告诉链接器也去指定目录查找。

          当你看到模型流畅地回复时,恭喜,推理引擎已经跑通了!

          🟣 确认 SME2 硬件支持 

          在电脑上另开一个终端窗口,运行:

            adb logcat | grep "device supports"

            会看到类似输出:

              The device supports: i8sdot:1, fp16:1, i8mm: 1, sve2: 1, sme2: 1

              其中 sme2: 1 表示手机的 CPU 硬件支持 SME2 指令集,MNN 引擎会自动使用 SME2 加速路径进行推理。

              💡 这行日志反映的是硬件检测结果,与编译选项无关。-DMNN_SME2=ON/OFF 控制的是编译产物中是否包含 SME2 优化代码——即使硬件支持,如果编译时关闭了该选项,引擎也不会走 SME2 加速路径。

              Step 4:构建端侧 AI 应用

              🟣 命令行验证成功后,我们可以将推理能力集成到一个完整的 Android APP 中。本文以 MNN 自带的 MNN Chat 示例应用为例:

                # 1. 进入示例应用目录
                cd MNN/apps/Android/MnnLlmChat


                # 2. 编译 APK
                ./gradlew assembleStandardDebug


                # 3. 安装到手机
                adb install app/build/outputs/apk/standard/debug/app-standard-debug.apk

                💡 提示:APP 编译时会自动从 project/android/build_64/lib/ 引用 libMNN.so 并打包进 APK,所以不需要再手动推送 .so 文件到手机——安装 APK 即完成了引擎的部署。

                安装完成后,如果之前 Step 3 已将模型推送到 /data/local/tmp/mnn_models/,打开 MNN Chat 即可在"我的模型"中找到 Qwen3-VL-4B-Instruct 模型。你也可以通过 APP 内的模型市场直接下载其他模型。

                以下是 MNN Chat 在手机上进行多模态问答的实际演示——用户拍照后,模型即可理解图片内容并流畅回答:

                性能测评:SME2 带来多大提升?

                为了验证 SME2 带来的实际性能收益,我们分别编译了 SME2 开启 和 SME2 关闭 两个版本的引擎,在同一台设备上使用 llm_bench 进行对比测试。

                测试环境

                • 设备:vivo X300

                • 模型:Qwen3-VL-4B-Instruct-MNN

                • 测试工具:llm_bench

                Prefill 阶段提升最为显著(+81%):因为 Prefill 需要一次性处理整段输入 token,是计算密集型任务(大批量矩阵乘),能充分利用 SME2 的矩阵外积指令和大 tile(HP=128)内核。这直接意味着更短的首字等待时间。

                Decode 阶段提升相对较小(+13%):因为 Decode 是逐 token 生成,矩阵乘退化为矩阵×向量运算(batch=1),瓶颈在内存带宽而非计算吞吐,SME2 的优势相对有限。

                进阶调优

                在完成基本部署后,你可以根据自己应用的需求,通过以下手段进一步提升性能和精度: 

                🟣 模型导出参数调优 在执行 llmexport.py 时,可以附加不同参数:

                🟣 运行时参数调优 模型导出后,可以通过修改 config.json 控制运行时行为:

                通过本文,我们完成了一条完整的端侧大模型部署路径:编译 MNN 引擎 → 准备模型 → 命令行验证 → 构建 APP → 性能测评。

                SME2 作为 Arm 最新的矩阵加速指令集,在 MNN 的深度适配下,为端侧大模型推理带来了实实在在的性能提升——Prefill 阶段提速超过 80%。而 MNN 的"编译时内建 + 运行时自动检测"设计,让开发者无需额外配置即可享受硬件加速红利。

                随着SME2技术的进一步广泛采用,端侧 AI 的性能天花板正在被不断抬高。期待看到更多创新的端侧 AI 应用!

                你在端侧部署中遇到的最大“坑”是什么?欢迎在评论区分享,我们将选取三位同学送出定制周边一份。

                推荐阅读

                Agent 辅助开发,一站式打通 Qwen3-VL Android 端侧推理

                教程首发|让手机拥有视觉感知能力

                跳转微信打开

                •  

                Agent-Native 开发框架设计

                idoubi 2026-06-11 18:00 广东

                聊聊 Agent-Native 开发框架应该怎么设计👇

                在谈 Agent-Native 之前,我们应该很熟悉 Cloud-Native 、AI-Native 这些概念,或者是 Native Speaker 这种表达

                Native 就是原生的意思,强调的是事物最开始就是这个样子的,而不是后来改成这样的。

                1. English Native Speaker 指的是一出生就在英语环境,母语是英语的人

                2. Cloud-Native 强调的是业务一开始就在云上跑,而不是通过去 IOE 化把原来的系统迁移上云

                3. AI-Native 强调的是产品设计之初,功能和流程都是基于 AI 的能力来设计的,离开 AI 跑不起来或者跑不出好的效果

                Agent-Native,讲的是产品功能和工作流程都是基于 Agent 的特性和能力来设计的,离开 Agent 就不 work

                回到 ShipAny 框架的设计。在 ShipAny One、ShipAny Two 里,我们已经积累了一堆常用的业务功能:登录、注册、支付、 存储、多语言、SEO、管理后台等。

                在新版本的 ShipAny 里,这些能力全部模块化了,按需启用,可插拔。关键是设计了几个核心的 Skills,把 ShipAny 内置的功能模块、开发流程都描述清楚,包括模块说明、数据表结构、API 参数等。Agent 读到这些 Skills 后,能快速搞懂整个框架的架构设计,然后按流程开发。

                Agent-Native 开发框架的设计,首先要保证集成的功能足够多,功能模块化、低耦合。其次要梳理通用的开发流程,包括初始化项目、创建新模块、设计新页面、设计图片等。然后把每个流程文档化,不同的流程可组合,沉淀成 Agent 能理解的 Skills。

                ShipAny 内置的核心 Skills 包括:

                1. quick-start:快速初始化新项目,完成 MVP 版本开发

                2. clone-website:复刻指定网址的项目

                3. new-module:开发新的功能模块

                4. new-page:开发新的页面

                5. deploy-cloudflare:一键发布到 Cloudflare

                还有 generate-image(生成图片)、sync-upstream(同步上游更新)、security-scan(安全扫描)、launch-audit(发布前审计)等,基本覆盖了一个项目的完整开发周期。

                ---

                ShipAny 新版本发布不到 2 天,已开 200 单,老用户复购比例很高,ShipAny 作为 AI 出海金刚铲的定位正在被越来越多的人认可。🎉

                在 ShipAny 官网输入优惠码 NEXT 下单,获取先进的 Agent-Native 开发框架。不需要人去写代码了,完全交给 Agent,一小时上线你的 AI 产品。😄

                跳转微信打开

                •  

                MiMo Code 发布并开源|模型 Agent 协同优化,迈向自进化时代

                原创 小米大模型 2026-06-11 02:06 北京

                始于编程,远不止于编程

                今天,我们正式发布并开源 MiMoCode V0.1.0—— 一款运行在终端里的探索性 AI 编程助手。

                MiMo Code 始于编程,不止于编程。它不只是一个好用的 AI Coding 工具,更是一位住在你电脑里、越用越懂你的 AI 队友。

                它内置限时免费的顶级多模态模型 MiMo-V2.5,性能比肩 Claude Sonnet 4.6;同时支持接入 DeepSeek、Kimi 和 GLM 等主流模型,以及第三方 Token Plan,满足不同开发者的需求。

                MiMo Code 基于开源项目 OpenCode 二次开发,发布并开源,采用 MIT协议。

                 核心能力

                持久记忆系统 + 无限上下文:从根上解决“AI健忘”

                MiMo Code 内置独创的持久记忆系统,用项目记忆、会话检查点、任务进度三重机制,解决长会话“越用越忘”的难题。即使上百轮的长程会话,也能保持输出质量、不丢关键信息。

                主流 Code Agent(Claude Code、Codex 等)多是“让 AI 自己记笔记”,但模型不会主动触发,记不记、何时记全靠它自觉。所以我们换了个思路:让主 agent 专心干活,记录完全外包 —— 由独立 subagent 自动保存状态,窗口快满时重建一份干净简报,主 agent 接着干而非从零开始。

                一句话:不赌模型自觉,用工程把它兜住。

                模型 Agent 协同优化 + 独创 Compose 模式

                大多数 Coding Agent 的工作方式是「拿到需求就埋头写代码」,像一个不看导航就上路的司机——看似高效,实则容易跑偏。

                但模型并非千篇一律:不同模型各有自己的"性格"与"禀赋",与不同的 Agent 框架之间也存在天然的"适配度"高低。把模型和框架简单拼在一起,往往发挥不出真正实力。

                MiMo Code 为 MiMo 系列模型量身打造了一套专属的 Harness 系统,让模型的能力与框架深度配合;再配合独创的 Compose 模式,实现 1+1>2 的协同效果。

                使用时,只需按 Tab 键切换到 Compose 模式,给它一个简单的想法,它就能自动完成设计、规划、编码、测试、审查的全流程,最终交付一套工业级的成品。

                实测对比

                我们给两个工具下了同样的指令:

                「帮我用 golang 实现一个 redis,需要支持用 redis-cli 连接。」

                Claude Code 出手很快,代码很快就跑了出来——但几乎没有配套测试,功能能用却不够扎实,后续返工的风险不小。

                MiMoCode 用 Compose 模式,前期花了更多时间做规划,看起来“慢”了一截;但落到结果上,它实现了更丰富的功能,并配上了完整、详尽的测试,真正体现出工业级代码该有的样子。

                有意思的是,算总账反而是 MiMoCode 更快:它把时间花在前期想清楚、后期验得稳上——慢写、快验,整体体验更省心。

                Dream:记忆沉淀,越用越懂你

                MiMoCode 内置了一个独特的 /dream命令。每 7 天自动触发,由独立 Agent 读取历史会话和现有记忆文件,执行合并、去重、验证路径有效性和压缩,将分散的记忆收敛为一份紧凑的当前状态,并更新全局记忆。

                到了下次使用,它会在合适的时机自动调用这些记忆。这意味着 MiMo Code 不会每次都从零开始,而是带着对你和你项目的理解持续成长——真正做到越用越顺手。

                支持语音输入:“君子动口不动手”

                MiMo Code 内置了语音输入与控制功能,背后是 MiMo-V2.5-ASR 的强大语音识别能力加持。动动嘴,活就干了。

                它能做的不只是“念出 prompt”:你可以口头修改写错的指令,也可以直接发出“发送”“执行”这类操作命令——从输入到操控,全程不用碰键盘,效率自然又上一个台阶。

                 用数据说话:同模型,更强表现

                在两个面向真实编程场景的权威测试集 SWE-Bench 和 Terminal Bench 上,我们做了一组对照实验:让 MiMo Code 与 Claude Code 使用同一个 MiMo 模型,只比拼各自的 Agent 系统本身。

                结果显示,MiMo Code 在 SWE-Bench Pro 上达到 62%(Claude Code 为 57%),在 Terminal Bench 2 上达到 73%(Claude Code 为 68%)—— 在模型完全相同的前提下,MiMo Code 凭借专属 Harness 与 Compose 模式的协同,拿到了较优的分数。

                 如何使用:零配置起步,开箱即用

                安装与启动:打开终端

                装好后,终端输入 mimo即可启动。为了获得最佳体验,强烈推荐 Mac用户在 iTerm 中或者 vscode 终端中使用。

                • 模型配置

                  • 内置 MiMo-V2.5 限时免费通道,无需注册即可使用

                  • 兼容 DeepSeek / Kimi / GLM 等主流模型 API,及第三方 Token Plan

                • 使用:

                  • 输入 / 查看各项配置

                  • 所有设置项全面中文汉化,本地友好

                  • TUI 页面右侧常驻状态看板,随时观察工作进度

                更多技术细节,欢迎关注我们的团队 Blog:https://mimo.xiaomi.com/mimocode

                 开源与展望

                MiMo Code 发布并开源,采用宽松的 MIT 协议——这意味着它对几乎所有人都敞开:

                • 个人开发者可以自由使用、修改、分发,想怎么折腾都行;

                • 企业可以把它集成进自己的开发工具链,无需担心授权束缚;

                • 社区可以基于它打造垂直领域的编程助手,长出更多可能。

                我们相信,一个好工具的价值不止于“能用”,更在于它能被多少人共同打磨、走向何方。期待与你一起,把 MiMo Code 变得更好。

                跳转微信打开

                •  

                推荐一个我做的 APP:Lastloops

                原创 刘飞Lufy 2026-06-10 19:27 浙江

                又做了一个 APP。

                1

                你有没有这种体验:绿植偶尔忘了浇,叶子已经蔫了才发现。

                类似的这类事情不少:换季洗床单、隔阵子给爸妈打电话、洗牙、给猫剪指甲、理发、体检,等等等等。

                这些事情,跟普通待办事项的主要区别是:它们没有精确的截止日期和时间,又属于循环任务。

                比如我们的提醒工具弹出通知,让我们给爸妈打电话的时候,我们大概率手头有事情在做。不管是工作,还是在看电影、刷视频。总觉得可以晚点做。但晚点就意味着没有具体的提醒时间了。下次再想起来,又到了新的周期了。

                这些提醒最大的问题就是,它们的执行周期其实是模糊的。

                比如我们一周没有给家里打电话了,那么接下来几天都可以做这件事。但提醒工具该怎么更好的给我们提醒呢?

                这就是我做接下来这个工具的出发点。

                2

                Lastloops 的形态,和市面上绝大多数清单 App 都不太一样。

                打开它,没有列表和卡片,只有一堆玻璃弹珠。一件事,就是一颗球。

                弹珠的大小,对应事情的紧迫程度。刚做完时,它只是一个不起眼的小圆点;拖着没做,它就会慢慢膨胀。从视觉上获取你的注意力。

                如果不断拖延,它最终能占满小半个屏幕。当几颗超期未办的大球戳在那儿,把别的小球挤到角落、卡来卡去时,你就知道现在这些事不得不做了。

                而要做这些事的时间,就由你自己决定。当你觉得需要关注一下的时候,打开 APP 直接看弹珠就可以了。

                当然,打开 APP 这个门槛也并不低,所以我也做了小组件。

                这个 APP 最早就是为我自己做的,我还是想从中获得一些情绪价值的,于是我把弹珠做成了有真实物理引擎的。

                手机一歪,小球会顺着方向滚动、互相磕碰,碰撞时还会伴随细腻的手机微震。手感极佳。

                完成一件事的操作也很解压:长按那颗球,一圈绿色的涟漪从中心散开,大球会一下变成小圆球,重新腾出屏幕空间。

                整个过程没有通知推送,没有弹窗打扰,Lastloops 从不主动催促。就安静地呆在那儿,偶尔打开看一眼,心里有数即可。

                3

                开发这个 App 的大半时间,我其实都在设法做减法。

                新建事项一直在做减法:一个名字,一个建议周期,一个 Emoji 图标。没有分类、没有标签、没有备注,更没有优先级。甚至连名字都限制了中文最多 6 个字。

                色彩也降低了优先级。一开始我想用颜色表示紧急度(比如变红代表超时),后来发现很多余,紧迫感交给「大小」去表达就足够了。现在球体的颜色只是根据 Emoji 提取的一点淡淡的色调,纯粹为了让视觉不那么单调。

                点击进入详情页,你能看到一张类似 GitHub 的绿格子热力图,最近一年做过几次、节奏如何,一目了然。我刻意去掉了「连续打卡天数」、「平均间隔」或「最长空窗期」这些数据。这些指标看着专业,但本质上只会给人带来被考核的焦虑感。

                当然,在这个热力图上,可以直接补记过去的某次完成,也可以取消掉过去的某次完成。

                有一个我自己挺喜欢的设计,就是关于背景。我本来想的是可以有自定义上传,但我直观感觉大家很难找到比较舒服的又干净的背景(弹珠是半透明的,所以大部分背景看起来都会很脏)。

                所以我设计了一个随机算法,每次点击可以呈现完全不同的渐变色背景,每一张都完全不一样,但又都比较优雅。

                4

                这次用 AI 辅助开发的整个过程,和上次做 Gamepix 类似,充满乐趣,也同样繁琐。

                最磨人的往往是那些用户未必能直接察觉、但极度影响体验的底层细节。比如「球体变大的逻辑」。

                不同事情的周期长短不一:3 天一次的事,每天打开都能看到球变大了一圈,反馈很直观;但如果是半年一次的事,前两三个月球体几乎没有视觉变化。

                为了让长周期的事情在前期也能有「正在慢慢长大」的动态反馈,我专门加了一道数学公式的非线性曲线校正,把前半段的变化幅度做了一定程度的放大。

                还有弹珠的物理引擎。起初我想让 AI 手搓碰撞逻辑,结果写出来一堆 bug,球体不是穿模、卡死,就是直接飞出屏幕。后来索性全盘换成系统的物理引擎在后台跑,才终于稳定下来。

                5

                最近做 AI 辅助编程,感受还是挺独特的。上瘾的地方在于,还是上次说的,想到就能做的感觉特别棒。不用过各种复杂的会议,不用去给程序员买奶茶,不用担心效果好不好,觉得有意思就直接做了。

                上瘾的其实不是AI,上瘾的是「闭环」。现代人的大部分日常工作都是流水线的环节,只能依赖协作。对我这种协作能力比较差的人来说,AI解决的就是能让我真的完成一些事情(播客和现在的公众号也是)。

                我自己在 Lastloops 增加了一个事项: AI 编程。我也希望保持做工具的这种状态,能让我不断思考,不断去训练手感。

                到了一定年纪和到了一定的人生阶段,思考就是会自然懒惰下来。一方面是生理性的,就是没有年轻的时候那么容易兴奋。另一方面,自己不在真实的产业里了,靠鬻文为生,赚钱的方式不复杂,社会产生连接的感知就变弱了。

                思考这件事就跟肌肉一样,还是得平时多用用,不然就会萎缩。而萎缩的人不会感觉自己在萎缩。

                有一些事情能拽着自己继续思考,也是不变老登的一种很重要的方式。一个人,如果到了可以依赖存量观点和惯性思考就过上不错日子的时候,通常来说就不会再吸收新鲜知识了。

                我自己的体感是越来越喜欢用 AI 做一些事情,同时越来越不喜欢「聊 AI」了。单纯聊 AI 和用 AI 做事情,就是完全不同的体验。当然,能对AI行业有洞察,甚至做出了不起的预测,本身是很厉害的。但多数时候,都容易变成痴心妄想、镜花水月。

                6

                目前 Lastloops 已经正式在 App Store 上架了,搜索名字就能搜到,感兴趣的朋友可以下载体验一下。

                是永远免费的,没有订阅,也没有内购,也不需要注册账号(目前支持备份和导入,但暂时不支持自动备份)。

                用起来觉得哪里别扭、哪里不对,欢迎反馈到公众号后台,或者点 App 里的「联系 / 反馈」,会直接打开邮件,可以发到 opencup2026@outlook.com。

                自己用了一阵子,我还挺喜欢这个产品的。如果说之前做的 Gamepix 是一个非常低频的工具,这次的 Lastloops 我真的是每天会扫两眼了。

                浇花、洗牙、给父母打个电话……看似是微不足道的小事。但这些一遍遍重复的、没有 ddl 的小事,也构建了我们日常生活的底色。就像我们总会做紧急重要乃至紧急不重要的事,却经常错过很多重要但不紧急的事。

                希望 Lastloops 能帮到大家。

                跳转微信打开

                •  

                AI 产品实战社团🥲

                idoubi 2026-06-10 16:30 广东

                跟风变科技合作搞了个《AI 产品实战社团》,主打 Vibe Coding 开发生产级项目

                今晚 7 点第一场直播,主题是《案例实操:用 ShipAny TanStack 开发 AI 图片生成器》

                直播链接:

                https://fclive.pandacollege.cn/p/GzfFt2

                社团七月中旬正式运营,现在是开团前的预热直播活动,感兴趣的朋友可以来听,觉得讲得好再参团,有专业的助教老师对接。[让我看看]

                跳转微信打开

                •  

                Claude Fable 5 发布:AI 工作流的关键正在转向 Loop 循环

                高可用架构 2026-06-10 09:53 广东

                刚刚,Anthropic 发布了 Fable 5,它在几乎所有测试过的基准上都达到顶尖水平

                今天,Anthropic 发布了 Fable 5,它在几乎所有测试过的基准上都达到顶尖水平,在软件工程、知识工作、科学研究和视觉任务上表现尤其出色。

                image.png
                image.png

                任务越长、越复杂,Fable 5 相比其他模型的领先幅度就越大。

                发布如此强大的模型也伴随着风险。如果没有防护措施,Fable 5 在网络安全等领域的能力可能遭到滥用,造成严重损害。

                针对少数几类主题的查询,系统会改用 Claude 次强的模型 Opus 4.8 来响应。

                Fable 5 的防护机制会检测与网络安全、生物与化学、蒸馏相关的请求。每当发生回退时,用户都会收到提示,平均发生在不到 5% 的会话中。

                Claude 会继续完善这些防护措施,减少误判。

                同时也面向一小部分网络防御人员和关键基础设施提供方推出 Claude Mythos 5。Mythos 5 与 Fable 5 共享同一个底层模型,但在部分领域放宽了防护限制。

                很快,计划通过更广泛的可信访问计划扩大 Mythos 5 的访问范围,用于防御性网络安全工作和生物医学研究。

                Claude Fable 5 今天已在所有平台可用。Claude Mythos 5 目前仅限 Glasswing 合作伙伴使用,直到 Anthropic 扩大可信访问计划。

                接下来是官方工程师 @RLanceMartin 介绍如何设计循环的教程

                使用 Fable 5 设计循环

                像 Claude Fable 5 这样的 Mythos-class 模型,已经改变了 Anthropic 许多人的工作方式。我想分享两个技巧,帮助你更好地使用这类模型。

                自我纠正循环

                最近大家对循环很感兴趣。@bcherny[1]提到过[2],“我的工作就是写循环”。让模型围绕评测进行迭代优化,是提升任务表现的常见做法:Claude Code 里的 /goal[3] 和 Claude Managed Agents 里的 Outcomes[4],都是能让你把这套通用方法应用到具体任务上的原语。

                正如我们在 提示词指南[5] 中提到的,Fable 5 擅长在循环中自我纠正。设计良好的目标或评分标准,会给 Claude 的运行环境加入反馈。这样 Claude 就能运行任务,通过目标或评分标准收集反馈,自我纠正,并持续推进,直到满足目标或评分标准为止。

                Image
                Image

                我分享一个用来测试 Fable 的玩具示例:Parameter Golf[6] 是一个开源 ML 工程挑战,目标是在 8xH100 上于 10 分钟内训练出最佳模型,并且模型产物要控制在 16MB 内。

                它有点像 @karpathy[7] 的 autoresearch[8] 项目:它测试的是一个 Agent(智能体)编辑基础训练代码的能力,包括修改单个 train_gpt.py 文件、启动训练、轮询日志、读取分数,并决定下一步该运行什么实验。

                我用 Claude Managed Agents[9](CMA)在这个挑战上比较了 Fable 5 和 Opus 4.7。CMA 提供 Agent 运行框架以及托管沙箱[10],因此很适合 Fable 5 这类长时间运行任务。针对 Parameter Golf,我让 CMA 通过 自托管沙箱[11] 访问 8xH100 GPU。

                一个微妙但重要的点是:由谁来做评判很关键。我们看到,模型在评判自己输出时会遇到问题。Prithvi Rajasekaran 在这篇文章中[12] 写过这一点。

                Image
                Image

                我们发现,对于 Fable 5,验证器子 Agent 通常优于[5] 自我批判,因为评分发生在一个独立的上下文窗口中。CMA 里的 Outcomes[4] 会通过生成一个评分子 Agent 来处理这件事。

                每次测试中,我都提供一份评分标准文件,其中包含九条可验证的标准,例如运行基线、运行 20 个实验等。然后,我让 Parameter Golf 最多运行 8 小时。Outcomes 评分器会确认所有实验标准都已满足,才允许 Claude 停止工作。

                Fable 5 对训练流水线的改进幅度约为 Opus 4.7 的 6 倍。如果把实验分为两类:结构性实验(如架构改动)和标量实验(如调整常数),Fable 5 更倾向于押注更大的结构性改动。它还表现出很强的韧性,例如在量化回归中坚持推进,最终取得了最大收益。

                Opus 4.7 的第一次实验带来了一点小收益,之后几乎所有实验都沿着同一个模板推进:调整一个标量、测量结果,如果为正就保留。

                记忆

                记忆是 Fable 擅长的另一个领域[13]。我们可以把它看成跨会话的外层循环:Claude 在一次会话中写入记忆,这些记忆可以在后续会话中检索出来。

                @pgasawa[14] 和团队最近发布了 Continual Learning Bench 1.0,所以我想用它来对比 Fable 5 和更早的模型。

                5 月 5 日

                今天,我们发布 Continual Learning Bench 1.0:第一个用于衡量 AI 系统在真实线上环境中如何持续进步的基准。目前的基准都假设模型是无状态的,每个样本彼此独立,一旦系统完成一个任务,它就会像……

                我比较了 Fable 5、Opus 4.7 和 Sonnet 4.6 在该基准中一项任务上的表现:任务要求 Agent 在可以访问 SQL 数据库的情况下,依次回答一系列问题。每个问题都是一个独立的 Agent 会话,并且系统会提供记忆。

                为此,我使用了带有 记忆功能[15] 的 CMA,它让每个 Agent 都能访问一个可跨会话共享的挂载文件系统。

                Image
                Image

                在这项任务中,有效使用记忆通常需要经历一个递进过程:① 失败,答错并记录下来;② 调查,在继续之前弄清楚为什么错;③ 验证,把诊断变成经过检查的事实;④ 提炼,把验证结果转化为通用规则;⑤ 查阅,读取规则,而不是重新推导一遍。

                Sonnet 4.6 大约停在 ① 阶段:它的存储内容是一串失败笔记和未验证的猜测,例如”也许应该用 prc,不该用 prc_usd?”。它很少查阅之前的笔记。要提升表现,需要加入任务特定的记忆指令。

                Opus 4.7 大约停在 ③ 阶段:它会创建一个带有不确定性标记的 schema 参考,例如”prc 可能以美分计价?验证一下。”,但验证覆盖率很低,只覆盖 7-33% 的问题,中位数约为 17%。

                Fable 5 往往能完成这个递进过程:在最强的一些运行中,验证覆盖率最高达到 73%,即 30 个问题中的 22 个,并且它会把学到的知识提炼成有助于未来任务的通用规则。

                与其直接提示和引导 Fable 5,不如设计循环,让模型根据环境反馈自我纠正(例如通过 /goal 或 Outcomes),并管理自己的上下文(例如通过记忆)。

                我这里只分享了几个自己做过的小规模实验,但建议你亲自用 Fable 5 测试有挑战性的任务,并用循环来做自我纠正或记忆管理。

                要开始使用,可以阅读我们的 文档[5],或者询问最新版 Claude Code。它可以使用我们内置的 /claude-api[16] 技能,告诉你 Fable 5 的相关内容,例如提示词最佳实践、/goal、Claude Managed Agents 或其他 API 功能。

                参考阅读

                References

                1. @bcherny: https://x.com/@bcherny
                2. 提到过: https://x.com/sairahul1/status/2064279904989147577?s=20
                3. /goal: https://code.claude.com/docs/en/goal
                4. Claude Managed Agents 里的 Outcomes: https://platform.claude.com/docs/en/managed-agents/define-outcomes
                5. 提示词指南: https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5
                6. Parameter Golf: https://github.com/openai/parameter-golf
                7. @karpathy: https://x.com/@karpathy
                8. autoresearch: https://github.com/karpathy/autoresearch
                9. Claude Managed Agents: https://platform.claude.com/docs/en/managed-agents/overview
                10. Agent 运行框架以及托管沙箱: https://www.anthropic.com/engineering/managed-agents
                11. 自托管沙箱: https://platform.claude.com/docs/en/managed-agents/self-hosted-sandboxes
                12. 在这篇文章中: https://www.anthropic.com/engineering/harness-design-long-running-apps
                13. Fable 擅长的另一个领域: https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices
                14. @pgasawa: https://x.com/@pgasawa
                15. 记忆功能: https://platform.claude.com/docs/en/managed-agents/memory
                16. /claude-api: https://github.com/anthropics/skills/tree/main/skills/claude-api

                如果你也在关注 AI 应用如何真正落地到生产环境,2026.6.26 - 6.27 GIAC 深圳站值得关注。这次大会会集中讨论智能应用开发、架构演进,以及来自一线实践的经验与案例。

                识别二维码可申请大会体验门票,点击阅读原文了解大会详细议程。

                Image

                阅读原文

                跳转微信打开

                •  

                ShipAny 新版发布:Agent-Native 开发框架

                原创 idoubi 2026-06-09 21:37 广东

                ShipAny 内置丰富的 Skills,让 Agent 开箱即用,帮助创作者一小时上线功能完整、可商业化的 AI 产品。

                ShipAny 新版本发布了🎉,上线了三套基础模板👇

                1. shipany-next:Agent-Native 开发框架,面向 Agent Coding 而设计,通过内置 Skills 极速开发新项目

                2. shipany-vinext:基于 Cloudflare 官方 Vinext 框架而设计,一键部署到 Cloudflare  Workers,压缩后体积是 shipany-two 的 1/7,绑定 CF 全家桶,节约成本

                3. shipany-tanstack:基于 TanStack Start 而设计,使用 Vite 构建,启动与运行速度极快,跨平台部署方便

                ShipAny 模板
                ShipAny 模板

                ShipAny 老用户支付 $1.99 获得新模板。新用户通过这个链接👇

                https://shipany.ai/zh/pricing?ivt=idoubi

                购买 Premium 会员,输入优惠码:NEXT,立减 $50

                ShipAny 价格
                ShipAny 价格

                ShipAny 官网也基于 shipany-tanstack 完成了重构,交互体验提升不少。

                ShipAny 官网
                ShipAny 官网

                ShipAny 开发文档也更新了。

                ShipAny 文档
                ShipAny 文档

                • ShipAny 新版本整合了流行的技术栈,主推 TanStack + Vite 生态,高性能运行,部署到 Cloudflare,极具性价比。

                ShipAny 快速上手指南
                ShipAny 快速上手指南
                • ShipAny 新版本精心设计了几个 Skills,在 Coding Agent 一键调用,对话式快速完成新项目开发。

                ShipAny 内置 Skills
                ShipAny 内置 Skills
                • 做 AI SaaS 网站需要的基础功能,ShipAny 基本上都集成了,主打一个开箱即用,让你的 Coding Agent 无需造轮子,快速上线。

                ShipAny 功能清单
                ShipAny 功能清单
                • ShipAny 官方出品的基础模板,ShipAny Premium 会员可以超低价获取,主打一个仪式感,让买模板跟买咖啡一样简单。

                image
                ShipAny 模板
                • ShipAny 用户提交了几百个案例,有一些有很大的流量,有一些赚到了钱。ShipAny 定位是一把好铲子,帮助用户去淘金。

                ShipAny 用户案例
                ShipAny 用户案例
                • 加入 ShipAny 联盟,设置专属的邀请链接和优惠码。可自行分配额度,帮助朋友获得优惠,自己获得奖励。

                ShipAny 联盟
                ShipAny 联盟

                我们已经进入了 Agent 主导开发的新时代,做产品变得极其简单。

                一个 Agent-Native 开发框架,可以让 Agent 更快速地集成项目需要的基础能力:登录、注册、支付、积分、存储、多语言、SEO、AI 生成、管理后台。

                ShipAny 的定位,就是这样一个 Agent-Native 开发框架,通过一系列的模板覆盖常用的技术栈和业务功能,内置丰富的 Skills 让 Agent 开箱即用,帮助创作者一小时上线功能完整、可商业化的 AI 产品。

                ❝

                新版本,新征程。期待与 ShipAny 用户共建生态,做大做强。✌️

                阅读原文

                跳转微信打开

                •  

                只给一份文档,Qwen3.7-Max 从 0 交付双端应用

                原创 通义实验室 2026-06-09 17:28 浙江

                实践经验详解

                让 Agent 改一个按钮、修一个 Bug,今天已不算新闻。

                但只给它一份调研文档,让它从 0 写出高度还原的完整应用呢?

                这是一条横跨规划、架构、十几个模块编码、验证、修复的超长程任务:几个小时、成百上千个决策、前后强依赖,错一步就会沿着后面几十步一路放大。这正是今天大多数 Agent 最容易翻车的地方。

                最近,我们和 Efflora 团队基于 Qwen3.7-Max 模型,做了一场实验:仅凭一份产品调研文档,在隔离环境中从 0 交付了移动端和 Web 端两套可运行应用。

                这场实验也揭示了一个被忽视的工程真相:质量不是模型一次「生成」出来的,是被闭环「收敛」出来的。

                我们用 Qwen3.7-Max 做了啥

                给 Qwen3.7-Max 一份产品调研文档,让它在隔离环境里,从 0 交付能真实跑起来的应用——而且移动端、Web 端各一套,发现页瀑布流、商城分类与商品卡、内容详情页的图文与评论流,核心界面与主要交互都被几近还原。

                • 唯一输入:「图文社区 + 商城」形态产品的用户流程文档 + 关键页面拆解报告,合计 约 15 万字、拆解 12 个核心页面(覆盖 8 大功能模块、7 条用户流程);

                • 没有给的:设计稿、现成代码、分步骤的人工拆解、后端逻辑;

                • 耗时:单端从 0 到可运行 约 4 个多小时全自动完成,中途无人工接管。

                本次实验亮眼的地方在于:

                1、它没「看」过任何一张图,却把界面还原了。

                Qwen3.7-Max 不具备图像理解能力,整个过程它没有看过任何一张设计稿或截图——还原靠的不是模型的眼睛,是约束。

                2、它写的是真应用,不是点击演示。

                在未提供后端逻辑的前提下,模型自行设计了一套完整的关系型数据模型(近 20 张表,含多对多关联表与索引),并写出带字段校验、分页过滤、错误处理的真实接口逻辑;前端则真实调用这些接口取数据、刷新、给用户反馈,而不是把数据写死在页面里。这是有建模意识、有副作用、有错误处理的真实工程,不是占位桩。

                ⚠️ 本次仅作为技术能力验证,目标 App 为一款图文社区 + 商城形态的生活方式产品(已匿名化)。文中界面均为模型自主复刻的还原效果,数据为预置的种子数据,不含任何真实用户数据,不作商业用途。

                怎么做到的:分阶段注入约束 + 分层验收

                与其说我们让模型写了应用,不如说我们设计了一套约束闭环:把整个 0→1 过程拆成有序的阶段,在每个阶段把「要做成什么样」翻译成机器可校验的硬约束,再用一道比一道更严的验收机制,把模型逐步逼到达标。标准的制定与验收,全部不交给模型——它只负责在每一格里做决策。

                值得强调的是:移动端和 Web 端用的是同一套方法论。技术栈不同,约束闭环不变——这恰恰说明,决定交付质量的是这套控制方法,而不是某一种框架、或某个模型的单点能力。

                这套约束闭环控制系统,不是「给模型一个写代码的地方」,而是一条「分阶段注入约束 → 逐层验收 → 带错纠正」的可收敛流水线。

                1️⃣ 分阶段,把约束「种」进每一步

                约束不是一次性丢进去的,而是跟着阶段逐层加码:规划阶段约束目标边界(从调研结论先推出页面 / 模块清单,想清楚「做成什么样」再动手);架构阶段约束技术选型与数据建模,并把真实 UI 的像素坐标反推成布局约束;编码阶段约束实现规则,并要求每个模块写完先自查、逐条指认「哪行代码落地了哪条约束」。

                不让模型看一段「页面描述」就拍脑袋,而是把真实界面的像素事实,直接翻译成它必须遵守的布局约束。

                但约束能落地,有一个隐含前提——模型得真的守规矩。我们给的硬规则(长文件分段读取、动手前先用 Glob 探查、改文件前先读原文)Qwen3.7-Max 在近 30 分钟、数百次工具调用里逐条照做,而不是盲写;它甚至会按真实依赖关系重排执行顺序(先把所有页面建好,再回头补路由),而非机械按编号推进。一个不守约束的模型,再好的约束工程也落不了地。

                2️⃣ 分层验收,一道比一道更接近「人」

                写完不算交付。我们架了一条逐级加码的验收阶梯,失败时把上一步的报错原文喂进下一次重试,让偏差当场收回:

                • 静态检查(命名、未用引用、空安全等)

                • 编译自检(必须 0 error 才算过)

                • 路由完整性(每个页面都接得上、点得到)

                • 功能扫描(空按钮、占位页、假加载等交互缺陷)

                • 部署到真实运行环境,冷启动,像人一样跑起来看

                这一步,是我们最想强调的认知

                机器可验 ≠ 应用可用。编译通过、0 error、路由齐全、功能扫描干净,这些只证明「代码成立」,不证明「应用可用」。一个真人怎么评价一个 App?他不会去看你静态检查过没过,他会打开它、在真机上点一遍、看顺不顺、像不像。所以验收标准必须贴近人——闭环的终点,是把应用装进真实运行环境冷启动、像人一样用一遍。

                3️⃣ 确定性兜底,长程里别丢步

                整条阶梯由一层确定性调度兜底:每个模块必然被执行、失败必然重试、中断可断点续跑。模型负责「智能」,调度负责「可靠」——用确定性的脚手架,包住非确定性的 Agent。

                细节 / 日志:约束是怎么被「执行」和「判定」的

                方法论容易说漂亮,真正可复现的是工程细节。以下两点,是整套约束闭环里最硬核的部分:

                • 解决「模糊的审美要求,怎么变成机器能逐条核对的事实」

                • 解决「怎么客观判定一个自由发挥的模型,到底成没成」

                细节一:让模型照着真实 App 的「像素坐标」写布局,而不是照着文字描述 

                问题:文字描述是有损压缩 

                复刻一个界面,最自然的做法是把调研报告喂给模型:「首页是两列视频网格,顶部有个推荐位」。它照着做出来,往往是——看着像、处处不对:列宽不对、卡片忽高忽矮、顶部那张大图被硬塞进了两列网格里。

                根因在于:这种文字描述本身是一次有损压缩。「两列网格」四个字,把列宽、卡片宽高比、有没有通栏大图、图标排几个这些可量化的事实全丢了,模型只能靠脑补补齐——而脑补基本不会对。(更何况 Qwen3.7-Max 看不懂截图,文字描述几乎是它唯一的视觉线索。)

                洞察:坐标是跑不掉的事实 

                但在真机界面里,每个元素的像素坐标是确定的、无损的。我们的调研产物里就躺着这样一份东西:ui_summary.txt——从真机界面 dump 出来的元素清单,一行一个控件,带着它的精确边界框。一行长这样(已简化,只留关键字段):

                  ... clickable="true"  bounds="[17,436][1423,1358]"

                  bounds="[左,上][右,下]" 就是像素级的事实——这一行说的是:一个可点击的卡片,左上角在 (17,436)、右下角在 (1423,1358),也就是宽 1406px。所以流水线立了一条原则:

                  bounds 是真相,描述是衍生物。布局必须由坐标反推,而不是由文字描述拍板。 

                  做法:把坐标换算成几条「不许违反」的事实

                   任务拆分完成后,一段程序会自动扫描这些坐标、做纯几何换算,把结果直接写死在每个页面的任务卡末尾。它本质上是在替设计师回答几个本该拍板的问题(括号里是判断依据):

                  这页是网格还是列表?(取面积最大的那个可滚动容器,看它的类型——决定该用网格还是列表来实现) 

                  一行排几列?(把可点击卡片按纵坐标聚成一行,容差 ≈ 50px,同一行里有几张就是几列) 

                  顶部那张大图要不要单独做?(宽度 ≥ 90% 屏宽的卡,就是一张通栏「头卡」,必须单独处理,不能塞进 N 列网格) 

                  所有卡能不能套同一个模子?(同一页若出现多种宽高比,如 0.55 瘦长、0.85 近方,就禁止用单一比例一压到底,必须分类型或上瀑布流——这恰恰是模型最爱犯的错) 

                  这个小方块是图标还是图片?(又小、又接近正方、还成排出现,同排 ≥ 3 个的,判定为图标位,强制用矢量图标,而不是拿照片去凑) 

                  最终产出,是一段叫「布局硬约束」的清单,长这样:

                    - 滚动根容器:网格 → 实现时用网格组件
                    - ⚠️ 检测到 1 张通栏头卡(宽度 ≥ 90% 屏宽)→ 必须含全宽头卡
                    - ⚠️ 混合宽高比:{0.55 瘦长卡, 0.85 近方卡} → 禁止用单一比例
                    - 图标位:1 行 6 列,边长 ≈ 168px → 必须用矢量图标

                    于是写代码的模型拿到的,不再是「做个好看的首页」这种含糊要求,而是一份可以逐条对照检查的事实清单——它在自查时甚至要指出「通栏头卡 → 首页第 42 行的 _LeaderCard」。我们把模糊的审美问题,压成了确定的几何约束。

                    细节二:怎么知道一个 Agent「到底成没成」 

                    一个被低估的难题 流水线是 Harness 调度 + 模型干活。Harness 要根据 Agent 的执行结果决定下一步:通过了就标记完成往下走,失败了就重试或回退。问题是——怎么判断一个自由发挥的语言模型「成功」了没有?模型不会返回 exit code 0,它返回的是一大段自然语言。

                    三层判定,逐层兜底

                    编排层:CLI 异常退出、撞上轮数上限(max_turns),直接判失败,异常被 try/except 兜住、转成「(错误文本, False)」。 

                    产物层:很多阶段不信 Agent 的「我做完了」,而是亲自查文件存不存在——规划阶段查开发指南、拆分阶段查有没有任务文件、打包阶段查 APK。说成功但文件没生成,照样算失败。 

                    协议层:对「修到没问题为止」这种没有明确产物的阶段,约定一个文本暗号——Agent 被要求在输出里打 ANALYZE_RESULT: PASS 或 VALIDATION_RESULT: PASS,再用字符串匹配判定。 

                      if"ANALYZE_RESULT: PASS" in result_text:
                            await mark_phase_done(PHASE_ANALYZE)
                            return True
                        prev_errors = result_text  # 没 PASS,把整段输出当作下一轮的输入

                      注意最后一行:失败时,Agent 这一轮的全部输出会原样变成下一轮的 prompt 上文。于是「剩余的 error 列表」自动传给下一轮去修——重试不是从头再来,而是带着上次的残局接着打。模块开发的重试同理:上次报错被截断后注入下一次(「【重试注意】上一次执行失败,错误信息如下……」),并且重试前先把上次可能写歪的文件清掉,避免脏文件干扰。

                      不止外层在收敛,模型自己也在收敛:带着上一轮的残局,Qwen3.7-Max 反复「生成 → 编译自检 → 读报错 → 修复 → 再编译」,把报错数一轮轮压下去(如 43 → 38 → 20 …)直到能成功构建。内层(模型自查)与外层(Harness 判定 + 带错重试)同频收敛——这正是它能独立交付可构建工程的关键。

                      结果与边界

                      先说结果

                      •  双端(移动端 + Web)从 0 交付,核心界面与主要交互几近还原。 

                      • 交付质量:功能验证 / 静态分析 / 打包 / 启动冒烟 4 道自动化关卡全部通过——移动端产出可安装 APK 并通过启动冒烟,Web 端 typecheck + 构建通过、34 条路由全部可达。 

                      • 整个过程跨越数小时、涉及大量长程依赖,由模型独立完成,中途没有人工接管做分步拆解。 

                      再说边界

                      •  「几近还原」不是「逐像素一致」:还原的是页面结构与主要交互路径,细节排版、边缘交互仍有出入。例如:评论区暂为平铺、未实现「展开 N 条回复」的分层视图;二维码为占位图、非真实可扫码;部分边缘入口(设置 / 收藏 / 直播创建等)仍是「敬请期待」占位提示。 

                      • 数据是 mock,不是真实后端:界面跑得起来,但不含真实用户数据,也不等于一套生产级后端。 

                      • 复现性依赖环境与输入质量:调研文档颗粒度、Sandbox 反馈信号是否到位,会直接影响产出稳定性——换一份模糊的输入,结果会明显退化。 

                      这是单次实验,不是统计意义上的稳定结论:它证明了「能做到」,「每次都稳定做到」还需要更大规模的验证。 

                      从这个实验我们发现了什么?

                      一、没有「自动判据」的闭环,只是伪闭环

                      遇到的问题: 起初,我们以为只要让模型写完代码、编译通过就算成功。但在长程任务中,错误会沿着链条累积:一个微小的命名规范错误,可能在几十步之后导致路由失效。如果没有自动化的判定机制,这些错误会被掩盖,直到最后真机运行才爆发。

                      我们的发现: 同一个模型,放进「能自动判定成败」的闭环里,长程交付的成功率明显高于「只给它一个编辑器」。

                      • 原因:没有可验证反馈时,错误是隐性的;有了硬信号(如编译报错、路由缺失),错误能被当场截断、回灌纠正。

                      • 关键点:判定能力必须一路建到贴近人的真机层。别停在编译过、单测通过就以为交付了——那是给机器看的,不是给用户用的。

                      二、约束越多,模型越爱「哄骗」校验

                      遇到的问题: 为了追求完美,我们一度加了多层质量校验循环,包括语义相似度匹配、风格一致性检查等模糊规则。结果发现,产出反而不稳定:模型开始花大量精力去生成那些能“骗过”校验器的关键词,而不是真正写对代码。

                      我们的发现: 约束要做减法,不要做加法。 当我们删掉模糊的关键词校验,换成可被字面匹配的硬规则(如“必须包含某函数名”、“文件行数必须大于X”)后,产出反而更稳。

                      • 原因:校验越模糊、越冗余,模型越容易把精力花在「通过校验」上,且校验自身的误判还会污染重试上下文。

                      • 关键点:只保留「能被机器明确验证」的约束。一条可字面校验的硬规则,胜过一堆似是而非的提醒。

                      三:工具层能补位,但补不了「地基」

                      遇到的问题: Qwen3.7-Max 不具备图像理解能力,这曾是我们担心的短板。我们试图通过工具层拦截截图、转化为文字描述来弥补。但我们发现,即便有了这些辅助,如果模型本身在长程指令遵循上漂移,整个工程依然会崩塌。

                      我们的发现: 模型的「长程指令遵循稳定性」是地基,工具层只是装修。 看不懂图可以靠工具层拦截 + 文字化补上;但要在近 30 分钟、数百次调用、上百个文件里守约束不漂移、按真实依赖排序、还能收敛式自我纠错,这件事约束工程替代不了——这正是 Qwen3.7-Max 这次顶住的地方。

                      • 原因:约束再好,也要有一个能稳定理解并持续遵循它的模型来执行;长上下文一旦跑偏,再多验收机制也救不回来。

                      • 关键点:选模型别只看单点跑分,重点看它在「长上下文、强指令、多轮自洽」下掉不掉链子。

                      推荐阅读

                      Agent 辅助开发,一站式打通 Qwen3-VL Android 端侧推理

                      Qwen3.7-Plus:把多模态AI变成“实干家”

                      跳转微信打开

                      •  

                      去哪儿网-ES分片运维实战:从原理到十万级分片治理

                      原创 许睿哲 2026-06-09 15:30 北京

                      e7aea0b2-cb9f-4322-b3ce-66271860cbe5.png

                      文章概览

                      图片

                      • 工作背景

                      • 分片管理核心原理

                      • 分片恢复核心参数与调优实践

                      • 分片重平衡参数与性能优化

                      • 分片策略最佳实践

                      • 分片治理生产案例

                      • 分片运维高频实操命令

                      • 分片使用运维总结

                      • 参考文献

                      作者介绍:

                      许睿哲,2020年12月加入去哪儿网-数据平台团队,目前主要负责公司ESAAS云服务与实时日志ELK平台的开发、维护与优化工作。主导了ES平台的SLA规则制定与开发,并负责容灾架构设计、实时日志集群构建与拆分重构等项目。

                      一、工作背景

                      在日常ES集群运维工作中,我们发现相当大比例的集群稳定性问题、性能瓶颈、扩容故障,核心问题都集中在分片规划不合理、分片恢复参数默认化、重平衡机制不熟悉这三点上。

                      此文从相关原理展开并结合生产实践(十万级分片治理),阐述ES分片的使用与实践方案。可以作为日常使用与运维参考。

                      二、分片管理核心原理

                      2.1 主分片与副本分片核心机制

                      ES 集群由多个索引构成,索引由多个分片构成。单个索引的数据会被拆分多份,分散存储在集群不同节点上,以此实现海量数据存储、读写负载分担和高可用容灾。

                      一般来说,分片分为主分片和副本分片两类,分工明确,缺一不可。

                      ES集群索引分片分布图

                      主分片(Primary Shards):集群写操作的唯一核心执行者,索引的新增、修改、删除请求,都会先在主分片执行成功,再同步数据至对应副本分片,保障集群数据一致性。

                      注:索引创建后,主分片数量无法修改。若规划失误,只能通过重建索引或Reindex迁移数据解决。

                      副本分片(Replica Shards):主分片的完整数据备份,不参与任何写请求,核心作用有两个:

                      1.高可用容灾:当主分片所在节点宕机、离线,副本分片会自动晋升为主分片,避免数据丢失、服务中断;

                      2.分担读压力:所有查询、检索请求并行命中主、副本分片,大幅提升集群查询吞吐量。

                      注:主分片只能有一份,副本分片可以设置0到多份。生产环境禁止配置0副本,否则存在丢数据风险。

                      2.1.1 生产分片分配核心原则

                      ES 有内置的分片分配策略(自动动态调整的),也是线上需要了解的分配策略:

                      • 核心定律:同一主分片和自身的副本分片绝对不会分配在同一个节点,避免单节点宕机导致分片整体丢失。

                      • 负载优先:集群会自动将分片分配到分片数较少、 CPU/内存/磁盘负载更低的节点,以均衡集群压力。

                      • 整体均衡:自动调整各节点分片数量,避免单节点分片过多引发资源耗尽或查询超时。

                      注:ES自带的分配策略不一定是最优的,有时必须人工干预。例如:日志集群新增3个节点后创建次日索引,大量分片会倾斜给新节点。若不干预,势必导致新节点压力飙高甚至宕机。

                      2.2 分片恢复与重平衡机制

                      当集群发生扩缩容、节点故障重启、索引创建时,ES 会自动触发分片恢复与重平衡(Rebalance)操作,该阶段也是集群抖动的高发期。只有深入理解底层机制,才能做到精准调参、有效规避故障。

                      2.2.1 分片恢复机制

                      当节点故障离线、集群新增节点后,集群中会出现大量未分配分片,ES 会自动将这些分片恢复、迁移至正常节点,恢复分片副本,保障数据高可用。

                      2.2.2 分片重平衡机制

                      当集群拓扑发生变化(节点新增、离线、故障)导致分片分布不均衡时,ES会自动执行重平衡,跨节点迁移分片以保证整体负载均匀。

                      注:中小集群重平衡利好,但十万级大集群的自动重平衡往往是故障根源。

                      2.2.3 生产常见分片状态解读

                      日常运维排查故障,重点关注这5种分片状态,快速定位问题:

                      • STARTED:分片初始化完成,正常运行、可读写,无异常。

                      • UNASSIGNED:分片未分配到任何节点,属于异常状态,需及时排查原因(磁盘不足、分配规则限制、节点故障等)。

                      • INITIALIZING:分片正在初始化,节点重启、分片新建后常见临时状态。

                      • RECOVERING:分片正在从其他节点同步恢复数据,扩容、重启后高频出现。

                      • RELOCATED:分片正在跨节点迁移,重平衡过程中的临时状态。

                      三、分片恢复核心参数与调优实践

                      分片恢复参数是集群运维的核心重点,默认参数适配性低,集群扩容、节点重启后,极易出现恢复速度过慢、长时间卡在恢复中,或者恢复并发过高打满磁盘、带宽的问题。合理调整参数对集群恢复正常运维是至关重要的。

                      3.1 核心恢复参数详解(业务集群使用)

                      以下参数均支持集群全局配置,适配ES主流版本,包括默认参数与生产建议值:

                      集群参数恢复参数配置示例:

                        PUT /_cluster/settings
                        {
                          "persistent": {
                            "cluster.routing.allocation.node_concurrent_recoveries": 8,
                            "cluster.routing.allocation.node_concurrent_incoming_recoveries": 8,
                            "cluster.routing.allocation.node_concurrent_outgoing_recoveries": 8,
                            "cluster.routing.allocation.node_initial_primaries_recoveries": 8,
                            "indices.recovery.max_bytes_per_sec": "200mb"
                          }
                        }

                        注:如果集群同时配置了transient和persistent,通常 transient会覆盖后者,但重启后会丢失。修改配置前请务必确认两者是否冲突,不一致时系统以transient为准。

                        3.2 分片恢复过程监控命令

                        扩容、重启、故障恢复期间,需实时监控分片恢复进度和节点负载:

                        # 1. 监控分片恢复详细进度、耗时、源目标节点
                        GET /_cat/recovery?v=true&h=i,s,t,ty,shost,thost,f,fp,b,bp
                        # 2. 查看集群整体健康状态,定位分片异常
                        GET /_cluster/health
                        # 3. 查看节点磁盘、堆内存负载,防止恢复过程资源打满
                        GET /_cat/nodes?v&h=name,diskUsed,diskAvail,heapUsed,heapMax

                        四、分片重平衡参数与性能优化

                        重平衡机制是一把双刃剑:默认自动均衡能保证分片均匀,但频繁、大规模重平衡会占用带宽和磁盘IO,导致业务查询超时。

                        4.1 重平衡核心参数详解

                        4.1.1 重平衡开关控制

                        cluster.routing.rebalance.enable:控制集群分片迁移、重平衡的权限,生产运维高频使用,支持4种配置:

                        • all:默认值,允许所有分片迁移、全量重平衡。

                        • primaries:仅主分片允许重平衡,副本禁止迁移。

                        • replicas:仅副本分片允许重平衡,主分片禁止迁移。

                        • none:关闭所有分片重平衡。维护、重启、扩容期间必备配置。

                        注:cluster.routing.rebalance.enable 和 cluster.routing.allocation.enable 容易搞混,以下是整理的区别:

                        1. cluster.routing.rebalance.enable:控制「已分配的分片要不要迁移均衡」(重平衡)有效值:all、primaries、replicas、none。

                        2. cluster.routing.allocation.enable:控制「新分片能不能分配、恢复」(分片分配)有效值:all、primaries、new_primaries、none。

                        4.1.2 重平衡并发控制

                        cluster.routing.allocation.cluster_concurrent_rebalance:控制集群全局同时执行的重平衡数量,默认2。高配集群可按需调大以加速均衡。

                        4.1.3 实操配置命令

                          # 1. 集群维护、节点重启:禁用所有分片迁移
                          PUT /_cluster/settings
                          {
                            "transient": {
                              "cluster.routing.rebalance.enable": "none"
                            }
                          }
                          # 2. 仅允许主分片移动
                          PUT /_cluster/settings
                          {
                            "transient": {
                              "cluster.routing.rebalance.enable": "primaries"
                            }
                          }
                          # 3. 维护完成,恢复默认重平衡规则
                          PUT /_cluster/settings
                          {
                            "transient": {
                              "cluster.routing.rebalance.enable": "all",
                              "cluster.routing.allocation.cluster_concurrent_rebalance": 2
                            }
                          }

                          4.2 重平衡配套优化策略

                          磁盘水位线是控制分片迁移的关键参数,生产环境必须提前配置:

                            PUT /_cluster/settings

                            {

                              "persistent": {

                                "cluster.routing.allocation.disk.watermark.low": "85%",

                                "cluster.routing.allocation.disk.watermark.high": "90%",

                                "cluster.routing.allocation.disk.watermark.flood_stage": "95%"

                              }

                            }


                            参数说明:

                            low(85%~90%):ES停止向该节点分配新分片,已有分片正常读写。

                            high(90%~95%):ES 会主动把当前节点上已有的分片迁移到其他空闲节点,逐步清空该节点压力。

                            flood_stage(95%):节点上的所有索引被强制设为只读,无法写入。

                            注:磁盘空间需配置告警,提前预警并及时处理,避免达flood_stage 影响业务。

                            五、分片策略最佳实践

                            5.1 分片数量规划规范

                            分片数量是前期规划的重中之重,一旦创建无法修改,不合理的分片数会长期拖累集群性能。统一的生产标准:

                            • 单分片最优大小: 业务索引10-30GB,日志索引可达50GB左右。过小浪费资源,过大影响恢复和查询。

                            • 分片数量上限: 单索引总分片数不超过集群数据节点数的2倍。

                            • 集群分片总数: 建议不超过10万。

                            • 节点分片总数: 默认不超过1000,最大建议不超过3000。过多会影响元数据和master稳定性,导致节点脱离集群。

                            分片规格常规推荐方案

                            分片数调整方案

                            主分片数创建后无法直接修改,只能通过重建索引调整:

                            5.1.1 常规分片重构(停服方式)

                              # 1. 新建目标分片数的索引

                              PUT /new-index

                              {

                                "settings": { "number_of_shards": 3 },

                                "mappings": { "properties": {} }

                              }

                              # 2. 全量迁移数据

                              POST /_reindex

                              {

                                "source": { "index": "my-index" },

                                "dest": { "index": "new-index" }

                              }

                              # 3. 删除原始索引并回写

                              DELETE my-index

                              POST /_reindex

                              {

                                "source": { "index": "new-index" },

                                "dest": { "index": "my-index" }

                              }

                              注:Reindex重构成本高,需停写与补数。若不接受停服,推荐使用下方别名方式。


                              5.1.2 生产推荐分片重构(零停机别名切换)

                              按照上述的索引名称:

                              • 旧索引:my-index(主分片不能改)

                              • 新索引:my-index-v2(新索引可以设置需要的新分片数)

                              • 业务使用别名:my-index-alias

                                # 1. 给旧索引绑定别名(业务统一使用别名访问)

                                POST /_aliases

                                {

                                  "actions": [{ "add": { "index": "my-index", "alias": "my-index-alias" } }]

                                }

                                # 2. 创建新索引(设置新的主分片数)

                                PUT /my-index-v2

                                {

                                  "settings": { "number_of_shards": 3, "number_of_replicas": 1 },

                                  "mappings": { "properties": { ... } }

                                }

                                # 3. 异步Reindex迁移数据

                                POST /_reindex?wait_for_completion=false

                                {

                                  "source": { "index": "my-index" },

                                  "dest": { "index": "my-index-v2" }

                                }

                                # 4. 查看进度:

                                GET _tasks/task_id

                                # 5. 无缝切换别名(原子操作,0停服)

                                POST /_aliases

                                {

                                  "actions": [

                                    { "remove": { "index": "my-index", "alias": "my-index-alias" } },

                                    { "add": { "index": "my-index-v2", "alias": "my-index-alias" } }

                                  ]

                                }

                                # 6. 验证

                                GET my-index-alias/_alias

                                # 确认别名指向 my-index-v2 即为切换成功

                                注:后续业务代码、查询、写入全部使用别名 my-index-alias,切勿直接使用真实索引名。


                                5.2 副本数配置规范

                                • 高可用生产集群:默认配置1个副本,兼顾容灾与资源消耗。

                                • 高查询、低写入场景:适当增加副本数分担读压力(需更多节点支撑)。

                                • 离线归档/日志数据:可配置0副本节省空间(需接受丢数据风险)。

                                5.3 单节点分片数限制配置

                                通过参数限制单节点最大分片数量,避免分片集中堆积,导致单节点负载过载:

                                  PUT /_cluster/settings

                                  {

                                    "persistent": {

                                      "cluster.routing.allocation.shards_per_node": 2

                                    }

                                  }

                                  注:如集群6个数据节点、索引6个分片,可设置shards_per_node: 2,保证主副分片均衡落入每个节点。


                                  六、分片治理生产案例

                                  6.1 案例一:集群扩容后分片负载不均问题

                                  问题背景:5节点ES集群扩容至10节点后,旧节点负载过高,新节点闲置,业务查询卡顿。

                                  解决方案:

                                  1. 优化分片恢复参数,提升迁移效率,避免长时间卡顿

                                    PUT /_cluster/settings

                                    {

                                      "persistent": {

                                        "cluster.routing.allocation.node_concurrent_recoveries": 8,

                                        "cluster.routing.allocation.node_concurrent_incoming_recoveries": 8,

                                        "cluster.routing.allocation.node_concurrent_outgoing_recoveries": 8,

                                        "cluster.routing.allocation.node_initial_primaries_recoveries": 8,

                                        "indices.recovery.max_bytes_per_sec": "200mb"

                                      }

                                    }


                                    2. 开启重平衡并调高并发

                                      PUT /_cluster/settings

                                      {

                                        "transient": {

                                          "cluster.routing.rebalance.enable": "all",

                                          "cluster.routing.rebalance.cluster_concurrent_rebalance": 8

                                        }

                                      }


                                      3. 全程监控分片分布与节点负载。

                                      4.对重要索引配置 shards_per_node 保证节点分片均衡。

                                      复盘最佳实践:扩容必须分步操作,禁止一次性批量加节点;扩容前提前调优恢复参数,扩容后监控均衡进度。

                                      6.2 案例二:十万级分片超大集群治理实战

                                      集群背景:Qunar-实时日志平台目前采用的是ELK架构方案,承载全司实时日志,集群节点规模达到数百节点,全局总分片最高突破10万,日均写入数据量数百TB级,属于典型的海量分片、高吞吐、低延迟稳态运行集群。长期以来面临诸多挑战,此案例也是将痛点风险一一拆解并给出实际生产运维方案。

                                      ELK日志架构示意图

                                      ES日志集群规模图

                                      核心痛点梳理如下:

                                      1、海量分片导致集群元数据体量巨大:master节点频繁处理分片状态变更、元数据同步,CPU、线程池长期高负载,偶发集群状态更新超时、轻微脑裂风险;

                                      2、分片分配不均衡:每周批量创建索引(周维度),面临索引分片分配不均衡,原生分片分配机制将新分片优先分配至空闲节点,导致新旧节点分片数量与负载严重分层,高负载节点频繁脱离集群;同时加重 master 元数据管理压力,进而引发更大范围的节点崩溃。

                                      3、集群加减节点导致分片同步压力大:节点滚动重启、增减节点、或者小规模扩容时,默认自动重平衡触发数百甚至上千分片同时同步,磁盘IO直线上升,影响读写,甚至消费堆积波动;

                                      4、超大分片导致读写不均衡:个别大索引的分片数分配不合理,会导致单个分片超大(大于100G甚至150G),平衡时间长。也有日志索引分片条数多,导致很快达到21.47 亿条(ES 单分片文档数上限为 2,147,483,519),超过最大限额无法写入。

                                      5、节点存储规格不同导致小存储节点更易先写满:集群配置有9t、14t、18t、20t多种规格(同时也有ssd和非ssd磁盘),小的存储更容易写满,触发磁盘水位线继而引发写入终止。

                                      6、索引未提前创建、mapping统一更新导致集群pending task上升和消费堆积:索引如果未提前创建(新周期),在新周期统一写入时创建,会有大量任务导致集群卡死,消费堆积。提前创建索引也会因为大索引的mapping更新导致pending task上升,继而加剧消费堆积。

                                      区别于中小集群轻量化运维,超大集群治理核心是锁死稳态参数、禁用原生自动重平衡机制、人工可控调度,以下是实际生产运维调优的方案:

                                      6.2.1 全局恢复参数固化(杜绝默认参数隐患)

                                      ES默认并发、限速、磁盘水位参数仅适配千级分片小集群,十万级分片场景下,要么恢复过慢堆积大量未分配分片,我们通过持久化参数统一固化分片恢复相关配置,长期生效不丢失,完整DSL如下:

                                        // ==================== 分片恢复参数说明 ====================


                                        // node_concurrent_recoveries:单节点分片恢复并发,适配高负载大集群


                                        // node_concurrent_incoming_recoveries:入向/出向恢复并发差异化管控,避免单向流量打爆


                                        // node_initial_primaries_recoveries:节点重启后主分片初始化并发,加速主分片恢复效率


                                        // max_bytes_per_sec:万兆网卡SSD集群提速分片传输,减少恢复时间


                                        PUT /_cluster/settings


                                        {


                                          "persistent": {


                                            "cluster.routing.allocation.node_concurrent_recoveries": 20,


                                            "cluster.routing.allocation.node_concurrent_incoming_recoveries": 10,


                                            "cluster.routing.allocation.node_concurrent_outgoing_recoveries": 10,


                                            "cluster.routing.allocation.node_initial_primaries_recoveries": 20,


                                            "indices.recovery.max_bytes_per_sec": "200mb"


                                          }


                                        }





                                        6.2.2 磁盘水位线调整

                                          PUT /_cluster/settings

                                          {

                                            "persistent": {

                                              "cluster.routing.allocation.disk.watermark.low": "92%",

                                              "cluster.routing.allocation.disk.watermark.high": "95%",

                                              "cluster.routing.allocation.disk.watermark.flood_stage": "98%"

                                            }

                                          }


                                          注:统一调高三类水位线,延迟触发各项风险,可以将磁盘利用率达到最大化。

                                          6.2.3 永久禁用全局自动重平衡(从根源杜绝集群抖动)

                                          自动重平衡对于小集群(节点小于100,或者分片数低于10000的)稳定高效,对大集群而言则是稳定性灾难:

                                            // ==================== 禁用自动重平衡参数说明 ====================

                                            // rebalance.enable: 彻底关闭所有场景自动重平衡,禁止已分配分片自动迁移

                                            // cluster_concurrent_rebalance: 全局重平衡并发置0,作为兜底防护防止误开启后触发大规模迁移

                                            PUT /_cluster/settings

                                            {

                                              "persistent": {

                                                "cluster.routing.rebalance.enable": "none",

                                                "cluster.routing.allocation.cluster_concurrent_rebalance": 0

                                              }

                                            }


                                            注:关闭重平衡后,在节点扩容、重启、离线时,避免了集群节点成百上千分片跨节点同步,避免集群整体抖动,磁盘io打满等风险。

                                            6.2.4 增加delayed_timeout时间

                                              // ==================== delayed_timeout参数说明 ====================

                                              // log_test-2026.21为示例索引,实际使用时请替换为目标索引名

                                              PUT log_test-2026.21/_settings

                                              {

                                                "index.unassigned.node_left.delayed_timeout": "50m"

                                              }


                                              注:默认 delayed_timeout 为 1 分钟,节点短暂脱离后极易触发大规模分片重分配与恢复,加剧集群负载。将其调整为 50m,可为节点重启或网络抖动预留充足的自愈窗口,避免无效的跨节点数据搬迁,保障集群稳定。

                                              注:不同索引分片大小不同,delayed_timeout 可有所偏差(分片大的适当延长,分片小的适当缩短)。全量索引均需设置此参数,生产中通过索引模板统一管理,禁止逐索引手动修改。

                                              6.2.5 索引提前创建机制与配置模板管理

                                              时序性日志索引需提前批量创建,并通过独立模板实现个性化配置,具体措施如下:

                                              1.模板管理

                                              对于索引创建一个通用模板log_default,存储通用 settings 与 mappings,类似如下:

                                                {

                                                  "order": 1,

                                                  "index_patterns": [

                                                    "log_*"

                                                  ],

                                                  "settings": {

                                                    "index": {

                                                      "routing": {

                                                        "allocation": {

                                                          "total_shards_per_node": "1"

                                                        }

                                                      },

                                                      "refresh_interval": "60s",

                                                      "number_of_shards": "12",

                                                      "translog": {

                                                        "durability": "async"

                                                      },

                                                      "number_of_replicas": "0"

                                                    }

                                                  },

                                                  "mappings": {

                                                    "dynamic_templates": [

                                                      {

                                                        "strings": {

                                                          "mapping": {

                                                            "norms": false,

                                                            "ignore_above": 256,

                                                            "type": "keyword"

                                                          },

                                                          "match_mapping_type": "string",

                                                          "match": "*"

                                                        }

                                                      }

                                                    ],

                                                    "properties": {

                                                      "@timestamp": {

                                                        "type": "date"

                                                      },

                                                      "log_name": {

                                                        "ignore_above": 256,

                                                        "type": "keyword"

                                                      },

                                                      "content": {

                                                        "norms": false,

                                                        "type": "text"

                                                      }

                                                    }

                                                  },

                                                  "aliases": {}

                                                }

                                                注:统一模板匹配log_*全量日志索引,可以覆盖新索引和老索引,新业务索引也会有默认mapping与分片配置,保证结构一致性,默认的12个分片也可以保证写入顺畅,不至于超过分片限额。


                                                对于具体索引采用个性化模板,每个索引一个模板,模板中只写独特的settings,mappings。

                                                每周任务进行索引mappings、settings的更新,主要针对于以下几个:

                                                mappings:主要针对于当前索引的mappings相较于通用模板的mappings新增字段,如有,则更新。

                                                settings:针对分片数、total_shards_per_node进行调整(下方具体阐述)。

                                                2.索引创建调度任务

                                                主要做以下几件事:

                                                • 分析索引的存储量:分析当前周索引的存储量,并增加一定比例buffer(因为是提前创建),作为索引下周存储量级。

                                                • 规范分片大小:按照30~50GB大小为基准来计算分片数,统一更新到索引对应的模板。

                                                • total_shards_per_node调整:为了避免多分片集中在某个节点上,提前算出每个索引的per_node,保证分片的均衡分布(计算方式:math.ceil(分片数/节点数))。

                                                • 索引提前创建:每周固定时间提前2天低峰创建次周索引(取用最新分片数信息)

                                                实际例子的模板调整案例:

                                                log_test-2026.21索引(存储量40TB,节点数550):

                                                  // ==================== 索引模板更新说明(个性化覆盖) ====================

                                                  // order: 99 高优先级,用于覆盖通用模板 log_default 中的同名配置

                                                  // total_shards_per_node: 【更新】由通用模板默认值调整为2,适配当前550节点规模下的分片均衡

                                                  // number_of_shards: 【更新】按单分片50GB基准重新计算,由原值调整为820

                                                  // reqSize: 【新增字段】long类型,用于记录请求体大小

                                                  // gid: 【新增字段】keyword类型,ignore_above=256,用于全局追踪标识

                                                  PUT _template/log_test_template

                                                  {

                                                    "order": 99,

                                                    "index_patterns": [

                                                      "log_test-*"

                                                    ],

                                                    "settings": {

                                                      "index": {

                                                        "routing": {

                                                          "allocation": {

                                                            "total_shards_per_node": "2"

                                                          }

                                                        },

                                                        "refresh_interval": "90s",

                                                        "number_of_shards": "820",

                                                        "number_of_replicas": "0"

                                                      }

                                                    },

                                                    "mappings": {

                                                      "properties": {

                                                        "reqSize": {

                                                          "type": "long"

                                                        },

                                                        "gid": {

                                                          "ignore_above": 256,

                                                          "type": "keyword"

                                                        }

                                                      }

                                                    },

                                                    "aliases": {}

                                                  }


                                                  注:这个DSL涵盖了新增的字段mappings,更新的分片数(按照50g计算)、均衡total_shards_per_node(820/550取2),每个节点最多有2个分片,也保留了一定冗余,同时避免分片倾斜。

                                                  6.2.6 自研离线分片调度体系(替代原生实时均衡,可控负载)

                                                  禁用自动均衡后,放弃ES原生实时调度,采用凌晨低峰批量调度方案,自动/人工可控实现集群负载均衡。

                                                  核心实操逻辑:

                                                  自研离线分片调度涵盖了索引创建均衡、迁移与磁盘均衡,具体如下:

                                                  第一步:新索引(提前生成的)提前均衡分片

                                                  主要是分析新创建的总索引的分片数,计算出节点平均分片数,将高负载迁移到低负载。

                                                  新索引创建均衡流程图

                                                  注:其中对于ssd和非ssd节点也做区分,前者分配更多分片,后者分配少量分片。

                                                  第二步:索引(当前索引或者历史索引)低峰均衡调度

                                                  低峰调度有两种情况:

                                                  1. 调度load高节点到低load节点

                                                  对于当前load较高的节点,将其对应的当前写的分片迁移到load低的节点上。

                                                  主要的DSL方式如下:

                                                    POST /_cluster/reroute

                                                    {

                                                      "commands": [

                                                        {

                                                          "move": {

                                                            "index": "target-log-index",

                                                            "shard": 0,

                                                            "from_node": "高负载节点",

                                                            "to_node": "空闲节点"

                                                          }

                                                        }

                                                      ]

                                                    }

                                                    通过定时脚本自动化执行以上逻辑,实现无感知、低压力、零抖动的分片均衡,完全替代原生激进均衡机制。


                                                    1. 调度高存储占比节点的历史索引到低存储占比节点

                                                    尤其是9t,14t等低存储节点在当周写到周三周四会有存储压力,需要提前几天低峰进行历史索引的同步。

                                                    将上一周(已经不写的索引)同步到低存储压力节点。历史索引读写量小,低峰同步不影响集群整体性能,可以整体控制磁盘使用量。

                                                    落地优化效果

                                                    1. master负载大幅回落:集群元数据同步频次大幅降低,彻底解决了master CPU高负载、线程池阻塞及集群状态超时问题,master节点长期使用率可控制在10%以内。

                                                    2. 集群节点变化零抖动:永久禁用自动重平衡后,扩容、滚动重启、节点上下线等运维操作,不再触发大规模分片迁移,节点压力大导致的消费延迟问题得以避免。

                                                    3. 节点磁盘利用率达到最大化且可控:整合现有不同规格的磁盘节点,利用低峰期批量迁移高存储分片,最大化提升磁盘利用率,同时结合新的水位线参数实现磁盘利用率的精细化管控。

                                                    4. 故障恢复效率翻倍:集群分片恢复卡顿、超时问题彻底解决,单批次分片恢复耗时缩短60%。

                                                    复盘总结

                                                    1. ES集群运维存在明显的规模分水岭:千级分片以内的中小集群,依赖原生自动均衡、默认参数即可稳定运行;

                                                    2. 万级以上海量分片超大集群,原生机制、通用特性,反而会成为集群最大隐患,需转为人工标准化管控。

                                                    3. 通过生产环境持续迭代验证与参数调优,逐步逼近集群最佳状态与性能上限。

                                                    七、分片运维高频实操命令

                                                    7.1 集群监控命令

                                                      # 查看全量分片分布状态

                                                      GET /_cat/shards

                                                      # 查看未分配分片及异常原因

                                                      GET /_cat/shards?v&h=index,shard,prirep,state,unassigned.reason


                                                      7.2 手动分片迁移命令

                                                        # 1. 手动迁移指定分片

                                                        POST /_cluster/reroute

                                                        {

                                                          "commands": [{

                                                            "move": {

                                                              "index": "my-index", "shard": 0,

                                                              "from_node": "node1", "to_node": "node2"

                                                            }

                                                          }]

                                                        }




                                                        # 2. 手动分配副本分片

                                                        POST /_cluster/reroute

                                                        {

                                                          "commands": [{

                                                            "allocate_replica": {

                                                              "index": "my-index", "shard": 0, "node": "node3"

                                                            }

                                                          }]

                                                        }

                                                        八、分片使用运维总结


                                                        分片是ES分布式集群的核心基础,所有运维操作的本质都是平衡性能、稳定性与资源成本。

                                                        1. 前期规划: 严格遵守单分片业务10-30GB、日志30-50GB标准,控制总分片数,合理配置副本。

                                                        2. 日常调优: 常态化配置恢复并发、传输限速、磁盘水位线,适配硬件。

                                                        3. 变更管控: 扩容/重启/变更前必须关闭重平衡,完成后逐步开启。

                                                        4. 常规监控: 重点关注主/副本分片数、UNASSIGNED Shard数、节点负载、磁盘使用率。

                                                        5. 大规模集群: 百级节点或万级分片以上的集群必须禁用重平衡,自研分片调度策略。

                                                        九、参考文献

                                                        [1] Elastic. Size your shards[EB/OL] 

                                                        [2] Elastic. Modules-cluster cluster setting[EB/OL] 

                                                        [3] Elastic. Cluster reroute API[EB/OL] 

                                                        [4] 微信公众号. ES分片运维实战[EB/OL] 

                                                        [5] CSDN博主. Elasticsearch分片分配原理详解[EB/OL] 

                                                        [6] Elastic. 分片内部原理[EB/OL] 

                                                        [7] Elastic. 索引别名[EB/OL] 

                                                        [8] 腾讯云开发者. Elasticsearch分片规划最佳实践[EB/OL]

                                                            长按识别二维码,查看全部文献完整原文链接⬆️

                                                            跳转微信打开

                                                            •  

                                                            Xiaomi MiMo 携手 TileRT|1T 模型首次突破 1000 tokens/s 输出速度

                                                            原创 小米大模型 2026-06-09 11:32 北京

                                                            天下武功,唯快不破

                                                             Xiaomi MiMo-V2.5-Pro-UltraSpeed:天下武功,唯快不破

                                                            从内燃机时代的第一辆跑车,到突破音障的超音速飞行,人类对速度的渴望,刻在基因里。

                                                            AI 推理的速度,同样决定了智能的边界。当模型足够快,它不再只是一个"等待出结果"的工具,而是成为你思维的延伸——实时响应、即时迭代、无缝协作。

                                                            今天,MiMo × TileRT 联合发布:Xiaomi MiMo-V2.5-Pro 的 UltraSpeed 模式,让万亿参数的旗舰模型输出速度首次突破 1000 tokens/s。

                                                            1000 tokens/s 到底有多快:

                                                             限时开放 · 申请制体验

                                                            MiMo-V2.5-Pro-UltraSpeed API 同步上线,采用限时体验价,定价为 MiMo-V2.5-Pro 的 3 倍,同时提供输出速度的约 10 倍提升!3 倍价格提升,10 倍输出体验。(仅支持 API 体验,暂不支持 Token Plan)

                                                            本次 MiMo-V2.5-Pro-UltraSpeed 采取申请制限时开放,申请通过的用户可限时接入 API 体验,时间限 2026 年 6 月 9 日 至 6 月 23 日 23:59。

                                                            昨晚 MiMo-V2.5-Pro-UltraSpeed 在 X(Twitter)平台发布后的 12 小时内,有超过 3000 家企业及其开发者申请了 UltraSpeed API 的试用名额,行业类别涵盖法律、金融、酒店、通信、物流、互联网、文化传媒、汽车制造等。

                                                            👉 申请入口:https://platform.xiaomimimo.com/ultraspeed

                                                            由于推理资源紧张,本次试用名额有限,提交申请后不承诺审核时效性和审核通过率;我们将优先审核具备真实业务需求的企业与专业开发者场景,如有 UltraSpeed 相关的大规模商用需求,欢迎联系 business-mimo@xiaomi.com。

                                                            💬 Chat 体验(限时免费)

                                                            通过审核的用户也可获得限时免费的 Chat 体验(两周开放窗口内有效),体验入口:https://ultraspeed.xiaomimimo.com

                                                            为保障资源受限条件下的体验质量与使用公平性,试用服务规则如下:每个账号每日最多成功进入队列 10 次;单次会话时长上限 30 分钟;如会话空闲超过 5 分钟,系统将自动释放资源。

                                                             1000 tokens/s,不仅是快,更是范式的质变

                                                            在万亿参数(1T)的尺度上,突破 1000 tps 绝不仅仅是打字机变快了,它带来的是 AI 应用范式的底层颠覆。

                                                            首先,速度本身开始转化为智能。过去面对难题你只能“等一个答案并祈祷它是对的”;现在在相同的等待时间内,模型能并行跑数十条推理路径(Best-of-N/Tree Search),在后台自动验证纠错,用“快”衍生出思考的深度,直接提升推理质量。

                                                            其次,它彻底解放了 Coding Agent 的生产力极限。以前让 AI 写代码,受限于推理速度,开发者往往需要坐在屏幕前痛苦地等待。而 1000 tps 的极速推理,带来了颠覆性的代码编写速度与生产效率狂飙。

                                                            最重要的是,万亿模型开始进入实时决策闭环。毫秒级的“思考-响应”循环,让 1T 旗舰模型能够毫无阻碍地接入那些对时间极度敏感的场景——高频量化交易信号生成、瞬时反欺诈风控拦截、智能竞价以及实时交互对话。

                                                            而当这种力量被注入到手术辅助、医疗影像分析等生命垂危的场景时,AI的速度,就不再只是衡量效率的指标,而是与死神赛跑的筹码。在手术台上,AI 每提前一秒完成病灶分析与风险预判,留给医生的处置空间就多一分。这让我们深信,速度的终极意义绝非只是提高生产力,而是让技术为人类提供更好的生活。

                                                             模型与系统的极致 Codesign

                                                            实现 1T 旗舰模型突破 1000 tokens/s 的输出速度,不是单一技术的突破,而是 MiMo 模型与 TileRT 系统团队深度协作,极致 Codesign 的成果。当前业界在追求类似极致速度时,往往选择走专用硬件路线,例如 Cerebras 的晶圆级集成(Wafer-Scale)或 Groq 基于纯片上 SRAM 的定制芯片架构。而我们选择了在通用 GPU上,通过模型-系统协同设计便实现了更惊人的推理速度。

                                                            模型侧针对通用硬件的带宽瓶颈,进行了 FP4 量化,大幅缩减模型体积并减少访存开销;同时引入基于块级 masked 并行预测的高效推测解码 DFlash,大幅提升单次验证的 Token 接受长度。系统侧 TileRT 完美适配算法的动态特性,为全新的量化和推测解码流程量身定制专项优化的编译引擎与计算核。正是凭借这种极致的 Codesign,我们仅用一个标准的 8 卡通用 GPU 节点,便让 1T 模型突破了 1000 tokens/s 的输出速度。 

                                                            FP4量化

                                                            在万亿参数(1T)的尺度上,传统的 8 比特(如 FP8/INT8)甚至 16 比特推理,会带来极其恐怖的显存占用和内存带宽压力。降低参数的比特位宽,可以直接贡献于解码输出速度。因此,我们采用了业界较为通用且验证过几乎无损的 FP4(MXFP4[1])量化。

                                                            然而,如果对整个模型“一刀切”地进行 FP4 量化,模型在复杂推理、逻辑代码上的精度和泛化能力往往会遭遇退化。针对 Xiaomi MiMo-V2.5-Pro 典型的 MoE(Mixture of Experts)架构特性,其 Expert 占据了参数的绝大部分,且对量化的精度容忍度最高。因此,我们选择只对 MoE Expert 进行参数 FP4 量化,而对其他模块则保留原有精度。通过这样的 FP4 QAT(量化感知训练),我们在大幅缩减模型体积、榨干硬件带宽的同时,使模型的整体能力与原模型基本持平。如下图所示:

                                                            [FP4 vs FP8 模型对比]

                                                            DFlash 投机解码

                                                            传统的 Speculative Decoding 依赖一个小型 draft 模型来"猜测"后续 tokens,再由大模型验证。这种方法将每次 forward 产出 1 个 token 的自回归生成转换为了多个 token 的并行生成,且大模型验证过程的拒绝采样机制保证了输出质量无损。但是,它的瓶颈在于 draft 模型的质量决定了接受率,而更强的 draft 模型又带来更高的计算开销,两者难以兼得。

                                                            为了打破这一僵局,我们采用了学术界创新的 DFlash 块级 masked 并行预测方法[2]:draft 模型在一次前向中同时填出一整块 mask 位置,从根源上解除了"draft 自回归"的串行约束。

                                                            我们在 MiMo-V2.5-Pro 上落地了这条路径并进行了定制优化,面向万亿 MoE 与长上下文场景,通过 Muon 二阶优化器与模型自蒸馏保证较小 mask 块仍能够提供理想接受率的同时把 draft 阶段的开销压缩到接近极限:

                                                            • Draft 模型全部采用滑动窗口注意力机制(Sliding Window Attention,SWA),与 MiMo-V2 系列模型自身的 SWA 设计天然对齐。这使得 draft 不再依赖完整前缀,单次预测的算力从随上下文长度线性增长变为常数级。

                                                            • 训练时 mask 信号采样下沉到 GPU 本地分片,使一条序列单步即可产出覆盖不同长度上下文位置的数万级独立训练信号,对齐 MiMo-V2 系列模型长上下文能力的同时避免跨设备通信开销。

                                                            效果上,我们的并行预测推测解码在多个 agent 和 coding 高价值场景实现了显著的接受长度提升,意味着大模型每次验证都能"一口气"确认更多内容;此外,我们将 mask 块大小限制为 8 以降低验证开销、提高并发水平,使得高接受长度直接转换为高推理吞吐:

                                                            [DFlash 在不同场景下的接受长度]

                                                            Coding 场景下可以达到平均 6.30 的接受长度,部分样本中达到了最高 7.14 的接受长度。意味着每轮验证的 8 个 draft token 中可吞下 6-7 个 token,draft 在维持轻量的同时把接受率推到了端到端真正受益的水平。我们也在发现,在语义更发散、不确定性更高的通用对话场景中,当前的接受率还并不高,我们正在持续优化算法,探索更高的泛化上限。

                                                            TileRT 超低延迟推理 Kernel/ 系统

                                                            如果说 MiMo 的算法重构为千亿与万亿模型卸下了沉重的带宽枷锁,那么 TileRT 推理系统则是直接将通用 GPU 的物理潜能压榨到了微秒级的绝对极限。

                                                            在 1000 tokens/s 的超高频运行状态下,单个算子的生命周期被压缩至微秒级,传统推理系统的“算子边界”成为了核心瓶颈——每一次算子启动、硬件同步和全局内存往返,都会在微秒尺度上将整条执行流打断,暴露出明显的“执行间隙(Execution Gap)”。

                                                            TileRT 的范式级执行模型变革作为超低延迟推理的底层基础设施,TileRT 引入了全新的执行模型,从根本上消灭了算子边界带来的执行间隙:

                                                            • 常驻内核引擎(Persistent Engine Kernel):彻底摒弃传统的逐算子启动模式,让整个计算流水线常驻在 GPU 内部持续流转。这让系统获得了全链路持续预取的能力,在当前 Tile 仍在 Tensor Core 计算时,后续数据已沿着存储架构提前流动,实现数据搬运与计算的极致重叠。

                                                            • 异构流水线协作(Warp Specialization):在 Tile 级别将通信、搬运和张量计算进行更精细的物理拆解。打破原有的同构串行步调,让不同的 Warp(线程束)甚至整张 GPU 的异构执行域各司其职、精密协作,将 GPU 彻底演化为一个持续流动、精密协作的异构执行系统。

                                                            微秒级尺度下的软硬件深度收敛(Codesign)当底层的执行模型将硬件性能推向极限时,纯粹的运行时(Runtime)优化开始触及物理局限。在此基础上,TileRT 系统团队与小米 MiMo 团队展开了深度的技术共创,打破了原有的软件分层藩篱。为了让模型行为完美契合这条超低延迟执行流水线的持续推进,模型层面最终采用了针对 MoE Expert 的 FP4 混合量化策略,并在万亿架构上落地了对齐 SWA 的 DFlash 投机解码。TileRT 紧密配合这些算法特征与量化方案,量身定制了底层的编译引擎与计算核,双方基于硬件物理限制做出了深刻的联合工程权衡,让执行压力最终在硬件边界内平稳闭环。

                                                            1000 tokens/s 的诞生,绝不是单点优化的巧合。它是高水平系统基础设施与极致算法模型向着彼此深度收敛、共同演化的必然结果。

                                                            TileRT 团队是聚焦于下一代 AI 基础设施、专注于极致低延迟推理的前沿系统架构团队。

                                                            团队致力于推动前沿大模型在生产环境中的毫秒级实时响应,以全新的运行时(Runtime)架构打破传统的存储与计算壁垒。团队推演并实现了全新的范式级执行模型。

                                                            通过常驻内核(Persistent kernels)、Tile 流水线(Tile pipelines)以及异构协同等底层技术的全栈突破,TileRT 在复杂的异构计算生态中实现了极致的算力释放。

                                                            作为核心基础设施的赋能者,团队积极携手行业顶尖伙伴开展软硬件协同设计(Co-design),为迈向极度渴望“极致速度”的自主智能(Autonomous)时代构筑高性能算力底座。

                                                            更多 TileRT 技术细节请阅读:https://www.tilert.ai/blog/breaking-1000-tps-zh.html

                                                             更多效果展示

                                                            仅需 10 秒,做一个贪吃蛇小游戏

                                                            仅需 1 分钟,复刻一个 MacOS 系统

                                                             开源与展望

                                                            MiMo × TileRT,模型与系统的极致 Co-design,让万亿参数模型实现 1000 TPS 的极致推理速度。

                                                            [1]https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf

                                                            [2]https://arxiv.org/abs/2602.06036

                                                            跳转微信打开

                                                            •  

                                                            李志飞受邀出席好未来AI业务论坛:AI正在重构企业战略本身

                                                            飞哥说AI 2026-06-09 10:02 北京

                                                            超级个体能力 × 协同机制 = 超级组织。

                                                            近日,好未来在京举办AI业务论坛。出门问问创始人、《超级组织》作者李志飞受邀出席,围绕“AI时代下的超级组织”进行主题分享,系统阐述AI时代企业组织变革的新逻辑。

                                                            本次分享也是《超级组织》方法论走进头部企业的一次重要交流。《超级组织》由出门问问创始人李志飞与AI原生组织理论提出者高佳合著,结合前沿公司的一线转型实践,系统讨论AI时代组织进化范式,提出“组织大折叠”“智能体飞轮效应”“AI原生组织操作系统”等关键命题,为企业理解和推进AI时代组织转型提供了新的思想框架与实践参照。

                                                            好未来相关负责人表示:“李志飞的分享让我们看到,AI不只是工具,它正在改变组织运作的方式,对我们推进AI业务和组织协同很有启发。”

                                                            图片

                                                            超级个体不等于超级组织,AI正在重构战略本身

                                                            AI工具的普及让越来越多个体实现效率跃升,但李志飞在分享中指出,一个关键误区正在出现:N个超级个体叠加,并不等于超级组织。

                                                            “超级个体的个人英雄主义在组织里可能是一场灾难。”李志飞表示,AI时代真正的公式不是“个体能力相加”,而是:超级个体能力 × 协同机制 = 超级组织。

                                                            在他看来,AI带来的不只是工具升级,而是决策逻辑和组织运行方式的底层重构。过去企业战略强调“想清楚再动”,但AI大幅降低试错成本之后,战略周期被压缩,组织需要从线性计划转向快速验证、快速反馈、快速迭代。“战略的本质没变,变的是更快看清、更快行动、更快迭代。”李志飞表示,AI时代企业真正的护城河,将越来越取决于决策速度、执行敏捷度和AI使用深度。

                                                            AI时代,CEO 要成为组织系统的设计者

                                                            围绕企业如何搭建超级组织系统,李志飞提出,AI时代的CEO和管理者不能只停留在“用AI提效”的层面,而要进一步成为组织系统的设计者。

                                                            他以出门问问自研的CodeBanana为例,介绍了企业AI原生协作平台的搭建路径:将公司协作场景映射成项目,为每个项目配置专属Agent;将重复流程模板化为Skill;配置Agent跨项目协作权限,让信息自动流转;最终将多个项目串联成完整业务流,实现从触发、执行到沉淀的自动闭环。“CEO设计系统,系统自己跑。”李志飞表示。

                                                            图片

                                                            从书到实践:《超级组织》方法论如何落地

                                                            《超级组织》中提出,AI时代最大的组织挑战,不是继续放大超级个体,而是如何把超级个体的产能转化为可持续、可规模化的组织能力。本书首次系统提出了极具实战指导意义的“AI 原生转型三步循环法”。

                                                            这一套底层方法论,也持续贯穿于出门问问内部的组织进化实践。过去一年,出门问问围绕信息流、协作模式和管理机制进行重构,推动研发团队全栈化、原子小队化,并通过CodeBanana让Agent真正进入组织工作流,参与任务理解、状态同步、协同执行与经验沉淀。

                                                            李志飞在现场分享中强调,AI转型不能只依靠工具采购,也不能停留在员工自发使用AI的阶段。真正有效的AI组织转型,需要管理者亲自下场,从自己最高频的工作场景切入,亲手搭项目、创建Agent、设计流程,再逐步推动团队进入新的协作平台。

                                                            “管理者不用,团队不会信。”李志飞表示,CEO和管理者首先要成为AI原生工作方式的实践者,才有可能推动组织形成新的惯性。

                                                            更多关于AI时代组织变革的系统方法论,可参见李志飞与高佳合著的《超级组织》。欢迎与更多企业共同探讨AI组织转型的落地实践。

                                                            ⬇️点击小程序购书⬇️

                                                            跳转微信打开

                                                            •  

                                                            从超级个体到组织能力:腾讯研究院报告呼应《超级组织》相关命题

                                                            飞哥说AI 2026-06-09 10:02 北京

                                                            腾讯研究院《超级个体时代》报告,与《超级组织》形成呼应。

                                                            近日,腾讯研究院发布《超级个体时代》报告。报告关注的一个核心问题是:当AI极大放大个体能力之后,组织如何承接这种新的生产力?报告中的相关观察,与《超级组织》所讨论的组织进化命题形成呼应。AI时代真正的挑战,不只是让个人变强,而是如何通过新的协作结构与组织系统,将个体产能转化为可持续、可规模化的组织能力。

                                                            报告中剖析了"个体能力被 AI 放大后,反而带来组织内耗"的现象,并引用《超级组织》中所首创定义的【幽灵效率】。腾讯研究院结合田野观察,精准呼应了这一底层管理学病理。

                                                            从CEO作为超级个体的极致深夜实验,到撞上"幽灵效率"问题,报告陈述了出门问问如何推动内部组织AI化实践,并自研CodeBanana,让Agent进入真实工作流,参与任务理解、协同推进、状态同步与经验沉淀。CodeBanana的核心,不只是让Agent进入协作工具,而是探索人、Agent、任务、上下文和反馈机制如何在同一套系统中协同运转。

                                                            报告将CodeBanana作为前沿标本进行了剖析。在具体的产品形态上,报告将出门问问列为「AI中枢型超级团队」的代表案例,并特别指出CodeBanana的两个核心设计:其一,每个项目的Team Agent成为项目的核心身份,人围绕Agent工作而非相反;其二,A2A功能(Agent-to-Agent)让不同项目的Agent直接协作,无需人工中转——在出门问问内部,研发实现100% AI Coding,整体产研效率提升4倍;非产研团队中超过三成成员已达到超级个体状态。CodeBanana这一设计,同时实现了两个功能——愿意使用平台的人自然被筛选出来,平台上其他人的成果则持续营造着「人人可以」的氛围,筛选与文化建设一步到位。

                                                            从《超级组织》的系统方法论,到CodeBanana的产品实践,再到腾讯研究院的外部观察,一个趋势正在变得更加清晰:AI进入企业之后,竞争不再只是工具能力和个体效率的竞争,而是组织能否承接、放大并沉淀AI生产力的竞争。


                                                            更多关于AI时代组织进化的系统思考和实践,可参见李志飞、高佳合著《超级组织》,读懂AI时代的组织进化法则。

                                                            ⬇️点击阅读原文,获取「超级个体时代|腾讯研究院3万字报告」

                                                            阅读原文

                                                            跳转微信打开

                                                            •  
                                                            ❌