11-19 更新 实时
首页/ 技术栈/ 正文

Kiro 中的 Kimi K3:前沿级编码能力,为生产交付而生

技术栈 来源:AWS 中国博客 2026-11-19 13:08 0 阅读 自动采集
Kiro 中的 Kimi K3:前沿级编码能力,为生产交付而生

摘要:同样的 Kimi K3 权重,在 Bedrock 和 Kiro 里都是几步就能用上,为什么要选 Kiro?在 Kiro 里,什么时候该选 Kimi K3?本文先给结论,再用两组对比测试来说明。


Moonshot AI 的模型 Kimi K3 现已同时上线 Amazon Bedrock 和 Kiro。开发者可以在 Bedrock 上通过 API 把 Kimi K3 接入自己的应用和 agent 框架,也可以在 Kiro IDE / Kiro CLI 里直接把 Kimi K3 当作编码模型使用。

客户反复问到一个很具体的问题:同样的 Kimi K3 权重,在 Bedrock 和 Kiro 里都是几步就能用上,为什么要选 Kiro?在 Kiro 里,什么时候该选 Kimi K3?本文先给结论,再用两组对比测试来说明。

先说结论:对企业客户,返工率才是最该看的指标

企业团队评估 AI 编码工具,最终关心的不是一次 benchmark 的分数,而是交付的代码有多少要打回重做、要改几轮才能通过验收。每多一轮返工,就多一轮 QA、多一段等待,也多一次把原本正确的代码改坏的风险。首次通过率和返工轮数,决定了 agent 能不能真正进入团队的交付流程。

我们的测试结果是:在 Kiro 里选择开放权重模型 Kimi K3,只用最轻量的 vibe 方式(直接把需求发给 agent,不走 spec 流程),在一个需求故意写得不完整的全栈电商项目上:

  • 首次交付就通过 70/80 个隐藏验收测试(87.5%)。
  • 只用 1 轮返工修复,80/80 全部通过验收。
  • 同一个 Kimi K3 模型放进一款通用开源 agent CLI,首次交付 61/80,用满 10 轮修复上限仍停在 76/80,没有通过验收。
  • Kiro 的费用约为对方的七分之一($2.2 对 $15.4),用时约为四分之一(21 分钟对 91 分钟)。

这个测试覆盖了软件交付中从产品简介到验收的主要环节:规划、构建、QA 验收和返工。测试的方法和方向符合亚马逊云科技提出的 AI-DLC(AI-Driven Development Lifecycle,AI 驱动的开发生命周期)理念:AI 先理解意图、制定计划再实施,人通过验收和反馈把关质量。

为什么 Kiro vibe 一轮就能收敛:“先规划、再动手”的 agent 循环

两边用的是同一个 Kimi K3 模型、同一份产品简介、同一套验收测试、同一份 QA 反馈,唯一的变量是 agent 外壳(harness)。所以首次通过率和返工轮数上的差距,来自 harness,而不是模型。

从测试结果看,Kiro vibe 的 agent 循环会先规划、再动手。用户不需要先写 spec、也不需要精心设计提示词,agent 会先理解需求、拆分模块、理清依赖,再逐步实现,并通过工具调用随时验证;拿到 QA 反馈后,又能对照整体结构精准修复。通用 CLI 则把需求和推理强度原样转发给模型,规划完全交给模型在一轮很长的推理里自己完成。

这一点在两组测试中都能看到:

  • 首次交付更完整。同一份简介,Kiro 首次交付比通用 CLI 少了 9 个失败测试,说明规划阶段就覆盖了更多业务规则。
  • 返工更精准,不会越改越乱。拿到 QA 报告后,Kiro 一轮就把剩下的 10 个问题全部改完;通用 CLI 用满 10 轮仍有 4 个没过。有了清晰的整体结构,修复可以对症下药,而不是牵一发动全身。
  • 推理轮次更少、更短。在第 2 部分的后端任务上,Kiro 每一轮保持简短、以工具调用为导向,单任务用时中位数 4.3 分钟对 12.1 分钟,没有一次撞到 30 分钟上限。

所以对企业来说,即使只用最轻量的 vibe 方式,Kiro + Kimi K3 也能交付可验收的结果,不依赖每位开发者都能写好 spec 或提示词。需要可评审、可追溯的需求、设计和任务文档时,再用 Kiro 的 spec 模式即可。

为什么是 Kimi K3

Kimi K3 是 Moonshot AI 的旗舰开放权重模型,也是首个参数规模达到 2.8 万亿的开放模型。它采用混合专家(MoE)架构,原生支持视觉输入、工具调用和可调节的推理强度,上下文窗口达到 100 万 token;据 Moonshot AI 披露,Kimi K3 的扩展效率比 Kimi K2 提升约 2.5 倍。对 coding agent 来说,Kimi K3 的优势主要有四点:

  • 超长上下文能把大型仓库的大部分代码一次性装进来,长时间会话中不容易丢失前文;
  • 长程规划能力强,动手前愿意先通读代码、理清依赖,和 Kiro harness 的规划能力相互配合;
  • 在高推理强度下“先想清楚再行动”,改动更扎实,返工更少;
  • 原生视觉能力让它不仅能读代码,还能直接理解设计稿、页面截图和运行画面,并结合视觉反馈迭代相关代码,减少把界面问题转译成文字的成本。

