Nested Team (Team → Team → Agent) with HITL: how to trigger top-level leader synthesis after acontinue_run?

[denizmatsu]

Hi Agno team 👋

I'm building a product where end-users compose their own sub-teams (with their own agents) and those sub-teams are added as members of a system-managed top-level team. I'm trying to find the idiomatic Agno-native way to handle HITL in this nested setup and would love some guidance.

Architecture

TopLeader    (Team, mode=coordinate)        ← user chats with this
  └─ SubTeam    (Team, mode=coordinate)     ← built by the end-user
        └─ MemberAgent (Agent)
              └─ Toolkit with a tool flagged
                 `requires_confirmation = True`

What I want to happen

1. User: "send 'hello' via the echo tool"
2. TopLeader delegates → SubTeam → MemberAgent → tool requests HITL → run pauses ✓
3. Frontend shows an approval widget, user clicks confirm ✓
4. acontinue_run runs → tool executes ✓
5. TopLeader produces a final synthesis (TeamRunContentEvent with team_id="TopLeader", no agent_id) — e.g. "✓ Sent to Telegram." — streamed to the user ✗

Step 5 is what I can't get working. After resume I only see AgentToolStarted/CompletedEvent from the member, then RunCompleted — no leader synthesis.

Minimal repro

Agno 2.6.6, Python 3.11, PostgresDb-backed sessions.

import asyncio

from agno.agent import Agent
from agno.team import Team
from agno.team.mode import TeamMode
from agno.models.openai import OpenAIChat
from agno.tools import Toolkit
from agno.db.postgres import PostgresDb

class EchoToolkit(Toolkit):
    def __init__(self):
        super().__init__(name="echo", tools=[self.send])
        # HITL: tool must be confirmed by the user before it runs
        self.functions["send"].requires_confirmation = True

    def send(self, message: str) -> str:
        return f"sent: {message}"

db = PostgresDb(db_url="postgresql+psycopg://user:pass@localhost:5432/agno")

member_agent = Agent(
    id="member-echo",
    name="Echo Agent",
    role="Sends echo messages to an external system.",
    model=OpenAIChat(id="gpt-4o-mini"),
    tools=[EchoToolkit()],
    db=db,
)

sub_team = Team(
    id="user-sub-team",
    name="User Sub Team",
    role="Wraps echo-related agents; delegates tasks internally.",
    model=OpenAIChat(id="gpt-4o-mini"),
    members=[member_agent],
    mode=TeamMode.coordinate,
    instructions="Delegate to the appropriate member. Return a short status.",
    db=db,
)

top_leader = Team(
    id="top-leader",
    name="Top Leader",
    model=OpenAIChat(id="gpt-4o-mini"),
    members=[sub_team],
    mode=TeamMode.coordinate,
    instructions=(
        "You are the assistant the user talks to. Delegate to the relevant "
        "sub-team. After it completes, briefly confirm the result to the user."
    ),
    db=db,
)

async def main():
    SESSION_ID = "nested-hitl-demo"

    print("── initial run (expect HITL pause) ──")
    async for event in top_leader.arun(
        input="send 'hello world' via the echo tool",
        stream=True, stream_events=True, session_id=SESSION_ID,
    ):
        print(type(event).__name__,
              "team=", getattr(event, "team_id", None),
              "agent=", getattr(event, "agent_id", None))

    session = await db.get_session(SESSION_ID)
    paused_run = next(r for r in (session.runs or [])
                      if str(r.status).upper() == "PAUSED")
    for req in paused_run.requirements or []:
        if getattr(req, "needs_confirmation", False):
            req.confirm()

    print("\n── continue after approval ──")
    async for event in top_leader.acontinue_run(
        run_id=paused_run.run_id,
        session_id=SESSION_ID,
        requirements=paused_run.requirements,
        stream=True, stream_events=True,
    ):
        print(type(event).__name__,
              "team=", getattr(event, "team_id", None),
              "agent=", getattr(event, "agent_id", None))

asyncio.run(main())

Observed event stream after resume

AgentToolStartedEvent    team=None  agent=member-echo
AgentToolCompletedEvent  team=None  agent=member-echo
TeamRunCompletedEvent    team=top-leader  agent=None     ← no content

No TeamRunContentEvent from top-leader.

What I'm asking

1. Is this the recommended way to structure a system-team + user-built sub-team that contains an HITL tool? Is there a more idiomatic Agno pattern I'm missing?
2. Is there a flag / hook / option to make the top-level leader re-invoke its LLM after a nested HITL resume so it produces the final user-facing synthesis?
3. If the current behavior is by design, what is the recommended way to surface a "done" message to the user — should we issue a follow-up arun() on the top leader manually with the member result as context?