goose 推出多智能体编排功能,可并行调度子智能体与 ACP 提供方
Orchestrate complex workflows across multiple agents with goose | goose | Your open source AI agent
goose 官方博客介绍其新增的多智能体编排能力,可把一个复杂任务拆成独立子任务,分别交给子智能体、ACP 提供方或另一个 goose 实例执行,并统一等待依赖、处理失败和合并结果。文中给出并行研究三个子智能体同时运行、以及研究到构建再到验证的分阶段工作流示例,并指出读取可并行、写入应串行。该功能在 CLI 和桌面应用中均可通过自然语言调用,使用 ACP 提供方前需先完成相应配置。
正文
当前显示原文,中文全文译文尚未就绪。
A lot of people prompt their agents one task at a time — "do this, now do that, now do the next thing." It works, but it's slow. Many people also want their agents doing many things at once: researching while coding, reviewing while testing, writing docs while refactoring.
That's what orchestration gives you. Instead of feeding goose one task at a time and waiting, you can have it coordinate multiple agents working in parallel — each focused on a specific piece of the puzzle, with goose keeping everything on track.
What is orchestration?
If you've used subagents before, you already know how to delegate work to independent AI instances. Orchestration is the layer above that — the part that decides who does what and when. Instead of one goose session doing everything sequentially, orchestration lets you:
Decompose a complex task into independent subtasks; Delegate each subtask to a separate agent (subagent, ACP provider, or another goose instance); Coordinate the results — waiting for dependencies, handling failures, merging outputs
Think of it as the difference between a solo developer and a tech lead managing a team.
Try it yourself
Here's something you can run right now to see orchestration in action. Ask goose:
goose will spin up three subagents simultaneously — one for each research task. You'll see them working at the same time in your session, and all three summaries come back roughly together instead of one after another. What would've been three sequential waits becomes one.
How it builds on what already exists
Orchestration doesn't replace subagents or subrecipes — it builds on them:
If subagents are your teammates, orchestration is the project plan that tells them what to do and when.
Phased workflows: research → build → verify
Not everything can run in parallel. Some workflows have natural phases where later steps depend on earlier results. You can describe this to goose naturally:
goose understands the dependency structure here. Phase 1 runs two research tasks in parallel. Phase 2 waits for those results before building. Phase 3 kicks off two independent verification tasks in parallel.
The key insight: reads can be parallel, writes should be sequential (especially if they touch the same files).
Orchestration + ACP: mixing agents
Here's where things get really interesting. Orchestration works with ACP providers, which means you can delegate to entirely different coding agents — not just goose subagents.
To use them, you just say so in your prompt, e.g:
goose understands that you want different agents handling different parts of the workflow. It delegates each task to the right agent, waits for the results, and brings everything together. This works the same whether you're on the CLI or the desktop app — you just ask in natural language.
The only prerequisite is having the provider configured for whichever agents you want to use.
Best practices
When you start orchestrating, it's important to do this with tasks that are conceptually separate and will be less likely to result in edit conflicts on shared files. Here are some tips:
Parallelize your reads
Research tasks are safe to run in parallel. Multiple agents can read the same codebase, docs, or APIs simultaneously without stepping on each other.
Be explicit in instructions
Delegates only know what you tell them. They don't share context with each other or with the parent session. If a delegate needs information from a previous phase, pass it explicitly in the instructions.
Start simple
You don't need to orchestrate everything. A single subagent is fine for straightforward tasks. Orchestration shines when you have genuinely independent work streams or need multiple perspectives on the same problem.
If you're already using goose, you can start orchestrating today. The simplest way is just to ask:
goose handles the rest — spinning up delegates, running them concurrently, and bringing the results together.
For reusable workflows, check out the subrecipes in parallel tutorial to build recipes you can share with your team. And if you want to bring in external agents, the ACP providers guide will get you set up with Claude Code, Codex, or Amp.