Amazon Bedrock 已于 2026 年 9 月正式上线 Kimi K3,并于 11 月上线 Kimi K3.1 Pro(Highspeed)。Kimi K3.1 Pro 是 Moonshot AI 迄今能力最强的 3 万亿参数级模型,同样是开放权重、原生多模态、100 万 token 上下文,在编码、3D 创造、金融研究和其他长程 agent 能力上有进一步提升;Highspeed 版本的输出速度更高,适合对响应时间敏感的交互式编码。两款模型在 Bedrock 上都与闭源模型运行在同一安全边界内,沿用相同的访问控制、加密和审计机制,支持显式提示缓存(prompt caching),并可通过跨区域推理在所有提供 Bedrock 的亚马逊云科技区域使用。企业客户可以在熟悉的安全与合规框架内使用一款前沿级的开放权重模型。本文的全部测试均基于 Kimi K3 进行。

1. 全栈电商应用,Kiro vibe 一轮返工即通过全部验收

本章节的测试基于 ShopFlow:一个我们自建的全栈电商需求测试。agent 拿到一份约 700 词的产品简介,从零写出一个带前台和后台的 FastAPI 电商应用;交付后用 80 个 agent 看不到的验收测试判分。没通过的部分整理成 QA 报告发回给 agent 修复,直到全部通过或修复轮数达到上限。我们用这套测试比较 Kiro CLI 和一款通用开源 CLI,都用 vibe 方式(直接把需求发给 agent,不走 spec 流程),都用 Kimi K3。产品简介、QA 报告格式和 Kiro 的配置见附录 C。

1.1 为什么选这套测试

常见的 coding benchmark 大多是边界清楚的单点任务,需求一次说全,验证几十个用例。真实的企业项目更常见的情况是:需求是一份产品简介,要做的是前后端都有的完整应用,很多业务规则简介里没写,要等测试或业务方发现问题后再改。这种情况下,返工率直接决定交付效率。ShopFlow 就是按这个场景设计的:

  • 全栈、跨模块。简介要求实现账号与角色(顾客、运营、管理员)、商品目录(上下架、搜索、筛选、分页)、购物车、订单(状态机、模拟支付、取消、发货、部分退款、超时未付自动关闭)、优惠券和销售报表,共 28 个 API 接口,再加一个由同一个 FastAPI 应用提供的前台和后台网页。
  • 80 个隐藏验收测试。72 个 API 测试加 8 个用 Playwright 驱动浏览器的 UI 测试,按简介里约定的按钮和输入框名称操作页面。测试代码、完整需求文档和参考实现都不放进 agent 的工作目录。我们测试时发现,agent 会主动在磁盘上搜索测试代码,所以每场结束后还要检查它读过哪些文件。测试套件自检过:参考实现通过 80/80,16 种典型缺陷(不检查库存、取消不回补库存、顾客能看别人的订单、报表统计了未付款订单等)都至少被一个测试抓到。
  • 需求故意不完整。每条规则都标了类别:简介里写明的、能从简介推出的、只有问了产品负责人才知道的。72 个 API 测试里有 24 个属于第三类,例如运费规则、库存何时扣减、优惠券限用次数、报表口径。agent 不可能一次全做对,所以这套测试衡量的不只是“写得对不对”,还有“按反馈改得快不快、会不会改坏别的”。
  • 修复流程模拟真实 QA。每轮修复,agent 只收到一份标准 QA 报告:开头一句“QA 跑了验收测试,发现以下问题,请全部修复且不要改坏其他功能”,后面逐条列出失败测试对应的现象描述,不含测试名、测试代码和通过数。每轮只发一次修复请求,最多 10 轮。

这套测试的方向也符合 AI-DLC 的理念:输入是一份业务意图(产品简介),agent 要自己理解需求、拆分模块、规划并构建,再由验收测试和 QA 反馈把关。首次通过率衡量的是规划和构建是否扎实,返工轮数衡量的是按反馈修复是否高效。

1.2 测试设置

Kiro CLI 通用开源 CLI
模型 kimi-k3(Kiro 模型目录) Kimi K3,通过 Amazon Bedrock 调用
工作方式 vibe(默认 agent) vibe(默认 agent)
第一条消息 产品简介原文 相同
验收 80 个隐藏测试(API 72 + UI 8),全部通过才算通过 相同
修复反馈 标准 QA 报告(失败现象描述) 相同
终止条件 全部通过,或修复达到 10 轮 相同

1.3 结果

指标 Kiro CLI + Kimi K3 通用开源 CLI + Kimi K3(Bedrock)
首次交付通过 70 / 80(87.5%) 61 / 80(76.3%)
首次交付需返工的测试 10 19
修复轮数 1 10(到上限)
最终通过 80 / 80,通过验收 76 / 80,未通过
费用 55 credits ≈ $2.2($0.04/credit;按套餐内 $0.02 约 $1.1) $15.4
总用时 21 分钟 91 分钟

1.4 测试结果解读

  • 差距在第一次交付时就出现了。同一个模型、同一份简介,Kiro 第一次交付少了 9 个失败测试。这和“先规划、再动手”有直接关系:在动手之前把意图拆成模块、把业务规则理清楚,首版覆盖面就更完整。
  • 返工阶段把差距拉大。Kiro 拿到一份 QA 报告就把剩下的 10 个问题全部改完;通用开源 CLI 用满 10 轮仍有 4 个测试没过。花费和用时的差距大部分来自这些多出来的修复轮次。放到企业的交付流程里,这就是返工的代价:每一轮返工都对应一次 QA 往返和一段等待。Kiro 一次反馈就把偏差收敛掉,而不是在反复返工中累积浪费。
  • 结论要按单次运行理解。每个组合只跑了 1 次,这是一个案例对比,能说明量级,不能说明波动范围。第 2 部分在 6 个任务、每个任务 3 次运行上的结果方向一致:任务越复杂,Kiro 在成本和用时上的优势越明显。

