Kimi or DeepSeek for building apps?
Neither wins outright, because Kimi and DeepSeek are shaped for different jobs. DeepSeek V4 ships under MIT across code and weights, in two sizes, with a published rate card, and DeepSeek V4 Flash built the best-looking app of its TSK-1 test (Aug 1, 2026). Kimi K3 is far larger at 2.8 trillion total parameters, 104 billion used per token, under Moonshot's bespoke Kimi K3 License. Pick DeepSeek when license simplicity and cost per token dominate. Pick Kimi when you want the largest open-weight model and are comfortable reading a vendor-specific license.
What TSK-1 Found
TSK-1 has tested DeepSeek several times and Kimi on Jul 31, 2026, and the two win on different things. DeepSeek V4 Flash built the best-looking app of its test at a fraction of what the rest of the field cost (Aug 1, 2026), and on Aug 3, 2026 it was the cheapest, the fastest, and the cleanest all at once. DeepSeek V4 Pro is the best we have measured at holding your information (Aug 6, 2026: 60 separate fields captured, 8 automations). Kimi K3's steps failed least often of the models tested on Jul 31, 2026 (7.2%).
- DeepSeek: Aug 1, 2026 — best-looking app of its test. Aug 3, 2026 — cheapest, fastest, and cleanest all at once. Aug 6, 2026 — best at holding your information (60 separate fields captured).
- Kimi: Jul 31, 2026 — fewest failed steps (7.2%), fewest steps overall, most accurate account of its own work.
See the full evidence at /tsk/deepseek, /tsk/kimi, and the TSK-1 hub.
The Headline
The context argument is over, and the license argument replaced it. For most of the last two years the clean split between these two families was window size. That is finished: Kimi K3 specifies 1,048,576 tokens and both DeepSeek V4 models reach 1 million. Whatever you are choosing on now, it is not reach.
What actually separates them is distribution terms and scale. DeepSeek V4 is MIT across both code and weights — about as few strings as open weights come with — in two sizes, with a published rate card you can budget against today. Kimi K3 is much larger at 2.8 trillion total parameters, 104 billion of them used per token, and ships under Moonshot's own bespoke Kimi K3 License, which permits self-hosting but is not a standard open-source license and deserves a read before you build a business on redistributing it.
TL;DR: DeepSeek V4 is the permissive, priced, plannable option: MIT weights,
deepseek-v4-flashat $0.44/$1.32 per 1M at peak anddeepseek-v4-proat $1.32/$3.96, both at 1M context. Kimi K3 is the larger open-weight option at 2.8T total, 104B active, and a 1,048,576-token context, under a bespoke license.
If Your DeepSeek Integration Broke in July, Read This First
Three breaking changes landed with the V4 generation, and each one silently invalidates older documentation.
- V3 and R1 are gone, and there is no R2. The generation is DeepSeek-V4.
deepseek-chatanddeepseek-reasonerwere retired and became inaccessible on 24 July 2026. If calls started failing then, this is why. The production ids aredeepseek-v4-flashanddeepseek-v4-pro, plus an experimentaldeepseek-v4-flash-vision-exp.- Reasoning is no longer a separate model. Thinking is a mode inside V4. Instead of routing to a reasoner endpoint, you set reasoning effort —
low,high, ormax— ondeepseek-v4-flash.
Any guide that tells you to send hard problems to deepseek-reasoner is describing an API that no longer exists.
The Routing Matrix
The useful question is never "which model is best". It is "which model for this step, and what does that choice cost".
| Task | Reach for | Why | Cost consequence |
|---|---|---|---|
| High-volume classification, tagging, extraction | deepseek-v4-flash |
Fewest parameters used per token here, cheapest published rate | $0.44 in / $1.32 out per 1M at peak, $0.22 / $0.66 off-peak |
| The same prompt prefix, thousands of times | deepseek-v4-flash with caching |
Cache hits are billed separately | $0.014 per 1M on a hit at peak ($0.007 off-peak) — about 31× below a miss |
| Harder reasoning without changing endpoints | deepseek-v4-flash at higher reasoning effort |
Thinking is a mode, dialled per request | You pay for extra thinking tokens, not a different rate |
| Heavier synthesis and long-form reasoning | deepseek-v4-pro |
1.6T total / 49B active | $1.32 in / $3.96 out at peak — exactly 3× flash, uniformly |
| Repeated long-context reads over a stable corpus | deepseek-v4-pro with caching |
Cache hit is dramatically cheaper | $0.044 per 1M on a hit at peak ($0.022 off-peak) — exactly 30× below a miss |
| Batch work with no latency deadline | Either DeepSeek model, scheduled off-peak | Peak is only 01:00–04:00 and 06:00–10:00 UTC, Mon–Fri | 50% off input and output |
| Whole-repo or whole-corpus ingest | Either family | Both reach ~1M tokens | Watch the 384K max-output ceiling on DeepSeek |
| Image plus text input | Kimi K3 | K3 is production image-text-to-text; DeepSeek's vision id is still experimental | Image tokens bill as input tokens |
| Dedicated coding agents | Kimi K2.7 Code, or deepseek-v4-pro |
K2.7 Code is a 1T model built for coding | Kimi rates: read at platform.kimi.ai |
| Maximum open-weight capacity | Kimi K3 | 2.8T total with 104B active is the largest here | Self-hosting it is a serious multi-GPU commitment |
| Redistributing a fine-tune commercially | DeepSeek | MIT across code and weights | Effectively no license-driven cost |
| On-premise or region-locked deployment | Either | Both publish weights | Infrastructure cost replaces API cost |
Two structural notes on that table. First, caching is a bigger lever than model choice on DeepSeek — a roughly 31× gap on flash and an exactly 30× gap on pro between hit and miss dwarfs the flat 3× gap between flash and pro, so restructure prompts around a stable prefix before you shop for a cheaper model. Second, the clock is a lever too: DeepSeek bills off-peak at exactly half the peak rate, and peak is a narrow window — 01:00 to 04:00 and 06:00 to 10:00 UTC, Monday to Friday. Anything you can queue outside those hours, including all weekend work, is a 50% saving for zero engineering. Every figure above is the published rate as of August 2026.
License: MIT vs Bespoke
This is the row most head-to-head write-ups get wrong, including earlier versions of this page.
| Dimension | Kimi K3 | DeepSeek V4 |
|---|---|---|
| License name | Kimi K3 License — Moonshot's own | MIT |
| Covers the code repository | ✅ Yes | ✅ Yes |
| Covers the model weights | ✅ Yes | ✅ Yes |
| Standard permissive open-source terms | ✗ No — bespoke vendor terms | ✅ Yes |
| Weights downloadable | ✅ Yes | ✅ Yes |
| Self-host | ✅ Yes, license permitting | ✅ Yes |
| Fine-tune | ✅ Yes | ✅ Yes |
| Redistribute a fine-tune | ⚠️ Read the license first | ✅ Yes, retain the copyright notice |
| Legal review before commercial redistribution | Yes | Minimal — MIT is well understood |
Stated plainly: DeepSeek V4 has the most permissive terms on this page, and MIT across both code and weights is unusually clean. Kimi K3's weights are downloadable and self-hostable, which is a real and meaningful freedom, but it comes under a vendor-specific license your legal team should read before redistributing. Those are not the same thing, and treating them as equivalent is how teams end up with a compliance surprise.
The wider 2026 picture: DeepSeek sits at MIT, Qwen's open weights are Apache 2.0, Kimi K3 sits on its own bespoke terms, and the closed frontier labs ship no weights at all. Kimi is meaningfully more open than a closed model and meaningfully less standardized than DeepSeek.
Architecture: Scale vs Efficiency
Both families are mixture-of-experts, and in both cases the number of parameters used per token is what you actually pay to run. Kimi K3 uses 104 billion of its 2.8 trillion parameters per token. DeepSeek V4 Pro uses 49 billion of 1.6 trillion, and V4 Flash uses roughly 13 billion. That last number is why Flash is cheap, and it lines up with the flat 3× price gap between Flash and Pro on both input and output.
Kimi's published detail goes further than DeepSeek's. Its 93 layers split into 69 Kimi Delta Attention layers — a linear-cost variant — and 24 gated multi-head latent attention layers, over a 160,000-token vocabulary. Moonshot makes stronger comparative claims about how that hybrid performs against full attention. Those are vendor claims; benchmark on your own workload before designing around them.
Speed and Serving: Kimi K3 vs DeepSeek V4
Both families are mixture-of-experts models, and for both the host sets the speed as much as the weights do. Artificial Analysis measured output speed per API endpoint (medians on a 10,000-token input, checked 2026-10-20). Kimi K3 ran from about 32 to about 422 output tokens per second across 17 endpoints. DeepSeek V4 Pro ran from about 56 to about 317 across 10. Moonshot's own API sat near the slow end at about 42, 16th of 17. DeepSeek's own API sat mid-pack at about 107, 5th of 10.
| Serving signal | Kimi K3 | DeepSeek V4 |
|---|---|---|
| Parameters used per token | 104B | Pro 49B, Flash about 13B |
| Output speed range across hosts (Artificial Analysis, 2026-10-20) | About 32 to 422 tokens/s, 17 endpoints | V4 Pro: about 56 to 317 tokens/s, 10 endpoints |
| First-party API speed (2026-10-20) | Moonshot about 42 tokens/s | DeepSeek about 107 tokens/s |
| Hosts listed by models.dev | 15, including Baseten, Nebius and Together AI | V4 Pro: 8, and 13 for its August 2026 release, including Baseten and Nebius |
| TSK-1 build time | Finishes later than every other model tested | V4 Flash was the fastest of its test (Aug 3, 2026) |
| Speed rating in Taskade | Slow | V4 Pro: Fast |
| In Taskade on Taskade credits | Max and Enterprise | V4 Pro on every paid plan |
Two serving notes follow from the architecture. Kimi K3's weights ship natively in MXFP4 at about 1.56 TB, which fits one 8-GPU B300 node but not an 8-GPU B200 node, so a host that serves it from one node needs the newest GPUs. K3's 69 Kimi Delta Attention layers also keep a fixed-size state per conversation instead of a growing cache, which changes how a host reuses a cached prompt. Speed figures move week to week, so re-check the Kimi K3 and DeepSeek V4 Pro provider pages before you pick a host. For no-code builders that run either family, see builders that run open-weight models.
Choose DeepSeek If…
A comparison that never concedes anything is not worth reading. DeepSeek is the better buy in several common cases.
- You want the simplest possible license. MIT across code and weights removes an entire category of legal review. For a startup shipping a fine-tuned model, that is worth more than any benchmark delta.
- You need a price you can put in a spreadsheet. DeepSeek publishes cache-miss input, cache-hit input, output and off-peak rates for both models. Budgeting against a published rate card beats estimating against one you cannot see.
- Your volume is high and your prompts repeat. The cache-hit economics — about 31× off on flash, 30× off on pro — stacked on the flat 50% off-peak discount are the strongest cost story on this page by a wide margin, and neither lever requires changing model.
- You want a model you can realistically host. At roughly 13 billion parameters per token, V4 Flash is a far more approachable self-hosting target than a 2.8-trillion-parameter model.
Choose Kimi If…
- You want the largest open-weight model available. 2.8 trillion total with 104 billion active is the top of the open-weight range, and capacity of that order is not otherwise downloadable.
- Your inputs include images. Kimi K3 is multimodal, taking image and text input.
- Coding is the whole job. Kimi K2.7 Code is a 1-trillion-parameter model built specifically for it.
- You are comfortable with vendor-specific terms. If you are self-hosting internally rather than redistributing, the bespoke license is a far smaller obstacle than it is for a company reselling inference.
Self-Host vs Managed Gateway
Both publish weights, so both can run on your hardware. The economics still favor a managed gateway for most teams, and the hardware ask varies wildly across these models.
| Kimi K3 | deepseek-v4-pro |
deepseek-v4-flash |
Taskade | |
|---|---|---|---|---|
| Weights available | ✅ Yes | ✅ Yes | ✅ Yes | Managed routing |
| License friction | ⚠️ Bespoke, read it | ✅ MIT | ✅ MIT | None for you |
| Parameters used per token | 104B | 49B | ~13B | n/a |
| Realistic hardware | Serious multi-GPU | Multi-GPU | The approachable one | None |
| Cost shape self-hosted | Fixed infrastructure + ops | Fixed infrastructure + ops | Fixed, smallest | Included in the subscription |
| Metered alternative | Read platform.kimi.ai | $1.32 / $3.96 per 1M peak | $0.44 / $1.32 per 1M peak | Included |
The decision rule is unglamorous. Below sustained high volume, a metered API or a managed gateway wins on every measure except control. Above it, self-host the smallest model that clears your quality bar — which is very often Flash, not the biggest thing you can download. And if data residency is the requirement, this stops being a cost decision at all.
The Taskade Angle: Route, Don't Standardize
Most comparison pages end with "pick one". Teams running this in production run several and route between them.
Taskade runs frontier models from top AI labs inside one workspace, with the AI allowance included in the subscription rather than a separate metered account with each lab. DeepSeek V4 Pro runs on Taskade credits on every paid plan. Kimi K3 runs on Taskade credits on Max and Enterprise, and on Business and up a Together AI key lets custom agents and Ask Agent pick Kimi K3 (see which models each key serves). Paid plans start at Pro $10/mo billed annually, with Business $25, Max $100 and Enterprise $250 per month billed annually. Routing is managed centrally and updates as new models ship — which matters more than usual in a year when a whole generation of model ids was retired inside a fortnight.
Four patterns that hold up:
- Cheap model triages, larger model resolves. Bulk classification and extraction run on the smallest capable model. Only escalations reach a larger one.
- Long-context ingest, short-context reasoning. One step reads the corpus. The next reasons over a distilled summary at a fraction of the tokens.
- Stable prefix, cached. Structure prompts so the invariant part is byte-identical every call. On DeepSeek that alone is a 30× to 31× difference on the cached portion, and scheduling the run off-peak halves the rest.
- Everything behind Workspace DNA. Whichever model runs a step, the output lands in the same project graph, so the next agent inherits context instead of re-deriving it, and scheduled automations read from the same place.
See 10 Best Open-Source AI LLMs in 2026 for where the rest of the open-weight field sits.
Frequently Asked Questions
Is Kimi better than DeepSeek?
They are shaped for different jobs, and the honest split is by license and by scale rather than by a leaderboard. DeepSeek V4 ships under the MIT License across both the code repository and the model weights, in two sizes, with published per-token pricing. Kimi K3 is far larger at 2.8 trillion total parameters with 104 billion active per token, and ships under Moonshot's own bespoke Kimi K3 License. Both reach a 1 million token context. Pick DeepSeek when license simplicity and cost per token dominate. Pick Kimi when you want the largest open-weight model available and are comfortable reading a vendor-specific license.
What happened to DeepSeek V3 and R1?
They are gone. The current generation is DeepSeek-V4, and there is no R2. The older deepseek-chat and deepseek-reasoner API model ids were retired and became inaccessible on 24 July 2026, so an integration still calling them is broken rather than merely outdated. The two production model ids are deepseek-v4-flash and deepseek-v4-pro, alongside an experimental vision id, deepseek-v4-flash-vision-exp, that shares Flash's rate card. If requests started failing in late July, that retirement is almost certainly why.
Is reasoning a separate DeepSeek model now?
No. Thinking is a mode inside V4 rather than a distinct model, which is the biggest structural change from the older lineup where a separate reasoner endpoint existed. The deepseek-v4-flash model exposes a reasoning-effort control with low, high and max settings, so you dial how much the model thinks per request instead of switching endpoints. Any guide written before the V4 generation that tells you to route hard problems to a separate reasoning model no longer describes the API.
How much does DeepSeek V4 cost?
DeepSeek prices V4 on a two-rate clock, so the honest answer is a range rather than a single number. At peak, deepseek-v4-flash is $0.44 per 1 million tokens for a cache miss on input and $1.32 for output. Off-peak it is exactly half that, $0.22 and $0.66. The larger deepseek-v4-pro is $1.32 for a cache miss on input and $3.96 for output at peak, and $0.66 and $1.98 off-peak. Peak hours run 01:00 to 04:00 and 06:00 to 10:00 UTC, Monday to Friday; everything outside those windows, including all weekend traffic, bills at the off-peak half rate. Cache hits are billed separately and are dramatically cheaper: on deepseek-v4-flash an input cache hit is $0.014 per 1 million tokens at peak and $0.007 off-peak, and on deepseek-v4-pro it is $0.044 at peak and $0.022 off-peak. That is roughly 31 times cheaper than a cache miss on flash and exactly 30 times cheaper on pro, at either rate. These are the figures published as of August 2026.
How much does Kimi K3 cost per token?
Moonshot AI publishes Kimi's API rates on its developer platform at platform.kimi.ai, and this page deliberately does not quote a figure, because a per-token price copied into a comparison page starts aging the day it is written. Read it at the source. Note that the older platform.moonshot.ai address now redirects to platform.kimi.ai, so update any integration base URL still pointing at the old host. Because K3's weights are downloadable, the model also has a self-hosting cost floor that a metered API alone does not describe.
Are both Kimi and DeepSeek MIT-licensed?
No, and this is the most commonly repeated error about these two models. DeepSeek V4 is MIT-licensed across both the repository and the model weights, which is about as permissive as open weights get. Kimi K3 is released under a bespoke Kimi K3 License that covers both the code and the weights, and it is neither MIT nor Apache 2.0. Modified MIT applied to the earlier Kimi K2 line and does not carry forward to K3. K3's weights remain downloadable and self-hostable, but a vendor-specific license is not interchangeable with a standard one, so have someone read it before you redistribute a fine-tune or resell inference.
Which has the longer context window?
Neither. Both DeepSeek V4 models and Kimi K3 reach roughly 1 million tokens, with Kimi K3 specified at 1,048,576 tokens and both DeepSeek V4 models at 1 million with a maximum output of 384,000 tokens. Context length used to be the clean dividing line between these two families and it no longer is. Choose on license, on parameter scale, and on cost per token instead.
How big are these models?
Kimi K3 is a mixture-of-experts model at 2.8 trillion total parameters with 104 billion used per token, routing across 896 experts with 16 routed plus 2 shared per token, across 93 layers split into 69 Kimi Delta Attention layers and 24 gated multi-head latent attention layers. DeepSeek V4 Pro is 1.6 trillion total with 49 billion used per token. DeepSeek V4 Flash is smaller, with vendor sources giving roughly 284 to 304 billion total parameters and 13 billion used per token. In every case the number used per token, not the total, is what drives running cost.
Which is cheaper to run for high-volume work?
DeepSeek publishes the numbers, so it is the side you can plan against. Within the V4 family, flash is uniformly one third the price of pro on both input and output. Two larger levers sit on top of that. Caching: an input cache hit bills at $0.014 per 1 million tokens on flash and $0.044 on pro at peak, roughly 31 and exactly 30 times below the respective cache-miss rates, so if your workload repeats a long stable prefix, restructuring prompts to hit cache changes the bill far more than switching models does. And the clock: off-peak billing is exactly half the peak rate, and peak covers only 01:00 to 04:00 and 06:00 to 10:00 UTC on weekdays, so batch work scheduled outside those windows costs half for no code change. For Kimi, the equivalent lever at very high sustained volume is self-hosting, which converts per-token spend into fixed infrastructure spend.
Can I self-host either model?
Both publish downloadable weights, so both are technically self-hostable, but the licenses are not equivalent and neither is the hardware ask. DeepSeek's MIT license is the more permissive of the two and imposes essentially no commercial conditions. Kimi K3's bespoke license permits self-hosting but should be read before redistribution. On hardware, a 2.8-trillion-parameter model is a serious multi-GPU deployment, while DeepSeek V4 Flash at roughly 13 billion parameters per token is the far more approachable starting point of the models discussed here.
Can I use Kimi and DeepSeek together inside Taskade?
Yes, on the right plan. Taskade runs frontier models from top AI labs inside one workspace, with the AI allowance included in the subscription rather than a separate metered account with each lab. DeepSeek V4 Pro runs on Taskade credits on every paid plan. Kimi K3 runs on Taskade credits on Max and Enterprise, and on Business and up a Together AI key lets custom agents and Ask Agent pick Kimi K3. A common pattern is running bulk classification and extraction on a cheap high-throughput model and reserving a larger model for the steps that need it, with every result landing in the same project graph so the next agent inherits the context.
Which Kimi and DeepSeek models are live right now?
On the DeepSeek side there are two production API model ids, deepseek-v4-flash and deepseek-v4-pro, plus an experimental vision id, deepseek-v4-flash-vision-exp, which bills on Flash's rate card and carries no separate stability or availability guarantee. Route production traffic between the two production tiers and treat the -exp id as a preview. Those are the ids listed as of August 2026. On the Moonshot side, Kimi K3 is the flagship, alongside Kimi K2.7 Code at 1 trillion parameters aimed specifically at coding, plus Kimi K2.6 and Kimi K2.5, also at 1 trillion. Separately, Moonshot set a full platform sunset for its older V1 series on 31 August 2026, so anything still pinned to a V1 endpoint needs migrating.
Final Word: Same Reach, Different Terms
Both of these families now reach a million tokens of context and both publish downloadable weights. The comparison that mattered in 2025 — whose window is longer — has resolved into a tie.
What is left is terms and scale. DeepSeek V4 is MIT, priced, and plannable, with a small model cheap enough to change how you architect high-volume work, cache economics around 30× on both tiers, and an off-peak rate at exactly half of peak. Kimi K3 is the largest open-weight model here, multimodal, with a published architecture and a license that is permissive in practice but bespoke on paper.
Neither is the winner. The winner is the setup that routes each step to the right one and can change its mind next quarter without a migration.
▲ Memory feeds Intelligence. ■ Intelligence triggers Execution. ● Execution creates Memory. Two open-weight families. One workspace. No single point of vendor failure.
This is the origin of living software. 🌱
Build with open-weight models side by side →
Related reading
- 10 Best Open-Source AI LLMs in 2026. The full open-weight ranking.
- Kimi vs Claude. Open weights versus a closed frontier family.
- Qwen vs DeepSeek. Apache 2.0 versus MIT, head to head.
- Multi-Model AI Access. How Taskade routes across providers.
- Multi-Agent Teams. Specialists with different model picks.
- Taskade MCP Server. Connect any MCP-compatible IDE to your workspace.
- Bring Your Own Key. Key routing options on Pro and up.
- TSK-1 DeepSeek profile — Full benchmark evidence for the DeepSeek family.
- TSK-1 Kimi profile — Full benchmark evidence for the Kimi family.
- TSK-1 hub — The complete model benchmark dataset.
