14 Steps That Unlock a 2.8T Open Model (and where it beats everything)

Cover image

Four days ago the largest open-weight AI model in history went live. No keynote. No livestream. @Kimi_Moonshot overnight AI flipped kimi.com overnight and shipped Kimi K3: 2.8 trillion parameters, a 1-million-token context window, and a coding result no open model had ever posted.

In blind human testing on Arena developers voting on outputs without knowing which model made them K3 took first place in the Frontend Code arena. It beat Claude Fable 5. It beat GPT-5.6 Sol. First place for building things, chosen by people who didn't know they were picking the open model.

Most people saw the headline and scrolled. Almost nobody pushed it to see what it builds — or learned the one setting that decides whether it saves you money or quietly torches it.

> Follow me I break down every major AI release without the hype and hand you the prompts to test it yourself: @adiix_official. Bookmark this before it scrolls away.

By the end you'll have: 20 things K3 builds from a single prompt (with copy-paste prompts), the six-minute setup, the routing that cuts your bill 10x, and the mistakes that turn a bargain into a surprise invoice. This is the playbook.

Honesty first, because it's the whole point: K3 is #1 in the world for frontend code and tops several coding and agent leaderboards — but on the aggregate Agent Arena it lands #4 overall, behind Fable 5, Opus 4.8, and GPT-5.6 Sol. Where it wins, it wins hard. This playbook lives in that territory. Sourced from Moonshot's launch, the Arena leaderboards, and hands-on testing.

60 seconds on what K3 actually is

The brain — a Mixture-of-Experts model. Picture a building with 896 specialists; for any task it wakes only the 16 best-suited (~1.8%) and the rest sleep. It carries 2.8T of knowledge but costs far less to run. Enormous on paper, lean in practice.
The reach — a 1,048,576-token context (a whole codebase fits), native vision (reads images and video directly), and always-on reasoning Moonshot calls "thinking mode."
Two flavors — K3 Max for chat and agent work; K3 Swarm for large-scale parallel jobs.
The origin — a Beijing lab founded by ex-Google researcher Yang Zhilin, backed by Alibaba. Launched July 16, 2026.
The date that matters — full weights go open on July 27 under a permissive (Modified MIT) license.

20 builds. 3 mistakes. One date. Stop screenshotting benchmarks — start routing.

The architecture that actually matters (the part most coverage skips)

Three published ideas explain the whole release — peer-inspectable research, not marketing.

Kimi Delta Attention (KDA) — a hybrid linear attention scheme. Result: up to 6.3x faster decoding in million-token contexts. A 1M window is theoretical if you wait forever; KDA makes it practical.
Attention Residuals (AttnRes) — the α operation that replaces standard residual connections, wired as a Block Attention Residuals backbone. Roughly 25% higher training efficiency at under 2% extra cost.
Stable LatentMoE + Gated MLA — the routing and attention stack that keeps a 2.8T sparse model stable.

Together they explain the token efficiency: K3 uses about 21% fewer output tokens than the previous generation on equivalent work. Remember that number — it's the entire pricing argument.

And the flex that should make you sit up: Moonshot handed K3 the job of optimizing its own attention kernels and left it alone. ~24 hours of autonomous experiments, zero human intervention, a measurable speedup — without changing the numerics. Recursive self-improvement as a boring engineering log. (Vendor-reported — but the technique is open.)

The pricing reality — read this carefully

K3 is not a discount model. At $3 / M input, $15 / M output, it's priced at roughly Claude Sonnet levels — not the deep discounts open models trained you to expect.

So where does "cheaper" come from? Per finished task, not per token. Because of that 21% token efficiency, on a representative coding job that runs ~$1.30 on a pricier frontier model, K3 lands near $0.25.

And the biggest hidden lever: cached input bills at $0.30/M instead of $3/M — a 10x cut — but only when your prefix is byte-identical across calls.

The honest framing: Sonnet price, frontier-level output, fewer steps to get there. Compare token prices and K3 looks unremarkable. Compare cost-to-finish-a-job and it's a different conversation.

The 20 builds — what K3 makes from one prompt

This is the territory that won it the #1 arena spot. Copy the prompts. Test them yourself.

Part 1 — Games & 3D worlds (where it beats everything)

1. Playable browser games with real physics. Hit reactions, momentum, camera feel — the twenty small things that normally break.

