# How to Run 300 AI Agents From One Prompt. 10 Workflows Most People Skip
**作者**: Khairallah AL-Awady
**日期**: 2026-06-04T09:10:19.000Z
**来源**: [https://x.com/eng_khairallah1/status/2062461939318730818](https://x.com/eng_khairallah1/status/2062461939318730818)
---
Here is what happens every single day.
Save this :)
Most people still use AI the way they used Google in 2010: type a query, read the answer, type the next one.A single thread you feed one item at a time.
But a model that can plan and call tools doesn't have to be used one item at a time. Hand it 100 PDFs and the obvious move isn't to walk through them in sequence: it's to open 100 of them at once, one reader per file, and have a coordinator stitch the readings back together. The prompt stays the same length. The work fans out behind it. You go from a single thread to a fan: one instruction in, a hundred workers spawned, one assembled deliverable out.
That is the whole shift, and it is the difference between reading 100 papers over a weekend and reading them over a coffee. The rest of this is the cost math, the setup, the prompts, the repos, the workflows, and the places where this quietly falls apart.
## The Real Cost Picture
This is where most people give up before they start. They assume running 300 agents must cost a fortune. It does not.
Take a real task: 100 PDF research papers analyzed into a single literature review with citations.
Sequential approach with Claude Opus 4.8: Roughly 6 hours of agent wall time at $5 per million input tokens and $25 per million output. Estimated cost: $40 to $60 per run depending on document length. Plus your time supervising.
Parallel approach with the Kimi K2.6 agent swarm: 100 agents spin up simultaneously, each handling one paper. Coordinator merges. Wall time: 12 to 18 minutes. Cost: $3 to $5 per run.
That is a 15x speed multiplier and a 10x cost multiplier on the same task. The math is not even close.
Now scale that. 50 support tickets analyzed for patterns. 100 cold outreach emails personalized to specific prospects. 40 academic PDFs turned into a 100,000-word literature review with citations. 30 brick-and-mortar businesses scraped and turned into individual landing pages. Every one of these used to require either a team of contractors or an entire day of sequential work.
Now it is one prompt, one coffee break, under $10.
A solo operator with this stack is not competing with other solo operators. They are competing with agencies.
## What Actually Changed in April
Three things landed in the same month that made this real for the first time.
Kimi K2.6 dropped April 20. Built by Moonshot AI, open-source under a Modified MIT License. The model was natively trained to coordinate up to 300 sub-agents across 4,000 coordinated steps from a single prompt. That is triple the limit of K2.5. The orchestration is not bolted onto a chat interface, it is baked into the model layer. 1 trillion total parameters, 32 billion active per token, 256k context window, 65,536 max output tokens per response. Pricing: $0.80 per million input tokens, $3.60 per million output. Roughly 8x cheaper than Claude Opus 4.8.
The numbers that matter most: 80.2% on SWE-bench Verified, 92.5% on DeepSearchQA, 66.7% on Terminal-Bench 2.0, 58.6% on SWE-bench Pro (tied with GPT-5.5). Hallucination rate dropped from 65% in K2.5 to 39%, which is essentially on par with Opus 4.8 at 36%.
In real-world testing, K2.6 autonomously overhauled an 8-year-old financial matching engine over 13 hours, iterated through 12 optimization strategies, made over 1,000 tool calls, modified more than 4,000 lines of code, and delivered a 185% throughput improvement. One of Moonshot's own teams ran it as an autonomous agent for five days straight, managing monitoring, incident response, and system operations without human intervention.
Claude Opus 4.8 dropped April 16. Sub-agent reliability improved significantly. New xhigh effort tier makes complex agent chains more deterministic. SWE-bench Pro lead at 64.3%. Vision jumped from 54.5% to 98.5% after a resolution upgrade. Still the gold standard for production code quality and legal-grade precision. Still $5/$25 per million tokens.
GPT-5.5 dropped April 23. Computer use jumped to 78.7% on OSWorld-Verified, meaning agents can now actually operate real GUIs without breaking. Long-context retrieval at 74% versus Claude's 32.2% on the same benchmark. Web research at 90.1% on BrowseComp. Pricing $5/$30 per million but uses fewer output tokens per task in practice.
The pattern: three frontier models in one week, each with a clear specialty. The losers are the developers who picked one and stuck with it. The winners are the ones who route each task to the right brain.
For parallel agent swarms specifically, K2.6 is the only model trained from the ground up to coordinate at this scale at a price that lets you actually use it.
## What 300 Parallel Agents Actually Looks Like
This is the part that matters. Not the spec sheet, the actual deliverables. Every one of these is from real prompts that real people ran in April 2026.
The literature review run. 40 academic PDFs uploaded. Output: a 100,000-word literature review with a fully cited dataset. 40 agents, each owning one paper, coordinated through a single merge step. Total runtime under 20 minutes.
The astrophysics paper transformation. One astrophysics paper went in. The output was a 40-page research report, a 20,000-row supporting dataset, and 14 publication-grade charts. The entire output was then packaged as a reusable Skill the agent system can apply to every future astrophysics paper automatically. The first run took 30 minutes. Every subsequent run on a new paper now takes 12 minutes because the Skill captures the structure.
The Google Maps to landing pages workflow. One prompt: search Google Maps for retail stores in Los Angeles that do not currently have a website, identify 30 unique businesses, scrape storefront photos and customer reviews, build a high-conversion landing page for each one with addresses, hours, value proposition tailored to the business type, and contact details. Output: 30 individual landing pages plus an Excel spreadsheet listing all 30 stores with full metadata. Runtime: under 45 minutes.
The job hunt automation. 100 job descriptions matched against one CV. Output: 100 individually tailored resumes, each optimized for the specific role's requirements and language. The kind of work a freelance career coach charges $50 per resume for. Total cost of the run: under $4.
The magazine cover series. One prompt asking for 10 tabloid-style magazine covers with real historical headlines. Each agent researched a different historical period, generated the headlines, designed the cover. Output: 10 polished magazine covers from one input prompt.
The five-day autonomous run. Moonshot's internal team pointed K2.6 at their monitoring and incident response pipeline. It ran for five days straight, handling alerts, opening pull requests, posting to Slack, escalating real incidents. No human intervention. This is not a demo. This is what an autonomous on-call engineer looks like in 2026.
If you have ever paid for batch processing work, your entire pipeline just got automated.
## How to Actually Set This Up
You do not need to build a framework. You do not need a PhD in distributed systems. The infrastructure is already done.
Option 1: Zero-setup web interface
Go to kimi{.}com/agent-swarm. Describe your task. Specify the number of sub-agents. Upload any files. Run. This is the entry point. No installation, no API keys, no config. The web UI handles agent decomposition, coordination, and final output assembly.
Use this for: one-off batch tasks, document processing workflows, research projects, any time you want to test if your task is even parallelizable before investing in code.
Option 2: API integration for production workflows
For programmatic access and integration into your own pipelines, use the Moonshot API directly with the K2.6 endpoint. Documentation lives at github.com/moonshotai/Kimi-K2.
```
pip install moonshotai
```
Spin up a parallel job by setting the agent_swarm parameter to true and the max_agents value up to 300. The model handles the decomposition natively. You provide the task description and any reference files, K2.6 handles the rest.
For self-hosting, the official repo has full deployment guides for vLLM and SGLang. Weights are on Hugging Face. You can run this entirely on your own infrastructure if you need to.
Option 3: LangGraph orchestration with K2.6 backend
For full control over the orchestration logic while keeping K2.6's pricing, use LangGraph as the orchestration layer and route model calls to K2.6 through OpenRouter.
```
pip install langgraph langchain-openai
```
Point the model parameter at the Kimi K2.6 endpoint, route through OpenRouter for unified billing across all your model providers. This is what production teams are running.
When to use this: you have a complex stateful workflow with custom branching logic, conditional routing between sub-agents, or human-in-the-loop checkpoints. LangGraph gives you the graph structure, K2.6 gives you the pricing and parallel execution capacity.
Option 4: Claude Code Router for mixed-model swarms
github.com/musistudio/claude-code-router lets you run Claude Code's interface but route specific sub-agents to whichever model fits the task best. Coordinator on Opus 4.8 for high-reliability planning, bulk sub-agents on K2.6 for cost-efficient parallel execution, computer-use sub-agents on GPT-5.5 for GUI navigation.
This is the most cost-efficient parallel stack you can build today. The coordinator handles maybe 5% of the total tokens and needs maximum reliability. The 300 sub-agents handle 95% of the tokens and need maximum cost efficiency. Routing each layer to the right model cuts total cost by another 60% compared to running everything on a single model.
## The Prompts to Install Right Now
Three system prompts. One for the coordinator, one for the sub-agents, one for the validator. Install these as persistent system prompts in your swarm config or paste them at the start of any session.
For the coordinator agent:
```
You are a coordinator orchestrating a swarm of parallel sub-agents.
Your job: decompose the user's request into the smallest number of
independent parallel tasks that fully cover the goal, dispatch them
to sub-agents, and merge the results into one coherent deliverable.
Rules:
- Identify the smallest unit of parallelizable work
- Each sub-task must be fully independent, no cross-dependencies
- Specify the exact output format every sub-agent must return
- Define the merge logic before dispatching anything
- If sub-tasks have dependencies, sequence them in phases instead of
forcing false parallelism
- Spawn no more sub-agents than the task requires
When merging:
- Resolve contradictions explicitly, do not paper over them
- Preserve attribution of which sub-agent produced which output
- Verify the merged output against the original request before
returning
Success: the final deliverable is coherent, complete, and traceable
back to specific sub-agent outputs.
```
For each sub-agent in the swarm:
```
You are a specialist sub-agent inside a larger swarm.
Your job: complete exactly one assigned sub-task and return your
output in the exact format the coordinator specified.
Rules:
- Read the full sub-task spec before doing anything
- Do not expand scope beyond what was assigned
- Return your output in the exact requested format, no preamble,
no commentary
- If you hit a blocker, return a clear flag instead of guessing
- If your sub-task requires information outside your assigned scope,
flag it for the coordinator instead of trying to fill it yourself
- Verify your output against the spec before returning
Success: your output plugs directly into the merge step without
requiring the coordinator to clean it up.
```
For the validator pass at the end:
```
You are the validator for a completed swarm output.
Your job: check whether the merged deliverable actually satisfies
the original user request.
Rules:
- Compare the final output against the original request, not against
the coordinator's plan
- Flag any gap between what was asked and what was delivered
- Identify contradictions in the merged output
- Identify any sub-agent outputs that were dropped or misinterpreted
in the merge
- Do not soften findings, surface every real issue
If the output is incomplete: list exactly what is missing.
If the output is wrong: identify which sub-agent's output caused it.
If the output is complete and correct: confirm and pass through.
Success: nothing broken or incomplete makes it past your check.
```
These three prompts are the difference between a swarm that produces coherent deliverables and one that produces 300 fragments you have to manually stitch together.
## The Repos You Need
This is the most important section. Bookmark every single one.
For the swarm itself:
github.com/moonshotai/Kimi-K2 is the official repo. Weights, deployment guides for vLLM and SGLang, API documentation, full setup for self-hosting or API integration. Start here.
github.com/chongdashu/cc-kimi-k2-thinking-prompts shows how to use K2.6 through the Claude Code CLI by swapping a single environment variable. Claude Code's full agent loop with K2.6's brain doing the work at a fraction of the cost.
github.com/dnnyngyen/kimi-agent-internals has the extracted system prompts for all six of Kimi's built-in agent types including Base Chat, OK Computer, Docs, Sheets, Slides, and Websites, plus the full Skill definitions and tool schemas. This is the closest thing to a reverse-engineered playbook for how Moonshot's own agents are built.
For orchestration:
github.com/langchain-ai/langgraph is the open-source orchestration framework most production parallel-agent teams are running. Mature, stateful, full control over the graph.
github.com/joaomdmoura/crewAI is the easier entry point if you want role-based agent definition without writing graph logic yourself. Less powerful, much friendlier on-ramp.
github.com/microsoft/autogen is Microsoft's framework for conversation-based multi-agent collaboration. Best for workflows where agents debate or refine each other's outputs rather than running in pure parallel.
github.com/musistudio/claude-code-router is the missing piece for mixed-model swarms. One interface, multiple model backends, routing logic per sub-agent type.
For the prompts and patterns:
github.com/asgeirtj/system_prompts_leaks has the leaked system prompts for K2.6, Opus 4.8, and GPT-5.5 in one place. Studying how each company shapes its model's behavior is one of the highest-leverage prompt engineering exercises you can do.
github.com/f/awesome-chatgpt-prompts at 143k+ stars is the canonical prompt library. Works across all three models, gives you templates for almost any agent pattern.
github.com/CheswickDEV/claude-opus-4.8-prompt-optimizer is a meta-prompt that transforms raw prompts into production-grade XML-structured prompts optimized for the new xhigh effort tier. Useful when your coordinator runs on Opus.
## Skills: The Quiet Force Multiplier
Most people will skip this section. They should not.
K2.6's swarm has a feature called Skills. You upload any document, any PDF, any spreadsheet, any deck, and the swarm extracts its structural and stylistic DNA into a reusable template.
The astrophysics paper example earlier became a Skill. So now every future astrophysics paper run takes 12 minutes instead of 30 because the swarm already knows the output structure, the chart styles, the citation format, the section hierarchy.
Real Skills people are running right now:
A WEF-style report Skill that takes any research input and produces a fully formatted institutional research publication with proper typography, color palette, two-column layouts, figure numbering, and methodology appendix.
An ink-wash presentation Skill that converts any content into elegant black-and-white shuimo-style slide decks with hand-painted illustrations, monochrome watercolor aesthetics, and asymmetrical layouts.
A pitch deck Skill that converts your raw business idea into a polished investor-ready deck.
The pattern is the same every time: upload one example of your best output, the swarm captures the DNA, every future task in that domain inherits that quality automatically.
This is where the leverage compounds. You stop reinventing the structure of your work every time. Each Skill makes every future run cheaper, faster, and more consistent.
If you do nothing else from this entire article, build three Skills this week from your three best pieces of past work. Your output quality and speed will permanently shift.
## Real Workflows You Can Build This Weekend
These are not hypothetical. Every single one of these is running in production right now.
1. The competitive intelligence pipeline. 50 agents pointed at 50 competitor websites. Each one extracts pricing, features, positioning, recent updates, customer reviews. Coordinator merges into a single competitive landscape report. Run it weekly. You will know the market better than anyone in your industry. Runtime: 20 minutes. Cost: under $5.
2. The content production assembly line. 20 agents researching different angles of one topic. One coordinator merges findings into an outline. One writer agent drafts. One editor agent refines. Four hours of human work becomes 15 minutes of agent runtime. Build a Skill from your best article, every future article inherits the structure.
3. The cold outreach personalization stack. Upload 100 prospect names and companies. 100 agents each research one prospect, find their recent work, identify a relevant pain point, draft a custom outreach message in your voice. Not generic AI slop. Real personalization executed in parallel. Cost per message: under 5 cents.
4. The legacy codebase audit. Spin up agents that each analyze a different module of a large codebase. One agent produces architecture documentation. Another finds dead code. Another flags security issues. Another suggests refactor candidates. Coordinator produces a single audit report. The kind of audit a consultancy bills $50,000 for. Now runs overnight for under $50.
5. The bulk freelance service automation. Have a service business? Cover letter writing, resume tailoring, proposal drafting, market research, ad copy variations. Build a swarm that processes each job from intake to delivery. One operator can handle the volume of an entire agency.
6. The documentation generation pipeline. Point agents at every file in your codebase. Each one generates documentation for its assigned module. Coordinator merges into a single docs site. Maintained automatically on every commit.
7. The autonomous monitoring agent. Point a long-running K2.6 agent at your error logs and deployment pipeline. When something breaks it identifies the relevant commits, opens a draft fix, posts to Slack with context. Your on-call engineer reviews a pull request instead of staring at a blank terminal at 3am.
8. The product launch coordination swarm. One agent writes the PRD. One designs mockups. One writes the launch blog post. One drafts the social media campaign. One builds the landing page. One drafts the press outreach. All in parallel, all merged into one coordinated launch package.
9. The market research at depth. Spin up 30 to 50 agents on a single research question, each covering a different angle. Coordinator merges and resolves contradictions. Structured report with full citations in the time it used to take to read 10 articles.
10. The SaaS prototype assembly. Describe the product, stack, and feature list. K2.6 scaffolds the frontend, backend, DevOps config, database schema, and authentication layer in parallel. Hand the output to Opus 4.8 to harden the production-critical paths. A weekend MVP that used to take a month.
## The Model Routing for Maximum Leverage
The smartest move is not running everything through K2.6's swarm. The smartest move is routing each layer of the swarm to the model that fits.
Coordinator on Opus 4.8. The coordinator handles maybe 5% of total tokens and 95% of the strategic decisions. Reliability matters more than cost. Use the best.
Bulk sub-agents on K2.6. The 300 sub-agents handle 95% of total tokens. Cost efficiency matters most. K2.6 is the only model that makes 300 parallel agents economically viable.
Web research sub-agents on GPT-5.5. When a sub-agent needs to browse and synthesize web information, GPT-5.5's 90.1% BrowseComp score and superior long-context retrieval pulls ahead of everything else. Route browsing sub-agents to GPT-5.5 specifically.
Vision sub-agents on Opus 4.8. Any sub-agent that needs to interpret images, design layouts, or work with visual references should route to Opus 4.8's 98.5% visual acuity score.
Computer use sub-agents on GPT-5.5. GUI operation, browser automation, anything requiring actual interface control. GPT-5.5's 78.7% OSWorld-Verified score is the highest in the market.
Set this up once. Use Claude Code Router to handle the routing logic. Your total swarm cost drops another 40 to 60% versus single-model execution.
This is what mastery looks like in 2026. Not loyalty to one tool, ruthless routing to the best tool for each layer of the work.
## The Honest Caveat
I am going to give you the unvarnished version because hype helps nobody.
Parallel agent orchestration is still fragile on the most complex long-horizon tasks. If your workflow requires deep sequential reasoning where each step depends on the last in non-obvious ways, parallelization does not help and can actively hurt. The merge step starts producing contradictions when sub-tasks are not actually independent.
Use swarms where work genuinely parallelizes: research, batch generation, multi-document analysis, content production at scale, anything with embarrassingly parallel structure where 50 inputs become 50 outputs through the same transformation.
For sequential reasoning, single-file debugging, novel architecture decisions, or any task where reliability over hundreds of dependent steps matters more than throughput, you still want a single high-quality model like Opus 4.8 working linearly.
Other real caveats:
Orchestration overhead is non-zero. Spinning up 300 agents takes a few minutes of coordination time. For tasks under 10 minutes of equivalent sequential work, the overhead eats the benefit. Do not throw swarms at small jobs.
Tool-schema retry rates are slightly higher on K2.6 than on Anthropic or OpenAI. If your sub-agents rely heavily on calling structured tool APIs, you will see occasional retries that you would not see with Opus.
K2.6 does not lead on pure math. If your sub-agents need to do heavy numerical reasoning, route them to GPT-5.5 specifically.
No image input on the K2.6 API yet. Image-heavy sub-tasks need to route to Opus or GPT-5.5.
Parallel agents are not magic. They are leverage for the right kind of task. The wins are massive when the task fits. The losses are real when it does not.
## The Mental Model Shift
For the last two years, the question for every AI workflow was: which model is best for this task?
That was the right question when models were sequential and the differences between them were significant.
The question in 2026 is different. Can this task be parallelized? If it can, what is the cheapest model that handles each sub-task at acceptable quality?
That is a completely different way of thinking about AI work.
The 10x operator is not the one with the best single model. The 10x operator is the one who decomposed the work into 50 parallel sub-tasks while everyone else was still running one prompt at a time, then routed each sub-task to the right model for the job.
Most people will read this article, find it interesting, and keep working sequentially. The infrastructure is too new and the mental shift is too uncomfortable. That is fine. That is also the opportunity.
The ones who actually rewire their workflow this week will be operating on a completely different level within 30 days. Not because they will be smarter. Because they will be running 50 to 100 times more attempts per day than anyone they are competing with.
More attempts means more learning. More learning means more output. More output means more leverage.
That compounds.
The infrastructure is here. The pricing is here. The tooling is here. The repos are public, the docs are written, the prompts are above.
The only question is whether you build the parallel agent stack now or wait until everyone else does first.
The people who pull ahead in AI in 2026 are not the ones with the most expensive subscriptions. They are the ones who understood the shift to parallel agent swarms before it became obvious.
I break down every major AI workflow and tool stack so you do not have to figure it out alone.
Follow me @eng_khairallah1 for more AI courses, tools, and workflows. New content every week.
hope this was useful for you, Khairallah ❤️
## 相关链接
- [Khairallah AL-Awady](https://x.com/eng_khairallah1)
- [@eng_khairallah1](https://x.com/eng_khairallah1)
- [218K](https://x.com/eng_khairallah1/status/2062461939318730818/analytics)
- [github.com/moonshotai/Kimi-K2](http://github.com/moonshotai/Kimi-K2)
- [github.com/musistudio/claude-code-router](http://github.com/musistudio/claude-code-router)
- [github.com/moonshotai/Kimi-K2](http://github.com/moonshotai/Kimi-K2)
- [github.com/chongdashu/cc-kimi-k2-thinking-prompts](http://github.com/chongdashu/cc-kimi-k2-thinking-prompts)
- [github.com/dnnyngyen/kimi-agent-internals](http://github.com/dnnyngyen/kimi-agent-internals)
- [github.com/langchain-ai/langgraph](http://github.com/langchain-ai/langgraph)
- [github.com/joaomdmoura/crewAI](http://github.com/joaomdmoura/crewAI)
- [github.com/microsoft/autogen](http://github.com/microsoft/autogen)
- [github.com/musistudio/claude-code-router](http://github.com/musistudio/claude-code-router)
- [github.com/asgeirtj/system_prompts_leaks](http://github.com/asgeirtj/system_prompts_leaks)
- [github.com/f/awesome-chatgpt-prompts](http://github.com/f/awesome-chatgpt-prompts)
- [github.com/CheswickDEV/claude-opus-4.8-prompt-optimizer](http://github.com/CheswickDEV/claude-opus-4.8-prompt-optimizer)
- [@eng_khairallah1](https://x.com/@eng_khairallah1)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [5:10 PM · Jun 4, 2026](https://x.com/eng_khairallah1/status/2062461939318730818)
- [218.6K Views](https://x.com/eng_khairallah1/status/2062461939318730818/analytics)
- [View quotes](https://x.com/eng_khairallah1/status/2062461939318730818/quotes)
---
*导出时间: 2026/6/5 11:03:03*
---
## 中文翻译
# 如何用一个提示词运行 300 个 AI 代理：大多数人会跳过的 10 个工作流
**作者**: Khairallah AL-Awady
**日期**: 2026-06-04T09:10:19.000Z
**来源**: [https://x.com/eng_khairallah1/status/2062461939318730818](https://x.com/eng_khairallah1/status/2062461939318730818)
---
这就是每天都在发生的事情。
收藏这篇 :)
大多数人仍然像 2010 年使用谷歌那样使用 AI：输入查询，阅读答案，输入下一个。在单一线程中一次喂给它一个项目。
但是，一个能够规划和调用工具的模型不必一次只处理一个项目。把 100 个 PDF 交给它，显而易见的做法不是按顺序浏览：而是一次打开 100 个，每个文件分配一个阅读器，然后让协调器将阅读结果缝合在一起。提示词的长度保持不变。工作在其后发散。你从单一线程变成了扇形：一个指令输入，生成 100 个工作进程，一个组装好的交付物输出。
这就是整个转变，也就是用一个周末读 100 篇论文和喝杯咖啡的功夫读完它们的区别。剩下的就是成本计算、设置、提示词、仓库、工作流，以及那些悄然失效的地方。
## 真实的成本全景
这是大多数人在开始之前就放弃的地方。他们认为运行 300 个代理肯定要花一大笔钱。其实不然。
以一个真实任务为例：将 100 篇 PDF 研究论文分析成一篇带有引用的单一文献综述。
使用 Claude Opus 4.8 的顺序方法：大约需要 6 小时的代理运行时间，输入每百万token收费 5 美元，输出每百万收费 25 美元。预估成本：每次运行 40 到 60 美元，取决于文档长度。加上你监督的时间。
使用 Kimi K2.6 代理群体的并行方法：100 个代理同时启动，每个处理一篇论文。协调器进行合并。运行时间：12 到 18 分钟。成本：每次运行 3 到 5 美元。
这就是同样的任务上 15 倍的速度提升和 10 倍的成本优势。这笔账算起来根本没有可比性。
现在扩展一下。分析 50 张支持工单以寻找模式。为特定潜在客户个性化 100 封冷开发邮件。将 40 篇学术 PDF 转化为包含引用的 10 万字文献综述。抓取 30 家实体企业的数据并转化为独立的落地页。这些任务中的每一个过去要么需要一个承包商团队，要么需要一整天的顺序工作。
现在，这是一个提示词，一次喝咖啡的休息时间，花费不到 10 美元。
拥有这个技术栈的独立操作者不是在与其他独立操作者竞争。他们是在与代理商竞争。
## 四月究竟发生了什么变化
有三件事在同一个月落地，使这首次成为现实。
Kimi K2.6 于 4 月 20 日发布。由 Moonshot AI 构建，采用修改后的 MIT 许可协议开源。该模型经过原生训练，可以从单个提示词协调多达 300 个子代理，跨越 4,000 个协调步骤。这是 K2.5 限制的三倍。编排不是附加在聊天界面上的，而是 baked into（ baked into 翻译为 融入/内嵌 ）模型层的。总参数 1 万亿，每 token 激活 320 亿，256k 上下文窗口，每次响应最大输出 65,536 个 token。价格：输入每百万 token 0.80 美元，输出每百万 3.60 美元。大约比 Claude Opus 4.8 便宜 8 倍。
最重要的数字：SWE-bench Verified 上得分 80.2%，DeepSearchQA 上 92.5%，Terminal-Bench 2.0 上 66.7%，SWE-bench Pro 上 58.6%（与 GPT-5.5 持平）。幻觉率从 K2.5 的 65% 下降到 39%，这基本上与 Opus 4.8 的 36% 持平。
在现实世界的测试中，K2.6 在 13 小时内自主彻底改造了一个有 8 年历史的金融匹配引擎，迭代了 12 种优化策略，进行了超过 1,000 次工具调用，修改了超过 4,000 行代码，并实现了 185% 的吞吐量提升。Moonshot 自己的团队之一让它作为自主代理连续运行了五天，管理监控、事件响应和系统操作，无需人工干预。
Claude Opus 4.8 于 4 月 16 日发布。子代理的可靠性显著提高。新的 xhigh effort tier 使复杂的代理链更具确定性。以 64.3% 的成绩领跑 SWE-bench Pro。在分辨率升级后，视觉能力从 54.5% 飙升到 98.5%。仍然是生产代码质量和法律级精度的黄金标准。价格依然是每百万 token 5/25 美元。
GPT-5.5 于 4 月 23 日发布。计算机使用能力在 OSWorld-Verified 上跃升至 78.7%，这意味着代理现在可以真正操作真实的 GUI 而不会崩溃。在相同基准测试下，长上下文检索率为 74%，而 Claude 为 32.2%。在 BrowseComp 上网络研究能力为 90.1%。价格为每百万 token 5/30 美元，但在实践中每项任务使用的输出 token 更少。
规律：一周内三个前沿模型，每一个都有明确的专长。输家是那些选中其中一个就死守不放的开发者。赢家是那些将每个任务路由到“最强大脑”的人。
特别是对于并行代理群体，K2.6 是唯一一个从底层训练以在这种规模下进行协调，且价格让你能真正用得起的模型。
## 300 个并行代理实际上是什么样子的
这是最重要的部分。不是规格表，而是实际的交付物。这些都是来自 2026 年 4 月真人运行的真实提示词的产物。
文献综述运行。上传了 40 篇学术 PDF。输出：一篇包含完全引用数据集的 10 万字文献综述。40 个代理，每个负责一篇论文，通过单一的合并步骤进行协调。总运行时间不到 20 分钟。
天体物理学论文转换。输入了一篇天体物理学论文。输出是一份 40 页的研究报告、一个包含 2 万行的支撑数据集和 14 张出版级图表。整个输出随后被打包为一个可重用的“技能”，代理系统可以自动将其应用于未来的每一篇天体物理学论文。第一次运行花了 30 分钟。现在在新论文上的每一次后续运行只需要 12 分钟，因为技能捕获了结构。
Google Maps 到落地页的工作流。一个提示词：在 Google Maps 上搜索洛杉矶目前没有网站的零售店，识别 30 家独特的商家，抓取店面照片和客户评论，为每一家建立一个高转化率的落地页，包含地址、营业时间、针对业务类型定制的价值主张和联系方式。输出：30 个独立的落地页加上一个 Excel 电子表格，列出所有 30 家商店及其完整的元数据。运行时间：不到 45 分钟。
求职自动化。100 份职位描述与一份简历进行匹配。输出：100 份量身定制的简历，每一份都针对特定职位的要求和语言进行了优化。这是一些自由职业职业顾问每份简历收费 50 美元的工作量。运行总成本：不到 4 美元。
杂志封面系列。一个提示词要求制作 10 张带有真实历史标题的小报风格杂志封面。每个代理研究不同的历史时期，生成标题，设计封面。输出：从单一输入提示词生成 10 张精致的杂志封面。
五天自主运行。Moonshot 的内部团队让 K2.6 接管他们的监控和事件响应管道。它连续运行了五天，处理警报、开启 pull request、发布到 Slack、升级真实事件。没有人工干预。这不是演示。这就是 2026 年自主待命工程师的样子。
如果你曾经为批量处理工作付过钱，你的整个管道刚刚被自动化了。
## 如何实际设置这个
你不需要构建框架。你不需要分布式系统的博士学位。基础设施已经完成。
选项 1：零设置的 Web 界面
访问 kimi{.}com/agent-swarm。描述你的任务。指定子代理的数量。上传任何文件。运行。这是入口点。无需安装，无需 API 密钥，无需配置。Web UI 处理代理分解、协调和最终输出生装。
将其用于：一次性批处理任务、文档处理工作流、研究项目，任何你想在投入代码之前测试任务是否可以并行化的时候。
选项 2：生产工作流的 API 集成
要以编程方式访问并集成到你自己的管道中，直接使用带有 K2.6 端点的 Moonshot API。文档位于 github.com/moonshotai/Kimi-K2。
```
pip install moonshotai
```
通过将 agent_swarm 参数设置为 true 并将 max_agents 值设置为最大 300 来启动并行作业。模型原生处理分解。你提供任务描述和任何参考文件，K2.6 处理其余部分。
对于自托管，官方仓库有完整的 vLLM 和 SGLang 部署指南。权重在 Hugging Face 上。如果需要，你可以完全在自己的基础设施上运行此程序。
选项 3：使用 K2.6 后端的 LangGraph 编排
为了在保持 K2.6 价格优势的同时对编排逻辑拥有完全控制，请使用 LangGraph 作为编排层，并通过 OpenRouter 将模型调用路由到 K2.6。
```
pip install langgraph langchain-openai
```
将模型参数指向 Kimi K2.6 端点，通过 OpenRouter 路由以统一所有模型提供商的账单。这是生产团队正在运行的方案。
何时使用此方法：当你拥有复杂的有状态工作流、自定义分支逻辑、子代理之间的条件路由，或人工干预检查点时。LangGraph 提供图结构，K2.6 提供定价和并行执行能力。
选项 4：用于混合模型群体的 Claude Code Router
github.com/musistudio/claude-code-router 允许你运行 Claude Code 的界面，但将特定的子代理路由到最适合任务的模型。Opus 4.8 上的协调员用于高可靠性规划，K2.6 上的批量子代理用于成本效益高的并行执行，GPT-5.5 上的计算机使用子代理用于 GUI 导航。
这是你能构建的最具成本效益的并行堆栈。协调员处理大约 5% 的总 token，需要最大可靠性。300 个子代理处理 95% 的 token，需要最大成本效率。将每一层路由到正确的模型，与在单个模型上运行所有内容相比，总成本再降低 60%。
## 现在就要安装的提示词
三个系统提示词。一个给协调员，一个给子代理，一个给验证器。将这些作为持久系统提示词安装在群体配置中，或在任何会话开始时粘贴它们。
对于协调员代理：
```
你是一个协调员，正在编排一个并行子代理群体。
你的工作：将用户的请求分解为尽可能少的独立并行任务，以完全覆盖目标，将它们分发给子代理，并将结果合并为一个连贯的交付物。
规则：
- 识别可并行化工作的最小单元
- 每个子任务必须完全独立，没有交叉依赖
- 指定每个子代理必须返回的确切输出格式
- 在分发任何内容之前定义合并逻辑
- 如果子任务有依赖关系，请按阶段对它们进行排序，而不是强求虚假的并行性
- 生成的子代理数量不要超过任务所需的数量
合并时：
- 明确解决矛盾，不要掩盖它们
- 保留哪个子代理产生了哪个输出的归属
- 在返回之前，根据原始请求验证合并后的输出
成功：最终交付物连贯、完整，并且可以追溯到特定的子代理输出。
```
对于群体中的每个子代理：
```
你是一个更大群体中的专业子代理。
你的工作：准确完成一项分配的子任务，并以协调员指定的确切格式返回你的输出。
规则：
- 在做任何事情之前阅读完整的子任务规范
- 不要将范围扩大到分配的范围之外
- 以确切的请求格式返回你的输出，没有前言，没有评论
- 如果遇到阻碍，请返回一个清晰的标志，而不是猜测
- 如果你的子任务需要分配范围之外的信息，请将其标记给协调员，而不是尝试自己填补
- 在返回之前根据规范验证你的输出
成功：你的输出直接插入合并步骤，无需协调员进行清理。
```
对于最后的验证器通过：
```
你是已完成群体输出的验证器。
你的工作：检查合并后的交付物是否真正满足用户的原始请求。
规则：
- 将最终输出与原始请求进行比较，而不是与协调员的计划进行比较
- 标记所要求的内容与交付的内容之间的任何差距
- 识别合并输出中的矛盾
- 识别在合并中被遗漏或误解的任何子代理输出
- 不要软化发现的问题，暴露每一个真正的问题
如果输出不完整：准确列出缺少的内容。
如果输出错误：识别哪个子代理的输出导致了它。
如果输出完整且正确：确认并放行。
成功：任何损坏或不完整的内容都无法通过你的检查。
```
这三个提示词是一个能产生连贯交付物的群体和一个产生 300 个你必须手动缝合的碎片的群体之间的区别。
## 你需要的仓库
这是最重要的部分。收藏每一个。
关于群体本身：
github.com/moonshotai/Kimi-K2 是官方仓库。权重、vLLM 和 SGLang 的部署指南、API 文档、自托管或 API 集成的完整设置。从这里开始。
github.com/chongdashu/cc-kimi-k2-thinking-prompts 展示了如何通过更改单个环境变量，通过 Claude Code CLI 使用 K2.6。Claude Code 的完整代理循环，由 K2.6 的大脑以一小部分成本完成工作。
github.com/dnnyngyen/kimi-agent-internals 包含了 Kimi 所有六种内置代理类型的提取系统提示词，包括 Base Chat、OK Computer、Docs、Sheets、Slides 和 Websites，以及完整的技能定义和工具模式。这是最接近 Moonshot 自己代理构建方式的逆向工程手册。
关于编排：
github.com/langchain-ai/langgraph 是大多数生产并行代理团队都在运行的开源编排框架。成熟、有状态，对图有完全控制。
github.com/joaomdmoura/crewAI 是一个更容易的入口点，如果你想基于角色的代理定义而不自己编写图逻辑。功能较弱，但更友好的入门通道。
github.com/microsoft/autogen 是微软的基于对话的多代理协作框架。最适合代理辩论或优化彼此输出而不是纯粹并行运行的工作流。
github.com/musistudio/claude-code-router 是混合模型群体的缺失部分。一个界面，多个模型后端，针对每种代理类型的路由逻辑。
关于提示词和模式：
github.com/asgeirtj/system_prompts_leaks 在一个地方汇总了 K2.6、Opus 4.8 和 GPT-5.5 的泄露系统提示词。研究每家公司如何塑造其模型的行为，是你能做的最高杠杆的提示词工程练习之一。
github.com/f/awesome-chatgpt-prompts 拥有 14 万多颗星，是规范的提示词库。适用于所有三种模型，为你提供几乎所有代理模式的模板。
github.com/CheswickDEV/claude-opus-4.8-prompt-optimizer 是一个元提示词，可将原始提示词转换为针对新的 xhigh effort tier 优化的生产级 XML 结构提示词。当你的协调员在 Opus 上运行时非常有用。
## 技能：静悄悄的力量倍增器
大多数人会跳过这一部分。他们不应该。
K2.6 的群体有一个名为技能的功能。你上传任何文档、任何 PDF、任何电子表格、任何演示文稿，群体会将其结构和风格的 DNA 提取为可重用的模板。
之前的天体物理学论文示例变成了一个技能。现在，未来的每一次天体物理学论文运行只需要 12 分钟而不是 30 分钟，因为群体已经知道输出结构、图表样式、引用格式和章节层次结构。
人们现在正在运行的真实技能：
一个 WEF 风格的报告技能，接受任何研究输入并生成一个完整的...