2. 同一个 Kimi K3,Kiro CLI 每成功任务成本低约 45%,用时约 1/3

第 1 部分说明了 Kiro + Kimi K3 交付质量更高、返工更少。接下来回答企业关心的另一个问题:同一个模型,放在 Kiro 里是否更划算?

本章节的所有测试都基于 aws-samples/sample-agent-cost-bench,一个开源的 benchmark 框架,用可插拔的验证器衡量 coding agent 在不同 CLI 和模型上的成本、质量和耗时。先给出结论:

  • 每成功完成一个任务的成本低约 45%。在 agent-cost-bench 的 6 个 Python 后端任务上(每个任务跑 3 次),Kiro CLI 搭配 Kimi K3 每成功完成一个任务平均花费 $0.19;一款通用开源 agent CLI 通过 Amazon Bedrock 调用同一个 Kimi K3 模型、同样的推理强度,每成功完成一个任务需要 $0.35。
  • 任务完成率 18/18 对 16/18,同一模型、同一提示词、同一套验证测试。
  • 单任务用时中位数 4.3 分钟对 12.1 分钟,从发出提示到通过验证。

要单独衡量 agent 外壳的贡献,最干净的办法是固定模型。这次测试就是这么安排的:同样的 kimi-k3 权重、同样的推理强度(最高)、同样的 6 个任务、同样的验证测试,同一天在同一台机器上各跑 3 次。

2.1 为什么选这套测试

Terminal-Bench 这类能力型基准衡量的是 agent 的上限:修复损坏的 git 仓库、从数据库 WAL 文件恢复数据、交叉编译一个游戏。这些题擅长区分模型强弱,但和大多数开发者的一天不太像。我们更想回答的是日常问题:拿到一段需求,在自己的终端里让 agent 把能跑、能过测试的代码写出来,花了多少钱,等了多久。agent-cost-bench 就是按这个思路设计的:任务是常见的后端开发工作,CLI 直接在你的机器上运行,验证用框架自带的 pytest 套件,成本是一等指标。

作为参照,我们也在 Terminal-Bench 2 的一个 30 题子集上跑过同样的两个 CLI 搭配 Kimi K3。两者的通过率在同一区间,差距在单次运行的波动范围内;Kiro 的用时和费用同样明显更低。本文不展开这部分,感兴趣的读者可以用 Harbor 自行复现。

2.2 测试设置

Kiro CLI 通用开源 agent CLI
模型 kimi-k3(Kiro 模型目录) global.moonshotai.kimi-k3,通过 Amazon Bedrock 的 OpenAI 兼容接口(us-west-2)
推理强度 --effort max reasoning_effort: max
版本 Kiro CLI 2.31.1 固定版本(见附录 B)
系统提示词 仅 CLI 默认 仅 CLI 默认
任务 agent-cost-bench 的 6 个 Python 任务(附录 A) 相同
验证 agent-cost-bench 自带的 pytest 套件,两边完全一致 相同
单任务时限 30 分钟 30 分钟
模式 cli-compare(附录 B) 相同

6 个任务从简单到复杂:FastAPI 的 Todo CRUD 接口、日志分析命令行工具、事件溯源/CQRS 系统、带 RBAC 的多租户 API、多租户工作流引擎、带插件机制的分布式任务处理器。前两道是简单题(任务自带时限 10 到 15 分钟),后四道需要跨多个文件搭建完整系统,验证测试各有 30 到 50 个用例。对比对象是一款维护良好、广泛使用的开源 agent CLI。本文关注的是 agent 外壳变化带来的影响,而不是某个具体产品;读者可以用附录 B 的配置替换为任意支持 OpenAI 兼容接口的 CLI 复现。

2.3 成本怎么算

只比单价说明不了 coding agent 的真实成本。两个 agent 用同一个模型、同样的 token 单价,每个任务消耗的 token 可以差好几倍;而一次便宜的失败仍然是失败。所以主指标是:

每成功任务成本 = 全部尝试的总花费 ÷ 通过验证的尝试次数

两边的花费用同一种方法计算。开源 CLI 一侧:实测的 token 数(输入、缓存输入、输出)乘以 Bedrock 上 Kimi K3 的公开按需价格(每百万 token 输入 $3、缓存读取 $0.30、输出 $15)。Kiro 一侧要说明一下,因为 Kiro 不按 token 计费:

  • Kiro 按 credit 计费。Pro 套餐 $20/月含 1,000 credits,即套餐内约 $0.02/credit;超出套餐后的加购 credit 为 $0.04/credit(见 Kiro 定价页)。
  • 不同模型有不同的 credit 倍率。同一个任务用默认的 Auto 消耗 X credits,换成 Kimi K3 消耗 2.4X credits。换句话说,Kimi K3 在套餐内的有效单价约为每“Auto 等效 credit” $0.02 × 2.4 ≈ $0.048。
  • Kiro CLI 在 stream-json 输出的 meteringUsage 事件里报告的是已经乘过倍率、实际从套餐扣除的 credits。本文直接取这个数乘以单价,不再重复乘 2.4。