Build a single-file browser game: a top-down arena where the player dodges
and shoots waves of enemies. Canvas or WebGL, no external assets.
Include: real movement momentum, enemy hit reactions, screen shake on impact,
a score counter, and a restart button. 60fps target.
Make it feel responsive, not floaty. Build the whole thing. Don't ask questions.

2. Interactive 3D products that look like renders. Correct glossiness, roughness, metalness, real shadows — a watch, a camera teardown, a mechanical object that assembles on click.

3. Computed physics, not animated. Cloth that drapes, a bridge that collapses into water, vehicles colliding with real momentum.

Build three HTML5 canvas scenes, computed physics, no libraries, one file each:
(1) a bridge collapsing and dropping a vehicle into water with displacement,
(2) cloth falling over an invisible object, (3) a block tower toppling from a nudge.
Physics computed not animated. 60fps. Reset button. Comment the equations so I
can verify them. Build all three. Don't ask clarifying questions first.

4. Shader & WebGPU scenes. The genuinely hard graphics work — a black hole bending the starfield, particle systems, procedural terrain. Name the standard out loud; K3 responds to standards more than instructions.

Build a single-file WebGL scene: a black hole with gravitational lensing that
visibly bends a starfield behind it, plus a temperature-colored accretion disk.
Add orbit controls. Quality bar: this should look like a science visualization,
not a shader tutorial. Build the file.

Part 2 — Real products & interfaces

5. Landing pages that look designed, not templated — give it an aesthetic ("brutalist," "warm editorial," "clean fintech").

6. Full-stack app scaffolds from a spec — frontend, API, schema, and auth, wired together.

Build the scaffold for a habit-tracking web app. Stack: React front end,
Node/Express API, Postgres, email+password auth. Features: signup,
create/edit/delete habits, daily check-ins, a streak counter, weekly summary.
Build the schema first, then the API, then the UI. Wire them together and note
anything I'd need to configure to run it.

7. Real-time collaboration that actually stays in sync — where weak models quietly fake it. Bugs only appear with two browsers open; force it to prove the work.

Add a real-time layer: live cursors + click-to-drop comment pins, like Figma.
WebSocket (Socket.io or native ws). Cursors live, comments instant for everyone,
graceful reconnect with no ghost cursors, debounced updates. Build end to end,
then prove sync with two simulated clients before calling it done.

8. Dashboards from raw data — its chart/figure reasoning (Python-backed) tells you what the data shows, not just plots it.

Part 3 — Serious engineering (the long-horizon superpower)

9. Whole-repo work with a measurable objective — the single most powerful way to use K3.

Read this entire codebase before changing anything.
Objective: cut p95 response time on /search by 30%.
Rules: profile first and show me where the time goes; don't change public
interfaces or outputs; run tests after every change; if a change makes things
worse, revert it and say why. Work until the objective is hit or you can prove
it can't be without breaking a rule.
End with a log: what you changed, what it bought, what you tried that failed.

10. A real repo in context at once — reason about your system, not fragments. Caveat: a tight 200K of the files that matter beats a bloated 900K monorepo. Focus, not volume.

11. Migrations between languages/frameworks — state-of-the-art on multilingual SWE; holds behavior constant across the port.

12. Autonomous sessions with a verifiable success condition — "make this test pass" works; "improve the code" makes it wander. Hand it a number, not a vibe.

Part 4 — Agents, tools & research

13. Terminal + browser orchestration — drives the shell, browser, and API calls without falling apart.

Goal: find the 3 most-requested features in this repo's GitHub issues, then draft
a spec for the top one. Steps: search the issues, rank by reactions and comments,
pick the highest-impact one, and write a one-page spec with scope, edge cases,
and a rough implementation plan. Show your work.

14. Deep, tool-augmented web research — #1 on BrowseComp: searches, reads primary sources, cross-references, returns something structured and cited.

15. Massive parallel jobs via K3 Swarm — fan a batch across many sub-agents, then merge.

16. A document pile → one deliverable — a folder of PDFs becomes one synthesized brief, not fifteen summaries.

Part 5 — Multimodal & power moves

17. Screenshot or mockup → working frontend — native vision + the frontend crown.

18. Reasoning over charts, figures & visual math — extracts the numbers and computes on them (Python-backed). Near the top of CharXiv (91.3).

19. Video as an input — hand it footage and have it reason about what happened on screen.

20. Owning the model outright after July 27 — weights open under a permissive license means self-hosting, fine-tuning on your data, inspecting how it behaves, and depending on no one's API or terms. That independence, on a frontier-adjacent model, is what reshapes the market.

