Claude Code Agent Teams Explained: Definition & Setup

Relying on a single AI session for complex, multi-domain workflows is inherently slow. Claude agent teams solve this by executing specialized agents in parallel, delivering deeper outputs at much higher speeds. This guide covers how Claude Code agent teams work, how to set them up, and best practices for maximizing their value.在处理复杂、多领域的工作流时，依赖单一的 AI 会话本质上是缓慢的。Claude 智能体团队（Agent Teams）通过并行执行专业智能体来解决这一问题，从而以更高的速度交付更深入的产出。本指南介绍了 Claude Code 智能体团队的工作原理、设置方法以及最大化其价值的最佳实践。

Claude Code agent teams are a multi-instance coordination system where multiple Claude sessions work in parallel on the same codebase. One session is designated as the lead agent, receives the overall task, decomposes it into subtasks, and synthesizes the final output. The other sub-agents are teammates, each running in their own isolated context window, own a discrete piece of work, and communicate with other teammates directly.Claude Code 智能体团队是一个多实例协作系统，允许多个 Claude 会话在同一代码库上并行工作。其中一个会话被指定为“主智能体”（Lead Agent），负责接收总体任务、将其分解为子任务并整合最终产出。其他“子智能体”（Teammates）则作为团队成员，各自在独立的上下文窗口中运行，承担具体的离散工作，并直接与其他成员进行沟通。

Agent teams differ from typical AI assistants in that they process tasks sequentially, one at a time. Agent teams break that constraint: when work can be genuinely parallelized, the wall-clock time drops accordingly.智能体团队与典型的 AI 助手不同，后者通常按顺序逐一处理任务。智能体团队打破了这一限制：当工作确实可以并行化时，实际耗时（wall-clock time）会相应缩短。

Meanwhile, agent teams are more than multiple sessions, for the coordination layer adds three capabilities that manual multi-session work lacks:同时，智能体团队不仅仅是多个会话的简单叠加，其协调层增加了手动多会话工作所缺乏的三种能力：

• Peer-to-peer messaging: Teammates can send messages directly to each other without routing through you or the lead. For example, an agent team with a security reviewer can flag a finding to the performance reviewer mid-run without stalling the whole team.点对点消息传递：团队成员可以直接互相发送消息，无需通过用户或主智能体进行路由。例如，拥有安全审查员的智能体团队可以在运行过程中向性能审查员标记发现的问题，而无需暂停整个团队。

• File locking: When a teammate writes to a file, it acquires a lock that prevents concurrent writes from other agents. This blocks the silent-overwrite class of merge conflicts.文件锁定：当某个成员写入文件时，它会获取一个锁，防止其他智能体同时进行写入。这杜绝了静默覆盖类的合并冲突。

• Dependency tracking: The lead encodes task dependencies during decomposition. The coordination layer enforces them, so no agent starts before its prerequisites are met, without manual polling.依赖项跟踪：主智能体在分解任务时会编码任务依赖关系。协调层会强制执行这些关系，确保在满足先决条件之前没有任何智能体启动，且无需手动轮询。

An agent team consists of the following components, each with a specific role:智能体团队由以下组件组成，每个组件都有特定的角色：

The team lead is the main Claude Code session. It creates the team, spawns teammates, coordinates work across them, and synthesizes the final result. This is the session you interact with directly.主智能体（Team Lead）是主要的 Claude Code 会话。它负责创建团队、生成团队成员、协调各成员的工作并整合最终结果。这是你直接交互的会话。

Teammates are separate Claude Code instances, each working independently on their assigned tasks within their own context window. They don't share context with the lead or with each other; their communication happens explicitly, through the task list and the mailbox.团队成员（Teammates）是独立的 Claude Code 实例，每个实例都在其自己的上下文窗口中独立处理分配的任务。它们不与主智能体或其他成员共享上下文；它们的通信是通过任务列表和邮箱显式进行的。

The shared task list and the mailbox enable coordination. The shared task list is a live queue that the agent group reads from and writes to. The lead populates it at decomposition time, and teammates claim tasks, work through them, and mark them complete. Dependencies are enforced automatically; when a teammate completes a task, any tasks that were blocked on it unblock without manual intervention. The mailbox is the messaging system for direct agent-to-agent communication. Messages flow automatically between teammates and the lead.共享任务列表和邮箱实现了协作。共享任务列表是一个智能体组可以读取和写入的实时队列。主智能体在分解任务时填充该列表，团队成员领取任务、完成任务并将其标记为完成。依赖关系会自动强制执行；当一个成员完成任务后，任何被其阻塞的任务都会自动解锁，无需人工干预。邮箱是用于智能体之间直接通信的消息系统。消息会在团队成员和主智能体之间自动流转。

