Approval Team

Three patterns for team approvals: tool on the team, on the member, or on both.

An @approval tool can live on the team, on a member agent, or on both. Each placement produces a different pause flow.

Case	Placement	Pause behavior
Team-level	Team	One pause when the team calls the tool.
Member-level	Member agent	One pause when the member calls the tool. The team pauses with it.
Both	Team and member	Two pauses, two separate admin approvals.

Team-level (Case 1)

team_level_approval.py

"""
Team-Level Approval (Case 1)
=============================

Approval tool lives on the team itself (not on a member agent).

Flow:
  1. User says "deploy payment to prod v2.5"
  2. Team calls approve_deployment -> run pauses
  3. Admin approves in Approvals page
  4. User clicks Continue Run -> tool executes -> team responds
"""

from agno.approval import approval
from agno.db.sqlite import SqliteDb
from agno.models.openai import OpenAIResponses
from agno.os import AgentOS
from agno.team import Team
from agno.tools import tool

DB_FILE = "tmp/team_level_approval.db"

session_db = SqliteDb(
    db_file=DB_FILE, session_table="agent_sessions", approvals_table="approvals"
)


@approval(type="required")
@tool(
    name="approve_deployment",
    description="Request human approval to deploy a service.",
    requires_confirmation=True,
)
def approve_deployment(service: str, environment: str, version: str) -> str:
    return (
        f"Deployment approved for service={service}, "
        f"environment={environment}, version={version}"
    )


approval_team = Team(
    id="team-level-approval",
    name="Deployment Approval Team",
    model=OpenAIResponses(id="gpt-5-mini"),
    members=[],
    tools=[approve_deployment],
    instructions=[
        "When the user asks to deploy, call approve_deployment with the service, environment, and version they provide.",
        "Do not ask for extra confirmation in chat. Just call the tool.",
    ],
    add_history_to_context=True,
    store_member_responses=True,
    db=session_db,
    telemetry=False,
)

agent_os = AgentOS(
    id="team-level-approval-demo",
    description="Team-level approval: the team has a tool that requires admin approval before executing",
    teams=[approval_team],
    db=session_db,
)

app = agent_os.get_app()

if __name__ == "__main__":
    agent_os.serve(app="team_level_approval:app", port=7777, reload=True)

Run the Example

# Clone and setup repo
git clone https://github.com/agno-agi/agno.git
cd agno/cookbook/02_agents/11_approvals

# Create and activate virtual environment
./scripts/demo_setup.sh
source .venvs/demo/bin/activate

python team_level_approval.py

Member-level (Case 2)

member_agent_level_approval.py

"""
Member-Level Approval (Case 2)
===============================

Approval tool lives on the member agent. The team has no approval tools.

Flow:
  1. User says "deploy services"
  2. Team delegates to Deployment Spec Collector member
  3. Member calls collect_deployment_specs -> member pauses -> team pauses
  4. User fills in the form fields (service, environment, version)
  5. Admin approves in Approvals page
  6. User clicks Continue Run -> member tool executes -> member returns result -> team responds
"""

from typing import Optional

from agno.agent import Agent
from agno.approval import approval
from agno.db.sqlite import SqliteDb
from agno.models.openai import OpenAIResponses
from agno.os import AgentOS
from agno.team import Team
from agno.tools import tool

DB_FILE = "tmp/member_level_approval.db"

session_db = SqliteDb(
    db_file=DB_FILE, session_table="agent_sessions", approvals_table="approvals"
)


@approval(type="required")
@tool(
    name="collect_deployment_specs",
    description="Collect deployment fields from the user via a form.",
    requires_user_input=True,
    user_input_fields=["service", "environment", "version"],
)
def collect_deployment_specs(
    service: Optional[str] = None,
    environment: Optional[str] = None,
    version: Optional[str] = None,
) -> str:
    return (
        f"Deployment specs collected: "
        f"service={service}, environment={environment}, version={version}"
    )


spec_collector = Agent(
    name="Deployment Spec Collector",
    model=OpenAIResponses(id="gpt-5-mini"),
    tools=[collect_deployment_specs],
    instructions=[
        "Call collect_deployment_specs to gather deployment details from the user.",
        "Always call it even if the user provided some values. Pass known values and None for missing ones.",
        "After the tool returns, output only the final values in one short line.",
    ],
    telemetry=False,
)

approval_team = Team(
    id="member-level-approval",
    name="Deployment Team",
    model=OpenAIResponses(id="gpt-5-mini"),
    members=[spec_collector],
    tools=[],
    instructions=[
        "Delegate to Deployment Spec Collector to gather deployment specs from the user.",
        "After the member returns, summarize the collected values.",
    ],
    add_history_to_context=True,
    store_member_responses=True,
    db=session_db,
    telemetry=False,
)

