Agent Collaboration Search (ACS)

Updated 8 July 2026

Agent Collaboration Search (ACS) is a framework that optimizes multi-agent coordination by searching over collaboration structures, workflows, and orchestration topologies under dynamic constraints.
ACS encompasses diverse formulations—from state embedding routing in STRMAC to MDP-based and graph search approaches—tailoring its search object based on task requirements and agent capabilities.
Optimization in ACS leverages techniques such as contrastive loss, REINFORCE, and Monte Carlo tree search to improve accuracy and efficiency in complex multi-agent systems.

Searching arXiv for the specified ACS-related papers to ground the article in the cited literature. {"query":"(Wang et al., 4 Nov 2025) Optimal-Agent-Selection State-Aware Routing Framework for Efficient Multi-Agent Collaboration", "max_results": 5} Agent Collaboration Search (ACS) denotes a class of problems in which a system must search over collaborating agents, actions, execution paths, or orchestration topologies in order to maximize task utility under dynamic state, budget, or coordination constraints. In recent LLM-based work, the term is formalized as a stepwise routing problem over state and agent embeddings in STRMAC (Wang et al., 4 Nov 2025); earlier work used ACS for collaborative behavior search and selection in a two-agent zero-sum stochastic game (Wang et al., 2019); and a later survey generalized the idea to optimization over collaboration graphs and policies in multi-agent systems (Qi et al., 14 May 2026). Across these formulations, the central question is not merely which agent is available, but which collaboration structure is most appropriate for the current state, task decomposition, and performance objective.

1. Formal definitions and problem scope

In STRMAC, ACS is defined over a set of $N$ autonomous agents $A_1,\dots,A_N$ , where the system state at step $t$ is $s_t=(q,h_t)$ , consisting of the initial query $q$ and the interaction history $h_t$ . Each agent $A_i$ is represented by a fixed embedding $k_i=E_L(A_i)$ , while a lightweight router encoder maps the current state to $z_t=E_R(s_t)$ . Compatibility is computed by cosine similarity, the routing function applies a softmax over agents, and the next actor is selected by $\arg\max_i R(s_t,\{k_j\})_i$ ; after that agent produces output $A_1,\dots,A_N$ 0, the history is updated to $A_1,\dots,A_N$ 1 (Wang et al., 4 Nov 2025).

The broader survey formulation treats a multi-agent system as the tuple $A_1,\dots,A_N$ 2, where $A_1,\dots,A_N$ 3 is the agent set, $A_1,\dots,A_N$ 4 the environment, $A_1,\dots,A_N$ 5 the communication protocol, $A_1,\dots,A_N$ 6 the orchestration topology, and $A_1,\dots,A_N$ 7 the collaboration policies. A collaboration policy $A_1,\dots,A_N$ 8 generates a trajectory $A_1,\dots,A_N$ 9, and ACS becomes the search for the collaboration graph $t$ 0 and policy $t$ 1 that maximize expected utility under constraints such as a communication budget $t$ 2 (Qi et al., 14 May 2026).

Other formulations shift the search object. MANGO constructs a flow network $t$ 3 from historical workflows, with nodes representing clusters of semantically similar operations and edges representing verified sequential transitions; ACS then becomes joint optimization of a workflow path $t$ 4 and prompt parameters $t$ 5 (Wang et al., 13 May 2026). TOA instead casts multi-agent sampling as an MDP with state $t$ 6, where $t$ 7 is the input question and $t$ 8 the set of samples generated so far, and action $t$ 9 chooses both a model and, optionally, a prior response to refine (Ye et al., 2024).

2. Search objects and system representations

A recurrent misconception is that ACS is equivalent to static task routing. The literature instead spans single-agent selection, subset selection, path search, graph-topology search, and graph-structured design search. The search object is therefore determined by how collaboration is represented.