Both the team config and the task list are stored locally (~/.claude/teams/ and ~/.claude/tasks/). Claude Code generates and maintains these files automatically. Do not edit them by hand, as any changes will be overwritten during the next state update.团队配置和任务列表都存储在本地（~/.claude/teams/ 和 ~/.claude/tasks/）。Claude Code 会自动生成并维护这些文件。请勿手动编辑它们，因为任何更改都会在下一次状态更新时被覆盖。

Claude agent teams are disabled by default in Claude Code. They're labeled experimental and require an explicit opt-in. Here's the complete setup path. Before enabling agent teams, you should confirm that your Claude Code version is v2.1.32 or later. You can run claude --version in the terminal to check.Claude 智能体团队在 Claude Code 中默认处于禁用状态。它们被标记为实验性功能，需要显式启用。以下是完整的设置路径。在启用智能体团队之前，请确认你的 Claude Code 版本为 v2.1.32 或更高版本。你可以在终端运行 claude --version 进行检查。

Set the CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS environment variable to 1. Three ways to do this:将 CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS 环境变量设置为 1。有三种方法可以做到这一点：

Option A: ~/.claude/settings.json (recommended)选项 A：~/.claude/settings.json（推荐）

Option B: Shell profile (~/.bashrc or ~/.zshrc)选项 B：Shell 配置文件（~/.bashrc 或 ~/.zshrc）

Option C: Inline, for a single session选项 C：内联方式，仅针对单个会话

If you edited settings.json or your shell profile, restart Claude Code for the flag to take effect.如果你编辑了 settings.json 或 Shell 配置文件，请重启 Claude Code 以使标志生效。

Agent teams display in two modes: In-process (all teammates run inside the main terminal) and split panes (each teammate has its own pane, which requires tmux or iTerm2). Running each teammate in its own terminal pane makes it significantly easier to monitor the team in real time.智能体团队有两种显示模式：进程内模式（In-process，所有成员在主终端内运行）和拆分窗格模式（Split panes，每个成员拥有自己的窗格，需要 tmux 或 iTerm2）。在各自的终端窗格中运行每个成员，可以显著方便实时监控团队状态。

To make sure to stay in split panes mode, setteammateMode in ~/.claude/settings.json:要确保使用拆分窗格模式，请在 ~/.claude/settings.json 中设置 teammateMode：

To override the default "auto" setting, set teammateMode in ~/.claude/settings.json as in-process. To force in-process mode for a single session, pass it as a flag: claude --teammate-mode in-process.要覆盖默认的“auto”设置，请在 ~/.claude/settings.json 中将 teammateMode 设置为 in-process。若要强制单个会话使用进程内模式，请将其作为标志传递：claude --teammate-mode in-process。

After enabling the agent team, simply tell Claude in natural language what tasks, deliverable, and team structure you want the agent team to do. You can specify each role in the prompt, and Claude will create the team, spawn teammates, and schedule tasks accordingly.启用智能体团队后，只需用自然语言告诉 Claude 你希望智能体团队执行的任务、交付成果和团队结构。你可以在提示词中指定每个角色，Claude 将创建团队、生成成员并相应地安排任务。

Example prompt:示例提示词：

You can specify what model your agent teams use, such as "Use Sonnet for every teammate". Teammates don't inherit the lead agent's model. Users must specify the model in the role file frontmatter or set a default teammate model via /config.你可以指定智能体团队使用的模型，例如“为每个成员使用 Sonnet”。成员不会继承主智能体的模型。用户必须在角色文件的元数据（frontmatter）中指定模型，或通过 /config 设置默认的成员模型。

For tasks of high risk and complexity, you can require the team to draw up a plan before execution. The teammates in the agent group will work in read-only mode, and the lead will review, revise, and finally pass the plan. Only when the plan is approved by the lead will the teammates start implementing.对于高风险和复杂的任务，你可以要求团队在执行前制定计划。智能体组中的成员将以只读模式工作，主智能体将审查、修改并最终通过该计划。只有在主智能体批准计划后，成员才会开始实施。

