MetaAgent: Meta-Level Multi-Agent Controller

• MetaAgent is a meta-level controller that organizes multiple agents, tools, and workflows to enable coordinated decision-making.
• Its architectures range from finite state machines and DAG-based constructs to reinforcement learning frameworks, ensuring structured task execution and verifiability.
• Applications span clinical consultation, patent analysis, and automated synthesis of multi-agent systems with quantifiable performance improvements.

Searching arXiv for papers on “MetaAgent” and closely related usages to ground the article in published work. “MetaAgent” is not a single canonical architecture in the arXiv literature, but a recurrent designation for a meta-level controller that organizes other agents, tools, or workflow components. The label has been used for collaborative generative agents in task-oriented social simulation (Li et al., 2023), for automatic multi-agent system construction via finite state machines (Zhang et al., 30 Jul 2025), for clinical consultation orchestration in ColaCare (Wang et al., 2024), for verified DAG-based synthesis and execution of multi-agent systems (Xu et al., 24 May 2026), for end-to-end reinforcement learning of designer and executor policies in MetaAgent-X (Zhang et al., 14 May 2026), for routing across heterogeneous computer-use agents in AgentStore (Jia et al., 2024), for orchestration in patent analysis (Srinivas et al., 2024), for self-evolving tool meta-learning (Qian et al., 1 Aug 2025), and for automated adversarial testing of conversational agents (Komoravolu et al., 24 Aug 2025). An Editor’s term, “second-order control,” usefully summarizes the shared pattern: the central model acts on agents, states, tools, or tests rather than only emitting a direct answer.

1. Conceptual scope and lineage

The term emerged in 2023 in a coordination setting where LLM-based agents were endowed with consistent behavior patterns, human-like reasoning abilities, and specialized skills, and were studied in a simulated job fair environment (Li et al., 2023). In 2024, the label broadened into domain orchestrators: ColaCare used a MetaAgent to synthesize DoctorAgent reviews and manage multi-round consultation over EHR data, while PatExpert used a MetaAgent as a central orchestrator for task planning, expert selection, aggregation, and critique-driven refinement (Wang et al., 2024, Srinivas et al., 2024). AgentStore extended the idea to heterogeneous computer-use agents, with a MetaAgent that can route to a single specialist or manage multi-agent decomposition with AgentTokens (Jia et al., 2024).

By 2025 and 2026, the term was attached to substantially more automated and formalized systems. One line constructs finite-state-machine-based multi-agent systems directly from task descriptions and then compacts them by state merging (Zhang et al., 30 Jul 2025). Another formulates Meta-Agent as a two-phase framework that synthesizes a DAG of agents with explicit input/output contracts and verification criteria, then executes it under verification gates and typed recovery (Xu et al., 24 May 2026). MetaAgent-X shifts the emphasis from orchestration to end-to-end trainability, jointly optimizing designer and executor policies with reinforcement learning (Zhang et al., 14 May 2026). In parallel, a different MetaAgent line treats the unitary agent itself as self-evolving through help-seeking, tool routing, reflection, and persistent tool-memory construction, without parameter updates (Qian et al., 1 Aug 2025). A further extension applies the meta-agent idea to evaluation rather than task execution: the Agent-Testing Agent analyzes an agent-under-test, mines literature, generates adaptive adversarial personas, and scores failures with an LLM-as-a-Judge (Komoravolu et al., 24 Aug 2025).

Paper	MetaAgent role	Formal backbone
(Li et al., 2023)	Task-oriented coordination	Memory, plan, reflection, goal update, skills
(Wang et al., 2024)	Clinical consultation orchestrator	Multi-round agree/disagree with STOP/CONTINUE
(Srinivas et al., 2024)	Patent-workflow orchestrator	Task DAG, expert selection, critique loop
(Jia et al., 2024)	Heterogeneous agent router/manager	AgentToken, Router Mode, Manager Mode
(Zhang et al., 30 Jul 2025)	Automatic MAS constructor	FSM with verifiers, listeners, state merging
(Qian et al., 1 Aug 2025)	Self-evolving tool agent	Help-seeking, tool router, meta tool learning
(Komoravolu et al., 24 Aug 2025)	Testing meta-agent	Weakness planning, adaptive adversarial testing
(Xu et al., 24 May 2026)	Verified MAS synthesizer	DAG, contracts, verification, typed recovery
(Zhang et al., 14 May 2026)	End-to-end automatic MAS learner	GRPO, hierarchical rollout, stagewise co-evolution

This variety suggests that “MetaAgent” currently functions less as a standardized framework name than as a research motif for meta-level orchestration, construction, adaptation, or evaluation.

2. Architectural decompositions