主表用套餐内 $0.02/credit 计算;由于加购单价是套餐内的 2 倍,我们同时给出按 $0.04 计算的结果,读者可以按自己的用量情况取用。agent-cost-bench 会同时记录两边的原始用量(token 数和 credits)。

2.4 结果

指标(6 任务 × 3 次) Kiro CLI + Kimi K3 开源 CLI + Kimi K3(Bedrock)
通过 / 运行次数 18 / 18 16 / 18
完成率 100% 89%
总花费(Kiro 为 155.5 credits) $3.11 $5.63
每成功任务成本(Kiro 按套餐内 $0.02/credit) $0.19 $0.35
每成功任务成本(Kiro 按加购 $0.04/credit) $0.39 $0.35
单任务用时中位数 4.3 分 12.1 分
18 次总用时 98 分 258 分
撞到 30 分钟上限的次数 0 1

36 次运行中有 3 次没有记录到用量(Kiro 2 次输出流缺少最后的计费事件,开源 CLI 1 次超时)。每成功任务成本按有记录的运行折算;如果按同任务均值补齐缺失的运行,为 $0.21 对 $0.38,结论不变。

逐任务(每格 3 次运行;$ 为有用量记录的运行的平均花费,Kiro 按 $0.02/credit;时间为中位数):

任务 Kiro 通过 Kiro $/次 Kiro 用时 开源 CLI 通过 开源 CLI $/次 开源 CLI 用时
rest-api 3/3 $0.05 1.4 分 2/3 $0.07 2.6 分
log-analyzer-cli 3/3 $0.05 1.2 分 3/3 $0.05 1.1 分
event-sourcing-cqrs 3/3 $0.23 5.6 分 3/3 $0.30 7.4 分
multitenant-rbac-api 3/3 $0.29 4.8 分 3/3 $0.38 17.6 分
multitenant-workflow-engine 3/3 $0.34 7.8 分 2/3 $0.49 24.7 分
distributed-task-processor 3/3 $0.28 9.7 分 3/3 $0.77 27.6 分

2.5 测试结果解读

  • 简单任务上没有差别。rest-api 和 log-analyzer-cli 两边都在 1 到 3 分钟内完成,花费约 $0.05。外壳的差异在这个量级上显现不出来。
  • 差距在复杂任务上拉开。在 distributed-task-processor 上,开源 CLI 为同样的通过结果花了 2.8 倍的钱和 2.8 倍的时间;在 multitenant-rbac-api 上是 1.3 倍的钱和 3.7 倍的时间。任务越需要跨文件搭建,越需要事先规划,差距越大。
  • 成本差从哪来。两边的模型和单价完全相同,所以差的是 token 用量,主要是推理轮次。在最高推理强度下,Kimi K3 会把外壳允许的时间都用来思考;通用 CLI 把推理强度原样转发、其余不干预,一轮可以持续很久,一次运行撞到了 30 分钟上限。Kiro 的 agent 循环先规划、再动手,每一轮保持简短、以工具调用为导向,同一个模型用更少的轮次就能通过验证。这与第 1 部分“一轮返工即收敛”是同一个原因。
  • 快不只是延迟。两边背后是同一等级的模型服务,中位用时 4.3 分对 12.1 分的差距来自更少、更短的推理轮次,不是 token 返回更快。
  • 成本结论取决于你的 credit 单价。套餐内($0.02/credit)Kiro 每成功任务便宜约 45%;如果你的用量主要靠加购 credit($0.04),两边每成功任务成本基本持平($0.39 对 $0.35),这时 Kiro 的优势主要在时间上:同样的结果快 2.8 倍。而在第 1 部分这类需要多轮返工的全栈场景里,即便按加购价计算,Kiro 的费用也只有约七分之一($2.2 对 $15.4)。
  • 质量结论要谨慎。18/18 对 16/18 的差距是两次失败(一次测试通过 73%,一次超时),换另外 6 个任务排名可能接近或反转;这组数据里比较可靠的,是每成功任务成本和用时的差距。

3. 动手试试及注意事项

3.1 上手步骤

Kiro IDE:在对话面板的模型选择器中选择 Kimi K3。

Kiro CLI

1. 安装或更新 Kiro CLI(2.31.1 及以上)并登录 kiro-cli login。

2. 列出模型,确认有 kimi-k3:

kiro-cli chat --list-models

3. 用你想要的推理强度启动会话。Kimi K3 在 Kiro 里支持 low、high、max:

kiro-cli chat --model kimi-k3 --effort high

max 结果最仔细、单轮最长;交互式工作用 high 更合适。

4. 无人值守运行(CI、benchmark)用非交互模式,配一个预先放行所需工具的 agent 配置,并输出结构化日志以便核算成本:

kiro-cli chat --no-interactive --trust-all-tools --agent <your-agent> \
  --model kimi-k3 --effort high --output-format stream-json "<task>"

stream-json 输出里的 meteringUsage 事件记录每一轮消耗的 credits。

5. 要复现第 2 部分的对比:克隆 agent-cost-bench,把附录 B 的配置保存为 config.cli-compare.yaml,把附录 A 的任务文件放到 tasks/ 下,运行 ./run.sh。

6. 第 1 部分 ShopFlow 测试使用的提示词、Kiro 配置和注意事项见附录 C。

