Sub-Agent-as-Tools Paradigm

• Sub-Agent-as-Tools is a modular approach where specialized sub-agents with defined interfaces act as callable tools to decompose and orchestrate complex tasks.
• It employs architectural patterns such as hierarchical task decomposition, centralized orchestrator loops, and knowledge graph-based retrieval to manage workflow complexity.
• The paradigm leverages dynamic tool retrieval, on-demand agent specialization, and rigorous performance metrics to enhance scalability, traceability, and robustness in AI systems.

The Sub-Agent-as-Tools paradigm formalizes the design of multi-agent AI systems in which specialized sub-agents are exposed and orchestrated as modular, invocable tools. Rather than treating agents as monolithic end-to-end decision-makers or as loosely defined “social role” players, this paradigm endows each sub-agent with a precisely defined interface, set of capabilities, and callable schemas. At both the conceptual and algorithmic levels, this enables decomposing complex tasks into sequences or graphs of sub-goals, each handled by a dedicated agent. The resulting orchestration layer coordinates these tool-like sub-agents via dynamic delegation, hierarchical abstraction, or knowledge graph-based retrieval, thereby yielding high levels of modularity, scalability, traceability, and robustness across diverse AI workflows.

1. Formal Definitions and Core Abstractions

The Sub-Agent-as-Tools paradigm is built upon formal agent and orchestration abstractions that support explicit tool invocation, context management, and precise capability routing. Several instantiations illustrate this approach:

• In Agent-as-Graph, the system constructs a bipartite graph $G=(V,E)$ with agent nodes ($V_{agent}$) and tool nodes ($V_{tool}$), plus parent/ownership edges $E_{parent}$ that expose each agent’s tools as first-class graph vertices (Nizar et al., 22 Nov 2025).
• In AOrchestra, every agent is defined by a tuple $\Phi=(I,C,T,M)$ specifying instruction (I), context (C), tools (T), and model (M). The orchestrator dynamically instantiates sub-agents with customizations of this tuple, yielding tailored execution for each sub-task (Ruan et al., 3 Feb 2026).
• In AgentOrchestra with the TEA protocol, “tools,” “agents,” and “environments” are unified as first-class resources, and every agent is elevated to tool status via the A2T (Agent-to-Tool) transformation (Zhang et al., 14 Jun 2025).
• In the AIOS framework, sub-agents (Agent Applications, AAPs) are registered as tools that the LLM kernel can call through explicit CALL actions, mirroring a classical operating system structure (Ge et al., 2023).

This formalization enables each sub-agent/tool to be independently registered, discovered, invoked, and composed within the multi-agent infrastructure, allowing orchestration policies to be written in terms of sub-agent capabilities rather than black-box role play or flat action sets.

2. Architectural Patterns and Orchestration Mechanisms

Sub-Agent-as-Tools systems converge on several distinctive architectural motifs for orchestration and workflow management:

• Hierarchical Task Decomposition: Via frameworks like the Hierarchical Task Abstraction Mechanism (HTAM), tasks are recursively decomposed into layers of sub-goals, with each layer’s sub-agents operating on intermediate outputs from preceding layers. This logical hierarchy enforces task-dependency constraints and ensures workflow correctness for complex domains such as geospatial analysis (Li et al., 21 Nov 2025).
• Centralized Orchestrator Loops: In both AOrchestra and AgentOrchestra, a central planning agent (the orchestrator) alternates between (a) synthesizing a new agent tuple/recipe for a pending sub-task and (b) delegating the sub-task to a spawned sub-agent. At termination, the orchestrator emits the final answer (Ruan et al., 3 Feb 2026, Zhang et al., 14 Jun 2025).
• Knowledge Graph-Based Retrieval: Agent-as-a-Graph treats both agents and tools as graph nodes, using embedding-based retrieval and reciprocal rank fusion (wRRF) to jointly rank agents/tools and dynamically select optimal executors for each query (Nizar et al., 22 Nov 2025).
• Information-Flow Orchestration: In the CORAL paradigm, a dedicated information-flow orchestrator maintains state $(q,\mathcal{H}_t,\Delta_t)$, routes instructions based on execution history, and coordinates sub-agent “tools” solely via agent-to-agent (A2A) natural-language communication, eliminating rigid, pre-encoded workflows (Ren et al., 14 Jan 2026).
• Multi-Agent Pipelines and Graphs: The AI Search paradigm organizes agents (Master, Planner, Executor, Writer) in a dynamic DAG, with each agent exposed as a callable modular tool whose outputs are composed or chained as dictated by task complexity and system feedback (Li et al., 20 Jun 2025).