A recurring design pattern is explicit modularization. In the job-fair coordination framework, each MetaAgent comprises four modules: a Perception Module for raw observations, a Memory Module storing tuples of observation, reflection, and plan, a Reasoning Module implementing plan generation, reflection, and goal update as few-shot LLM prompts, and an Execution Module containing specialized skill functions such as interview(), write_code(), and design_poster() (Li et al., 2023). The emphasis is on embedding cognitively flavored routines inside an agent that must coordinate with other agents under task constraints.

The FSM-based automatic MetaAgent system decomposes the whole multi-agent system into states rather than into cognitive submodules. Each state contains an assigned task-solving LLM agent, a natural-language instruction, a companion Condition Verifier, and a listener set specifying whose memory should be updated with the state output (Zhang et al., 30 Jul 2025). Runtime behavior is therefore governed by a control graph in which agents are local executors embedded inside a higher-level symbolic controller.

The verified Meta-Agent framework pushes structural explicitness further. It separates a construction phase from an execution phase. In construction, a planner decomposes a natural-language task into a DAG of agent specifications, each with role description, input schema, output schema, and verification criteria; web search grounds the specifications, a code generation module emits prompts and tool configurations, and construction-time verification can trigger regeneration or re-planning (Xu et al., 24 May 2026). In execution, a coordinator dispatches subtasks only when predecessor outputs have passed verification gates. This architecture places meta-level reliability mechanisms on equal footing with planning.

Domain-specific MetaAgents preserve the same pattern of centralization but tailor the surrounding modules to their application. In ColaCare, the MetaAgent consumes patient structured EHR embeddings, demographics, retrieved MSD guideline passages, and DoctorAgent reviews; it synthesizes a preliminary report, orchestrates consultation rounds, and emits a final meta-report that is fused with the original EHR embeddings for mortality prediction (Wang et al., 2024). In PatExpert, the MetaAgent accepts a patent query, decomposes it into subtasks, maintains a task-dependency DAG, selects expert agents, aggregates outputs, and iterates through critique agents that judge correctness and reward quality (Srinivas et al., 2024).

3. Control formalisms and decision mechanisms

The literature uses several distinct control abstractions. In the 2023 coordination setting, the problem is stated as a multi-agent coordination problem where agents must form teams to solve tasks. The global state is

$s_k=(E_k,\{m_i^k,g_i^k\}_{i=1}^N),$

and the episode objective is to output a recruited subset $A_{\rm rec}$, a workflow $\tau$, and an assignment $\phi$. Utility is defined as

$$U = \mathbf 1\{\text{Identical recruited set}\} + \mathbf 1\{\text{Correct workflow design}\} + \mathbf 1\{\text{Correct assignment}\},$$

with role allocation formalized by maximizing the sum of match rewards between agent skills and workflow phases (Li et al., 2023). The meta-level decision problem is therefore explicit team composition under memory- and goal-conditioned interaction.

The FSM formulation turns control into state transition. MetaAgent defines

$M = (E, S, s_0, F, \delta),$

where each state encapsulates an executor, an instruction, a verifier, and listeners; after the executor produces an output, the verifier matches natural-language transition conditions and chooses the next state (Zhang et al., 30 Jul 2025). Two features are especially characteristic: null-transitions, which permit self-loops and iterative refinement, and traceback, which permits back-jumps to earlier states. The optimization procedure then attempts to minimize state and transition count through iterative state merging while preserving functional equivalence.

The verified DAG-based framework uses a different formal object: a directed acyclic graph $G=(V,E)$, where each node corresponds to an agent specification with explicit input schema $\mathcal I_i$, output schema $\mathcal O_i$, and verification criteria $\mathcal C_i$ (Xu et al., 24 May 2026). The system requires structural correctness, interface consistency, and verifiability; execution-time outputs must satisfy $A_{\rm rec}$0 before downstream propagation. Failure handling is typed: local, upstream, and structural failures trigger localized retry, partial re-execution, or re-decomposition, respectively.

AgentStore treats routing as token prediction. It augments the LM head with learnable AgentToken embeddings, yielding

$A_{\rm rec}$1

Router Mode dispatches when the highest-probability token is an AgentToken; Manager Mode selects the Top-$A_{\rm rec}$2 AgentTokens and then decomposes the task using only those agents’ enrollment documents (Jia et al., 2024). This makes routing a native decoding operation rather than an external classifier.

MetaAgent-X replaces symbolic control with joint policy optimization over design and execution. It defines a bilevel expected return

$A_{\rm rec}$3

uses Group Relative Policy Optimization separately for designer and executor, and introduces hierarchical rollout and stagewise co-evolution to stabilize credit assignment (Zhang et al., 14 May 2026). Here the meta-agent is not merely a scheduler; it is part of a trainable coupled dynamical system.

4. Memory, grounding, reflection, and tool use