agent_os = AgentOS(
    id="member-level-approval-demo",
    description="Member-level approval: a member agent has a tool that requires admin approval",
    agents=[spec_collector],
    teams=[approval_team],
    db=session_db,
)

app = agent_os.get_app()

if __name__ == "__main__":
    agent_os.serve(app="member_agent_level_approval:app", port=7777, reload=True)

Run the Example

# Clone and setup repo
git clone https://github.com/agno-agi/agno.git
cd agno/cookbook/02_agents/11_approvals

# Create and activate virtual environment
./scripts/demo_setup.sh
source .venvs/demo/bin/activate

python member_agent_level_approval.py

Team + Member (Case 3)

team_and_member_agent_both_level_approval.py

"""
Both Member + Team Level Approval (Case 3)
============================================

Approval tools on both the member agent AND the team.
This creates a two-pause flow with two separate admin approvals.

Flow:
  1. User says "deploy services"
  2. Team delegates to Deployment Spec Collector member
  3. Member calls collect_deployment_specs -> member pauses -> team pauses (PAUSE 1)
  4. User fills in the form, admin approves
  5. User clicks Continue Run -> member tool executes -> member returns values to team
  6. Team calls approve_deployment with the collected values -> team pauses (PAUSE 2)
  7. Admin approves in Approvals page
  8. User clicks Continue Run -> team tool executes -> team responds with final result
"""

from typing import Optional

from agno.agent import Agent
from agno.approval import approval
from agno.db.sqlite import SqliteDb
from agno.models.openai import OpenAIResponses
from agno.os import AgentOS
from agno.team import Team
from agno.tools import tool

DB_FILE = "tmp/both_level_approval.db"

session_db = SqliteDb(
    db_file=DB_FILE, session_table="agent_sessions", approvals_table="approvals"
)


# --- Member agent tool: collects deployment specs via user input form ---


@approval(type="required")
@tool(
    name="collect_deployment_specs",
    description="Collect deployment fields from the user via a form.",
    requires_user_input=True,
    user_input_fields=["service", "environment", "version"],
)
def collect_deployment_specs(
    service: Optional[str] = None,
    environment: Optional[str] = None,
    version: Optional[str] = None,
) -> str:
    return (
        f"Deployment specs collected: "
        f"service={service}, environment={environment}, version={version}"
    )


# --- Team tool: requires confirmation before deploying ---


@approval(type="required")
@tool(
    name="approve_deployment",
    description="Request human approval to deploy a service. Call after collecting specs from the member.",
    requires_confirmation=True,
)
def approve_deployment(service: str, environment: str, version: str) -> str:
    return (
        f"Deployment approved for service={service}, "
        f"environment={environment}, version={version}"
    )


spec_collector = Agent(
    name="Deployment Spec Collector",
    model=OpenAIResponses(id="gpt-5-mini"),
    tools=[collect_deployment_specs],
    instructions=[
        "Call collect_deployment_specs to gather deployment details from the user.",
        "Always call it even if the user provided some values. Pass known values and None for missing ones.",
        "After the tool returns, output only the final values in one short line.",
    ],
    telemetry=False,
)

approval_team = Team(
    id="both-level-approval",
    name="Deployment Approval Team",
    model=OpenAIResponses(id="gpt-5-mini"),
    members=[spec_collector],
    tools=[approve_deployment],
    instructions=[
        "Delegate to Deployment Spec Collector first to gather specs via its form.",
        "Once the member returns service, environment, and version, call approve_deployment immediately.",
        "Do not ask for extra confirmation in chat. Use the tools.",
    ],
    add_history_to_context=True,
    store_member_responses=True,
    db=session_db,
    telemetry=False,
)

agent_os = AgentOS(
    id="both-level-approval-demo",
    description="Both-level approval: member collects specs (approval 1), team approves deployment (approval 2)",
    agents=[spec_collector],
    teams=[approval_team],
    db=session_db,
)

app = agent_os.get_app()

if __name__ == "__main__":
    agent_os.serve(
        app="team_and_member_agent_both_level_approval:app", port=7777, reload=True
    )

Run the Example

# Clone and setup repo
git clone https://github.com/agno-agi/agno.git
cd agno/cookbook/02_agents/11_approvals

# Create and activate virtual environment
./scripts/demo_setup.sh
source .venvs/demo/bin/activate

python team_and_member_agent_both_level_approval.py