Work	Search object	Representation
STRMAC (Wang et al., 4 Nov 2025)	Next acting agent	State embedding $s_t=(q,h_t)$ 0 and frozen agent embeddings $s_t=(q,h_t)$ 1
MANGO (Wang et al., 13 May 2026)	Workflow path and prompts	Flow network of clustered operations
TOA (Ye et al., 2024)	Model/response chain	Two-layer alternating MCTS tree
TCAR (Zhao et al., 8 Jan 2026)	Candidate agent subset	Natural-language reasoning chain plus agent descriptions
M-ASK (Chen et al., 8 Jan 2026)	Search and knowledge actions	Shared structured knowledge state $s_t=(q,h_t)$ 2
NADER (Yang et al., 2024)	Architecture modification sequence	DAG, modification tree, and experience pool
Capability discovery (Guo et al., 24 Nov 2025)	Top- $s_t=(q,h_t)$ 3 agents for a task	Capability profiles, dense embeddings, and quantized index
ACS for RoboCup (Wang et al., 2019)	CACOP selection	Feasible collaborative behavior set $s_t=(q,h_t)$ 4

This diversity suggests that ACS is better understood as a search layer over collaboration structure rather than as a single routing primitive. In some systems the search state is the conversational history; in others it is a workflow graph, a structured knowledge state, a capability registry, or a neural-architecture DAG. The commonality is that collaboration is made explicit and searchable.

3. Optimization mechanisms and credit assignment

STRMAC trains only the router encoder $s_t=(q,h_t)$ 5 with a contrastive objective. For each training step, if $s_t=(q,h_t)$ 6 is the agent whose action leads to the optimal outcome, the loss is

$s_t=(q,h_t)$ 7

with frozen agent embeddings, standard $s_t=(q,h_t)$ 8 regularization, and early stopping on a held-out set (Wang et al., 4 Nov 2025).

MANGO decomposes ACS into path selection and prompt tuning. Path selection is an MDP optimized with REINFORCE, where the state includes similarities between the current subtask plan and node role descriptions or demonstrated experiences, and the reward is $s_t=(q,h_t)$ 9. Prompt and role-description tuning uses “textual gradients,” combining a global end-to-end loss with a local subgoal loss, and a skipping mechanism lets the policy bypass already well-tuned or redundant agents through up to $q$ 0-hop actions (Wang et al., 13 May 2026).

TOA uses Monte Carlo Tree Search with a UCT/UCB rule,

$q$ 1

over an alternating tree of model nodes and response nodes. Newly generated responses are scored immediately by a reward model, and the reward is backpropagated through the tree. This makes ACS an online exploration problem guided by real-time reward feedback rather than a fixed pipeline (Ye et al., 2024).

Search-R2 addresses a different failure mode: sparse trajectory-level rewards in search-integrated reasoning. It decomposes generation into an Actor and a Meta-Refiner, where the refiner uses a discriminator and a trimmer to selectively “cut-and-regenerate” flawed suffixes. The reward is hybrid,

$q$ 2

and optimization is performed with GRPO over an augmented policy that includes both reasoning actions and refinement actions (He et al., 3 Feb 2026).

M-ASK assigns turn-level rewards to specialized agents that plan, search, summarize, update knowledge, and answer. Planning receives absolute $q$ 3, the answer agent receives $q$ 4, and the search, summary, and update agents share the incremental reward $q$ 5; all are trained with PPO-style optimization on a shared LLM backbone (Chen et al., 8 Jan 2026). In the earlier RoboCup ACS formulation, optimization is split differently: predictive models and parallel search first construct a feasible collaborative behavior set $q$ 6, and a deep Q-network then scores each feasible CACOP and selects the highest-scoring behavior (Wang et al., 2019).

4. Data generation, memory, and continual adaptation

A distinctive contribution of STRMAC is its self-evolving data generation procedure. The first 20% of training data are collected with a depth-first search using “solution-aware” early stopping: as soon as any partial path yields a correct final answer, all descendants are pruned, and the minimal-token correct path is recorded. A preliminary router is then trained, and the remaining 80% of data are gathered through iterative rounds in which the current router predicts top- $q$ 7 promising agents at each node, only those branches are expanded, all successful paths are collected, and the router is retrained until validation performance converges or the data budget is exhausted. This reduces sampled paths to approximately 10–16% of full enumeration, with a reported 90.1% reduction in data collection overhead (Wang et al., 4 Nov 2025).

