⏱️ Lectura: 11 min
Moonshot AI completely redesigned kimi.com and now splits its assistant into three separate products: Kimi Work, Kimi Code, and Kimi Claw, all running on the Kimi K3 model. The interface change replaces the previous single chat with an offering segmented by task.
📑 En este artículo
The Chinese company, the same one behind the Kimi K2 and K2.6 models that already held a prominent spot among open models on coding benchmarks, is now betting that users won’t pick a model but a product: writing a report, generating code, or letting an agent run scheduled tasks without constant supervision.
TL;DR
- Moonshot AI relaunched kimi.com organized into three products: Kimi Work, Kimi Code, and Kimi Claw, all on the Kimi K3 model.
- The platform adds Scheduled Tasks and a plugin system visible in the main menu.
- Kimi Code targets agentic coding: generate, run, and fix code within the same agent flow.
- Kimi Claw focuses on autonomous web tasks that run without constant supervision thanks to scheduled tasks.
- Kimi Work offers the general knowledge assistant to write, summarize, and analyze documents.
- Moonshot AI has not yet published a spec sheet with Kimi K3’s parameter count.
- The Kimi API remains compatible with OpenAI’s format, which lets you reuse existing SDKs.
- Its direct predecessors, Kimi K2 and K2.6, already ranked among the standout open models on code benchmarks.
What happened
As soon as it opens, kimi.com now shows three shortcuts with their own names: Kimi Work, Kimi Code, and Kimi Claw. Alongside them, the main menu now features the Plugins and Scheduled Tasks sections, two features that previously had no visible place in the Kimi interface.
Kimi Work concentrates the assistant’s general use: writing text, summarizing documents, and answering knowledge questions, Kimi’s original function since its earliest versions. Kimi Code positions itself as the product built for agentic coding, in the same category as Anthropic’s Claude Code, GitHub’s Copilot Workspace, or Cursor. Kimi Claw completes the trio with a focus on web automation: tasks an agent runs on its own, recurrently, thanks to the scheduled tasks system.
Moonshot AI didn’t pair the relaunch with an extensive technical release or a benchmark sheet for K3. The information available at the time of this piece comes from the site’s own public interface, without a paper or technical report equivalent to the one the company published for K2.
Context and history
Moonshot AI is the Chinese startup behind the Kimi model family, known for releasing open weights under an MIT-derived license. Kimi K2, launched in 2025, uses a mixture-of-experts (MoE) architecture with a total parameter count far larger than what activates on each inference, a design that lowers the compute cost per token without sacrificing the model’s total capacity. Moonshot documented that architecture and the use of the Muon optimizer in the repositories it maintains on GitHub.
The K2.6 update deepened that agentic bet: even then the model stood out on open-source coding benchmarks, something this channel covered at the time. Kimi K3 arrives as the next step in that line, but with a shift in product strategy rather than a simple version bump: instead of offering a generic chat, Moonshot packages the model into three specialized surfaces.
That move follows a trend other labs already set: separating the conversational assistant from the code agent, and in turn separating the code agent from the agent that browses and acts on the web without direct supervision. Kimi Work, Kimi Code, and Kimi Claw mirror that split into three products with their own names.
Technical details and performance
As of this writing, Moonshot AI had not published a Kimi K3 spec sheet with parameter count, context size, or benchmark results. What can be described with certainty is the technical lineage it rests on: Kimi K2 uses an MoE architecture with a reduced fraction of active parameters per token, trained with the Muon optimizer, and exposes its API under an OpenAI-compatible format.
That API compatibility is the most relevant piece for anyone who wants to integrate Kimi K3 today: any code written against the OpenAI SDK works against Moonshot’s endpoint by changing just the base URL and the API key. It’s the same pattern other providers already use to reduce adoption friction.
⚠️ Heads up: Moonshot AI has not published a spec sheet with the parameter count or official benchmarks for Kimi K3 as of this piece; the architecture details described above correspond to K2 and K2.6, its confirmed predecessors.
The table below summarizes what each product in the new family solves:
| Product | What it’s for | Advantage | Limitation |
|---|---|---|---|
| Kimi Work | Write, summarize, and analyze general knowledge documents | Simple interface, built for non-programmers | Less fine-grained control over tools and code execution |
| Kimi Code | Agentic coding: generate, run, and debug code | Integrates tool calling built for development flows | Requires the user to properly define the available tools |
| Kimi Claw | Automate web tasks and scheduled tasks | Can operate without constant supervision thanks to Scheduled Tasks | Higher risk of unwanted actions if the agent browses without clear limits |
Kimi Code is the one that comes closest to the agentic coding category the platform’s own tagline promises: an agent that not only suggests code but runs it, runs tests, and fixes the result within the same flow, using tool calling in OpenAI’s standard function-calling format. Kimi Claw, by contrast, targets tasks that go beyond code: monitoring something, generating a periodic report, all scheduled with Scheduled Tasks to run without the user triggering each execution by hand.
How to try Kimi K3
To experiment with Kimi K3 today you don’t need to wait for an official API announcement: Moonshot exposes its models under an OpenAI-compatible endpoint, which lets you reuse the official Python SDK or any HTTP client.
The first step is to set the API key as an environment variable. The syntax changes depending on the operating system:
- macOS and Linux (bash/zsh):
export MOONSHOT_API_KEY="sk-your-key" - Windows (PowerShell):
$env:MOONSHOT_API_KEY = "sk-your-key" - Windows (cmd):
set MOONSHOT_API_KEY=sk-your-key
With the key set, a minimal curl call is enough to confirm the endpoint responds:
curl https://api.moonshot.ai/v1/chat/completions \
-H "Authorization: Bearer $MOONSHOT_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "kimi-k3",
"messages": [{"role": "user", "content": "Hi Kimi, introduce yourself in one line"}]
}'This example assumes Moonshot exposes K3 under an identifier like kimi-k3; confirm the exact model name in your account before integrating it into production. For a more realistic agentic coding case, the OpenAI Python SDK pointed at Moonshot’s endpoint lets you define tools the model can invoke, such as running a test suite:
from openai import OpenAI
client = OpenAI(
api_key="YOUR_MOONSHOT_API_KEY",
base_url="https://api.moonshot.ai/v1",
)
response = client.chat.completions.create(
model="kimi-k3",
messages=[
{"role": "system", "content": "You are a Kimi Code agent that fixes bugs in Python."},
{"role": "user", "content": "This script fails with ZeroDivisionError, fix it: def divide(a, b): return a / b"},
],
tools=[{
"type": "function",
"function": {
"name": "run_tests",
"description": "Runs the repo's test suite and returns the result",
"parameters": {"type": "object", "properties": {}, "required": []},
},
}],
)
print(response.choices[0].message)This pattern, a system message that defines the agent’s role plus a list of tools, is the same one Kimi Code and other coding agents use to decide when to run an action instead of just returning text. To confirm the account has access to the K3 model and not an earlier version, it’s a good idea to list the available models before integrating it into production:
curl https://api.moonshot.ai/v1/models -H "Authorization: Bearer $MOONSHOT_API_KEY"and check that the K3 identifier appears in the response.
💡 Tip: Before pointing your OpenAI SDK at Moonshot’s endpoint, run the call to /v1/models to confirm the exact identifier of the K3 model available in your account; model names often change between announcements and real API availability.
Impact and analysis
Moonshot AI’s bet arrives at a moment when the code-agent category already has established players: Anthropic’s Claude Code, GitHub’s Copilot Workspace, Cursor, and Windsurf compete for the same type of user, a developer who wants to delegate not just the code suggestion but the full execution of a task.
Separating Kimi Work from Kimi Code and Kimi Claw simplifies the product message: each surface promises one concrete thing instead of a generic assistant that does everything. The trade-off is that a user who wants to combine the three functions in a single flow (writing a report that also runs code and schedules an automatic follow-up) has to move between three different products instead of one.
Another real limitation: without a public spec sheet for K3, a team evaluating the platform for production has no way to objectively compare the cost per token, the context size, or performance against K2.6 or against models from other providers. Migrating an agent flow to Kimi Claw, in particular, requires trusting a model that browses and acts on the web when the company hasn’t yet published what safety limits it applies to those actions.
The following diagram summarizes what a Kimi Claw scheduled task looks like in practice:
sequenceDiagram
participant U as User
participant K as Kimi Claw
participant W as Target website
participant N as Notification
U->>K: schedules recurring task
K->>W: browses and runs the action
W-->>K: returns result
K-->>N: sends summary to the user
Note over U,K: the task repeats on the defined scheduleWhat’s next
Open questions remain that only Moonshot AI can answer with a formal announcement: whether K3 keeps K2’s MoE architecture, whether the parameter count changed, and whether the model will remain available with open weights like its predecessors. There is also, for now, no public pricing table for Kimi Work, Kimi Code, or Kimi Claw as separate products.
What is predictable from the pattern K2 and K2.6 followed: if Moonshot keeps its open-weights strategy, it’s reasonable to expect that at some point it will publish a repository and a technical report for Kimi K3 in its GitHub organization, as it did with the earlier versions.
📖 Summary on Telegram: View summary
Try it yourself: go to kimi.com, open Kimi Code, and ask it to fix a real bug in your repo to see the tool-calling flow in action today.
Frequently Asked Questions
What is Kimi K3?
It’s the model behind Moonshot AI’s new generation of products, the shared foundation of Kimi Work, Kimi Code, and Kimi Claw introduced in the kimi.com redesign.
How do Kimi Work, Kimi Code, and Kimi Claw differ?
Kimi Work targets general knowledge tasks like writing and summarizing, Kimi Code targets agentic coding with code execution, and Kimi Claw targets web automation with scheduled tasks.
Is the Kimi K3 API compatible with the OpenAI SDK?
Yes. Moonshot exposes its models under an OpenAI-compatible API format, which lets you reuse the official SDK by changing the base URL and the API key.
How many parameters does Kimi K3 have?
Moonshot AI has not published that figure as of this piece. Its predecessor, Kimi K2, uses a mixture-of-experts architecture with a fraction of active parameters per token, documented in the company’s repository on GitHub.
Is Kimi K3 an open-weights model?
It’s not confirmed yet. K2 and K2.6 were released with open weights under an MIT-derived license; Moonshot hasn’t clarified whether it will keep that policy with K3.
What are Kimi Claw’s Scheduled Tasks?
It’s the system that lets you schedule a task for the agent to repeat on a defined schedule, without the user having to trigger each execution manually.
References
- Kimi AI: official page presenting the K3 platform with Kimi Work, Kimi Code, and Kimi Claw.
- Moonshot AI on GitHub: repositories where the company published the open weights of the Kimi K2 family.
- Moonshot AI Platform: documentation for the OpenAI-compatible API used to integrate the Kimi models.
- Wikipedia: Moonshot AI: general context on the company and its Kimi model line.
📱 Enjoying this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day. @programacion
Featured image: Photo by Caspar Camille Rubin on Unsplash
0 Comments