Note that the lead agent will make decisions, so you can also provide some criteria for decision-making.请注意，主智能体会做出决策，因此你也可以提供一些决策标准。

Example prompt:

If any teammate writes files, Claude Code worktrees are strongly recommended. A git worktree is a separate working directory on its own branch, sharing the same .git history as your main checkout. Each agent gets isolated file access, and edits from one worktree never touch another agent's in-progress work.如果任何成员需要写入文件，强烈建议使用 Claude Code 工作树。Git 工作树是一个位于其自身分支上的独立工作目录，与你的主检出（main checkout）共享相同的 .git 历史记录。每个智能体都能获得隔离的文件访问权限，一个工作树中的编辑永远不会触及另一个智能体正在进行的工作。

To enable this per-agent, simply add isolation: worktree to the agent's YAML frontmatter. Claude Code provisions a fresh worktree for each parallel agent invocation and cleans it up automatically when the agent finishes.要为每个智能体启用此功能，只需在智能体的 YAML 元数据中添加 isolation: worktree。Claude Code 会为每个并行智能体调用预配一个新的工作树，并在智能体完成任务后自动清理。

For CLI usage: claude --worktree or claude -w starts a session in its own worktree. The desktop app automatically creates a Claude Code worktree per session.对于 CLI 使用：claude --worktree 或 claude -w 可以在其自己的工作树中启动会话。桌面应用程序会自动为每个会话创建一个 Claude Code 工作树。

Agent teams are not set-and-forget, and long-running teams may drift. Agents might get stuck on permission prompts, mark tasks done prematurely, or lose track of scope. You can check in every 10–15 minutes and review the shared task list for stuck or unclaimed tasks. If a task hasn't moved in 20–30 minutes, it might be due to a permission block or a mis-specified role that requires manual intervention.智能体团队并非“设置好后即可不管”，长时间运行的团队可能会出现偏差。智能体可能会卡在权限提示上、过早将任务标记为完成或偏离范围。你可以每 10-15 分钟检查一次，并审查共享任务列表，查看是否有卡住或未领取的任务。如果一个任务在 20-30 分钟内没有进展，可能是因为权限阻塞或角色指定错误，需要人工干预。

Subagents are a delegation pattern. Agent teams are a collaboration pattern. The difference shapes everything from how context is managed to how much a run costs.子智能体是一种委托模式，而智能体团队是一种协作模式。这种差异决定了一切，从上下文管理方式到运行成本。

Subagents are a one-way delegation pattern: the lead sends a task, the subagent executes it within its own context window, and the result is returned. There's no shared state, no direct communication between sibling agents, and no coordination layer, just a clean dispatch-and-return loop.子智能体是一种单向委托模式：主智能体发送任务，子智能体在其自己的上下文窗口中执行，然后返回结果。没有共享状态，同级智能体之间没有直接通信，也没有协调层，只是一个纯粹的“分派-返回”循环。

Agent teams work on a shared task list with automatic dependency enforcement, and message peer-to-peer between teammates via the mailbox.智能体团队则在共享任务列表上工作，具有自动依赖强制执行功能，并通过邮箱在成员之间进行点对点消息传递。

In short, agent teams pay off when the work is divided into genuinely independent parallel tracks that need to share findings and coordinate with each other. For quick results, sequential tasks, single-file edits, or anything where cost predictability matters more than speed, subagents are the better call.简而言之，当工作被划分为真正独立的并行轨道，且需要共享发现并相互协调时，智能体团队非常值得。对于快速结果、顺序任务、单文件编辑，或者任何更看重成本可预测性而非速度的情况，子智能体是更好的选择。

Use agent teams when:在以下情况使用智能体团队：

• Teammates need to communicate directly with each other成员之间需要直接沟通

• The work requires a shared task list with dependency tracking across parallel workstreams工作需要跨并行工作流的、带有依赖跟踪的共享任务列表

• The task is too large for a single session, and each worker needs their own fully independent context任务对于单个会话来说太大，且每个工作者都需要自己完全独立的上下文

Use subagents when:在以下情况使用子智能体：

• You only need the final summary, not the full intermediate output你只需要最终摘要，不需要完整的中间产出

• The work is self-contained enough to return a clean result工作足够独立，可以返回一个清晰的结果

• You want to restrict tools or route to a cheaper model你希望限制工具使用或路由到更便宜的模型

• You need parallel research paths that don't depend on each other你需要互不依赖的并行研究路径