At larger scale, capability discovery in the Internet of Agents introduces a two-stage framework: autonomous capability announcement and task-driven capability discovery. Each agent publishes a profile $q$ 8, which is embedded as $q$ 9; a task description $h_t$ 0 is embedded as $h_t$ 1; and agents are ranked by

$h_t$ 2

To support scalability, the embeddings are stored in a product-quantization-style index with approximate nearest-code lookup, sub-linear query time, and $h_t$ 3 updates for new agents. Continual discovery is stabilized by knowledge replay and a regularizer that preserves important embedding dimensions (Guo et al., 24 Nov 2025).

Several systems treat memory as part of the search mechanism itself. ACN uses Reflective Forward Optimization, a depth-first forward-reflection procedure that propagates user feedback through the active agent stack and updates prompts as adjustable parameters (Shi et al., 2024). NADER’s Reflector combines immediate graph verification with long-term retrieval from a vector database of prior design experiences, allowing future modifications to be conditioned on both successful and failed proposals (Yang et al., 2024). In a human collaborative search setting, CoSearchAgent maintains a sliding window of the last 20 utterances, stores conversation logs in MySQL, asks at most one clarifying question, and logs both search and click events for later analysis (Gong et al., 2024).

5. Empirical performance and application domains

STRMAC evaluates ACS on PDDP and EBFC using Accuracy, token consumption, and a Cost-Adjusted Score,

$h_t$ 4

with $h_t$ 5 and $h_t$ 6. On PDDP with Llama-3.1-70B, Random-Chain achieves 59.6% Accuracy and STRMAC reaches 64.0%, while CAS improves from the best baseline value 45.7 to 59.1. On EBFC with the same backbone, Random-Chain reaches 79.2% and STRMAC reaches 85.2%, with CAS improving from 59.8 to 82.4. The reported maximum gain is +23.8% Accuracy versus Random-Chain on EBFC with Qwen-32B, and router-guided iterative rounds add +4.4% Accuracy on PDDP and +11.9% on EBFC. Path analysis further shows that the single-agent path using Agent_BHC dominates at greater than 60% frequency, while multi-agent paths such as BHC→SH or BHC→MSIP are chosen only when supplementary evidence is needed (Wang et al., 4 Nov 2025).

Across broader benchmarks, MANGO reports up to +12.8% absolute improvement on MATH over MaAS and +5.1% on DROP, while $h_t$ 7 skipping reduces training and inference time by 41.5% and 47.4% relative to the best baselines while retaining greater than 90% of peak accuracy (Wang et al., 13 May 2026). TOA reaches a 71.8% length-controlled win rate on AlpacaEval versus 70.0% for sequential refine and 65.4% for MoA, and reports an average KIWI-XXL score of 84.05 on WMT’21/’22 versus 83.97 for MoA and 82.60 for GPT-4 (Ye et al., 2024). Search-R2 improves average EM from 35.0 to 40.4 on Qwen2.5-7B, from 40.0 to 44.6 on Qwen3-8B, and from 45.6 to 50.8 on Qwen2.5-32B, with the largest listed per-dataset gain being +11.4 on Bamboogle for the 32B model (He et al., 3 Feb 2026). M-ASK reaches an overall average $h_t$ 8 of 50.09, improves HotpotQA from 52.49 to 58.31, records 0% collapse rate versus 90% for Search-r1 by step 1000, and maintains average response length below 300 tokens while Search-r1 exceeds 1000 tokens (Chen et al., 8 Jan 2026).

