待翻译：I Tried Kimi Agent and Here’s What I Found

AI 服务暂时不可用，以下为来源正文，待恢复后补全翻译。

--> I Tried Kimi Agent and Here’s What I Found - KDnuggets --> Join Newsletter "Kimi Agent" isn't one product; it's a name that's come to cover a sprawling family, and untangling it matters before judging any piece of it. Kimi K3 is the underlying model: a 2.8-trillion-parameter mixture-of-experts (MoE) model (16 of 896 experts active per token) with a 1-million-token context window, developed by Moonshot AI, a Beijing-based lab backed by Alibaba. Agent Swarm is the architecture built on top of it — a system that can spin up dozens or hundreds of coordinated sub-agents on a single task rather than working through it sequentially. Goal is the feature for autonomous multi-step objectives: set a plain-language target and the agent plans and executes toward it. OK Computer is the agent mode built directly into Kimi's chat interface, generating multi-page sites and slide decks from a single prompt. Kimi Work, launched June 10, 2026, is a separate desktop app for macOS (Apple Silicon) and Windows that acts directly on your computer through a browser-control extension called WebBridge, searching, scrolling, and filling out forms the way a person would. Kimi Claw is the cloud counterpart that keeps tasks running when your machine goes to sleep, since Kimi Work's local tasks otherwise stop the moment the laptop lid closes. Kimi Code is the dedicated coding command-line interface (CLI). The Architecture Claim: Agent Swarm Agent Swarm is the headline feature, and Moonshot's own description of it is genuinely more specific than most vendor marketing. It first shipped January 27, 2026 alongside Kimi K2.5, described as a scale-out architecture that coordinates sub-agent collaboration without predefined roles or manually designed workflows. The April 20, 2026 release of K2.6 gave it a real capacity jump: up to 300 simultaneous sub-agent instances and more than 4,000 tool calls in a single task, with Moonshot claiming a 4.5x speed advantage over a single agent working the same task sequentially. Agent Swarm now runs on K3 as well, with Moonshot describing further improvements to large-scale parallel search without publishing new capacity numbers beyond the K2.6 figures. What's unusually candid here — and worth crediting directly — is that Moonshot documents its own two failure modes for this architecture rather than only the wins: serial collapse, where the orchestrator fans work out but the sub-agents end up blocking on each other anyway, and fake parallelism, where work looks distributed but isn't actually independent enough to benefit from it. That's a genuinely useful decision framework for anyone deciding whether to fan a task out at all, not just a Kimi-specific caveat, and it's rare for a vendor to publish its own failure taxonomy alongside the capability numbers. Getting Started and Trying It Here's what I could verify directly, without a paid plan. Signing up at kimi.com takes a Google account and about ten seconds, no credit card required to start. The free tier gets you real functionality, but it's genuinely limited: according to a hands-on review from TechRadar Pro, the free tier caps you to one concurrent agent task at a time, and the full agentic feature set — meaning real use of Agent Swarm at scale — only unlocks at $39 a month and above. That's a meaningful gate if the swarm architecture is specifically what drew you in, since a single concurrent task rather defeats the point of parallel sub-agents. Hands-On With the API Moonshot's Kimi API is OpenAI-compatible, which means the standard openai Python SDK works against it with only the base URL and model name changed. Prerequisites: Python 3.9+ Moonshot API key from platform.moonshot.ai, and pip install openai export MOONSHOT_API_KEY=your-key-here # run_task.py import os import json from openai import OpenAI client = OpenAI( api_key=os.environ["MOONSHOT_API_KEY"], base_url="https://api.moonshot.ai/v1", ) MODEL = "kimi-k3" TOOLS = [{ "type": "function", "function": { "name": "count_words", "description": "Counts the number of words in a block of text.", "parameters": { "type": "object", "properties": {"text": {"type": "string"}}, "required": ["text"], }, }, }] def count_words(text: str) -> int: return len(text.split()) def run_task(task: str, max_turns: int = 6) -> dict: """Runs a task through Kimi K3, executing any tool calls it makes, and returns a small report of what happened.""" messages = [{"role": "user", "content": task}] total_prompt_tokens = 0 total_completion_tokens = 0 turns_used = 0 for turn in range(max_turns): turns_used = turn + 1 response = client.chat.completions.create( model=MODEL, max_tokens=1024, tools=TOOLS, messages=messages, reasoning_effort="max", # K3 replaced the old thinking param with this ) usage = response.usage total_prompt_tokens += usage.prompt_tokens total_completion_tokens += usage.completion_tokens message = response.choices[0].message if response.choices[0].finish_reason != "tool_calls": return { "answer": message.content, "turns_used": turns_used, "prompt_tokens": total_prompt_tokens, "completion_tokens": total_completion_tokens, } messages.append(message.model_dump(exclude_none=True)) for tool_call in message.tool_calls: if tool_call.function.name == "count_words": args = json.loads(tool_call.function.arguments) result = count_words(args["text"]) messages.append({ "role": "tool", "tool_call_id": tool_call.id, "content": str(result), }) return {"answer": None, "turns_used": turns_used, "error": "Hit max_turns without finishing"} if name == "main": task = ( "Write a two-sentence description of what a mixture-of-experts " "model is, then use the count_words tool to tell me exactly how " "many words your description contains." ) report = run_task(task) print(json.dumps(report, indent=2)) What this does: because Moonshot's API follows the standard OpenAI chat-completions contract, tool calls arrive in the familiar message.tool_calls shape rather than a custom format, and finish_reason == "tool_calls" is the signal to execute a tool and loop back rather than return. One K3-specific detail worth flagging directly: the older thinking parameter from the K2 line is gone in K3, replaced by reasoning_effort, and as of this writing "max" is the only supported value, with more levels promised later. How to run it: with your key exported, run python run_task.py On pricing, since it's central to Kimi's whole pitch: K3 runs $3 per million input tokens and $15 per million output tokens, flat across the entire 1-million-token context with no tiered pricing by length. That's roughly a 5x jump over K2.6's pricing, notable because it's Moonshot moving away from the ultra-cheap positioning on which the Kimi line built its reputation. Automatic prefix caching, however, drops the cached-input rate to $0.30 per million tokens, which meaningfully changes the economics for long-context, multi-turn conversations specifically. What Independent Testers Actually Found On the positive side, TechRadar's hands-on testing described genuinely strong results on document-heavy work: dropping two long PDFs into one conversation and asking Kimi to cross-reference specific sections came back accurate and well-organized, holding up through follow-up questions — describing long-context handling as one of Kimi's strongest suits, available even on the free tier. The same review tested Kimi Code on a Python refactoring task and found the output clean, with architectural reasoning that held up under questioning, if not quite matching Claude Code's structured explanations — a trade-off the reviewer judged worth it given the price difference. A Hacker News user's blunt assessment in the same discussion thread rated K2.6 as below Sonnet and Opus 4.0 on raw capability. And in a detail worth taking seriously precisely because it comes from the vendor itself rather than a critic, Moonshot's own K3 launch materials are candid that K3 trails Claude Fable 5 and GPT-5.6 Sol on their internal comparisons, positioning it as strong and dramatically cheaper rather than a clean frontier win. Held together, that's a coherent picture rather than a contradiction: Kimi is genuinely capable on long-context document work and competent, cost-effective coding, and it falls short of Claude and GPT specifically on the hardest, most agent-coordination-heavy tasks — which happens to be exactly the category Agent Swarm is built to sell. The Rough Edges Worth Knowing About A few things worth knowing before adopting this for real work — none of them disqualifying on their own, all worth factoring in. On July 20, 2026, Moonshot paused new K3 subscriptions entirely after GPU capacity hit its limit following a demand surge — a real signal about scaling growing pains rather than a rumor. Moonshot's own documentation flags "excessive proactiveness" as an observed K3 behavior, where the model makes unprompted decisions when it hits ambiguity mid-task rather than pausing to ask — a direct consequence of training it heavily on long, difficult tasks. There's also a genuine harness-compatibility issue: Moonshot states K3 was trained to preserve reasoning history across a session, and output quality can degrade if an agent harness doesn't pass that history back correctly, or if a session started on a different model gets switched to K3 mid-conversation — which is why Moonshot recommends its own verified-compatible tooling and advises against a mid-session model swap. Finally, for regulated industries specifically, Kimi's hosted API routes through China-based servers — a real, practical consideration entirely separate from the model's capability. On licensing: the full K3 weights landed July 27, 2026 under a bespoke Kimi K3 License, open-weight in the sense that you can download and run them, but not an OSI-recognized open source license — worth knowing if "open" was doing specific legal work in your evaluation rather than just meaning "downloadable." Comparison Table # Kimi K3 / Agent Swarm Claude (Opus/Sonnet class) GPT-class agents Context window 1,000,000 tokens Varies by model, generally smaller than K3's 1M Varies by model Pricing (per million tokens) $3 input / $15 output, cached input $0.30 Higher list price than K3 Higher list price than K3 Parallel agent architecture Native, up to 300 sub-agents, 4,000+ tool calls per task Sub-agent orchestration available via Claude Code Teams, not the same fan-out scale by design Handoff-based orchestration via Agents SDK Independent hard-task benchmark result 68/100 on an independent FlowGraph test, concentrated gap in multi-agent coordination 91/100 on the same independent test Not directly tested in that comparison Vendor's own positioning Moonshot states K3 trails Claude Fable 5 and GPT-5.6 Sol on their internal comparisons N/A N/A Weight availability Open-weight under a bespoke license (not OSI open source) Closed Closed Data hosting China-based servers US-based US-based Wrapping Up The honest answer sits between the two extremes a launch post and a skeptical tweet would each give you. Kimi's pricing is genuinely disruptive, its long-context document handling is genuinely strong even on the free tier, and Agent Swarm is a real, more thoughtfully documented architecture than most competitors' equivalent features — including an unusually honest account of its own failure modes. Set against that: independent testing on the hardest agentic coordination tasks, the exact category Agent Swarm exists to win, shows a real, measured gap against Claude and GPT — one Moonshot's own launch materials don't fully dispute either. If your work is long-document analysis, cost-sensitive high-volume coding, or you specifically want an open-weight model with genuine ag [truncated for AI cost control]