Kimi K3 Swarm Max: How to Run 300 Research Agents from a Single Prompt

Kimi K3 dropped on July 16, 2026. 2.8 trillion parameters. 1 million token context. The largest open-weight model ever released.

The headline feature is K3 Swarm Max: up to 300 sub-agents running in parallel, coordinating across 4,000 steps, producing real files instead of chat answers. Two variants share the same brain. K3 Max handles everyday tasks. K3 Swarm Max points a fleet at the problem.

Most people open Kimi, type a question, get an answer, close the tab. That is about 10% of what the product does. This guide covers the other 90%.

The swarm is not a bolt-on. The orchestrator is a learned policy trained with Parallel-Agent Reinforcement Learning. You describe the goal. The swarm decides how to split it, how many agents to spawn, and how to stitch the results back together. Swarms win on broad, parallelizable work: research across 50+ sources, batch analysis, competitive monitoring, dataset building. They struggle on deep sequential tasks where step 3 depends on step 2.

• Write a spec, not a prompt

"Research the fitness app market" is how you burn credits and get junk. A one-line prompt gives the swarm permission to decide everything. It will decide wrong.

Treat the swarm like a contractor. A spec defines what to collect, what counts as valid, which sources are allowed, the exact output format, and what to do on conflict. The spec is the single highest-leverage artifact in the whole workflow, because in Level 2 it becomes the seed of your reusable Skill.

1# PROJECT: [name]
2GOAL: [one sentence, the deliverable, not the topic]
3SCOPE: [what is in, what is explicitly out]
4RULES: [validation, what counts as a verified finding]
5SOURCES: [official posts, papers, primary only, no aggregators]
6OUTPUT: [file type / count / naming / format details]
7ON CONFLICT: flag the row, never resolve silently
8STOP CONDITION: [when to halt and report instead of guessing]

• Read the decomposition plan before you spend

After you submit the spec, Kimi shows you the execution plan before it runs: how many sub-agents, what each one handles, the dependency order, the step budget. This is the step first-timers skip, and it is the most expensive one to skip.

A 200-agent swarm decomposed wrong costs real money. Checking the plan costs nothing. You are looking for three things: does it understand the scope, is the agent count sane for the task, and does the output plan match what you actually need.

1Show me the proposed decomposition before running:
2- how many sub-agents, and what each one handles
3- the dependency order (what blocks what)
4- estimated step budget
5- where the biggest quality-drop risk sits
6Do NOT execute yet. Wait for my confirmation.

One detail worth knowing: the 4,000 steps is a total coordinated budget across the swarm, not 4,000 per agent. A 300-agent run averages roughly 13 steps each. That tells you whether your task fits the shape.

• Run it

Now you execute. Up to 300 sub-agents fire in parallel waves, each in its own bounded context. Only structured output flows back to the coordinator.

1Execute the spec end to end.
2Parallelize wherever the plan allows.
3Flag any blocker immediately, do not work around it silently.
4Merge everything into the OUTPUT defined in the spec.

What you have after Level 1

A single swarm output built from your spec. Raw, unverified, but structured. Most people stop here. The value starts in Level 2.

• Demand real files, not a chat answer

"A comprehensive report" gives agents permission to stop early. "A 40-page PDF + one CSV with 20,000 rows + 14 export-ready PNG charts" gives them a quality target.

Lead the spec with the output, always. Specificity at the output level is the difference between a research team and an expensive suggestion box.

1# strong output examples:
2OUTPUT: 1 .xlsx, one row per model, + 200-word brief
3OUTPUT: 30 HTML files, one per store, named by business
4OUTPUT: 40-page PDF + 20,000-row CSV + 14 PNG charts

• Demand real files, not a chat answer

"A comprehensive report" gives agents permission to stop early. "A 40-page PDF + one CSV with 20,000 rows + 14 export-ready PNG charts" gives them a quality target. Lead the spec with the output, always. Specificity at the output level is the difference between a research team and an expensive suggestion box.

1# strong output examples:
2OUTPUT: 1 .xlsx, one row per model, + 200-word brief
3OUTPUT: 30 HTML files, one per store, named by business
4OUTPUT: 40-page PDF + 20,000-row CSV + 14 PNG charts

• Point a separate model at the output

The swarm's known flaw: unless you explicitly demand verification, it produces confident, under-cited claims, and independent sub-agents sometimes contradict each other. "Looks done" and "is correct" are different planets.

Use a second model as the verify gate. Its only job: refute, not praise. You are not paying premium tokens to generate. You are paying them to catch the silent flaw before the next step saves the workflow as a reusable Skill.

1You are the VERIFIER. A swarm of agents produced the attached output.
2Your only job is to find what is wrong.
3
4Check:
5- Does every claimed figure trace to a named source?
6- Do any two sections contradict each other?
7- Is anything presented as fact that is actually inference?
8- Does the output match the spec's format requirements?
9
10For each issue: cite the exact location and the fix.
11If everything holds: APPROVED.
12If anything fails: REJECTED + the single most critical fix first.

• Save the whole workflow as a Skill

After a verified run, tell Kimi to capture the entire workflow: input format, agent steps, output format, validation rules. The first run takes 20 minutes. Every run after takes 30 seconds. The Skill is the reason the system compounds instead of restarting every time.

