SeaWorkKimi K3 for Coding (2026): 88.3 Terminal-Bench, $3/$15 API & Open Weights
Kimi K3 released July 27 2026: 88.3 Terminal-Bench, $3/$15 API pricing, open weights, and how to run coding agents from your phone with SeaWork.
Kimi K3 is Moonshot AI’s open-weight native multimodal agentic MoE, with weights published on Hugging Face on July 27, 2026. The official API model ID is kimi-k3. On Moonshot’s coding table at max effort it scores 88.3 on Terminal-Bench 2.1, and official Kimi API pricing is $3.00 per million cache-miss input tokens and $15.00 per million output tokens (cache-hit input is $0.30). Context is 1,048,576 tokens.
That combination — open weights, a 1M window, and frontier-adjacent coding scores at a mid-tier API rate — is why developers are looking at K3 for long agent runs. A long run should not require staying at a desk: run an agent that supports custom endpoints (Codex with a custom provider config, for example) against the API that serves kimi-k3, keep the agent on the machine that holds your repository, and steer it from your phone with SeaWork.
What Kimi K3 is
Kimi K3 is an open-weight native multimodal agentic mixture-of-experts model from Moonshot AI. The Hugging Face model card and README list the scale and architecture:
- 2.8T total parameters, 104B activated per token
- 896 experts, 16 experts selected per token, plus 2 shared experts
- 1,048,576-token (1M) context
- Kimi Delta Attention (KDA) with Attention Residuals: 69 KDA layers and 24 Gated MLA layers, with Stable LatentMoE
- Quantization-aware training with MXFP4 weights and MXFP8 activations
- Vision encoder: MoonViT-V2 (401M)
Weights and the model card live at moonshotai/Kimi-K3. Moonshot’s tech blog states full weights were released by July 27, 2026; the Hugging Face lastModified timestamp matches that date. The technical report PDF is on the MoonshotAI/Kimi-K3 GitHub repository. API model ID: kimi-k3.
The license is the Kimi K3 License, not plain MIT. The LICENSE file grants MIT-style rights to use, modify, and distribute, with commercial conditions: if you operate Model-as-a-Service and aggregate revenue exceeds $20M USD over any consecutive 12 months, you need a separate agreement with Moonshot; large commercial products (>100M MAU or >$20M monthly revenue) must display “Kimi K3” branding. Read the LICENSE before shipping a product on the weights.
Together AI also serves moonshotai/Kimi-K3, with a listed release date of July 27, 2026, at the same cache-miss and output rates as the official Kimi API (see pricing below).
Kimi K3 vs Kimi K2.7 Code: which one for coding
Moonshot already ships a dedicated coding sibling: Kimi K2.7 Code. That model is not a drop-in substitute for K3, and the choice is mostly about cost, speed, and horizon length rather than brand.
| Dimension | Kimi K3 (kimi-k3) |
Kimi K2.7 Code (kimi-k2.7-code) |
|---|---|---|
| Role | Frontier multimodal agentic MoE | Dedicated coding model |
| Context | 1,048,576 tokens | 256k (262,144 tokens) |
| Modalities | Native multimodal (incl. MoonViT-V2) | Text / image / video, thinking mode |
| Highspeed variant | — | kimi-k2.7-code-highspeed |
| Cache-hit / miss / out (per 1M) | $0.30 / $3.00 / $15.00 | $0.19 / $0.95 / $4.00 |
| Highspeed rates | — | $0.38 / $1.90 / $8.00 |
Official docs put K2.7 Code Highspeed at about 180 tok/s, up to 260 tok/s on short context. That is the day-to-day coding-agent lane: cheaper tokens, faster decode, 256k context.
Use K2.7 Code (or highspeed) for routine agent work — feature implementation, test writing, mechanical refactors, short-horizon tool loops where latency and bill size dominate. Use K3 when the task is long-horizon, needs the 1M window, or benefits from the broader agentic / multimodal stack Moonshot positions as frontier. The split is the same first-principles trade you already make between a flash-class and a flagship model: pay for depth only when the hard subtask needs it.
For another open-weight coding path and the same cost-vs-depth logic, see the DeepSeek V4 coding guide.
Why developers care: the price-performance math
Moonshot publishes coding scores on the Kimi-K3 Hugging Face model card (max effort). Treat them as vendor-reported standardized scores, not a guarantee for a given repository. Footnote context on the card: K3 is measured with the Kimi Code harness; the other columns are best-across-harnesses.
| Benchmark | Kimi K3 | Claude Fable 5 | GPT-5.6 Sol | Claude Opus 4.8 | GPT-5.5 | GLM-5.2 |
|---|---|---|---|---|---|---|
| Terminal-Bench 2.1 | 88.3 | 88.0 | 88.8 | 84.6 | 83.4 | 82.7 |
| DeepSWE | 67.5 | 70.0 | 73.0 | 59.0 | 67.0 | 46.2 |
| ProgramBench | 77.8 | 76.8 | 77.6 | 71.9 | 70.8 | 63.7 |
| SWE-Marathon | 42.0 | 35.0 | 39.0 | 40.0 | 14.0 | 13.0 |
| FrontierSWE | 81.2 | 86.6 | 71.3 | 66.7 | 64.9 | 67.3 |
On Terminal-Bench 2.1, K3 is 0.5 points behind GPT-5.6 Sol (88.8) and slightly above Claude Fable 5 (88.0). It leads the table on SWE-Marathon (42.0) and sits near the top of ProgramBench (77.8). It trails Fable 5 and GPT-5.6 Sol on DeepSWE, and trails Fable 5 on FrontierSWE. The useful reading is not “K3 wins coding” — it is that open weights land inside the same band as closed frontier models on several agentic coding measures.
Official Kimi API pricing for kimi-k3 (per 1M tokens, 1,048,576 context):
| Rate type | USD / 1M tokens |
|---|---|
| Cache-hit input | $0.30 |
| Cache-miss input | $3.00 |
| Output | $15.00 |
Together AI lists the same structure for moonshotai/Kimi-K3: input $3.00 / 1M, cached input $0.30 / 1M, output $15.00 / 1M. Moonshot’s tech blog claims cache hit rates above 90% in coding workloads; treat that as a Moonshot claim, not a measured result on your stack. If the claim holds for your harness, effective input cost moves toward the $0.30 hit rate and the math improves sharply on long runs with a stable system prompt and repo context.
Put the list rates next to K2.7 Code and a closed flagship. K2.7 Code cache-miss input is $0.95 and output $4.00 — roughly 3× cheaper miss input and ~4× cheaper output than K3. Claude Opus 5 standard API is $5 / $25 per the Anthropic announcement (context in Claude Opus 5 for coding). K3’s $3 / $15 sits between cheap coding siblings and top closed tiers: more expensive than K2.7 Code, cheaper on list input than Opus 5, and competitive if cache hits dominate.
Self-hosting is a separate cost line. Unsloth reports full-precision inference storage of about 1.56 TB, a 1-bit Unsloth Dynamic GGUF near 594 GB (about 62% smaller), and that those builds can run on an NVIDIA DGX Station or a Mac Studio connected to a 128GB RAM device. Attribute those figures to Unsloth, not Moonshot.
How to run Kimi K3 with SeaWork
SeaWork remote-controls the coding agents already running on your machine — Claude Code and Codex today. Kimi K3 is served by the official Kimi API (kimi-k3) and Together (moonshotai/Kimi-K3): configure an agent that supports custom endpoints (Codex with a custom provider config, for example) against the host that serves it, swap the model ID in when your provider ships it, and let SeaWork steer the local agent.
The product job is control, not model hosting. The daemon runs on your development machine. Your code, credentials, and MCP servers stay there. The phone is a control surface: watch every tool call, read the full conversation, redirect mid-run, and answer approval prompts that would otherwise freeze the session until you return to a desk. The optional relay is end-to-end encrypted; it forwards encrypted packets and does not hold the keys to your prompts or diffs.
Three commands show the loop:
seawork run --provider codex --model kimi-k3 "your task"
seawork ls -a
seawork logs <id> -fUse kimi-k3 when your Codex (or Claude) provider accepts that ID; on Together, the provider-specific ID is moonshotai/Kimi-K3. Start the agent on the machine with the repo, then pick the same session up on your phone. Long K3 runs are exactly when unattended tool loops go sideways — mid-run redirect and mobile approvals are the practical fix, not moving the repository into a hosted sandbox.
When Kimi K3 fits — and when to reach for Claude or GPT
Reach for Kimi K3 when you want open weights under the Kimi K3 License, a 1M context for large repos or long tool traces, and vendor-reported agentic coding scores that sit next to Fable 5 and GPT-5.6 Sol on Terminal-Bench 2.1 and ProgramBench. It also fits if you prefer API pricing with a cheap cache-hit tier ($0.30) and are willing to engineer for cache locality, or if you plan to self-host once Unsloth-class quantizations fit your hardware.
Reach for Kimi K2.7 Code when day-to-day coding agents should be cheaper and faster: $0.95 miss / $4.00 out (or highspeed at higher rates and ~180 tok/s), 256k context, thinking mode. Default the bulk of mechanical work there; escalate the hard long-horizon slice to K3.
Reach for Claude or GPT when your evaluation on your codebase favors them — for example Fable 5’s lead on FrontierSWE (86.6 vs K3’s 81.2) or GPT-5.6 Sol’s lead on DeepSWE (73.0 vs 67.5) and Terminal-Bench 2.1 (88.8 vs 88.3) — or when you already live in Claude Code / Codex workflows that those vendors optimize. Published tables narrow the shortlist; tests and review on the real repo decide.
The safe operating pattern is the same for any of them: scoped task, visible tool trajectory, tests as the gate, intervene early when the agent picks the wrong path. SeaWork exists so that intervention does not require a desk.
FAQ
When was Kimi K3 released?
Moonshot published full weights by July 27, 2026. The Hugging Face model card for moonshotai/Kimi-K3 shows lastModified on that date, and Together AI lists the same release day for its moonshotai/Kimi-K3 endpoint.
What is Kimi K3’s Terminal-Bench score? On the official Hugging Face model-card table at max effort, Kimi K3 scores 88.3 on Terminal-Bench 2.1. That is 0.5 points behind GPT-5.6 Sol (88.8) and slightly above Claude Fable 5 (88.0). K3 was measured with the Kimi Code harness; other columns are best-across-harnesses. Vendor-reported scores are not a promise for your repository.
How much does the Kimi K3 API cost?
Official Kimi pricing for kimi-k3 is $0.30 cache-hit input, $3.00 cache-miss input, and $15.00 output per million tokens, with a 1,048,576-token context. Together AI lists the same $3.00 / $0.30 / $15.00 structure for moonshotai/Kimi-K3. Moonshot claims cache hit rates above 90% in coding workloads; verify that against your traffic.
Can I run Kimi K3 locally?
Yes under the Kimi K3 License conditions. Weights are on Hugging Face (moonshotai/Kimi-K3). Unsloth reports ~1.56 TB full-precision inference storage, a ~594 GB 1-bit Dynamic GGUF (~62% smaller), and runnable setups on NVIDIA DGX Station or a Mac Studio paired with a 128GB RAM device. Hardware and license compliance are on you; large commercial MaaS use may need a separate Moonshot agreement.
Kimi K3 vs Claude for coding — which should I use? Use K3 when open weights, 1M context, or the $3/$15 (miss/output) price band matter, and your own evals hold. Prefer Claude (for example Opus 5 at $5/$25, or Fable 5 when its FrontierSWE and ecosystem fit justify it) when closed-model tooling or your measured results favor them. K2.7 Code remains the cheaper Moonshot default for everyday agent volume. Compare closed-flagship detail in Claude Opus 5 for coding.
Do I need a new API key to use Kimi K3 with SeaWork?
Point an agent that supports custom endpoints (such as Codex with a custom provider config) at the Kimi or Together host that serves the model, using kimi-k3 or moonshotai/Kimi-K3 as appropriate. SeaWork steers that local agent from desktop and phone, whichever endpoint serves the model. Credentials stay on your machine.
Where to start
Start with a bounded coding task against the official API or Together, model ID kimi-k3 (or moonshotai/Kimi-K3). Keep K2.7 Code for cheap high-volume agent work; escalate long-horizon or 1M-context jobs to K3. Judge results with your tests, not only the model-card table.
When a run is long enough to leave the desk, run the agent where the repository already lives and keep tool calls, conversation, and approvals on your phone with SeaWork — code and credentials stay local.
Download SeaWork to control local coding agents, or read the DeepSeek V4 coding guide and Claude Opus 5 for coding for adjacent open-weight and closed-flagship options.