# 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)
---
以下就是每天发生的事情。
收藏这篇文章吧 :)
大多数人使用 AI 的方式仍停留在 2010 年使用 Google 的阶段：输入一个查询，阅读答案，再输入下一个。一条单线程对话，一次只处理一个项目。
但一个能够规划并调用工具的模型，不必一次只处理一个项目。把 100 份 PDF 交给它，显而易见的做法不是按顺序逐一处理：而是一次性打开全部 100 份，每个文件一个阅读器，再由一个协调器把所有阅读结果整合起来。提示词长度保持不变。工作在背后扇形展开。你从单线程变成扇形结构：一条指令输入，生成一百个工作者，产出一个整合好的交付物。
这就是全部的转变，也是“用一个周末读 100 篇论文”和“喝一杯咖啡的时间读完”之间的区别。接下来是成本测算、环境搭建、提示词、代码仓库、工作流，以及这套方案悄然失效的地方。
## 真实的成本状况
这正是大多数人在开始之前就放弃的地方。他们以为运行 300 个智能体一定费用高昂。其实不然。
以一个真实任务为例：将 100 份 PDF 研究论文分析成一篇带引用的文献综述。
使用 Claude Opus 4.8 的串行方式：智能体实际运行时间约 6 小时，输入每百万 token 5 美元，输出每百万 token 25 美元。估计成本：每次运行 40 至 60 美元，取决于文档长度。还要加上你监督所花的时间。
使用 Kimi K2.6 智能体集群的并行方式：100 个智能体同时启动，每个处理一篇论文。由协调器合并。实际运行时间：12 至 18 分钟。成本：每次运行 3 至 5 美元。
同一个任务，15 倍的速度提升和 10 倍的成本优势。这笔账差距悬殊。
再放大规模看。分析 50 个客服工单找出规律。为 100 个潜在客户定制 100 封冷启动开发邮件。把 40 份学术 PDF 转换成一篇带引用的 10 万字文献综述。抓取 30 家实体企业信息并分别为其生成独立落地页。这些任务过去要么需要一支外包团队，要么需要一整天的串行工作。
现在只需要一条提示词、一次咖啡休息时间，不到 10 美元。
拥有这套工具组合的独立运营者，竞争对手已不是其他独立运营者，而是代理公司。
## 四月真正改变了什么
同一个月里发生了三件事，让这一切第一次成为现实。
Kimi K2.6 于 4 月 20 日发布。由月之暗面打造，以修改版 MIT 许可证开源。该模型经过原生训练，可以通过单条提示词协调多达 300 个子智能体，执行 4,000 个协同步骤。这是 K2.5 上限的三倍。这种编排能力不是外挂在聊天界面上，而是内建于模型层。总参数量 1 万亿，每个 token 激活 320 亿参数，256k 上下文窗口，每次响应最大输出 65,536 个 token。定价：输入每百万 token 0.80 美元，输出每百万 token 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 自主重构了一套有 8 年历史的金融撮合引擎，耗时 13 小时，迭代了 12 种优化策略，进行了超过 1,000 次工具调用，修改了超过 4,000 行代码，最终实现 185% 的吞吐量提升。月之暗面自己的一个团队曾让它作为自主智能体连续运行五天，在无人干预的情况下管理监控、事件响应和系统运维。
Claude Opus 4.8 于 4 月 16 日发布。子智能体可靠性显著提升。新增的 xhigh 努力等级让复杂智能体链更加确定化。SWE-bench Pro 以 64.3% 领先。视觉能力在分辨率升级后从 54.5% 跃升至 98.5%。在生产级代码质量和法律级精确度方面依然是黄金标准。价格仍是每百万 token 5/25 美元。
GPT-5.5 于 4 月 23 日发布。计算机操作能力在 OSWorld-Verified 上跃升至 78.7%，意味着智能体现在可以真正操作真实图形界面而不出错。长上下文检索达 74%，而 Claude 在同一基准上为 32.2%。网页研究在 BrowseComp 上达 90.1%。定价为每百万 token 5/30 美元，但实际使用中每个任务的输出 token 更少。
规律很明显：一周之内出现三个前沿模型，各有明确专长。输家是那些选了一个就一条道走到黑的开发者。赢家是那些为每个任务分配最合适大脑的人。
具体到并行智能体集群，K2.6 是唯一一个从零开始就为此规模协调而训练的模型，而且价格让普通人真正用得起。
## 300 个并行智能体实际是什么样的
这才是关键部分。不是参数表，而是实际交付成果。以下每一个都来自 2026 年 4 月真实用户运行过的真实提示词。
文献综述运行。上传 40 份学术 PDF。产出：一篇 10 万字的文献综述，附带完整引用的数据集。40 个智能体，每人负责一篇论文，通过单一合并步骤协调。总运行时间不到 20 分钟。
天体物理论文转换。输入一篇天体物理论文。产出是一份 40 页的研究报告、一个 2 万行的支持数据集和 14 张达到出版级别的图表。随后整个产出被封装成一个可复用的 Skill（技能），智能体系统可以自动将其应用于未来每一篇天体物理论文。第一次运行花了 30 分钟。此后每次处理新论文只需 12 分钟，因为 Skill 已经捕获了处理结构。
Google Maps 到落地页的工作流。一条提示词：在 Google Maps 上搜索洛杉矶目前没有网站的零售店，找出 30 家不重复的商家，抓取店面照片和顾客评价，为每一家构建一个高转化落地页，包含地址、营业时间、针对其业务类型量身定制的价值主张以及联系方式。输出：30 个独立落地页，外加一个列出全部 30 家店铺完整元数据的 Excel 表格。运行时间：不到 45 分钟。
求职自动化。100 份职位描述与一份简历进行匹配。输出：100 份逐一量身定制的简历，每份都针对该职位的具体要求和用语进行了优化。这种工作，自由职业的职业教练每份简历收费 50 美元。整个运行的总成本：不到 4 美元。
杂志封面系列。一条提示词，要求生成 10 张小报风格的杂志封面，配以真实的历史头条。每个智能体研究一个不同的历史时期，生成头条，设计封面。输出：一条输入提示词产出 10 张精修杂志封面。
五天自主运行。Moonshot 内部团队让 K2.6 接管了他们的监控和事件响应流水线。它连续运行了五天，处理警报、提交拉取请求、在 Slack 上发布消息、升级真实事件。全程无人干预。这不是演示。这就是 2026 年一名自主值班工程师的样子。
只要你曾为批处理工作付过钱，你的整条流水线刚刚被自动化了。
## 实际如何搭建
你不需要构建框架。你不需要分布式系统博士学位。基础设施已经就绪。
方案 1：零配置网页界面
前往 kimi{.}com/agent-swarm。描述你的任务。指定子智能体数量。上传任何文件。运行。这就是入口。无需安装，无需 API 密钥，无需配置。网页 UI 会处理智能体分解、协调以及最终输出的组装。
适用于：一次性批处理任务、文档处理工作流、研究项目，以及任何你想在投入写代码之前先测试任务是否可并行的场景。
方案 2：用于生产工作流的 API 集成
如需程序化访问并集成到你自己的流水线中，直接使用 Moonshot API 的 K2.6 端点。文档位于 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
```
将 model 参数指向 Kimi K2.6 端点，通过 OpenRouter 路由，实现对所有模型供应商的统一计费。这就是生产团队正在使用的方案。
何时使用：你有一个包含自定义分支逻辑、子智能体之间条件路由或人工检查点的复杂有状态工作流。LangGraph 提供图结构，K2.6 提供定价优势和并行执行能力。
方案 4：用于混合模型集群的 Claude Code Router
github.com/musistudio/claude-code-router 让你运行 Claude Code 的界面，但将特定子智能体路由到最适合该任务的模型。协调器用 Opus 4.8 以获得高可靠性规划，大量子智能体用 K2.6 以获得高性价比的并行执行，GUI 导航用 GPT-5.5 的 computer-use 子智能体。
这是你今天能搭建的最高性价比并行技术栈。协调器大约只占总 token 的 5%，但需要最高可靠性。300 个子智能体处理 95% 的 token，需要最高的成本效率。将每一层路由到合适的模型，相比全部跑在单一模型上，能再削减 60% 的总成本。
## 立即可安装的提示词
三段系统提示词。一段给协调器，一段给子智能体，一段给验证器。将它们安装为集群配置中的持久系统提示词，或粘贴到任何会话的开头。
给协调器智能体：
```
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.
```
给集群中的每个子智能体：
```
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.
规则：
- 先完整阅读子任务规范，再开始任何操作
- 不要把工作范围扩大到被分配的任务之外
- 按照要求的精确格式返回输出，不加前言、不加评论
- 如果遇到阻碍，返回明确的标记，而不是靠猜测
- 如果你的子任务需要分配范围之外的信息，向协调员标记出来，而不是自己去补
- 返回前对照规范核验你的输出
成功标准：你的输出可以直接接入合并步骤，无需协调员再做清理。
```
用于最后的校验环节：
```
你是已完成群体输出的校验器。
你的任务：检查合并后的交付物是否真正满足原始用户请求。
规则：
- 将最终输出与原始请求对比，而不是与协调员的计划对比
- 标记出所要求内容与实际交付内容之间的任何差距
- 识别合并输出中的矛盾之处
- 识别在合并过程中被丢弃或被误解的任何子智能体输出
- 不要弱化发现的问题，呈现每一个真实问题
如果输出不完整：精确列出缺失的内容。
如果输出有误：指出是哪个子智能体的输出导致的。
如果输出完整且正确：确认并放行。
成功标准：任何破损或不完整的内容都不能通过你的检查。
```
这三个提示词决定了一个能产出连贯交付物的群体与一个只能产出 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）提取出的系统提示词，外加完整的 Skill 定义和工具模式。这是目前最接近逆向工程出来的、关于 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.3 万以上星标，是经典提示词库。适用于全部三个模型，为几乎任何智能体模式提供模板。
github.com/CheswickDEV/claude-opus-4.8-prompt-optimizer 是一个元提示词，可将原始提示词转化为针对全新 xhigh 努力等级优化的生产级 XML 结构化提示词。当你的协调员运行在 Opus 上时非常有用。
## Skills：安静的力量倍增器
大多数人会跳过这一部分。他们不应该。
K2.6 的群体有一个叫 Skills 的功能。你上传任何文档——任何 PDF、任何电子表格、任何幻灯片——群体就会提取其结构和风格 DNA，生成可复用的模板。
前面那个天体物理论文的例子变成了一个 Skill。于是现在每一次天体物理论文运行只需 12 分钟而不是 30 分钟，因为群体已经知道了输出结构、图表样式、引用格式和章节层级。
人们现在正在运行的真实 Skills：
一个 WEF 风格报告 Skill，接收任何研究输入，产出一篇排版完整的机构研究报告，具备正规字体排印、配色方案、双栏布局、图表编号和方法论附录。
一个水墨演示 Skill，可将任何内容转化为优雅的黑白水墨风格幻灯片，配有手绘插图、单色水彩美学和不对称布局。
一个融资路演 Skill，可将你的原始商业想法转化为精致的、可拿给投资人的演示文稿。
模式每次都一样：上传一份你最佳输出的示例，群体捕获其 DNA，该领域的每个后续任务都会自动继承这种质量。
这正是杠杆复利发挥作用的地方。你不再需要每次都重新发明你工作的结构。每个 Skill 都让未来的每次运行更便宜、更快速、更一致。
如果你从整篇文章中只做一件事，那就是在本周用你过去三份最好的作品构建三个 Skill。你的输出质量和速度将发生永久性转变。
## 你可以在这个周末搭建的真实工作流
这些不是假设。每一个现在都在生产环境中运行。
1. 竞争情报流水线。50 个智能体分别指向 50 个竞争对手网站。每个智能体提取定价、功能、定位、近期更新和客户评价。协调员将其合并为一份竞争格局报告。每周运行一次。你会比行业中的任何人都更了解这个市场。运行时间：20 分钟。成本：不到 5 美元。
2. 内容生产流水线。20 个智能体从不同角度研究同一个主题。一个协调者将发现整合成大纲。一个写作智能体起草。一个编辑智能体润色。人类四小时的工作变成了智能体 15 分钟的运行时间。用你最好的文章构建一个 Skill，之后每篇文章都继承其结构。
3. 冷启动外联个性化套件。上传 100 个潜在客户的姓名和公司。100 个智能体各自研究一个潜在客户，找到他们近期的作品，识别相关痛点，用你的语气起草一封定制外联信息。不是千篇一律的 AI 垃圾内容。而是真正并行执行的个性化。每条消息的成本：不到 5 美分。
4. 遗留代码库审计。启动多个智能体，每个智能体分析大型代码库的不同模块。一个智能体生成架构文档。另一个查找死代码。另一个标记安全问题。另一个建议重构候选。协调者生成一份审计报告。这种审计咨询公司要收 5 万美元。现在一夜之间跑完，成本不到 50 美元。
5. 批量自由职业服务自动化。有服务型业务？求职信撰写、简历定制、提案起草、市场调研、广告文案变体。构建一个集群，将每个任务从接单处理到交付。一个操作者就能处理整个代理机构的工作量。
6. 文档生成流水线。让智能体指向代码库中的每个文件。每个智能体为其分配的模块生成文档。协调者合并成一个文档站点。每次提交时自动维护。
7. 自主监控智能体。让一个长时间运行的 K2.6 智能体盯着你的错误日志和部署流水线。当出现故障时，它会识别相关的提交，起草修复方案，并附上上下文发布到 Slack。你的值班工程师审查一个拉取请求，而不是凌晨 3 点盯着空白终端发呆。
8. 产品发布协调集群。一个智能体撰写 PRD。一个设计原型图。一个撰写发布博客文章。一个起草社交媒体营销方案。一个构建落地页。一个起草媒体外联。全部并行进行，全部合并为一个协调的发布包。
9. 深度市场调研。针对一个研究问题启动 30 到 50 个智能体，每个覆盖不同角度。协调者合并并解决矛盾。在以前阅读 10 篇文章所需的时间内，生成带有完整引用的结构化报告。
10. SaaS 原型组装。描述产品、技术栈和功能列表。K2.6 并行搭建前端、后端、DevOps 配置、数据库模式（schema）和身份验证层。把输出交给 Opus 4.8 加固生产关键路径。以前需要一个月的周末 MVP。
## 实现最大杠杆的模型路由
最聪明的做法不是把所有事情都跑在 K2.6 的集群上。最聪明的做法是把集群的每一层路由到最合适的模型。
协调者用 Opus 4.8。协调者大约只占总 token 的 5%，却做出 95% 的战略决策。可靠性比成本更重要。用最好的。
批量子智能体用 K2.6。300 个子智能体处理 95% 的总 token。成本效率最重要。K2.6 是唯一让 300 个并行智能体在经济上可行的模型。
网络调研子智能体用 GPT-5.5。当子智能体需要浏览和综合网络信息时，GPT-5.5 的 90.1% BrowseComp 得分和卓越的长上下文检索能力领先于其他一切。专门将浏览类子智能体路由到 GPT-5.5。
视觉子智能体用 Opus 4.8。任何需要解读图像、设计布局或处理视觉参考的子智能体都应路由到 Opus 4.8 的 98.5% 视觉敏锐度得分。
计算机操作子智能体用 GPT-5.5。GUI 操作、浏览器自动化，任何需要实际界面控制的任务。GPT-5.5 的 78.7% OSWorld-Verified 得分是市场上最高的。
设置一次即可。使用 Claude Code Router 处理路由逻辑。与单模型执行相比，你的集群总成本再下降 40% 到 60%。
这就是 2026 年的精通之道。不是忠于一个工具，而是无情地将每一层工作路由到最佳工具。
## 诚实的警告
我会给你不加粉饰的版本，因为炒作对任何人都没有帮助。
在最复杂的长时程任务上，并行智能体编排仍然脆弱。如果你的工作流程需要深度顺序推理，即每一步都以不明显的方式依赖上一步，那么并行化没有帮助，甚至可能有害。当子任务实际上并不独立时，合并步骤就会开始产生矛盾。
在工作真正可并行的场景使用集群：研究、批量生成、多文档分析、大规模内容生产，以及任何具有“极易并行”结构、即 50 个输入通过相同变换变成 50 个输出的任务。
对于顺序推理、单文件调试、新颖架构决策，或任何可靠性（数百个依赖步骤）比吞吐量更重要的任务，你仍然需要一个像 Opus 4.8 这样的单一高质量模型线性工作。
其他真实警告：
编排开销并非为零。启动 300 个智能体需要几分钟的协调时间。对于相当于 10 分钟以内顺序工作的任务，开销会吃掉收益。不要对小任务使用集群。
K2.6 的工具模式（tool-schema）重试率略高于 Anthropic 或 OpenAI。如果你的子智能体严重依赖调用结构化工具 API，你会看到 Opus 不会出现的偶尔重试。
K2.6 在纯数学上不领先。如果你的子智能体需要进行繁重的数值推理，专门把它们路由到 GPT-5.5。
K2.6 API 尚不支持图像输入。图像密集的子任务需要路由到 Opus 或 GPT-5.5。
并行智能体不是魔法。它们是针对合适任务的杠杆。任务契合时收益巨大。不契合时损失也是真实的。
## 思维模式的转变
在过去两年里，每个 AI 工作流面临的问题都是：哪个模型最适合这个任务？
当模型是串行运行的、且它们之间的差异显著时，这个问题是对的。
2026 年的问题不一样了。这个任务能否并行化？如果能，处理每个子任务、且质量可接受的最便宜模型是什么？
这是一种完全不同的思考 AI 工作的方式。
10 倍效率的操作者不是拥有最好的单一模型的人。10 倍效率的操作者是在别人还在一次运行一个提示词时，就已经把工作分解成 50 个并行子任务，然后把每个子任务路由到适合该工作的模型的人。
大多数人会读完这篇文章，觉得有趣，然后继续串行工作。基础设施太新了，思维转变也太不舒服了。没关系。这恰恰也是机会所在。
本周真正重构自己工作流的人，将在 30 天内运作在一个完全不同的层次上。不是因为他们会更聪明，而是因为他们每天运行的尝试次数将是竞争对手的 50 到 100 倍。
更多的尝试意味着更多的学习。更多的学习意味着更多的产出。更多的产出意味着更多的杠杆。
这是复利。
基础设施已经就位。定价已经就位。工具已经就位。仓库是公开的，文档已经写好，提示词就在上面。
唯一的问题是：你是现在就搭建并行智能体技术栈，还是等别人先做。
2026 年在 AI 领域遥遥领先的人，不是订阅最贵的人。而是在并行智能体集群这一转变变得显而易见之前，就理解了它的人。
我会拆解每一个主流 AI 工作流和工具栈，让你不必独自摸索。
关注我 @eng_khairallah1 获取更多 AI 课程、工具和工作流。每周都有新内容。
希望这对你有用，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)
- [升级到 Premium](https://x.com/i/premium_sign_up)
- [2026年6月4日 下午5:10](https://x.com/eng_khairallah1/status/2062461939318730818)
- [218.6K 次浏览](https://x.com/eng_khairallah1/status/2062461939318730818/analytics)
- [查看引用](https://x.com/eng_khairallah1/status/2062461939318730818/quotes)
---
*导出时间: 2026/6/5 11:03:03*