1Save this entire workflow as a reusable Skill: "[name]"
2Capture:
3- input format (what files / spec shape it expects)
4- the agent steps that worked
5- the output format and naming convention
6- the validation rules from the spec
7Next time I run this, I attach new files and get the same shape.

What you have after Level 2

A verified output you can trust, and a saved Skill you can replay without rebuilding the spec. This is where the loop starts compounding.

• Feed your own documents in as swarm knowledge

Skills capture process. Document-to-Skill captures domain. Upload your best work and Kimi captures its structural fingerprint as a skill every future swarm applies.

Every PDF, transcript, or spreadsheet you feed in becomes context that all 300 agents ground against, instead of falling back on training data. The more you feed it, the more the output reads like your work instead of generic AI.

1Capture this document as a reusable skill. Identify what makes it work:
2- structure and section order
3- tone and voice register
4- depth of analysis per section
5Save it as "[name]". Then produce a new document on [different topic]
6using the captured skill. Match the quality bar, not the content.

• Turn every rejection into a permanent rule

The verify step catches a flaw once. This step makes sure the swarm never makes it again. Distill the feedback into hard rules and write them into a constraints file the swarm reads before doing anything.

1# CONSTRAINTS.md, loaded automatically
2- every claimed figure must trace to a primary source or be flagged
3- no silent conflict resolution: surface contradictions
4- [rule distilled from last run's verifier feedback]
5- [the mistake you never want repeated]
6Scope-lock: do not touch anything outside the spec's SCOPE block.

• Replay the skill on new inputs

This is where "compounding" stops being a buzzword and shows up on the invoice. Run two does not start from zero. It starts from the skill, the swarm knowledge, and the constraints file you built above. Same workflow, new files, a fraction of the setup.

The economics shift dramatically on replay. K3's cache-hit pricing drops to $0.30 per million tokens for repeat context, 10x cheaper than the first-run input price. The skill, constraints, and spec are all repeat context. Only your new input files cost the full rate. The first run is an investment. Every subsequent run harvests the return.

The output also improves structurally. The Skill enforces the format. The constraints block every mistake the verifier already caught. The swarm knowledge grounds every agent against your actual documents instead of training data. Run four does not just cost less than run one. It produces better results, because the system has learned from three rounds of real feedback.

1Run the saved skill "[name]" on these new inputs.
2Apply CONSTRAINTS.md. Use the captured output format.
3[attach new files]
4
5Compare this run's output against the last run.
6Report:
7- new findings not present last time
8- findings that changed since last run
9- anything that disappeared (flag as potential gap)
10- deviations from the skill's expected shape

What you have after Level 3

A self-improving research pipeline. Each run is cheaper, faster, and more accurate than the last because the skill library, knowledge base, and constraints file keep growing.

• Promote the skill to a scheduled agent

Once the loop is stable and skill-backed, you stop launching it by hand. Point Kimi at a trigger: a schedule, a new file drop, a monitored URL. Let it run the whole swarm proactively, surfacing only the deliverable and the deviations worth your attention.

Competitive monitoring is the clean example. Run one: you build and verify by hand. By the time it is a background agent, it is checking every competitor in parallel weekly and dropping a brief in your inbox at zero marginal time cost. The only human left in the loop is the question you set and the decision you make on the answer.

1Run skill "[name]" on a weekly schedule.
2Trigger: [schedule / new file / monitored URL]
3On each run: execute the swarm, apply CONSTRAINTS.md,
4verify, then deliver the OUTPUT + a diff vs last run.
5Only ping me if a deviation crosses [threshold].

What 2.8T parameters don't fix

Hallucination scales with parallelism. More agents searching means more confident wrong answers unless you run a verify pass. The swarm does not fact-check itself.

K3 costs 3-4x more than K2.6. Input: $3.00/M vs $0.95/M. Output: $15.00/M vs $4.00/M. Cache helps on replays, but the first run is expensive. For pure cost optimization, K2.6 is still the budget play.

Open weights are not out yet. Moonshot promised them by July 27, 2026. Until then, K3 runs only via the API and the Kimi app.

Swarms amplify bad specs. A vague prompt through one agent wastes one context window. Through 300 agents it wastes 300 in parallel.

The short list

• One-liner prompts. The swarm decides everything. It decides wrong.
• Skipping the decomposition review. The most expensive step to skip.
• No verify pass. "Looks done" is not "is correct."
• Saving unverified output as a skill. The mistake compounds on every future run.
• 300 agents on a sequential task. A swarm cannot parallelize a chain of thought.
• Using K3 where K2.6 is enough. Not every task needs 2.8T parameters.

Conclusion

Most people will open Kimi, type a question, close the tab. That is the chatbox. It is about 10% of what K3 does.

The other 90% is a research team you build once and replay forever. Each level unlocks more leverage: first run, then trust, then compounding, then autonomy. You do not need all four on day one. Start at Level 1 with one spec. If the output is useful, move to Level 2 and verify it. If you plan to run it again, save the Skill. The system gets sharper from there on its own.

Write the spec, not the prompt. Verify before you save. Then watch every run get cheaper and sharper than the last.