3.2 注意事项

  • Kiro Excluded Model。Kimi K3 属于 Kiro Excluded Model,用它生成的内容不在亚马逊云科技的知识产权赔偿范围内。如果你的组织依赖这项保障,请把 Kimi K3 限定在探索性工作,或按自己的 IP 流程审查生成的代码。具体条款见 Kiro 文档中关于 excluded models 的说明。
  • max 下的长时间推理。最高推理强度下 Kimi K3 单轮可能持续数分钟。自动化运行请设置时间预算,交互式使用优先选 high。
  • 本次评测的规模和覆盖面。第 2 部分为 6 个 Python 后端任务、每个 3 次、一天、一台机器;第 1 部分每个组合运行 1 次。每成功任务成本和用时的差距足够大,是有意义的结论;完成率上一两次的差距则不是。任务以从零开始的绿地开发为主,在现有代码库里修改和修 bug 的棕地场景没有覆盖;agent-cost-bench 支持这类任务,读者可以按附录的方式自行加入。模型服务存在逐日波动,在我们更大范围的内部测试中,同一配置在不同周之间 30 题会浮动 ±2 题,所以请在同一天内比较不同外壳,把绝对通过率当作参考值。
  • Kimi K3 在 Kiro 中的计费。Kimi K3 在 Kiro 模型目录中按 2.4 倍 credits 计费,默认的 Auto 为 1.0 倍。按 Pro 套餐 $20/1,000 credits 计算,Kimi K3 的有效单价约为每 Auto 等效 credit $0.048;加购 credit 为 $0.04/credit,Kimi K3 对应约 $0.096。本文测试中一次复杂任务(多文件 FastAPI 系统)消耗 12 到 17 credits,简单任务 2 到 3 credits。长时间的 agent 会话请据此预留额度。
  • 缓存与价格。成本按实测 token 数和撰文时的公开价格计算,不含缓存写入费用,也不反映未来价格变动。

4. 总结:Kimi K3 在 Kiro 里适合哪些场景

同一个 Kimi K3,Bedrock 给你把它接入任意工具和框架的灵活性,Kiro 给你一个为 Kimi K3 调好、先规划再动手的 agent 外壳和开发工作流。两组对比都固定了模型、只换 agent 外壳,结论方向一致:

  • 交付质量与返工率(第 1 部分)。在需求不完整、有 80 个隐藏验收测试的 ShopFlow 全栈电商项目上,Kiro vibe 一轮返工就通过了全部验收,通用开源 CLI 用满 10 轮仍有 4 个测试没过;Kiro 的费用约为对方的七分之一,用时约为四分之一。这部分每个组合只跑了 1 次,适合看量级。
  • 性价比(第 2 部分)。6 个后端任务各跑 3 次,Kiro CLI 每成功任务成本低约 45%(按套餐内单价计算,按加购价则基本持平),用时约为三分之一。简单任务上两者差别不大,差距主要出现在需要跨文件搭建系统的复杂任务上。

任务越复杂、越需要根据反馈反复修改,同一个 Kimi K3 在 Kiro 里的优势越明显:先规划、再动手的 agent 循环带来更高的首次通过率和更少的返工轮次,进而换来更低的成本和更短的等待。对正在推进 AI-DLC 的企业来说,Kiro + 开放权重的 Kimi K3 提供了一条门槛低、可验证的路径:从 vibe 起步就能获得可验收的交付,需要更严格的流程治理时再升级到 spec 驱动开发。

4.1 适合交给 Kimi K3 的场景

  • 从产品简介出发、需要验收的全栈功能开发。ShopFlow 测的就是这种场景:需求不完整、业务规则要靠 QA 反馈补齐。Kiro vibe + Kimi K3 首版覆盖面广、一轮返工即收敛,适合企业里“业务方给需求、AI 规划与构建、QA 验收”的交付流程。如果业务规则能提前确认,用 spec 模式在动手前写清楚,可以进一步减少返工。
  • 跨多个文件、需要长时间连续推进的工程任务。Moonshot AI 把 Kimi K3 定位为长程编码模型:在很少人工干预的情况下,它能持续推进长时间的工程任务,在大型仓库里定位代码,并调度终端工具(Kimi K3 技术博客)。本文的数据也指向同一结论:多租户 RBAC、工作流引擎、分布式任务处理器这类需要从零搭建完整系统的任务,Kiro + Kimi K3 每次都通过了验证。
  • 需要把大量上下文同时装进来的工作。100 万 token 的上下文能同时放下代码库、完整的 spec 文档、测试套件和对话历史。Kiro 官方博客特别提到,这让 Kimi K3 适合多文件重构、梳理层层嵌套的依赖链,以及在 spec 驱动开发里从需求、设计一路走到实现和验证时保持上下文连贯(Kiro 博客)。
  • Spec 驱动开发的实现阶段。需求和设计已经写清楚时,Kimi K3 能按 tasks.md 逐项推进,Kiro 的验证步骤再检查实现是否符合 spec。
  • 需要看图的前端和可视化任务。Kimi K3 原生支持视觉输入,可以根据截图和视觉反馈反复调整前端页面、游戏和 CAD 相关代码(Kimi API 文档)。在 Kiro 里可以直接把设计稿或页面截图拖进对话。