If you can't identify at least three genuinely independent parallel workstreams, a single session or subagents will likely outperform an agent team at lower cost.如果你无法确定至少三个真正独立的并行工作流，那么单个会话或子智能体的表现可能会以更低的成本优于智能体团队。

When the work naturally divides into scoped, bounded workstreams, those workstreams can proceed without waiting for one another (or their dependencies can be encoded explicitly), and the overhead of coordination is small relative to the time saved by running in parallel. Here are five use cases where agent teams outperform a single session.当工作自然地划分为有界限的独立工作流时，这些工作流可以在无需等待彼此的情况下进行（或其依赖关系可以显式编码），且协调开销相对于并行运行节省的时间较小时，智能体团队的表现优于单个会话。以下是智能体团队优于单个会话的五个用例。

Assign three reviewers to a pull request simultaneously, including a security agent, a performance agent, and a test coverage agent. The lead synthesizes three parallel reports into one prioritized action list. This pattern also works for architecture review (scalability agent, security agent, maintainability agent) or compliance checks across different regulatory frameworks.同时为拉取请求（PR）分配三名审查员，包括一名安全智能体、一名性能智能体和一名测试覆盖率智能体。主智能体将三份并行报告整合为一份优先级的行动列表。此模式也适用于架构审查（可扩展性智能体、安全智能体、可维护性智能体）或跨不同监管框架的合规性检查。

Spawn five agents, each with a single hypothesis, to test specific files or logs to examine a production bug. The first agent to confirm its hypothesis surfaces the fix, and the others can be stopped. This is a more efficient way than investigating each theory sequentially and spending hours of debugging one path, backtracking, and starting the next.生成五个智能体，每个智能体持有一个假设，去测试特定的文件或日志以检查生产环境中的 Bug。第一个确认其假设的智能体会提交修复方案，其他智能体可以停止。这比依次调查每个理论、花费数小时调试一条路径、回溯并开始下一条路径要高效得多。

A cross-layer refactor task contains both sequential and parallel steps. For instance, a breaking API change needs updates in backend endpoints, frontend components consuming those endpoints, and the test suite covering both. The backend work must be completed before the frontend can begin. Once the backend task is underway, the test suite agent can start scaffolding the new test structure in parallel. In an agent team, the lead uses the shared task list's dependency tracking to encode this ordering.跨层重构任务包含顺序步骤和并行步骤。例如，破坏性的 API 更改需要更新后端端点、调用这些端点的前端组件以及覆盖两者的测试套件。后端工作必须在前端开始之前完成。一旦后端任务进行中，测试套件智能体就可以并行开始构建新的测试结构。在智能体团队中，主智能体利用共享任务列表的依赖跟踪来编码这种顺序。

A technical decision may require surveying multiple independent bodies of evidence, such as choosing a database engine, evaluating three third-party APIs, and assessing build tooling. Assign each agent a non-overlapping domain, and each posts a structured summary. The lead aggregates into a comparison document. The isolation preserves an independent perspective, improving the quality of the results.技术决策可能需要调查多个独立的证据主体，例如选择数据库引擎、评估三个第三方 API 以及评估构建工具。为每个智能体分配一个不重叠的领域，每个智能体发布一份结构化摘要。主智能体将其汇总为比较文档。这种隔离保留了独立的视角，提高了结果的质量。

Upgrading a major dependency across a large codebase typically involves touching multiple modules. If those modules have clean boundaries and can migrate simultaneously, agent teams help. Assign one agent per independent module; each agent migrates its module, runs its own test suite, and reports back with a migration summary that includes any changed interfaces. The lead reviews interface changes before declaring the migration complete and coordinates the merge sequence.在大型代码库中升级主要依赖项通常涉及多个模块。如果这些模块边界清晰且可以同时迁移，智能体团队会有所帮助。为每个独立模块分配一个智能体；每个智能体迁移其模块、运行自己的测试套件，并报告包含任何已更改接口的迁移摘要。主智能体在宣布迁移完成前审查接口更改，并协调合并顺序。

Building a parallel agent system with Claude Code is straightforward to set up, but easy to get wrong. These are the design principles that determine whether your agent team performs or wastes time.使用 Claude Code 构建并行智能体系统设置起来很简单，但很容易出错。以下设计原则决定了你的智能体团队是高效执行还是浪费时间。