These orchestration mechanisms are algorithmically realized via a mixture of policy learning (e.g., with RL/PPO), prompt-based subgoal synthesis, and dynamic API invocation, often with resource- and performance-aware control loops.

3. Retrieval, Composition, and Dynamic Specialization

A defining feature of the paradigm is dynamic retrieval and specialization of sub-agent “tools”:

• Embedding and Retrieval: Agent-as-a-Graph learns dual embedding spaces for agents and tools, enabling retrieval via $\operatorname{sim_{agent}}(a,q)$ and $\operatorname{sim_{tool}}(t,q)$, followed by graph fusion to resolve to a callable executor. This achieves absolute lifts in Recall@5 (+14.9%) and nDCG@5 (+14.6%) on the LiveMCPBench (Nizar et al., 22 Nov 2025).
• On-Demand Creation: AgentOrchestra features a ToolManagerAgent capable of generating, validating, and registering new sub-agent tools at runtime when no existing candidate matches a pending sub-task—a pipeline consisting of intent analysis, code synthesis, validation, and registry update (Zhang et al., 14 Jun 2025).
• Cost–Performance Routing: AOrchestra’s orchestrator is trained to optimize

$$\max_{\pi}\; \mathbb{E}\,\left[1\{\text{Success}(G)\} - \lambda \cdot \mathrm{Cost}(\tau) \right]$$

where $\lambda$ is a configurable tradeoff and Cost$(\tau)$ accounts for resource use, tool call count, etc., with prompt-level meta-optimization further improving Pareto efficiency (Ruan et al., 3 Feb 2026).

• Tool API Layering: In AIOS, a sub-agent/tool is specified by $$(\mathrm{name},\mathrm{schema},\mathrm{driver},\mathrm{description})$$, and invoked via explicit CALL actions, allowing easy addition, removal, and upgradability of agent-implemented tools (Ge et al., 2023).

This modular approach affords extensibility, granular introspection, plug-and-play capability, and robust adaptation to task or domain drift.

4. Algorithmic Formalisms and Performance Metrics

A range of formal mathematical frameworks underpins the Sub-Agent-as-Tools paradigm across instantiations:

• Principal-Agent Formalism: Sub-agents are conceptualized as “tools” in a microeconomic principal-agent model, with information asymmetry ($\theta_i$), action profiles $(a_1,\dots,a_n)$, and contract mechanisms (IR, IC constraints) used to analyze and mitigate “agency loss” from misalignment, deferred/covert subversion (scheming), and incentive-compatibility breakdowns (Rauba et al., 30 Jan 2026).
• Hierarchical MDPs: In an RL setting, the planner sub-agent policy $\pi_\theta$ chooses among THINK, TOOL_CALL, or ANSWER actions, while the fixed Toolcaller executes tool commands and returns structured results. Policies are optimized via PPO variants (e.g., GRPO), with explicit credit assignment through observation masking and reward only at episode termination (Zhang, 2 Jul 2025).
• Orchestration Pseudocode: Typical coordination loops follow:

  for t in 1..T: Φ_t = SYNTHESIZE_TUPLE(state) sub_agent = DELEGATE(Φ_t) obs = SUB_AGENT_EXECUTE(Φ_t) update_state(...) if ORCHESTRATOR_DECIDES_FINISH(state): return answer

  (Ruan et al., 3 Feb 2026).
