> ## Documentation Index
> Fetch the complete documentation index at: https://agno-v2-docs-scavio-google-v2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Orchestration patterns

> Choose a Team mode or Workflow based on ownership, execution order, and review requirements.

Choose the orchestration primitive from the research flow. Route a factual lookup to one specialist, broadcast a high-stakes decision to every specialist, and use a Workflow for a standardized review with an explicit step graph.

## Choose an orchestration pattern

| Pattern        | Primitive                                           | Best for                                                         |
| -------------- | --------------------------------------------------- | ---------------------------------------------------------------- |
| **Route**      | `Team` ([route mode](/teams/delegation#route-mode)) | A direct question that one specialist owns                       |
| **Coordinate** | `Team` (coordinate mode)                            | Open-ended questions where a lead decides who to consult         |
| **Broadcast**  | `Team` (broadcast mode)                             | High-stakes calls where every specialist evaluates independently |
| **Task**       | `Team` ([tasks mode](/teams/delegation#tasks-mode)) | Multi-step jobs the team decomposes autonomously                 |
| **Pipeline**   | `Workflow`                                          | Reviews with an explicit sequence and error policy               |

## Coordinate: a lead orchestrates dynamically

A lead model decides which analysts to consult based on the question, then synthesizes.

```python theme={null}
from agno.models.google import Gemini
from agno.team import Team, TeamMode

coordinate_team = Team(
    id="coordinate-team",
    name="Investment Team - Coordinate",
    mode=TeamMode.coordinate,
    model=Gemini(id="gemini-3.1-pro-preview"),
    members=[market_analyst, financial_analyst, technical_analyst, risk_officer],
    instructions=[
        "Dynamically decide which analysts to consult based on the question.",
        "Always consult the Risk Officer before any allocation decision.",
        "Provide a final recommendation with a specific dollar allocation.",
    ],
)

response = coordinate_team.run("Should we add NVDA at a $2M position?")
answer = response.content
# The lead chooses which members to consult and synthesizes a recommendation.
# response.member_responses holds each consulted member's run.
```

The lead receives an instruction to consult the Risk Officer. Enforce mandatory review with a `Workflow` step or an application-side gate.

## Broadcast: independent evaluations, one synthesis

Every analyst assesses the same question independently. The lead reconciles agreement and disagreement into one call. Use this when independence reduces bias.

```python theme={null}
broadcast_team = Team(
    id="broadcast-team",
    name="Investment Team - Broadcast",
    mode=TeamMode.broadcast,
    model=Gemini(id="gemini-3.1-pro-preview"),
    members=[market_analyst, financial_analyst, technical_analyst, risk_officer],
    instructions=[
        "All analysts evaluated this independently.",
        "Note where they agree and disagree, then decide.",
        "Weight the Risk Officer's concerns heavily in position sizing.",
    ],
)
```

Set `store_member_responses=True` to persist each member's run with the team's run record.

## Pipeline: explicit execution order

When a review needs an explicit execution path, a `Workflow` fixes the step graph. Each step's output feeds the next; independent steps run in [parallel](/use-cases/deep-research/parallel-investigation).

```python theme={null}
from agno.workflow import Parallel, Step, Workflow

investment_workflow = Workflow(
    id="investment-workflow",
    name="Investment Review Pipeline",
    steps=[
        Step(name="Market Assessment", agent=market_analyst),
        Parallel(
            Step(name="Fundamental Analysis", agent=financial_analyst),
            Step(name="Technical Analysis", agent=technical_analyst),
            name="Deep Dive",
        ),
        Step(name="Risk Assessment", agent=risk_officer),
        Step(name="Investment Memo", agent=memo_writer),
        Step(name="Committee Decision", agent=committee_chair),
    ],
)

result = investment_workflow.run("Run a full investment review on NVDA")
# result.content is the Committee Decision; result.step_results holds each
# step in order (the Deep Dive is one StepOutput with the two analyses in
# its .steps).
```

## Teams vs Workflows

|                | Team                                        | Workflow                                        |
| -------------- | ------------------------------------------- | ----------------------------------------------- |
| Control        | A lead model decides the flow               | You define the steps                            |
| Best for       | Open-ended or adaptive research             | Standardized, repeatable reviews                |
| Execution path | The lead chooses members at run time        | The declared step graph controls execution      |
| Error handling | The lead may retry or choose another member | Each step uses its configured `on_error` policy |

Use Teams for adaptive exploration and a Workflow when the decision path must be explicit. Add a database to retain the run record.

## Next steps

| Task                        | Guide                                                                     |
| --------------------------- | ------------------------------------------------------------------------- |
| Fan specialists out at once | [Parallel investigation](/use-cases/deep-research/parallel-investigation) |
| Ground every member         | [Grounding research](/use-cases/deep-research/grounding-research)         |

## Developer Resources

* [Teams](/teams/overview)
* [Team delegation](/teams/delegation)
* [Team modes cookbook](https://github.com/agno-agi/agno/tree/main/cookbook/03_teams/02_modes)
* [Workflows](/workflows/overview)
* [Workflow cookbook](https://github.com/agno-agi/agno/tree/main/cookbook/04_workflows)