# Kimi K3: Complete A-Z Guide to the Open Model that Beat Fable 5
**作者**: Kirill
**日期**: 2026-07-16T18:58:25.000Z
**来源**: [https://x.com/kirillk_web3/status/2078880995705516361](https://x.com/kirillk_web3/status/2078880995705516361)
---
This is a complete A–Z breakdown of what Kimi K3 actually is, what it can do, and why it's quietly becoming the most important coding model nobody is talking about yet.
> Bookmark this page so you don't lose this article.
2.8 trillion parameters. 1 million token context.
Here's everything in it.
## Before We Talk About Benchmarks, Let's Talk About What Just Happened
For the last three years the story has been the same: American labs build the frontier, Chinese labs build the cheap copy six months later.
On July 16, Moonshot AI released Kimi K3.
> **Kimi.ai@Kimi_Moonshot**: [原文链接](https://x.com/Kimi_Moonshot/status/2077830229968683203)
>
> Introducing Kimi K3: Open Frontier Intelligence
> 2.8 Trillion Parameters, 1 Million Context, Native Multimodal
> Kimi Delta Attention enables up to 6.3x faster decoding in million-token contexts
> Attention Residuals deliver ~25% higher training efficiency at <2% additional
>
> 
> 
2.8 trillion total parameters — roughly 75% larger than DeepSeek's V4 Pro and nearly 4x Zhipu's GLM 5 series. The largest open-source model ever released.
It outperforms Claude Opus 4.8. It outperforms GPT-5.6 Sol. And on Moonshot's benchmarks, it sits on par with Fable 5 — the most capable model available to the public today.
The copy story is over.
## The Numbers
That last row is the one people are misreading. Let's deal with it properly.
## The Pricing Reality — Read This Carefully
Kimi K3 is not a discount model. At $3/$15 per million tokens, it's priced at roughly Claude Sonnet levels — not at the deep discounts Moonshot's earlier releases offered.
So where does "5x cheaper than Fable 5" come from?
Per-task cost, not per-token price.
K3 uses substantially fewer output tokens to complete the same work. On a representative coding task: Fable 5 costs around $1.30. K3 costs around $0.25.
Same output tier. Fewer tokens. Lower total bill.
The honest framing: Sonnet price, Fable-level experience. You're not buying the cheapest tokens on the market. You're buying frontier capability at mid-tier pricing, and getting there in fewer steps.
If you're comparing raw token prices, K3 looks unremarkable. If you're comparing what it costs to finish a job, it's a different conversation entirely.
## Where Kimi K3 Is State of the Art
According to Moonshot's published benchmarks, K3 sets SOTA on:
- HLE with tools — Humanity's Last Exam, tool-augmented
- SWE-Bench Pro — real-world software engineering
- SWE-Bench Multilingual — engineering across languages
- BrowseComp — web browsing and research
- Toolathlon — tool use at scale
- CharXiv with Python — chart and figure reasoning
- MathVision with Python — visual mathematics
Against the competition: outperforms Opus 4.8 and GPT-5.6 Sol, on par with Fable 5.
In blind testing by the AI evaluator Arena, developers preferred Kimi over every leading U.S. model.
## The Two Architecture Innovations That Actually Matter
This is the part most coverage is skipping, and it's the most interesting thing in the release.
- Kimi Delta Attention (KDA)
A hybrid linear attention mechanism. The result: up to 6.3x faster decoding in million-token contexts.
A 1M context window is only useful if you can actually work in it without waiting forever. KDA is what makes the context window practical instead of theoretical.
- Attention Residuals (AttnRes)
A drop-in replacement for residual connections. Delivers roughly 25% higher training efficiency at under 2% additional cost.
Both techniques were published as open research by the Moonshot team on GitHub before the model shipped. This isn't marketing — it's peer-inspectable work.
And combined, they explain the token efficiency: K3 uses 21% fewer output tokens than K2.6 on equivalent tasks.
## The Part That Should Make You Sit Up: K3 Optimized Its Own Architecture
Moonshot gave K3 the implementation of Attention Residuals — its own architectural component — and one objective: make it faster on H200 hardware without changing numerical behavior.
Then they left it alone.
20 hours of experiments. Zero human intervention. 1.6x speedup.
In a separate run, K3 cut the FLA Triton AttnRes forward/backward time from 283.6ms to 114.4ms — a 2.48x speedup — again without changing the numerics.
And it iterated faster than Fable 5 doing the same task.
Read that again. The model improved the mechanism that makes the model work. Autonomously. Overnight.
This is what "recursive self-improvement" looks like in practice — not a sci-fi scenario, a 20-hour job with a measurable result. It's the same capability Anthropic flagged as a reason for caution weeks ago, running in an open-weight model that anyone can download on July 27.
## Long-Horizon Coding Is the Whole Point
Moonshot's own framing: "K3 stands as Moonshot AI's most powerful open-source coding model to date. Operating with minimal human oversight, it can sustain long engineering sessions, navigate massive repositories, and orchestrate terminal tools."
The three things that matter for real engineering work:
1. Sustained sessions — the 20-hour autonomous experiment isn't a demo. It's the design target.
2. Massive repositories — a 1M context window with 6.3x faster decoding means you can put a real codebase in context and actually work in it.
3. Tool orchestration — SOTA on Toolathlon and BrowseComp means it handles the terminal, the browser, and the API calls without falling apart.
Frontend coding lands at Fable 5 level. AAA-quality game scenes from a single prompt. WebGPU, Three.js, shaders, physics — the stuff that used to require a studio.
## Vibe Coding With Kimi K3
This is where the model stops being a benchmark number and starts being obviously useful.
K3's frontend coding sits at Fable 5 level. In practice that means the wall between a description and a working 3D product is now one prompt.
What people have actually shipped from single prompts:
Games — WebGPU combat arenas with VFX. Browser-based 3D city traversal with grappling mechanics.
1. Zombie FPS.
2. Multiplayer racing.
3. A working 3D GBA emulator.
4. Full MMORPG scaffolding.
Not "a game-like demo" — playable scenes with hit reactions, impact feedback, and physics that behave.
*(视频内容)*
3D objects with real material work — A Rolex with correct glossiness and light behavior. A CSGO weapon that assembles and disassembles across 33 individually modeled parts. A Sony camera teardown. A black hole with gravitational lensing. Ocean simulation with actual wave dynamics.
*(视频内容)*
Physics scenes — Fabric simulation. Structural collapse. Vehicle collisions with momentum transfer that looks right instead of looking scripted.
The thing that makes this different from previous "AI builds a website" demos: K3 handles the details that normally break. Lighting. Shadows. Material glossiness. The 20 small things that separate "clearly AI-generated" from "someone built this."
One prompt. Four million tokens. A scene that used to need a team.
## 4 Battle-Tested Prompts (Copy-Paste Ready)
These are structured to exploit what K3 is actually good at: long-horizon work, tool use, and holding a large context without drifting.
Prompt 1 — The Physics Stress Test
This is the prompt that separates real capability from demo polish. If a model can do all three scenes at quality, it's real.
```
Build three self-contained HTML5 canvas scenes with real physics.
No external libraries. Everything in one file per scene.
Scene 1: A train derailing off a broken bridge into water.
Include: carriage momentum, bridge structural failure,
water displacement on impact.
Scene 2: Two cars jumping off ramps and colliding mid-air
over a canyon. Include: correct trajectory arcs,
collision momentum transfer, debris.
Scene 3: A monster truck crushing a row of parked cars.
Include: suspension compression, sheet metal deformation,
weight distribution.
Requirements for all three:
- Physics must be computed, not animated
- 60fps target
- Include a reset button
- Comment the physics math so I can verify it
Build all three. Don't ask clarifying questions.
```
Prompt 2 — The Long-Horizon Repo Task
This is what K3 was actually built for. Point it at a real codebase and give it an outcome, not a task.
```
Read this entire codebase before writing anything.
[paste your repo, or point it at the directory]
Objective: [state a measurable outcome — e.g. "reduce
p95 API response time by 30%" or "eliminate all N+1
queries in the data layer"]
Rules:
- Profile first. Show me where the time actually goes
before you change anything.
- Do not change public interfaces or numerical behavior.
- Run the existing test suite after each change.
- If a change makes things worse, revert it and tell me why.
- Work until the objective is hit or you can prove it's
not achievable without breaking the rules.
Report at the end: what you changed, what it bought,
what you tried that didn't work.
```
The "what you tried that didn't work" line matters. It's what turns the output from a diff into an engineering log.
Prompt 3 — The 3D Product Build
For anyone doing frontend, landing pages, or product visualization.
```
Build an interactive 3D [object] in the browser.
Single HTML file. Three.js.
The object: [describe it precisely — materials,
number of parts, what moves]
Must include:
- Correct material properties (glossiness, roughness,
metalness where relevant)
- Three-point lighting with real shadows
- Orbit controls
- [Any interaction — assembly/disassembly, animation,
hover states]
Quality bar: this should look like a product render,
not a WebGL demo. If a detail would be visible in real
life, model it.
Build the whole thing. Show me the file.
```
The "quality bar" line does more work than anything else in the prompt. K3 responds to standards, not just instructions.
Prompt 4 — Real-Time Feature With a Moving Part
Full-stack CRUD is one shape of app. Real-time is a different shape entirely — state has to stay in sync across clients, not just persist to a database. This is where a lot of models quietly fall apart.
```
Add a real-time feature to an existing app: a live collaborative
cursor + comment system, like Figma's.
REQUIREMENTS:
- WebSocket connection (use Socket.io or native ws)
- Show other connected users' cursor positions in real time
- Click anywhere to drop a comment pin
- Comments update live for all connected clients
- Handle disconnect/reconnect gracefully — no ghost cursors
- Debounce cursor updates so it doesn't flood the socket
BUILD:
1. Set up the WebSocket server
2. Build the client-side connection with auto-reconnect
3. Implement cursor broadcasting with debouncing
4. Implement the comment pin system
5. Add a simple presence indicator (who's online)
6. Test with at least 2 simulated clients to confirm sync works
Show me how you tested multi-client sync before calling this done.
```
Expected result: A working real-time layer in 15–30 minutes, with visible proof it was tested against more than one client.
The last line is the important part. Real-time bugs don't show up with one browser tab open — they show up with two. A model that skips multi-client testing will hand you code that looks done and isn't.
## When K3 Goes Wrong: Troubleshooting Guide
It's a new model with real rough edges. Here's what breaks and what to do.
- Problem: It burns tokens on trivial tasks
This is the big one, and it's structural.
K3 currently ships with only one reasoning effort level — 'max'. There's no "just answer quickly" mode. Independent testers clocked 13,241 reasoning tokens for generating a simple SVG — roughly $0.25 for something that should cost fractions of a cent.
> The fix: don't route simple work to K3. It's a frontier model with one gear, and that gear is "think hard about everything." Use K2.7 or a smaller model for boilerplate, formatting, and anything mechanical. Save K3 for work that justifies the reasoning.
This is the single biggest mistake people will make in the first month: making K3 the default for everything and then being surprised by the bill.
- Problem: The context window fills up anyway
1M tokens sounds infinite until you put a real repo in it and it isn't.
> The fix: don't dump everything. Point it at the directories that matter. K3's strength on long-horizon work comes from sustained focus, not from having every file in context. A tight 200K of the right code beats a bloated 900K of the whole monorepo.
- Problem: It drifts on very long autonomous runs
The 20-hour autonomous experiment is real, but it worked because the objective was measurable — "make this faster on H200 without changing numerics." Give it a vague goal and a long leash and it will wander.
> The fix: every long-horizon prompt needs a verifiable success condition. Not "improve the code." A number, a test that passes, a benchmark that moves. If you can't state how you'd check whether it succeeded, it will drift.
- Problem: You can't reproduce someone's benchmark result
Nobody outside Moonshot has audited this model. Weights don't drop until July 27. Every number circulating right now — including in this article — is vendor-reported.
> The fix: wait for July 27, or test on your own tasks and trust that instead. Your five real tasks are worth more than anyone's benchmark table.
- Problem: Integration errors after switching from OpenAI or Anthropic
K3 is OpenAI SDK compatible, which handles 90% of the migration. The remaining 10% is usually the reasoning behavior — K3 thinks by default and returns reasoning tokens you may not be expecting in your response handling.
> The fix: check your token accounting and your response parsing before you assume the model is broken. Most "K3 is expensive" complaints are actually "I forgot reasoning tokens are output tokens."
## The Context Nobody Should Ignore
Moonshot is based in Beijing, founded by Yang Zhilin, a former Google researcher, and backed by Alibaba.
> **Kirill@kirillk_web3**: [原文链接](https://x.com/kirillk_web3/status/2057528102368977328)
>
> instead of watching 2 hours of Netflix tonight, watch this 40-minute masterclass from the founder of a $20B China AI company
> it's the clearest explanation I've seen of how Agent Swarms and AI systems actually work at scale
> useful whether you've never built an agent in your life
>
> 
They built a 2.8-trillion-parameter frontier model under three years of escalating U.S. export controls on advanced chips.
Bank of America's analysts put it directly: "Despite persistent hardware/compute capacity constraints in China, K3 demonstrates that pre-training scaling, paired with architectural innovation, can still deliver step-change gains for flagship Chinese models."
And the timing isn't accidental: K3 landed days before the 2026 World Artificial Intelligence Conference in Shanghai.
## The July 27 Question
Weights drop July 27. That date matters more than the launch date.
Until then, K3 is a frontier model you can use through an API — impressive.
On July 27, it becomes something else: a frontier-class model that anyone can download, inspect, modify, and run on their own hardware. No API. No usage limits. No terms of service. No 30-day prompt retention.
That's the actual story. Not "China caught up."
China caught up and gave it away.
Worth noting: Chinese regulators have been discussing AI export controls of their own. Whether K3 is the last frontier open-weight release from China or the first of many is genuinely unclear right now.
## How to Try It
Chat: kimi.com — K3 is live now
API: OpenAI SDK compatible, so if you're already building on OpenAI or Anthropic toolchains, integration is a config change, not a rewrite
Weights: July 27
The SDK compatibility is a bigger deal than it sounds. Swapping models usually means rewriting your integration layer. Here it means changing a base URL and a model string.
## How to Install Kimi Code (The Terminal Agent)
If you want K3 running inside your actual codebase instead of a chat window, this is the setup.
Requirements:
- A computer (Mac, Windows, or Linux)
- Terminal access
- Kimi account — kimi.com
Step 1 — Install Kimi Code
Mac/Linux:
```
curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash
```
Windows (PowerShell):
```
irm https://code.kimi.com/kimi-code/install.ps1 | iex
```
On Windows, install Git for Windows first — Kimi Code CLI uses its bundled Git Bash as the shell environment.
Verify the install:
```
kimi --version
```
> Due to macOS Gatekeeper, the first run may take noticeably longer. Add your terminal app in System Settings → Privacy & Security → Developer Tools to speed up later launches.
If you already have uv installed, you can install directly:
```
uv tool install --python 3.13 kimi-cli
```
Kimi Code CLI supports Python 3.12–3.14, with 3.13 recommended for best compatibility.
Step 2 — Navigate to your project and launch
```
cd your-project
kimi
```
On first launch, run /login inside the session to configure your API source — it opens a browser window for OAuth.
Step 3 — Give it a task
Kimi Code is now running inside your project, with direct read/write access to every file. Describe a task in plain English — it plans the steps, edits the code, runs tests, and reports what it did.
## What This Actually Means
If you're running production workloads:
Test it before switching. Vendor benchmarks and real-world performance diverge constantly. Pick five real tasks, run K3 and your current model side by side, measure cost per completed job — not cost per token.
The per-task math is the whole argument. At $3/$15 K3 isn't cheap on paper. At 21% fewer tokens and Fable-level output, it's cheap where it counts.
July 27 changes the calculus. Open weights means self-hosting, fine-tuning, and zero dependency on anyone's API staying online or anyone's terms staying favorable. For anything sensitive, that's not a small thing.
## Conclusion
The frontier used to be a place American labs built and everyone else visited six months later.
2.8 trillion parameters. 1M context. Fable 5-level coding at Sonnet pricing. Built under export controls, by the lowest-valued lab in the room, and given away for free on July 27.
The interesting question isn't whether K3 beats Fable 5 on some benchmark. It's what happens to the economics of closed frontier models when an open-weight one matches them.
## Links
- Kimi K3: https://www.kimi.com
- My Telegram: https://t.me/kirillk_web3
- My Twitter/X: https://x.com/kirillk_web3
- Partner Hosting: https://ishosting.com/affiliate/NzE0MiM2
Follow for more Vibe Coding information. Thank you for reading!
## 相关链接
- [Kirill](https://x.com/kirillk_web3)
- [@kirillk_web3](https://x.com/kirillk_web3)
- [337K](https://x.com/kirillk_web3/status/2078880995705516361/analytics)
- [Jul 17](https://x.com/Kimi_Moonshot/status/2077830229968683203)
- [23M](https://x.com/Kimi_Moonshot/status/2077830229968683203/analytics)
- [May 22](https://x.com/kirillk_web3/status/2057528102368977328)
- [13M](https://x.com/kirillk_web3/status/2057528102368977328/analytics)
- [kimi.com](https://kimi.com/)
- [kimi.com](https://kimi.com/)
- [https://www.kimi.com](https://www.kimi.com/)
- [https://t.me/kirillk_web3](https://t.me/kirillk_web3)
- [https://x.com/kirillk_web3](https://x.com/kirillk_web3)
- [https://ishosting.com/affiliate/NzE0MiM2](https://ishosting.com/affiliate/NzE0MiM2)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [12:33 AM · Jul 20, 2026](https://x.com/kirillk_web3/status/2078880995705516361)
- [337.8K Views](https://x.com/kirillk_web3/status/2078880995705516361/analytics)
- [View quotes](https://x.com/kirillk_web3/status/2078880995705516361/quotes)
---
*导出时间: 2026/7/21 09:41:46*
---
## 中文翻译
# Kimi K3：击败 Fable 5 的开源模型完整 A-Z 指南
**作者**: Kirill
**日期**: 2026-07-16T18:58:25.000Z
**来源**: [https://x.com/kirillk_web3/status/2078880995705516361](https://x.com/kirillk_web3/status/2078880995705516361)
---
这是一篇关于 Kimi K3 究竟是什么、它能做什么，以及为什么它正悄悄成为最重要的、却还没人讨论的编程模型的完整 A-Z 解析。
> 收藏本页，以免丢失这篇文章。
2.8 万亿参数。100 万 token 上下文。
以下是全部内容。
## 在谈论基准测试之前，先谈谈刚刚发生了什么
过去三年故事一直是一样的：美国实验室构建前沿模型，中国实验室在六个月后构建廉价复制品。
7 月 16 日，Moonshot AI 发布了 Kimi K3。
> **Kimi.ai@Kimi_Moonshot**: [原文链接](https://x.com/Kimi_Moonshot/status/2077830229968683203)
>
> 介绍 Kimi K3：开放的前沿智能
> 2.8 万亿参数，100 万上下文，原生多模态
> Kimi Delta Attention 实现了百万 token 上下文下高达 6.3 倍的解码加速
> Attention Residuals 在增加不到 2% 成本的情况下，实现了约 25% 的训练效率提升
>
> 
> 
2.8 万亿总参数——比 DeepSeek V4 Pro 大约大 75%，几乎是智谱 GLM 5 系列的 4 倍。这是迄今为止发布的最大的开源模型。
它击败了 Claude Opus 4.8。它击败了 GPT-5.6 Sol。在 Moonshot 的基准测试中，它与 Fable 5 并驾齐驱——这是目前公众可获得的最强模型。
复制品的故事结束了。
## 数字
最后一行是人们误读的地方。让我们正确地处理它。
## 定价真相——请仔细阅读
Kimi K3 不是一个折扣模型。每百万 token 3/15 美元的价格，它的定价大约在 Claude Sonnet 级别——而不是 Moonshot 早期发布产品提供的深度折扣。
那么，“比 Fable 5 便宜 5 倍”从何而来？
按任务成本，而非每 token 价格。
K3 完成同样的工作使用明显更少的输出 token。在一个典型的编码任务中：Fable 5 的成本约为 1.30 美元。K3 的成本约为 0.25 美元。
相同的输出等级。更少的 token。更低的账单总额。
诚实的说法是：Sonnet 的价格，Fable 级的体验。你不是在购买市场上最便宜的 token。你是在以中端价格购买前沿能力，并且用更少的步骤就能达到目标。
如果你比较原始 token 价格，K3 看起来平平无奇。如果你比较完成工作的成本，那完全是另一回事。
## Kimi K3 处于最前沿（SOTA）的领域
根据 Moonshot 发布的基准测试，K3 在以下方面达到了 SOTA：
- HLE with tools——人类最后的考试，工具增强版
- SWE-Bench Pro——现实世界软件工程
- SWE-Bench Multilingual——跨语言工程
- BrowseComp——网页浏览和研究
- Toolathlon——规模化工具使用
- CharXiv with Python——图表和图形推理
- MathVision with Python——视觉数学
与竞争对手相比：击败了 Opus 4.8 和 GPT-5.6 Sol，与 Fable 5 持平。
在 AI 评估者 Arena 的盲测中，开发者更喜欢 Kimi，而不是所有领先的美国模型。
## 两个真正重要的架构创新
这是大多数报道都跳过的部分，也是本次发布中最有趣的地方。
- Kimi Delta Attention (KDA)
一种混合线性注意力机制。结果是：在百万 token 上下文中，解码速度最高提升 6.3 倍。
一个 1M 的上下文窗口只有在你能实际在其中工作而无需等待很久的情况下才有用。KDA 让上下文窗口变得实用，而非仅仅是理论上的。
- Attention Residuals (AttnRes)
残差连接的直接替代品。在增加不到 2% 成本的情况下，提供约 25% 的训练效率提升。
这两种技术都在模型发布前由 Moonshot 团队在 GitHub 上作为开源研究发表了。这不是营销——这是可经同行审查的工作。
结合起来，它们解释了 token 效率：在同等任务下，K3 比 K2.6 少使用 21% 的输出 token。
## 该让你警醒的部分：K3 优化了自己的架构
Moonshot 给了 K3 Attention Residuals 的实现——这是它自己的架构组件——以及一个目标：在不改变数值行为的情况下，让它在 H200 硬件上运行得更快。
然后他们就撒手不管了。
20 小时的实验。零人工干预。1.6 倍加速。
在另一次运行中，K3 将 FLA Triton AttnRes 的前向/后向时间从 283.6ms 缩短到 114.4ms——2.48 倍加速——同样没有改变数值。
而且它的迭代速度比做同样任务的 Fable 5 更快。
再读一遍。模型改进了让模型工作的机制。自主地。一夜之间。
这就是“递归自我改进”在实践中的样子——不是科幻场景，而是一项有可衡量结果的 20 小时工作。这正是 Anthropic 几周前发出警告的同一能力，现在正运行在一个任何人都可以在 7 月 27 日下载的开源权重模型中。
## 长周期编码才是全部重点
Moonshot 自己的表述：“K3 是 Moonshot AI 迄今为止最强大的开源编程模型。在最少人工监督下运行，它可以维持长时间的工程会话，导航庞大的代码库，并编排终端工具。”
对于真正的工程工作而言，三件事最重要：
1. 持续的会话——20 小时的自主实验不是演示。这是设计目标。
2. 庞大的代码库——具有 6.3 倍解码速度的 1M 上下文窗口意味着你可以把真实的代码库放入上下文中并实际在其中工作。
3. 工具编排——在 Toolathlon 和 BrowseComp 上达到 SOTA 意味着它能处理终端、浏览器和 API 调用而不会崩溃。
前端编码达到了 Fable 5 级别。单次提示即可生成 AAA 级游戏场景。WebGPU、Three.js、着色器、物理引擎——这些以前需要工作室才能完成的东西。
## 用 Kimi K3 进行“氛围感编码”
这就是模型不再是一个基准测试数字，而是变得明显有用的地方。
K3 的前端编码处于 Fable 5 级别。实际上，这意味着描述和可工作的 3D 产品之间的界限现在只剩下一个提示。
人们实际上通过单次提示交付了什么：
游戏——带有 VFX 的 WebGPU 战斗竞技场。带有抓钩机制的浏览器内 3D 城市穿越。
1. 僵尸 FPS。
2. 多人赛车。
3. 一个可运行的 3D GBA 模拟器。
4. 完整的 MMORPG 脚手架。
不是“一个类似游戏的演示”——而是具有受击反应、冲击反馈和物理行为的可游玩场景。
*(视频内容)*
具有真实材质效果的 3D 物体——一块光泽度和光线行为正确的劳力士。一把 CS:GO 武器，包含 33 个独立建模的部件，可以组装和拆卸。索尼相机的拆解。具有引力透镜效应的黑洞。具有真实波浪动态的海洋模拟。
*(视频内容)*
物理场景——布料模拟。结构坍塌。具有动量传递的车辆碰撞，看起来是正确的而不是脚本化的。
这让这区别于以前“AI 构建网站”演示的地方是：K3 处理了通常会出错的细节。光照。阴影。材质光泽度。那 20 件区分“明显是 AI 生成的”和“有人手工构建的”小事情。
一个提示。四百万 token。一个以前需要一个团队的场景。
## 4 个久经考验的提示词（复制即用）
这些提示词的结构是为了利用 K3 真正擅长的东西：长周期工作、工具使用，以及在不跑偏的情况下保持大上下文。
提示词 1——物理压力测试
这是区分真实能力和演示打磨的提示词。如果一个模型能以质量完成这三个场景，那就是真材实料。
```
构建三个独立的 HTML5 canvas 物理场景。
不要外部库。每个场景一个文件。
场景 1：一列火车脱轨冲出断裂的桥梁落入水中。
包括：车厢动量、桥梁结构失效、
撞击时的水面排开。
场景 2：两辆车从坡道跳起并在峡谷上空
半空中相撞。包括：正确的弹道弧线、
碰撞动量传递、碎片。
场景 3：一辆巨型卡车碾碎一排停放的汽车。
包括：悬挂压缩、金属板变形、
重量分布。
所有三个场景的要求：
- 物理必须是计算出来的，而不是动画
- 目标 60fps
- 包含一个重置按钮
- 注释物理数学计算以便我验证
构建全部三个。不要问澄清性问题。
```
提示词 2——长周期代码库任务
这才是 K3 真正的用武之地。指向一个真实的代码库并给它一个结果，而不是一个任务。
```
在写任何东西之前阅读整个代码库。
[粘贴你的代码库，或指向目录]
目标：[陈述一个可衡量的结果——例如“将
p95 API 响应时间减少 30%”或“消除
数据层中的所有 N+1 查询”]
规则：
- 先做性能分析。在你改变任何东西之前，
向我展示时间实际上花在了哪里。
- 不要更改公共接口或数值行为。
- 每次更改后运行现有的测试套件。
- 如果更改让情况变糟，回滚它并告诉我原因。
- 工作直到达到目标，或者你能证明
在不违反规则的情况下无法实现。
最后报告：你改变了什么，带来了什么，
你尝试了什么但没有奏效。
```
“你尝试了什么但没有奏效”这一行很重要。它把输出从一个差异文件变成了工程日志。
提示词 3——3D 产品构建
对于任何从事前端、落地页或产品可视化的人。
```
在浏览器中构建一个交互式 3D [物体]。
单个 HTML 文件。Three.js。
物体：[精确描述它——材质、
部件数量，什么会动]
必须包括：
- 正确的材质属性（光泽度、粗糙度、
相关处的金属度）
- 带有真实阴影的三点光照
- 轨道控制
- [任何交互——组装/拆卸、动画、
悬停状态]
质量标准：这应该看起来像产品渲染图，
而不是 WebGL 演示。如果一个细节在现实
生活中可见，就把它建模出来。
构建整个东西。给我看文件。
```
“质量标准”这一行比提示词中的任何其他指令都管用。K3 响应的是标准，而不仅仅是指令。
提示词 4 —— 带有动态部分的实时功能
全栈 CRUD 是一种应用形态。实时是完全不同的形态——状态必须跨客户端保持同步，而不仅仅是持久化到数据库。这正是许多模型悄悄崩溃的地方。
```
为现有应用添加一个实时功能：一个实时的协作光标 +
评论系统，类似 Figma 的。
要求：
- WebSocket 连接（使用 Socket.io 或原生 ws）
- 实时显示其他连接用户的游标位置
- 点击任意位置放置评论图钉
- 评论对所有连接客户端实时更新
- 优雅处理断开/重连——没有幽灵游标
- 对游标更新进行防抖，以免淹没 socket
构建：
1. 设置 WebSocket 服务器
2. 构建具有自动重连功能的客户端连接
3. 实现带防抖的游标广播
4. 实现评论图钉系统
5. 添加一个简单的在线状态指示器（谁在线）
6. 至少用 2 个模拟客户端进行测试，以确认同步有效
在宣称完成之前，向我展示你如何测试多客户端同步。
```
预期结果：在 15–30 分钟内得到一个可工作的实时层，并有可见证据证明它是针对多个客户端进行过测试的。
最后一行是重要的部分。实时 bug 不会只打开一个浏览器标签就出现——它们出现在打开两个标签的时候。跳过多客户端测试的模型会交给你看起来完成了但实际上没完成的代码。
## 当 K3 出错时：故障排除指南
这是一个具有真实棱角的新模型。以下是什么会出问题以及该怎么做。
- 问题：它在琐碎任务上消耗大量 token
这是个大问题，而且是结构性的。
K3 目前只提供一个推理努力级别——'max'。没有“快速回答”模式。独立测试人员记录到生成一个简单的 SVG 消耗了 13,241 个推理 token——大约 0.25 美元，而本应花费几分之一美分。
> 解决方法：不要把简单的工作路由给 K3。它是一个只有一个档位的前沿模型，那个档位就是“努力思考一切”。使用 K2.7 或更小的模型来处理样板代码、格式化和任何机械性工作。把 K3 留给值得推理的工作。
这是人们在第一个月会犯的最大的单一错误：把 K3 作为默认选项处理所有事情，然后对账单感到惊讶。
- 问题：上下文窗口反正还是会被填满
100 万 token 听起来是无限的，直到你把一个真实的代码库放进去，然后它就不无限了。
> 解决方法：不要倾倒所有东西。指向重要的目录。K3 在长周期工作上的优势来自于持续的专注，而不是拥有上下文中的每个文件。紧凑的 200K 正确代码胜过臃肿的 900K 整个 monorepo。
- 问题：在非常长的自主运行中它会跑偏
20 小时的自主实验是真实的，但它之所以奏效，是因为目标是可衡量的——“在不改变数值行为的情况下让它在 H200 上更快”。给它一个模糊的目标和长绳索，它就会漫无目的地游荡。
> 解决方法：每个长周期提示词都需要一个可验证的成功条件。不是“改进代码”。一个数字、一个通过的测试、一个移动的基准。如果你不能陈述如何检查它是否成功，它就会跑偏。
- 问题：你无法复现某人的基准测试结果
Moonshot 之外没有人审计过这个模型。权重直到 7 月 27 日才会发布。目前流传的每一个数字——包括本文中的——都是供应商报告的。
> 解决方法：等到 7 月 27 日，或者在你自己的任务上测试并相信那些结果。你的五个真实任务比任何人的基准测试表格都有价值。
- 问题：从 OpenAI 或 Anthropic 切换后出现集成错误
K3 兼容 OpenAI SDK，这解决了 90% 的迁移问题。剩下的 10% 通常是推理行为——K3 默认会思考并返回推理 token，这可能是你在响应处理中没有预料到的。
> 解决方法：在你假设模型损坏之前，检查你的 token 计费和响应解析。大多数“K3 很贵”的抱怨实际上是“我忘了推理 token 也是输出 token”。
## 不应被忽视的背景
Moonshot 总部位于北京，由前谷歌研究员杨植麟创立，并获得阿里巴巴支持。
> **Kirill@kirillk_web3**: [原文链接](https://x.com/kirillk_web3/status/2057528102368977328)
>
> 今晚与其看两小时 Netflix，不如看看这家价值 200 亿美元的中国 AI 公司创始人的 40 分钟大师课
> 这是我见过的关于 Agent 群和 AI 系统实际上如何大规模工作的最清晰的解释
> 无论你一生中是否从未构建过 agent，这都很有用
>
> 
他们在针对先进芯片的三年不断升级的美国出口管制下，构建了一个 2.8 万亿参数的前沿模型。
美银分析师直接指出：“尽管中国持续面临硬件/算力能力限制，但 K3 表明，预训练扩展与架构创新的结合，仍可为中国旗舰模型带来阶跃式提升。”
而且时机并非偶然：K3 在 2026 年上海世界人工智能大会召开前几天落地。
## 7 月 27 日的问题
权重将于 7 月 27 日发布。那个日期比发布日期更重要。
在那之前，K3 是一个你可以通过 API 使用的前沿模型——令人印象深刻。
7 月 27 日，i