• Evaluation Metrics: Metrics such as Recall@K, nDCG@K (Nizar et al., 22 Nov 2025), pass@1 (Ren et al., 14 Jan 2026, Ruan et al., 3 Feb 2026, Zhang et al., 14 Jun 2025), Exact Match, Cover Exact Match (Zhang, 2 Jul 2025), and step-level ablations quantify retrieval, routing, and orchestration efficacy. For example, AgentOrchestra demonstrates that adding each type of sub-agent tool increases GAIA performance from 36.5% (“P only”) to 83.4% with all sub-agents (Zhang et al., 14 Jun 2025).

5. Applications, Benchmarks, and Empirical Outcomes

The paradigm is validated over numerous complex, multi-step, and long-horizon tasks:

• Geospatial Analysis: In EarthAgent, HTAM aligns agent hierarchy with the task-dependency graph intrinsic to remote sensing, enforced through hierarchical layers of sub-agents. The system outperforms single-agent and flat multi-agent approaches on the GeoPlan-bench evaluation (Li et al., 21 Nov 2025).
• General-Purpose Task Solving: AOrchestra demonstrates robust and cost-efficient orchestration across GAIA (visual/web/coding), Terminal-Bench (shell repair), and SWE-Bench (code patch), achieving state-of-the-art pass@1 rates (e.g., 80.0% on GAIA with Gemini-3-Flash) and optimal resource utilization (Ruan et al., 3 Feb 2026).
• Co-Design Platforms: Historical micro-agent paradigms (μ-tools) in PLACID manage atomic collaboration functions (chat, voting) under a 5-layer agent system, illustrating modular manageability and integration (Fougères, 2012).
• Flexible Information Routing: The information-flow-orchestrated A2A paradigm in CORAL supports dynamic sub-agent selection and robust mediation of edge cases, yielding a substantial 8.49 percentage point accuracy gain relative to OWL on GAIA under resource-controlled configurations (Ren et al., 14 Jan 2026).
• Retrieval-Augmented Generation for Search: The AI Search architecture orchestrates tool-bound sub-agents (Master/Planner/Executor/Writer), supporting flexible composition, adaptive fallback management, and scalable parallel execution for both simple and high-complexity queries (Li et al., 20 Jun 2025).

Empirically, the stepwise addition of specialized sub-agents, invoked and coordinated as tools, consistently boosts both final answer accuracy and system robustness, particularly for scenarios requiring tool chaining, adaptive error handling, or dynamic re-planning.

6. Evolution, Generalization, and Ecosystem Roadmap

The conceptual trajectory and extensibility of the Sub-Agent-as-Tools paradigm span both technical and ecosystem-level considerations:

• Dynamic Instantiation and Plug-and-Play: Modern orchestration strategies support on-the-fly spawning, registration, and hot-swapping of sub-agent executors (Ruan et al., 3 Feb 2026, Ge et al., 2023).
• Natural Language Programming and Discovery: Systems like AIOS expose a natural-language DSL for tool/sub-agent composition, iteratively moving toward richer grammars, marketplace-driven discovery, and self-optimizing tool selection via telemetry (Ge et al., 2023).
• Security, Auditability, Marketplaces: The evolution roadmap anticipates sandboxing, sub-agent trust metrics, automated governance, and dynamic deprecation or patching based on system-wide performance feedback (Ge et al., 2023).
• Broader Applicability: The paradigm is generalizable across domains such as web automation, code synthesis, scientific computing, collaborative design, and any task amenable to modular decomposition and tool-mediated workflow.
• Alignment and Safety: Embedding principal-agent mitigation strategies (screening menus, performance contingent payoffs, randomized monitoring) directly into orchestration policies proactively addresses agency loss and misalignment (Rauba et al., 30 Jan 2026).

The Sub-Agent-as-Tools paradigm thus defines a foundational architectural principle for robust, extensible, and tractable multi-agent AI systems, supporting scalable modularity, traceable reasoning, and dynamic adaptability across domains and evolving system requirements.