Memory is often the substrate on which meta-level control operates. In the collaborative generative-agent framework, memory entries are scored by recency, relevance, and importance,

$A_{\rm rec}$4

and top-$A_{\rm rec}$5 memories are retrieved before plan generation, reflection, and goal update (Li et al., 2023). Reflection is not ancillary: an ablation in Scenario 2 reports that removing reflection drops overall success by 21 percentage points, with the identification rate suffering most through 23 percentage points of redundant hires.

The self-evolving MetaAgent line treats help-seeking as first-class behavior. Its initial core contains a frozen reasoning engine $A_{\rm rec}$6, an integrated help-seeking policy, and a Tool Router $A_{\rm rec}$7 (Qian et al., 1 Aug 2025). When a knowledge gap is detected, the agent emits a natural-language help request; the router scores tools by semantic similarity,

$A_{\rm rec}$8

selects the best tool, and returns distilled knowledge. Across tasks, self-reflection and verified reflection write concise lessons into contextual experience $A_{\rm rec}$9, while the raw external artifacts behind tool outputs are accumulated into a persistent knowledge base $\tau$0. The model parameters remain fixed; adaptation occurs through memory growth and tool-use abstraction.

Grounding mechanisms differ across domains but serve analogous purposes. ColaCare retrieves top-$\tau$1 MSD passages, has DoctorAgents produce initial reviews, and then asks them to agree or disagree with the current meta-report over at most three consultation rounds; the MetaAgent stops only when all DoctorAgents agree or the round limit is reached (Wang et al., 2024). PatExpert’s multi-patent analysis uses Graph Retrieval-Augmented Generation, combining semantic retrieval with knowledge-graph triples and parent chunks; its critique loop relies on a Gold-LLM-as-a-Judge and a Reward-LLM-as-a-Judge (Srinivas et al., 2024). The verified Meta-Agent framework grounds agent specifications with targeted web search before code generation and verification (Xu et al., 24 May 2026). Across these systems, orchestration is coupled to evidence acquisition rather than confined to message passing.

5. Application domains and empirical performance

The task-oriented social-simulation line evaluates MetaAgents in a simulated job fair with three companies, nine job-seeking agents, and in some scenarios 1–3 recruiting agents (Li et al., 2023). Overall success rates across four scenarios are 70%, 53%, 42%, and 16%, while identification, workflow design, and alignment degrade as complexity increases. Scenario 4 is especially revealing: overall success is 16%, identification 20%, design 58%, and alignment 32%. The authors therefore report both promising performance and clear breakdowns under more complex coordination.

The FSM-based automatic-construction line reports gains on both text-based and practical tasks (Zhang et al., 30 Jul 2025). On Trivial Creative Writing and GPQA-Diamond, MetaAgent reaches 0.86 and 0.60 success rate, compared with 0.79 and 0.45 for SPP and 0.76 and 0.46 for Direct prompting. On ml_bench, MetaAgent achieves average NPS 0.83, below DataInterpreter’s 0.86 but above AutoGen’s 0.77 and substantially above several other baselines. On software-development tasks, MetaAgent reaches average pass rate 0.85 versus 0.35 for MetaGPT, 0.20 for AutoAgents, and 0.15 for SPP. Token usage is reported as approximately 48K for machine-learning tasks and 46K for software tasks, compared with MetaGPT human design at approximately 60K tokens per domain.

The verified DAG-based Meta-Agent reports an average score of 82.7 across HumanEval, MBPP, GSM8K, MATH, HotpotQA, and DROP, compared with AFlow’s 80.3, and leads on 5 of 6 tasks (Xu et al., 24 May 2026). The largest improvements are on MATH (+13.4) and DROP (+2.1). On DROP, removing prompt analysis, planning, API research, and verification yields drops of 2.4, 3.5, 5.5, and 7.1, respectively. Holding construction fixed and swapping the executor to Claude Sonnet 4.6 raises the average to 87.9 with no regressions.

MetaAgent-X evaluates end-to-end automatic MAS learning on three code and three math benchmarks with Qwen3-4B and Qwen3-8B backbones (Zhang et al., 14 May 2026). For the 8B setting, average accuracy rises from 27.2 for the single-agent baseline to 38.33 for MetaAgent-X. The largest reported benchmark-specific gain is +21.7 percentage points on AIME24, from 18.3 to 40.0. Hierarchical rollout with $\tau$2 outperforms $\tau$3 by +6.7 percentage points on AIME24, and stagewise co-evolution reaches 44.8% math and 32.0% code versus 36.7% and 25.2% for coupled training.