• Pre-approve permissions: Teammates start with the lead's permission settings. If the lead runs with --dangerously-skip-permissions, all teammates inherit that too. You can adjust individual teammate modes after spawning, but per-teammate modes cannot be configured at spawn time. Plan your permission posture through the lead before launching the team.预先批准权限：团队成员以主智能体的权限设置开始。如果主智能体在运行 --dangerously-skip-permissions，所有成员也会继承该权限。你可以在生成后调整单个成员的模式，但不能在生成时配置每个成员的模式。在启动团队之前，请通过主智能体规划好你的权限姿态。

• Write tight role prompts: Each role prompt should specify four things: what to do, which files or domains to work in, what to focus on and what to exclude, and what the deliverable looks like. When spawning teammates, you can refer to subagent types from any subagent scope: project, user, plugin, or CLI-defined. This lets you define a role once, such as a security reviewer or test runner, and reuse it both as a delegated subagent and as an agent team teammate.编写严谨的角色提示词：每个角色提示词应明确四点：做什么、在哪些文件或领域工作、重点关注什么及排除什么、交付成果是什么。在生成团队成员时，你可以引用任何子智能体范围内的子智能体类型：项目、用户、插件或 CLI 定义。这使你可以定义一次角色（例如安全审查员或测试运行器），并将其既作为委托的子智能体，也作为智能体团队成员重复使用。

• Enforce file isolation: For any agent that writes to disk, use isolation. Two agents modifying the same file simultaneously is one of the most reliable ways to produce corrupted output.强制执行文件隔离：对于任何写入磁盘的智能体，请使用隔离功能。两个智能体同时修改同一个文件是产生损坏输出的最可靠方式之一。

• Check in on a schedule: Every 10–15 minutes for active agent teams. Look at the shared task list for tasks that haven't moved. A task stuck for more than 20–30 minutes might be due to a permission issue, a mis-specified role, or a circular dependency, which may require manual resolution.按计划检查：对于活跃的智能体团队，每 10-15 分钟检查一次。查看共享任务列表中是否有未移动的任务。卡住超过 20-30 分钟的任务可能是由于权限问题、角色指定错误或循环依赖引起的，可能需要人工解决。

• Encode dependencies explicitly: If Task B logically follows Task A, write that dependency into the task list at decomposition time, not as an instruction in a role prompt. The coordination layer enforces dependencies automatically; instructions in prompts can be misread or ignored.显式编码依赖关系：如果任务 B 在逻辑上跟随任务 A，请在分解时将该依赖关系写入任务列表，而不是作为角色提示词中的指令。协调层会自动强制执行依赖关系；提示词中的指令可能会被误读或忽略。

• Define ownership boundaries in your md file: For multi-session projects, write a rule that each module or directory has exactly one owning agent. This prevents overlap before the team is even launched.在 md 文件中定义所有权边界：对于多会话项目，编写一条规则，规定每个模块或目录仅由一个智能体拥有。这可以在团队启动之前防止重叠。

• Always clean up through the lead, not through a teammate: The lead checks for active teammates before clearing resources. Teammates lack the full team context to clean up safely; doing so risks leaving the session in an inconsistent state.始终通过主智能体进行清理，而不是通过成员：主智能体会在清除资源前检查活跃的成员。成员缺乏完整的团队上下文，无法安全地进行清理；这样做有导致会话处于不一致状态的风险。

• Don't spawn a team for a task that one session handles cleanly: Before writing a single role file or sending a single swarm prompt, draw the task graph. Which subtasks are genuinely independent? Which have dependencies? Is it a sequentially dependent work? If you can't articulate three parallel tracks with clean boundaries, a single session will outperform the team.不要为单个会话就能处理的任务生成团队：在编写角色文件或发送 swarm 提示词之前，先画出任务图。哪些子任务是真正独立的？哪些有依赖关系？它是顺序依赖的工作吗？如果你无法明确三个边界清晰的并行轨道，单个会话的表现将优于团队。

• Don't assign two agents to the same file. This is the most common source of merge conflicts and silent overwrites. If your task decomposition produces two agents that need to touch the same component, that component's work should be sequential — assign it to one agent after the other completes.不要为同一个文件分配两个智能体。这是合并冲突和静默覆盖的最常见来源。如果你的任务分解产生两个需要触及同一组件的智能体，那么该组件的工作应该是顺序的——在一个智能体完成后将其分配给另一个。

