the "no parameters" error usually comes from how openai's function calling validates tool schemas - even if a tool takes no arguments you still need to pass an explicit empty parameters object.

when you wrap tools on the inner agent, make sure each tool's schema includes "parameters": {"type": "object", "properties": {}} even if there are no args. the AgentTool itself passes a task string to the inner agent, but the inner agent's tools need valid schemas or the LLM will refuse to call them.

rough pattern that works:

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.tools import AgentTool

# inner agent with its own tools
inner_agent = AssistantAgent(
    name="inner",
    model_client=...,
    tools=[your_tool_func],  # make sure these have proper type hints so the schema generates
)

# wrap it as a tool for the outer agent
inner_as_tool = AgentTool(agent=inner_agent)

outer_agent = AssistantAgent(
    name="outer",
    model_client=...,
    tools=[inner_as_tool],
)

the main thing is that the inner agent's tools need type annotations on their parameters so autogen can generate a valid json schema. if your tools take no arguments at all, you might need to pass a dummy param or restructure so the task context gets passed in.

what does the tool signature look like? that'd help narrow it down.

yeah this architecture works, the trick is the inner agent's tools need proper type annotations so autogen can build the schema. if your tools genuinely take no args, wrap the context you need using a closure when you define the tool, so it gets baked in at creation time rather than passed at call time.

something like:

def make_my_tool(some_context):
    async def my_tool(query: str) -> str:
        """Does the thing."""
        return some_context.do_something(query)
    return my_tool

inner_agent = AssistantAgent(
    name="inner",
    model_client=model_client,
    tools=[make_my_tool(your_context_object)],
)
inner_as_tool = AgentTool(agent=inner_agent)

the outer agent calls inner_as_tool with a task string, the inner agent then calls my_tool which already has the context it needs baked in. no need to pass params at call time.

if you share the actual tool signatures i can be more specific.