Network Tools

When you call HubClient.register(agent, ...) with the default attach_plugin=True, the framework attaches NetworkPlugin to your agent. The plugin does two things:

1. Adds an assembly policy that prefixes every LLM call with the agent's name and id plus a one-line list of network tool names.
2. Adds six LLM-facing tools to agent.tools so the model can drive network operations directly: say, delegate, peers, channels, tasks, context.

These are the vocabulary the LLM uses to participate in the network — discovery, messaging, lifecycle, history — without your code having to interpret tool calls and proxy them.

Two flat tools cover the hot path#

say is the most common verb — every reply on a multi-party turn flows through it. delegate is the second-most-common because "ask one specialist a question, take their answer" is the canonical multi-agent pattern.

1
2
3

# The LLM emits, e.g.:
#   say(content="Here's my answer: …")
#   delegate(target="bob", prompt="What's the right way to model X?", capability="modeling")

The framework resolves ChannelInject (current channel) and AgentClientInject (calling agent's hub client) automatically inside the notify handler, so the LLM never sees those parameters.

Four grouped action-dispatch tools#

Each grouped tool takes an action literal plus action-specific args, keeping the LLM's tool list short.

peers(action) — discovery#

channels(action) — lifecycle#

tasks(action) — task lifecycle#

Two halves: active actions (the agent is inside its own agent.task(...) block) and observation actions (any task the hub has observed).

"start" is intentionally not a tool — calling it from the LLM would bypass the async with agent.task(...) lifecycle that scopes TaskInject correctly. Owners start tasks in their own code; the LLM uses "progress"/"complete" once a task is active, and delegate for one-shot remote work.

context(action) — past content#

scope="knowledge" reaches into the calling agent's own KnowledgeStore. Substring search only — for vector / semantic search, the agent's own loop calls into framework-core recall directly.

What gets injected, automatically#

Every grouped tool accepts AgentClientInject, ChannelInject, and (for tasks) TaskInject parameters that the framework resolves from context.dependencies when the tool runs inside a notify handler. Your code does not need to wire them up — the default handler stamps them via stamp_dependencies before invoking the agent's turn.

If you are testing a tool outside the notify-handler context, pass them yourself:

1
2
3
4
5
6
7
8
9

from autogen.beta import Context
from autogen.beta.network import AGENT_CLIENT_DEP, CHANNEL_DEP, Channel

ctx = Context(
    dependencies={
        AGENT_CLIENT_DEP: alice,
        CHANNEL_DEP: Channel(metadata=channel.metadata, client=alice),
    },
)

Opting out#

Pass attach_plugin=False to HubClient.register for a bare agent — useful for headless workers or gateways that handle envelopes entirely in your own code without needing the LLM-facing tool surface.

1
2

worker = await hc.register(agent, passport, resume, attach_plugin=False)
worker.on_envelope(my_custom_handler)

See also#

• Agent Clients and Handlers — what the default handler does and how to replace it.
• Workflow — hand-written Handoff-returning tools complement ToolCalled → AgentTarget transitions for graph-driven routing.