The six-minute setup

Wire it in — it's OpenAI-compatible. A base URL and a model string, not a rewrite.

from openai import OpenAI
client = OpenAI(api_key=MOONSHOT_API_KEY, base_url="https://api.moonshot.ai/v1")
resp = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "system", "content": STABLE_PROJECT_CONTEXT},  # keep identical → cache hit at $0.30/M
        {"role": "user",   "content": task},                     # only this changes
    ],
)

Run it in your repo.

curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash   # Mac/Linux
cd your-project && kim

Drop this routing block into your CLAUDE.md / AGENTS.md:

## Model routing
- Long-context reading, repo-wide analysis, doc synthesis → Kimi K3 (1M window, cache at $0.30)
- Frontend, 3D, UI-heavy builds → Kimi K3, then verify visually
- Agent loops with repeated context → Kimi K3 via cache-hit prefixes
- Quick edits, boilerplate, formatting → a smaller/faster model
- Highest-stakes factual work → verify, or stay on your audited model

When K3 goes wrong — troubleshooting

It burns tokens on trivial tasks. Thinking is always on (one gear: max). Fix: don't route boilerplate to K3.
The 1M context fills up anyway. Fix: a tight 200K of the right files beats a bloated 900K monorepo.
It drifts on long autonomous runs. Fix: every long-horizon prompt needs a verifiable success condition — a number, a passing test.
You can't reproduce a benchmark. Everything is vendor-reported until July 27. Fix: trust your own five tasks.
Integration errors after switching. K3 returns reasoning tokens you may not expect. Fix: check your token accounting — most "K3 is expensive" complaints are "I forgot reasoning tokens are output tokens."

The 3 mistakes that keep K3 at 10%

Making it your default for everything. Always-on thinking makes trivia expensive — testers watched it burn 13,241 reasoning tokens on a single SVG (Simon Willison). Route by weight.
Thinking "open weights" means "runs on my laptop." Even heavily compressed it's well over a terabyte and needs dozens of accelerators. Open weights is a gift to teams that self-host and researchers who fine-tune — for almost everyone, "using K3" means the app or API, and that's fine.
Quoting benchmarks as fact. Vendor-reported until July 27. And mind the hallucination tax: accuracy rose to ~46%, but confident nonsense rose too — ~51% (Artificial Analysis). For facts, verify before you ship.

Who should NOT switch yet — and the honest ranking

Mostly quick edits and boilerplate → the one-gear tax makes trivia expensive.
Need audited, reproducible numbers today → wait for July 27.
Need the cheapest tokens and can't self-host → K3 is Sonnet-priced, not bargain-priced.
Factual, high-stakes work with no verification layer → see the hallucination tax.

If you're on this list, K3 isn't a downgrade — it's just not your tool this month.

Why this is bigger than a benchmark

Moonshot built a 2.8-trillion-parameter frontier-class model under three years of escalating US export controls — through architecture, not raw compute — then announced they'd give the weights away, timed to land just before the World AI Conference in Shanghai. Not a coincidence.

The interesting question was never "did China catch up." It's what happens to the economics of closed, expensive frontier models when a free, open one lands in the same tier. When frontier-grade capability stops being something only three companies can sell, the pricing power of the closed labs changes. That pressure is the event.

Conclusion

For three years the deal was simple: American labs built the frontier, everyone else got a cheaper copy six months later. Kimi K3 broke that.

Largest open model ever made. #1 in the world for frontend code, top of several coding and agent leaderboards, #4 overall. Built under export controls. And in one week, given away.

It's not the cheapest tokens, it doesn't top every chart, and you won't run it at home. All true — and none of it changes the headline: a frontier-tier model that beats the closed flagships at building things is about to belong to everyone.

Route by weight. Cache the stable prefix. Give it outcomes, not chores. Verify everything.

Most people will read the launch tweet and never open the model. Spend one evening building with it and you'll be a month ahead of the entire timeline.

Test it on five real tasks. Route the heavy work. Keep the receipts.

How to try it

Chat & app: kimi.com (live now) · API: OpenAI-SDK compatible · Open weights: July 27

Links

Follow me on X: @adiix_official
My Telegram: https://t.me/+bkqbSTOD9z02OTQy

*Sources: Arena.ai leaderboards (Frontend Code #1, Agent #4) · Tom's Hardware · MarkTechPost — architecture · Simon Willison — hands-on · Artificial Analysis via apido*