• Don't skip permission pre-approval in Claude Code. Permission prompts that fire mid-run stall parallel execution and require manual intervention. The overhead eliminates much of the benefit. Pre-approve file writes and shell commands for the working directory before launching.不要跳过 Claude Code 中的权限预批准。运行中触发的权限提示会阻塞并行执行并需要人工干预。这种开销消除了大部分收益。在启动前，为工作目录预批准文件写入和 Shell 命令。

• Don't expect to restore your Claude Code team. If a session is cleaned, /resume and /rewind do not restore in-process teammates. Save important intermediate outputs before long runs.不要指望恢复你的 Claude Code 团队。如果会话被清理，/resume 和 /rewind 不会恢复进程内的成员。在长时间运行前保存重要的中间产出。

• Don't run a team past five without a clear reason. Token costs scale linearly, but coordination overhead grows faster. Three focused agents with tight roles consistently outperform five agents with vague ones. Add teammates only when there's an explicit parallel workstream waiting — not because more feels like more.除非有明确理由，否则不要运行超过五个人的团队。Token 成本是线性扩展的，但协调开销增长得更快。三个角色明确、专注的智能体始终优于五个角色模糊的智能体。只有在有明确的并行工作流等待时才添加成员，不要因为感觉“人多力量大”而添加。

Claude Code agent teams excel in developer-native scenarios, integrating deeply with terminal workflows and the Git ecosystem. However, the paradigm of multi-agent collaboration extends far beyond the command line. Kimi Agent Swarm is where that paradigm becomes accessible to everyone.Claude Code 智能体团队擅长开发者原生场景，直接从终端与工作流和 Git 生态系统深度集成。然而，多智能体协作的范式远不止于命令行。Kimi Agent Swarm 让这种范式变得触手可及。

Kimi Agent Swarm is Kimi's multi-agent collaboration system built for complex, large-scale tasks. It breaks a broad goal into discrete subtasks and schedules different agents and skills to handle search, reading, analysis, writing, coding, spreadsheet generation, slide creation, and web page building simultaneously. No env flags. No git config required.Kimi Agent Swarm 是 Kimi 的多智能体协作系统，专为复杂的大规模任务而构建。它将广泛的目标分解为离散的子任务，并调度不同的智能体和技能同时处理搜索、阅读、分析、写作、编码、电子表格生成、幻灯片制作和网页构建。无需 env 标志，无需 Git 配置。

• Parallel collaboration across up to 300 sub-agents: Kimi Agent Swarm decomposes a complex task and schedules multiple sub-agents to handle subtasks simultaneously. The system can coordinate up to 300 sub-agents to execute more than 4,000 tool calls in a single run.跨多达 300 个子智能体的并行协作：Kimi Agent Swarm 分解复杂任务并调度多个子智能体同时处理子任务。该系统可以在单次运行中协调多达 300 个子智能体执行超过 4,000 次工具调用。

• Multi-skill compound execution: The Swarm can combine multiple specialized skills in a single run, including deep research, pptx, report writing, vibe-coding, website building, paper writing, and outperforming a single agent in output depth and format coverage.多技能复合执行：Swarm 可以在单次运行中结合多种专业技能，包括深度研究、PPTX 制作、报告撰写、vibe-coding、网站构建、论文写作，在产出深度和格式覆盖范围上优于单个智能体。

• Large-scale document processing: Agent Swarm can batch-process files across 20+ formats (PDF, Word, Excel, PPT, images, etc.), reading, extracting information, and summarizing content in parallel across the full document set, able to reference libraries, competitive intelligence files, or multi-source data ingestion.大规模文档处理：Agent Swarm 可以批量处理 20 多种格式（PDF、Word、Excel、PPT、图像等）的文件，并行读取、提取信息并总结整个文档集的内容，能够引用库、竞争情报文件或多源数据摄入。

• Proactive broad research: For tasks that require information across wide surface areas, Agent Swarm dispatches sub-agents to search the web, locate sources, download content, categorize findings, and generate structured summaries in parallel.主动式广泛研究：对于需要跨大范围信息面的任务，Agent Swarm 会派遣子智能体并行搜索网络、定位来源、下载内容、分类发现并生成结构化摘要。

• Multi-perspective reasoning: Agent Swarm can run multiple expert viewpoints on the same problem simultaneously. This produces a more complete analysis than a single-viewpoint pass and surfaces blind spots that sequential review misses.多视角推理：Agent Swarm 可以同时针对同一问题运行多个专家视角。这比单视角处理能产生更完整的分析，并能发现顺序审查所遗漏的盲点。

