Agentic GraphSearch Workflow

• Agentic GraphSearch Workflow is a search-driven, programmatic method that autonomously discovers and refines agent workflows using reward-guided code mutations.
• It leverages a domain-adapted Monte Carlo Tree Search to iteratively optimize candidate workflows, achieving superior accuracy and cost efficiency across multidimensional wireless benchmarks.
• By representing workflows as nodes in a combinatorial program-edit graph and enforcing modularity through typed operators, the approach enhances transparency, reproducibility, and robustness in agent design.

An Agentic GraphSearch Workflow is a search-driven, programmatic methodology for autonomous agentic workflow discovery and optimization, in which candidate agent workflows are represented as nodes in a combinatorial program-edit graph and are refined via iterative, reward-guided search facilitated by focused code mutations. This paradigm, realized most concretely in the WirelessAgent++ system, recasts agent design as an executable-program search problem, equipped with domain-adapted Monte Carlo Tree Search (MCTS) and a repertoire of modular, composable operators. The approach is empirically validated by its superior accuracy and cost-efficiency across multidimensional wireless benchmarks, and the methodology is generalizable to other domains requiring self-evolving, robust agentic systems (Tong et al., 28 Feb 2026).

1. Formal Workflow and Search Space Representation

Each agentic workflow is modeled as a node in a dynamically expanding search tree, where each node is a Python program that constitutes a valid instantiation of a Workflow class with a prescribed async call interface. The search space S, denoted Ω, consists of all syntactically valid workflows built from a finite operator set ℴ and domain tool set 𝔽:

• Operators include Custom (LLM calls), ToolAgent (ReAct-style LLM+tool loops), CodeLevel (hard tool calls), ensemble/voting aggregators (ScEnsemble, MdEnsemble), and orchestration primitives (Review, Revise, Test, etc.).
• Each workflow W embeds its full prompt-string θ and is statically required to return (ŷ, cost) upon execution over an input.
• Admissible code mutations, or edges in the search graph (a ∈ A(s)), are restricted to insert/delete/modify up to 5 lines of code (Algorithm 2, line 7), ensuring a tractable and semantically meaningful program-edit graph (Tong et al., 28 Feb 2026).

2. Search Problem Specification and Reward Modeling

The agentic graph-search workflow optimization is formally cast as a Markov Decision Process (MDP):

• State space (S = Ω): All possible executable workflows as described above.
• Action space (A(s)): Valid single-edit code mutations, covering operator insertion/removal, prompt text edits, operator type switching.
• Transition function (T(s, a)): Deterministic application of action a to workflow s, yielding s′ = T(s, a).
• Reward function (R(s, a)): Median validation score after V repeated executions of s′ on a held-out validation subset 𝒟_val, mitigating LLM stochasticity:

