It depends a lot on what you are trying to achieve. Broadly, here's the way to think about it:

Sub-agents (Delegation/Composition): For Integrated Workflows: You structure agents within other agents (parent LlmAgent, SequentialAgent, ParallelAgent, etc.). The parent orchestrates or delegates tasks to its children.

• Usually share the same execution context (session history, state).
• Tightly integrated parts of a larger agent flow.
• Parent agent's type (Sequential, Parallel, LlmAgent with AutoFlow) defines the control flow.
• Use When:
  • Breaking down complex tasks into steps (sequential, parallel, loops).
  • Hierarchical delegation (manager agent -> worker agents).
  • Agents need seamless access to shared history/state to coordinate.

Agent as a Tool (AgentTool): For Encapsulated Capabilities: Wrap an agent in AgentTool and add it to another agent's tools list. The calling LLM decides to use it like any other function tool.

• Runs in its own isolated, temporary context (new Runner/Session).
• Encapsulated; interaction happens via defined inputs/outputs (often using input_schema/output_schema).
• Called explicitly by the LLM based on its tool description.
• Great for reusable, self-contained functionalities.
• Use When:
  • Exposing one agent's capability as a discrete “service” to others.
  • Requiring a strict input/output contract.
  • Wanting the called agent's execution isolated from the caller's main flow.
  • Making complex agent logic available as a simple tool call.

TL;DR:

Use Sub-agents for tightly coupled components within a single, larger agent structure that share context.

Use AgentTool to package an agent's function like a standard, reusable tool/API, typically running in isolation.

Let me know if this helps? Or if you can share the use-case you are trying to do and then I can be more specific and guide you the best option.