• Deep content delivery: Agent Swarm's parallel architecture is built for sustained-depth outputs, such as multi-hundred-page research reports, long-form industry analyses, academic literature reviews, structured learning guides, and extended narrative content.深度内容交付：Agent Swarm 的并行架构专为持续深度的产出而构建，例如数百页的研究报告、长篇行业分析、学术文献综述、结构化学习指南和扩展叙事内容。

• Multi-format output in a single run: Agent Swarm can produce multiple deliverable types simultaneously on the same task, such as a PDF report, a PPT deck, a web page, an Excel dataset, and a code project.单次运行中的多格式输出：Agent Swarm 可以在同一任务中同时生成多种交付类型，例如 PDF 报告、PPT 演示文稿、网页、Excel 数据集和代码项目。

Step 1: Open Kimi Agent Swarm and enter your prompt第 1 步：打开 Kimi Agent Swarm 并输入提示词

Open the Agent Swarm page and describe your task in the input box. For best results, be specific about the scope, the deliverables you expect, and any constraints such as time range, sources, or format requirements.打开 Agent Swarm 页面并在输入框中描述你的任务。为了获得最佳效果，请具体说明范围、你期望的交付成果，以及任何约束条件，如时间范围、来源或格式要求。

Example prompt:

Step 2: Let Kimi Agent Swarm work第 2 步：让 Kimi Agent Swarm 工作

After sending your prompt, Agent Swarm will break the task into subtasks and dispatch subagents to work in parallel. You can watch real-time progress, including task planning, sub-agent spawning, and parallel execution.发送提示词后，Agent Swarm 会将任务分解为子任务并派遣子智能体并行工作。你可以实时查看进度，包括任务规划、子智能体生成和并行执行情况。

Step 3: Receive, preview, and download or share the results第 3 步：接收、预览并下载或分享结果

Once the run is complete, your deliverables are ready to preview directly in the interface. Depending on your task, outputs may include research reports, data analyses, PPT decks, web pages, code projects, or a combination of these. You can download the files and share them directly.运行完成后，你的交付成果即可直接在界面中预览。根据你的任务，产出可能包括研究报告、数据分析、PPT 演示文稿、网页、代码项目或这些内容的组合。你可以直接下载文件并分享。

• Tender and proposal writing: Assign parallel agents to technical specs, compliance requirements, pricing models, and case studies simultaneously; the orchestrator integrates them into a cohesive proposal.标书和提案撰写：同时分配并行智能体处理技术规格、合规要求、定价模型和案例研究；编排器将其整合为一份连贯的提案。

• Financial analysis: Assign parallel agents to deal with market data, competitor filings, macro indicators, and internal models; the orchestrator synthesizes them into a unified analysis.财务分析：分配并行智能体处理市场数据、竞争对手申报文件、宏观指标和内部模型；编排器将其合成为统一的分析报告。

• Business research: Assign parallel agents for competitive landscapes, customer interviews, industry reports, and regulatory context from different sources; the orchestrator produces a structured output.商业研究：分配并行智能体进行竞争格局分析、客户访谈、行业报告和来自不同来源的监管背景调查；编排器生成结构化输出。

• Security testing: Run parallel agents for reconnaissance, vulnerability scanning, dependency auditing, and privilege escalation checks; the orchestrator aggregates the findings into a final report.安全测试：运行并行智能体进行侦察、漏洞扫描、依赖项审计和权限提升检查；编排器将发现结果汇总为最终报告。

• Full-stack development: Build parallel agents for frontend components, backend endpoints, database schema, and test suites; the orchestrator coordinates integration across the full stack.全栈开发：构建并行智能体处理前端组件、后端端点、数据库架构和测试套件；编排器协调整个技术栈的集成。

Claude Code agent teams are purpose-built for engineering workflows, bringing parallel execution to complex codebases directly from the terminal. If your work extends beyond code, Kimi Agent Swarm brings the same multi-agent paradigm to research, analysis, content, and more. Simply describe your task and let the swarm handle the rest.Claude Code 智能体团队专为工程工作流构建，直接从终端将并行执行带入复杂的代码库。如果你的工作超出了代码范畴，Kimi Agent Swarm 将同样的多智能体范式带到了研究、分析、内容创作等领域。只需描述你的任务，让 Swarm 处理剩下的事情。