$$R(s, a) = \mathrm{median}_{v=1..V}\left[\mathcal{M}(s'(x_i), y_i)\right]$$

Joint cost-optimization is enabled by subtracting λ·cost(s′) if needed. This reward tightly couples workflow efficacy to domain-specific task metrics, such as accuracy, composite metric aggregation, or problem-specific score functions as implemented in WirelessBench (Tong et al., 28 Feb 2026).

3. Domain-Adapted Monte Carlo Tree Search

The WirelessAgent++ workflow implements a domain-adapted MCTS variant with four operational phases per iteration [Algorithm 2, (Tong et al., 28 Feb 2026)]:

• Selection: Top-K candidate parent workflows, sorted by score, are assigned penalty factors ρ_i∈[0.1,1.3] depending on local failure/success rates (Equation 10). Parent workflow selection is governed by Penalized Boltzmann sampling:

$$p_i = \lambda\frac{1}{K} + (1-\lambda) \frac{\rho_i \exp(\alpha(s_i - s_{\max}))}{\sum_j \rho_j \exp(\alpha(s_j - s_{\max}))}$$

This policy adaptively prunes persistent failure points, while retaining structured exploration.

• Expansion: An Optimizer LLM receives the parent code, prompt, experience logs, and a critic report. Only permissible, XML-encoded code mutations are admitted; duplicates and known-failure patterns are filtered.
• Simulation/Evaluation: Each mutated candidate workflow Ŵ is executed V times over 𝒟_val using a cost-efficient Executor LLM, and the median score is computed as the simulated reward.
• Backpropagation: The reward delta Δs = ȳ - s_parent is thresholded by ε = 0.02 into Success (Δs>+ε), Neutral (|Δs|≤ε), or Failure (Δs<−ε) (Equation 17). Only successful mutation paths are actively reinforced, and failure patterns are penalized through dynamic adjustment of ρ_i.

Unlike classic UCB-based MCTS, this penalized Boltzmann approach leverages domain-specific experience and persistent-failure tracking to accelerate convergence and robustness in workflow optimization (Tong et al., 28 Feb 2026).

4. Executable Workflow Construction: Modular Operators

Each workflow is programmatically constructed as a Python class that instantiates and composes operators from a typed operator set ℴ, where each operator implements a strongly typed API (Pydantic I/O schema). Representative operators include:

• Custom(x, p): Direct LLM call with custom prompt.
• ToolAgent(x, s): Alternating LLM and domain tool invocations, following the ReAct pattern.
• CodeLevel(x, f): Direct, deterministic function call to compiled code/tool f.
• ScEnsemble, MdEnsemble: Voting by self-consistency.
• Review, Revise, Test, Format, AnswerGenerate, etc.: Typed, composable orchestration elements.

The implementation enforces that all candidate workflows use only these predefined operators and domain tools, ensuring interpretability, composability, and syntactic safety (Tong et al., 28 Feb 2026).

5. Algorithmic Outline and Concrete Implementation

The WirelessAgent++ MCTS process is explicitly coded as:

1. Seed evaluation: W₀ is validated and its score s₀ recorded.
2. For each round t = 1..T: a. Gather experience logs and select top-K parents using penalized Boltzmann selection. b. Generate a critic report and feed to the Optimizer LLM along with parent code and history. c. Candidate child workflow Ŵ is mutated and validated for admissibility. d. Ŵ is executed V times; median score ȳ is calculated. e. Update parent/child experience per 3-class classification (success, neutral, failure); update parent ρ_i. f. Store the tuple (Ŵ, ȳ). g. Early stop if no top-K improvement occurs within a threshold number of rounds.
3. Output W* = argmax_t ȳ_t as the best discovered workflow.

This loop enables efficient, iterative, and self-correcting exploration of the workflow search space (Tong et al., 28 Feb 2026).

6. Empirical Outcomes and Evaluation Methodology

The WirelessBench suite provides rigorous, multidimensional evaluation for WirelessAgent++:

• WCHW (wireless communication homework): Numeric/formula/text scoring.
• WCNS (network slicing) and WCMSA (mobile service assurance): Composite metrics covering subtask CQI, bandwidth, throughput, slice type, QoS.

Experiments demonstrate:

• WCHW: 78.37% accuracy
• WCNS: 90.95% composite score
• WCMSA: 97.07% composite score
• Full MCTS search costs: ≤\$4.95 (WCHW), \$0.99 (WCNS), \$1.05 (WCMSA); per-test inference cost < \$0.001

WirelessAgent++ exceeds hand-crafted prompt baselines by ≤31pp and general workflow optimizers (AFlow) by 11.1pp in accuracy. Ablation demonstrates domain tools and 3-class experience replay are critical to performance, with respective ablation drops of −19.3pp and −3.19pp on WCHW (Tong et al., 28 Feb 2026).

7. Methodological Significance and Generalization

By modeling agent workflow optimization as graph search over program-edits with:

• A rigorously defined MDP,
• Typed, modular operator composition,
• Reward-driven code mutation guided by domain-adapted MCTS,
• Stochastic evaluation for noise robustness,
• Rich, fine-grained experience replay and penalization mechanisms,

the Agentic GraphSearch Workflow as realized in WirelessAgent++ provides a blueprint for automatic, robust, and efficient agentic workflow design in any domain demanding LLM-tool orchestration. The architecture supports rapid convergence (<20 rounds), transparent cost estimation, and is reproducible for domains beyond wireless by adapting operator sets and reward models (Tong et al., 28 Feb 2026).