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

# Building Teams

> Define team members, roles, and structure for multi-agent coordination.

Start simple: a model, team members, and instructions. Add functionality as needed.

## Minimal Example

```python research_team.py theme={null}
from agno.team import Team
from agno.agent import Agent
from agno.models.openai import OpenAIResponses
from agno.tools.hackernews import HackerNewsTools
from agno.tools.yfinance import YFinanceTools

news_agent = Agent(
    name="News Agent",
    role="Get trending tech news from HackerNews",
    tools=[HackerNewsTools()]
)

finance_agent = Agent(
    name="Finance Agent",
    role="Get stock prices and financial data",
    tools=[YFinanceTools()]
)

team = Team(
    name="Research Team",
    members=[news_agent, finance_agent],
    model=OpenAIResponses(id="gpt-4o"),
    instructions="Delegate to the appropriate agent based on the request."
)

team.print_response("What are the trending AI stories and how is NVDA stock doing?", stream=True)
```

## Team Modes

Teams default to coordinate mode (leader delegates and synthesizes). Set `mode` to change how the leader collaborates with members.

```python theme={null}
from agno.team.mode import TeamMode
from agno.models.openai import OpenAIResponses

team = Team(
    name="Language Router",
    members=[...],
    model=OpenAIResponses(id="gpt-4o"),
    mode=TeamMode.route
)
```

<Snippet file="team-snippet.mdx" />

Tasks mode runs an iterative task loop. Use `max_iterations` to cap how many cycles the leader can run.

```python theme={null}
from agno.models.openai import OpenAIResponses

team = Team(
    name="Ops Team",
    members=[...],
    model=OpenAIResponses(id="gpt-4o"),
    mode=TeamMode.tasks,
    max_iterations=6
)
```

## Team Members

Each member should have a `name` and `role`. The team leader uses these to decide who handles what.

```python theme={null}
news_agent = Agent(
    name="News Agent",                              # Identifies the agent
    role="Get trending tech news from HackerNews",  # Tells the leader what this agent does
    tools=[HackerNewsTools()]
)
```

For better tracing, also set an `id`:

```python theme={null}
news_agent = Agent(
    id="news-agent",
    name="News Agent",
    role="Get trending tech news from HackerNews",
    tools=[HackerNewsTools()]
)
```

When both `id` and `name` are set on a member, team delegation uses `id` as the member identifier.

## Nested Teams

Teams can contain other teams. The top-level leader delegates to sub-team leaders, who delegate to their members.

```python theme={null}
from agno.team import Team
from agno.agent import Agent

team = Team(
    name="Language Team",
    members=[
        Agent(name="English Agent", role="Answer in English"),
        Agent(name="Chinese Agent", role="Answer in Chinese"),
        Team(
            name="Germanic Team",
            role="Handle German and Dutch questions",
            members=[
                Agent(name="German Agent", role="Answer in German"),
                Agent(name="Dutch Agent", role="Answer in Dutch"),
            ],
        ),
    ],
)
```

## Model Inheritance

Team members inherit the `model` from their parent team if not explicitly set.

```python theme={null}
from agno.team import Team
from agno.agent import Agent
from agno.models.openai import OpenAIResponses
from agno.models.anthropic import Claude

# This agent uses its own model (Claude)
agent_with_model = Agent(
    name="Claude Agent",
    model=Claude(id="claude-sonnet-4-5"),
    role="Research with Claude"
)

# This agent inherits gpt-4o from the team
agent_without_model = Agent(
    name="Inherited Agent",
    role="Research with inherited model"
)

team = Team(
    name="Research Team",
    model=OpenAIResponses(id="gpt-4o"),  # Default for team and members without a model
    members=[agent_with_model, agent_without_model]
)
```

## Callable Factories

Build dynamically configurable teams with [Callable Factories](/teams/overview#callable-factories).

Agno framework supports the Callable Factory Pattern for Team configurations just as it does for individual Agents. This allows you to dynamically resolve team members, tools, and knowledge at runtime based on the specific session or user context.

You can pass a function to the `members`, `tools`, or `knowledge` parameters of a Team. The framework uses signature inspection to inject the team instance and `run_context`.

```python theme={null}
from agno.team import Team
from agno.agent import Agent
from agno.models.openai import OpenAIChat

def get_team_members(team: Team, run_context: any):
    """
    Dynamic member factory: 
    Only include the 'Analyst' if the user is a premium user.
    """
    members = [Agent(name="Generalist", model=OpenAIChat(id="gpt-5"))]
    
    # Logic based on session/user metadata
    if run_context.user_id == "premium_user_123":
        members.append(Agent(name="Analyst", role="High-level data insights"))
        
    return members

# Initialize team with the factory function
agent_team = Team(
    name="Dynamic Team",
    members=get_team_members,  # Callable factory
    show_tool_calls=True,
    cache_callables=True       # Optional: Cache the result for the session
)
```

### Callable Caching Settings

<Snippet file="concept-callable-factories-caching.mdx" />

## Team Features

Teams support the same features as agents:

| Feature      | Description                                                                    |
| ------------ | ------------------------------------------------------------------------------ |
| Instructions | Guide the team leader on how to coordinate                                     |
| Mode         | Choose the coordination strategy (`coordinate`, `route`, `broadcast`, `tasks`) |
| Database     | Persist session history and state                                              |
| Reasoning    | Enable the leader to plan before delegating                                    |
| Knowledge    | Give the leader access to a knowledge base                                     |
| Memory       | Store and recall information across sessions                                   |
| Tools        | Give the leader tools to use directly                                          |

See the guides below to add these features.

## Next Steps

| Task                | Guide                                      |
| ------------------- | ------------------------------------------ |
| Run teams           | [Running Teams](/teams/running-teams)      |
| Control delegation  | [Delegation](/teams/delegation)            |
| Add chat history    | [Chat History](/history/team/overview)     |
| Manage sessions     | [Sessions](/sessions/overview)             |
| Handle input/output | [Input and Output](/input-output/overview) |
| Add knowledge       | [Knowledge](/knowledge/overview)           |
| Add guardrails      | [Guardrails](/guardrails/overview)         |

## Developer Resources

* [Team reference](/reference/teams/team)
* [Team examples](/cookbook/teams/overview)