4.2 不必交给 Kimi K3 的场景

  • 简单、边界清楚的小任务。在第 2 部分,Todo CRUD 接口和日志分析工具两道简单题只需 1 到 2 分钟,用不上 Kimi K3 的长程能力。Kimi K3 在 Kiro 里按 2.4 倍 credits 计费,日常的小改动、补注释、写单测用默认的 Auto 更划算。
  • 出错代价高、边界条件很隐蔽的改动,不要只靠 Kimi K3 一次完成。安全、计费、数据迁移这类改动,建议给 Kimi K3 的结果加一道更严格的测试和人工评审,再合入代码。

4.3 用好 Kimi K3 的几点建议

  • 在新会话里切换到 Kimi K3,不要中途换模型。Kimi K3 在多轮对话中保留思考历史,如果中途从其他模型切换到 Kimi K3,生成质量可能非常不稳定(Kimi K3 技术博客)。想先用另一个模型写 spec、再用 Kimi K3 实现,可以在 spec 定稿后新开一个会话,再选 Kimi K3 执行任务。
  • 用 steering 文件把边界写清楚。Moonshot AI 提到 Kimi K3 有“过度主动”的倾向:遇到小问题或意图不明确时,可能替用户做出意料之外的决定,建议在系统提示词或 AGENTS.md 里写明行为约束。在 Kiro 里可以把这些约束写进 .kiro/steering/,例如“不要修改测试文件”“不确定的需求先停下来提问”“不要引入新依赖”。
  • 按任务选推理强度。交互式开发用 high,响应快、结果足够扎实;无人值守的复杂任务(本文的测试都在这一档)可以用 max,但要设置时间预算;low 适合查代码、问问题这类不需要深度推理的工作。

欢迎在 Kiro 中试用 Kimi K3,或在 Amazon Bedrock 控制台 通过 API 调用;也欢迎用 agent-cost-bench 在你自己的任务上复现本文的对比,并在评论区分享结果。

附录 A:任务文件

6 个任务均为 agent-cost-bench(commit 270c6f1)自带,位于 tasks/vibe/<task-id>/,每个目录有 task.yaml(提示词、时限、验证依赖)和存放隐藏 pytest 套件的 verify/。我们未做任何修改。任务文件里各自的 effort: 被附录 B 中硬编码的 --effort=max / reasoningEffort: max 覆盖。

任务 id agent 需要实现什么 任务自带时限
rest-api FastAPI Todo CRUD API, in-memory store, pytest+httpx tests 10 min
log-analyzer-cli CLI that parses Common Log Format access logs into summaries 15 min
event-sourcing-cqrs Event store, aggregates, projections and command/query handlers 20 min
multitenant-rbac-api Multi-tenant FastAPI service with RBAC and cursor pagination 20 min
multitenant-workflow-engine Multi-tenant FastAPI service with RBAC and a document workflow engine 25 min
distributed-task-processor Multi-tenant distributed task processor with plugins, retries and metrics 30 min

实际运行使用下面配置中的 30 分钟统一时限(覆盖任务自带时限,保证两个 CLI 预算相同)。

附录 B:配置

config.cli-compare.yaml(Kiro credit 单价见第 2 部分“成本怎么算”一节;Bedrock 价格为撰文时 Kimi K3 Global CRIS 的公开价):

# Kimi K3, same model on two agent CLIs, max reasoning effort on both.
comparison_label: "Kimi K3: Kiro CLI vs open-source agent CLI (Bedrock)"

runners:
  - name: kiro
    display_name: "Kiro CLI (kimi-k3, effort max)"
    cli_path: kiro-cli
    model_id: kimi-k3
    pricing:
      usd_per_credit: 0.02        # Kiro credit list price
    # effort hard-coded to max (per-task effort in task.yaml would otherwise override)
    cli_base_args: [chat, --no-interactive, --trust-all-tools,
                    --output-format, stream-json,
                    "--model={model}", "--effort=max"]

  - name: oss-cli
    display_name: "Open-source agent CLI (kimi-k3 via Bedrock, effort max)"
    cli_path: <your-open-source-cli>
    model_id: bedrock-oai/global.moonshotai.kimi-k3
    pricing:
      usd_per_input_token:        0.000003    # $3.00 / 1M  (Bedrock Global CRIS, Kimi K3)
      usd_per_cached_input_token: 0.0000003   # $0.30 / 1M
      usd_per_output_token:       0.000015    # $15.00 / 1M
    # reasoningEffort=max is set in the CLI's own provider config (see below)
    # replace with your CLI's non-interactive arguments: JSON output, workspace dir, model, prompt
    cli_base_args: [<non-interactive args>, "{workspace}", "{model}", "{prompt}"]

tasks_dir: tasks
task_ids: [rest-api, log-analyzer-cli, event-sourcing-cqrs, multitenant-rbac-api,
           multitenant-workflow-engine, distributed-task-processor]
modes: ["vibe"]

concurrency: per_target
timeout_minutes: 30
repeats: 3
functional_pass_threshold: 0.99
workspace_base: /tmp/agent-cost-bench-k3
output_dir: results-k3
report_title: "Kimi K3: Kiro CLI vs open-source agent CLI (Bedrock), 6 Python tasks x 3"
open_report: false

通用开源 CLI 一侧需要在它自己的 provider 配置里添加一个 OpenAI 兼容的 provider,指向 Bedrock。Bedrock 的 bearer token 来自环境变量(AWS_BEARER_TOKEN_BEDROCK,用 aws-bedrock-token-generator 生成,12 小时有效),配置文件里不保存任何密钥:

配置项 值
provider 类型 OpenAI 兼容接口
baseURL https://bedrock-runtime.us-west-2.amazonaws.com/openai/v1
API key 从环境变量 AWS_BEARER_TOKEN_BEDROCK 读取
模型 global.moonshotai.kimi-k3
推理强度 reasoningEffort: max

运行前:kiro-cli login,导出 AWS_BEARER_TOKEN_BEDROCK,然后 agent-cost-bench cli-compare run config.cli-compare.yaml。登录会话和 token 都会过期;数小时的运行建议按任务分批(task_ids: [<单个任务>]),每批之间刷新凭证。

附录 C:ShopFlow 测试的提示词与 Kiro 配置

本附录介绍第 1 部分 ShopFlow 测试的提示词、Kiro CLI 的配置和运行时的注意事项,验收测试和运行脚本的源代码从略。

C.1 测试流程

  1. 新建一个空的工作目录,把 C.2 的产品简介原文作为第一条消息发给 agent,不加任何其他说明。
  2. agent 结束后,用 80 个隐藏验收测试(72 个 API 测试、8 个 UI 测试)判分。
  3. 有测试没通过时,按 C.3 的格式生成一份 QA 报告,作为下一条消息发给同一个会话。
  4. 重复第 2、3 步,直到 80 个测试全部通过,或者修复满 10 轮。

C.2 产品简介(第一条消息)

agent 收到的第一条消息就是下面这段英文原文:

Build "ShopFlow", a small full-stack online shop: a storefront for customers and a back office for our staff. Use Python + FastAPI for the backend. The web UI can use any approach (server-rendered pages, plain JS, or a built SPA), but it must be served by the same FastAPI app.

Who uses it
- Customers browse products, keep a cart, place orders and pay for them, see their order history, and can cancel orders.
- Operators (staff) manage the catalog (categories, products, stock), process orders (ship, mark delivered, refund) and run coupon promotions.
- Admins manage staff accounts and see sales reports, and can do everything operators can.

Business notes from the product team
- Products have a price and a stock level. We must never sell more than we have.
- Orders go through: pending_payment -> paid -> shipped -> delivered. Orders can also be cancelled, and paid orders can be refunded in full or in part.
- Unpaid orders expire after 30 minutes.
- We run coupon campaigns (percentage or fixed amount off).
- Payments are simulated for now (no real payment provider).
- Money has two decimal places.

API contract (JSON, all under /api)
- POST /api/auth/register {email, password, name} -> 201 user (role customer)
- POST /api/auth/login {email, password} -> {access_token}; send it as `Authorization: Bearer <token>`
- GET /api/me
- An admin account exists at startup: admin@shop.local / admin12345
- POST /api/admin/users {email, password, name, role}  ·  GET /api/admin/users  ·  PATCH /api/admin/users/{id} {role?, is_active?}
- GET /api/categories  ·  POST /api/categories {name}
- GET /api/products?q=&category_id=&min_price=&max_price=&page=&page_size= -> {items, total, page, page_size}
- GET /api/products/{id}  ·  POST /api/products {name, description?, category_id?, price, stock, status}  ·  PATCH /api/products/{id}
  (status is one of draft, active, inactive)
- GET /api/cart -> {items: [{product_id, name, unit_price, quantity, line_total}], subtotal}
- POST /api/cart/items {product_id, quantity}  ·  PATCH /api/cart/items/{product_id} {quantity}  ·  DELETE /api/cart/items/{product_id}
- POST /api/orders {shipping_address: {name, line1, city, postal_code, country}, coupon_code?} -> order created from the cart
  order: {id, status, items, subtotal, discount, shipping_fee, total, coupon_code, created_at, ...}
- GET /api/orders (mine; staff see all)  ·  GET /api/orders/{id}
- POST /api/orders/{id}/pay {card_number}   (simulated: card 4000000000000002 is declined, any other 16-digit number succeeds)
- POST /api/orders/{id}/cancel  ·  POST /api/orders/{id}/ship {tracking_number}  ·  POST /api/orders/{id}/deliver
- POST /api/orders/{id}/refund {amount, reason}
- POST /api/coupons {code, type, value, min_order_amount?, max_uses?, expires_at?}  ·  GET /api/coupons   (type is percent or fixed)
- GET /api/admin/reports/sales?from=YYYY-MM-DD&to=YYYY-MM-DD -> {order_count, gross_sales, refunds, net_sales, top_products: [{product_id, name, quantity}]}
- POST /api/admin/maintenance/expire-orders -> runs the unpaid-order expiry immediately (our scheduler calls it every minute)
- Invalid state transitions return 409. Unauthenticated calls return 401, forbidden ones 403.

Web UI contract (our QA automation relies on these accessible names; anything else is up to you)
- Storefront at /: a search box labelled "Search", product cards each showing the product name and price, a link per product to its detail page.
- Product detail page: heading with the product name, price, a quantity input labelled "Quantity", a button "Add to cart". When out of stock it shows the text "Out of stock" and the button is disabled.
- A "Cart" link in the header that shows the number of items, e.g. "Cart (2)".
- /login page: inputs labelled "Email" and "Password", button "Log in". /register page: "Name", "Email", "Password", button "Create account".
- Cart page: lines with name, quantity and line total, the subtotal, and a button "Checkout".
- Checkout page: inputs labelled "Full name", "Address", "City", "Postal code", "Country", optional "Coupon code", and a button "Place order". After placing the order the page shows "Order #<id>" and a button "Pay now"; paying uses an input labelled "Card number" and a button "Pay".
- "My orders" page at /orders listing my orders with their status.
- Back office at /admin (staff only): a "Products" section with a "New product" button and a form with inputs labelled "Name", "Price", "Stock", a select labelled "Status", and a button "Save" (the form may have more fields, but they must be optional).