AgentStore evaluates MetaAgent as a routing and management core for heterogeneous computer-use agents (Jia et al., 2024). On OSWorld, average success rises from 11.21% for the prior state of the art to 23.85% for AgentStore, with an upper-bound “GT” routing score of 29.54%. On APPAgent, AgentStore reaches 57.8% versus 26.7% for GPT-4o. In routing ablations on an InternVL base, ICL routing scores 41.6%, LoRA-tuned routing 60.8%, and AgentToken routing 80.6%. On OSWorld-Multi, Manager Mode obtains AgentMatch 36.6%, SubtaskAcc 62.2%, and ExecutionAcc 22.8%.

PatExpert reports gains across planning, selection, execution, and task-specific patent metrics (Srinivas et al., 2024). On task planning, TUA is 0.94 versus 0.92 for the strongest baseline, Accuracy 0.91 versus 0.89, and Dependency Graph Consistency 0.95 versus 0.93. Tool Selection improves Recall@K to 0.95 and NDCG@K to 0.93; Tool Calling improves Parameter Consistency to 0.95, Error Rate to 0.04, and Execution Accuracy to 0.96. Task-level results include EM 0.90 and F1 0.95 for classification and acceptance, BLEU 0.85 and ROUGE-L 0.83 for summarization, BLEU 0.88 and ROUGE-L 0.86 for claim generation, and BLEU 0.90 and ROUGE-L 0.87 for multi-patent analysis.

The self-evolving MetaAgent line emphasizes difficult knowledge-discovery settings (Qian et al., 1 Aug 2025). Reported scores are 47.6 on GAIA, 52.1 on WebWalkerQA, and 7.1 on BrowseCamp. The paper states that removing self-reflection or verified reflection drops GAIA by approximately 8–10 points, removing the in-house tool drops approximately 6 points, and the minimal workflow alone performs below 20%. The ATA line measures the effectiveness of a meta-agent for testing rather than solving tasks: it completes a full evaluation pass in 20–30 minutes, whereas human evaluation required approximately ten annotator-days, and ablating code analysis plus web search increases variance from 3.23 to 7.15 while worsening calibration on key criteria (Komoravolu et al., 24 Aug 2025).

6. Limitations, misconceptions, and research directions

A frequent misconception is that “MetaAgent” denotes a single interoperable framework. The literature does not support that reading. The cited systems use incompatible control objects—memory-driven social agents, FSMs, DAGs with typed contracts, token-augmented routers, RL-coupled designer/executor policies, and adaptive evaluation threads—and their metrics span success rate, NPS, pass@1, solve rate, exact match, BLEU, ROUGE-L, LSS, and judge-based rubric scores (Zhang et al., 30 Jul 2025, Xu et al., 24 May 2026, Jia et al., 2024, Srinivas et al., 2024). This suggests that the term currently names a family resemblance rather than a standardized technical stack.

The limitations are similarly heterogeneous. In the job-fair coordination setting, the authors identify misalignment of LLMs through “skill-exaggeration,” high inference cost, text-only perception, and pre-set static goals (Li et al., 2023). The FSM-based system notes reliance on LLM quality, prompt-engineering sensitivity in verifiers, and scaling costs for very large state spaces (Zhang et al., 30 Jul 2025). The verified DAG-based system notes that fully automatic workflows can underperform expert-tuned multi-agent systems rich in domain heuristics (Xu et al., 24 May 2026). MetaAgent-X highlights high compute requirements for $\tau$4 rollouts and leaves scaling to larger models or richer tool sets untested (Zhang et al., 14 May 2026). The self-evolving MetaAgent requires ground truth for verified reflection, uses a simple text-matching router, and faces persistent-memory scaling issues as $\tau$5 grows (Qian et al., 1 Aug 2025). AgentStore reports that overall success on OSWorld remains modest, that quality depends on the base multimodal LLM and completeness of the AgentPool, and that Manager Mode remains sensitive to prompt quality (Jia et al., 2024). ATA shows that human annotators still surface some tone and voice problems not encoded in its rubric (Komoravolu et al., 24 Aug 2025).

The future directions are correspondingly diverse but converge on stronger grounding, richer interfaces, and more adaptive control. Proposed extensions include multi-modal perception and embodied agents, autonomous generation and update of multi-level goals, broader social-cognitive evaluation, automatic equivalence checking for FSM compression, reinforcement-learning signals for transition thresholds, lightweight domain priors and hybrid human-in-the-loop correction, richer tool suites, adaptive rollout budgets, larger persistent knowledge bases, multi-modal tools, and benchmark-driven curation of agent pools (Li et al., 2023, Zhang et al., 30 Jul 2025, Xu et al., 24 May 2026, Zhang et al., 14 May 2026, Qian et al., 1 Aug 2025, Jia et al., 2024). Taken together, these directions indicate that MetaAgent research is moving from ad hoc orchestration toward formally specified, evidence-grounded, self-improving, and verification-aware multi-agent systems, while still lacking a unified canonical definition.