ACS-like methods also appear in highly domain-specific settings. CS-Agent improves baseline $h_t$ 9 on synthetic community-search benchmarks by +4.4 to +61.6 points on PSG and +13.6 to +42.7 points on LFR under zero-shot prompting, with gains up to +73.5 points on hard k-ECC under 0-CoT; its decider almost always matches or exceeds the best single-round result (Hua et al., 13 Aug 2025). TCAR reports 91.25 on CLINC150, 91.63 on HWU64, 96.70 on MINDS14, 91.58 on SGD, and 93.98 on QCloud for routing $A_i$ 0 or accuracy, and the Refiner increases end-user task success by up to +8–10% on QCloud troubleshooting queries; notably, the system averages only approximately 1.37 agents per query, reinforcing that effective ACS is often selective rather than maximally parallel (Zhao et al., 8 Jan 2026). NADER reaches 94.52% on CIFAR-10, 74.65% on CIFAR-100, and 49.63% on ImageNet16-120 in NAS-Bench-201 comparisons, and in a 500-trial CIFAR-100 run, 30.8% of generated architectures exceed NAS-optimal (Yang et al., 2024). The earlier RoboCup ACS system reduced wall-clock time from 13.77 ms/frame for full enumeration plus simple scoring to 4.04 ms/frame for ACS with screen and deep-Q scoring, approximately a 3.4× speedup (Wang et al., 2019). In collaborative web search, CoSearchAgent reports 3.8 s end-to-end latency, a clarification rate of about 15%, no hallucinations in 95% of sampled runs under manual QA, and a 28% click-through rate (Gong et al., 2024).

6. Limitations, evaluation tensions, and research directions

Several limitations recur across the literature. STRMAC notes that fixed agent embeddings may not adapt to evolving agent capabilities, and that greedy top- $A_i$ 1 expansions can miss rare long-range dependencies; the authors explicitly suggest dynamic embedding updates and look-ahead search as future work (Wang et al., 4 Nov 2025). CS-Agent is limited by synthetic PSG and LFR graphs, uses Validator memory clearing as a heuristic, and shows that gains plateau or even degrade if $A_i$ 2 (Hua et al., 13 Aug 2025). TCAR depends on manually authored agent descriptions and still struggles with rare long-tail scenarios (Zhao et al., 8 Jan 2026). NADER remains LLM-reliant, is bounded by context-window size for larger graphs, incurs API and submodel-training cost, and requires periodic pruning of its growing experience database (Yang et al., 2024). The Internet-of-Agents work emphasizes that capability is heterogeneous and context-dependent, so scalable and long-lived discovery remains an open systems problem rather than a solved indexing problem (Guo et al., 24 Nov 2025). Search-R2 improves accuracy with only training-time overhead, but that overhead is still measurable at +8.7% for Qwen2.5-7B, +4.1% for Qwen3-8B, and +2.4% for Qwen2.5-32B (He et al., 3 Feb 2026).

Evaluation itself is a source of controversy. A two-agent e-commerce simulation framework reports that Gemini and Claude disagree by at least 2 points in 30% of conversations, that exact agreement on CHAT Helpfulness is only 13%, and that Gemini assigns 5/5 CHAT Helpfulness to 74% of conversations while Claude does so for only 5.9%. The same study shows that rolling-window memory outperforms intent-extraction memory on all quality metrics while being 35% faster per query, and that targeted fixes derived from systematic failure analysis reduce failure and near-failure rates by 62% across the full dataset. These results indicate that ACS conclusions can be sensitive not only to architecture and policy but also to the judging model and rubric (Duraj et al., 11 Jun 2026).

The survey literature frames future work through the LIFE progression: lay the capability foundation, integrate agents through collaboration, find faults through attribution, and evolve through autonomous self-improvement (Qi et al., 14 May 2026). Read together, the current corpus suggests three durable research directions. First, ACS is moving from fixed workflows toward adaptive routing, tree search, and topology search. Second, credit assignment is shifting from sparse trajectory-level rewards toward denser local signals, whether through contrastive supervision, process rewards, turn-level rewards, or textual gradients. Third, self-improvement is increasingly treated as part of the search problem itself, through self-evolving data generation, continual capability discovery, reflective prompt updating, and experience retrieval. The implication is not that one canonical ACS algorithm has emerged, but that the field is converging on a shared view: collaboration quality depends on how well the system can search, diagnose, and revise its own coordination structure over time.