Runtime contract: the app must be importable as `from main import app`, start with `uvicorn main:app` and no environment variables, and use in-memory storage or SQLite. If PAYMENT_TIMEOUT_MINUTES is set it overrides the 30-minute expiry (our QA uses it).

C.3 QA 报告(修复轮的消息)

每轮修复只发一条消息:固定的开头一句,后面逐条列出失败测试对应的现象描述。报告不含测试名、测试代码、规则编号和通过数。应用无法启动时,报告只有一条“应用无法启动”的说明。示例:

QA ran the acceptance tests against the current build and found the problems below. Please fix all of them without breaking anything else.

1. An order can be placed for more units than are in stock.
2. The same customer can use the same coupon on more than one order.

C.4 Kiro CLI 的配置

本测试使用 Kiro CLI 2.33.1,运行期间关闭了自动更新。第一条消息和每轮修复都用非交互模式发送,修复轮通过 --resume-id 接续同一个会话:

# 第一条消息:产品简介原文
kiro-cli chat --no-interactive --trust-all-tools --output-format stream-json --v3 \
  --model=kimi-k3 --effort=high "<C.2 的产品简介原文>"

# 修复轮:接续同一个会话,发送 QA 报告
kiro-cli chat --no-interactive --trust-all-tools --output-format stream-json --v3 \
  --model=kimi-k3 --effort=high --resume-id <session-id> "<C.3 格式的 QA 报告>"
配置项 设置 说明
工作方式 vibe,默认 agent 不指定 --agent,不走 spec 流程
模型 --model=kimi-k3 会话结束后逐轮核对主会话和所有子 agent,出现其他模型就判为无效
推理强度 --effort=high 交互式工作的推荐档位
agent 引擎 --v3 使用新一代 Kiro agent
工具权限 --trust-all-tools 无人值守运行,预先放行所有工具
输出格式 --output-format stream-json 用其中的 meteringUsage 事件统计每轮消耗的 credits
用户级上下文 会话期间移开 ~/.kiro/steering、~/.kiro/memories、~/.kiro/skills 避免个人配置影响结果,会话结束后恢复
修复上限 10 轮 两个 CLI 相同
时间上限 单场 5 小时 两个 CLI 相同

C.5 注意事项

  • 不要让 agent 看到验收材料。agent 以 --trust-all-tools 运行,和你是同一个系统用户,能读到你能读的任何文件。工作目录要和存放测试代码的目录分开,也不要把测试代码的路径写进 agent 能读到的配置(工作目录下的 .kiro/、~/.kiro/agents/、MCP 配置、shell 启动文件),会话里也不要提到它。我们在测试中观察到,agent 会主动在磁盘上搜索测试代码,所以每场会话结束后都要检查事件流,确认它没有打开验收材料。要彻底隔离,最好让 agent 在单独的系统用户、容器或另一台机器上运行。
  • 不要把亚马逊云科技凭证交给 agent。启动 agent 前,从它的环境变量里去掉所有 AWS_* 变量。
  • 固定版本,关闭自动更新。Kiro CLI 会自动升级,运行中途换版本会让结果不可比,测试期间要关闭自动更新,并记录使用的版本。
  • 服务中断要重试。长时间运行时可能遇到 Kiro 服务断线,这一轮要重新发送,并在记录里标明。
  • PyPI 不可达时使用镜像。agent 安装依赖和判分都需要访问 pypi.org,网络受限时两边要用同一个镜像,并在记录里标明。
  • 结果按单次运行理解。第 1 部分每个组合只跑了 1 次,复现时数字会有波动,建议多跑几次,比较量级和方向。

如果需要完整的测试代码(验收测试、判分脚本和会话驱动脚本),请联系作者。

*前述特定亚马逊云科技生成式人工智能相关的服务目前在亚马逊云科技海外区域可用。亚马逊云科技中国区域相关云服务由西云数据和光环新网运营,具体信息以中国区域官网为准。

本篇作者

唐飞虎

Kimi 研发工程师 开发者关系负责人

夏卫国

亚马逊云科技合作伙伴解决方案架构师,负责亚马逊云科技合作伙伴生态系统的云计算方案架构咨询和设计,同时致力于亚马逊云科技云服务在国内的应用和推广。

汪其香

亚马逊云科技解决方案架构师,负责基于AWS云计算方案的架构咨询和设计实现,具有丰富的解决客户实际问题的经验,同时热衷于深度学习的研究与应用。

陈映初

亚马逊云科技解决方案架构师,专注于 Agentic AI 与生成式 AI 应用在 AWS 上的架构设计与落地实践。拥有 12 年以上软件研发经验,精通前后端全栈开发,兼具 DevOps 实战经验。Apache DevLake(ASF 顶级项目)PMC 成员。


AWS 架构师中心:云端创新的引领者

探索 AWS 架构师中心,获取经实战验证的最佳实践与架构指南,助您高效构建安全、可靠的云上应用

本文由采集器自动同步

原文发布于 AWS 中国博客,正文由采集器自动抓取,版权归来源站点所有。

阅读原文 ↗