💬 NLP

FutureWeaver: Planning Test-Time Compute for Multi-Agent Systems with Modularized Collaboration

FutureWeaver is a framework that enhances multi-agent system performance under fixed test-time compute budgets by introducing self-induced collaboration modules and a dual-level planning architecture to optimize inference trajectories through principled resource allocation.

Original authors: Dongwon Jung, Peng Shi, Muhao Chen, Yi Zhang

Published 2026-06-03

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Dongwon Jung, Peng Shi, Muhao Chen, Yi Zhang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are the manager of a team of specialized experts (like a researcher, a coder, a writer, and a fact-checker) trying to solve a very difficult puzzle. You have a strict limit on how much money you can spend on their time and effort (your "budget").

In the past, if you wanted your team to do a better job, you might just tell them to "think harder" or "try again." But in a multi-agent system, simply telling one person to work harder doesn't always help. Sometimes, you need the researcher to talk to the coder, or the fact-checker to review the writer's draft before you move on. The problem is: How do you decide who talks to whom, when, and for how long, without blowing your budget?

This is the problem the paper FUTUREWEAVER tries to solve. Here is how it works, broken down into simple concepts:

1. The Problem: The "Rigid Assembly Line"

Most current systems work like a rigid assembly line. One person does a task, passes it to the next, and so on. If the first person makes a mistake, the whole line might fail, or you might waste money repeating the same step over and over.

The Issue: These systems don't know how to mix and match their team members effectively. They also struggle to plan ahead. They might spend all their money on the first step of a puzzle, leaving nothing for the crucial final steps.

2. The Solution: "Collaboration Modules" (The Pre-Made Recipes)

FUTUREWEAVER introduces a new idea called Collaboration Modules.

The Analogy: Imagine instead of just having a list of individual chefs, you have a library of pre-made recipes.
- Recipe A: "The Researcher and the Writer work together to draft a story."
- Recipe B: "Three Coders write code in parallel, and a Reviewer picks the best one."
How it works: The system doesn't just call one agent; it can call a whole "recipe" (a module) that automatically coordinates several agents at once. These recipes aren't hand-written by humans; the system learns them by watching itself succeed. It plays the game many times, sees which team-ups worked best, and turns those successful patterns into reusable "recipes."

3. The Brain: "Dual-Level Planning" (The GPS and the Scout)

Even with great recipes, you still need to know which one to pick at any given moment. FUTUREWEAVER uses a two-part planning system, similar to a GPS combined with a scout:

Short-Term Planning (The Scout): This looks at the immediate next step. "If I use the 'Researcher + Writer' recipe right now, does it look like a good idea based on what we just did?" It checks if the team agrees on the move and if it has worked well in similar past situations.
Long-Term Planning (The GPS): This is the magic part. It doesn't actually do the work yet; it imagines the future. It asks, "If I choose this recipe now, will I run out of money before I finish the puzzle?" It simulates the rest of the journey in its head (without spending real money) to see if the path is feasible.
The Result: The system picks the move that is not only good right now but also guarantees it won't run out of budget before the job is done.

4. The "Self-Play" (Learning by Doing)

How does the system know which recipes are good or how much they cost? It uses Self-Play Reflection.

The Analogy: Think of a chess player who plays thousands of games against themselves to learn the best strategies.
How it works: Before solving real problems, the system runs through many practice tasks. It records how much each "recipe" cost and how often it led to a win. It then uses this data to build its library of recipes and its cost estimates. It's like a coach reviewing game tape to create a playbook.

5. The Results: Getting More Bang for the Buck

The paper tested this system on three difficult challenges:

General Knowledge & Web Browsing: Finding answers on the internet.
Deep Research: Digging through many documents to find specific facts.
Coding: Writing and checking computer code.

What happened?

Old methods often wasted money. They would spend too much on early steps or get stuck in loops, leaving them with no budget for the final answer.
FUTUREWEAVER consistently got better answers while staying within the budget. It learned to spend money aggressively when it mattered (like checking code) and conservatively when it didn't.

Summary

FUTUREWEAVER is like a smart project manager for a team of AI agents. Instead of just telling them to "work harder," it:

Creates reusable teamwork recipes based on what has worked in the past.
Plans two steps ahead (and further) to ensure it doesn't run out of money before the job is finished.
Learns from its own practice runs to get better at managing the team.

The result is a system that solves harder problems with the same amount of money, simply by being smarter about how it uses its team.

Technical Summary: FUTUREWEAVER

Problem Statement

While scaling test-time computation has proven effective for improving Large Language Model (LLM) performance in single-agent settings (e.g., via self-correction, iterative verification, or Best-of-N sampling), extending these techniques to multi-agent systems presents unique challenges. Existing approaches often rely on rigid orchestrator-worker paradigms that execute agents sequentially, failing to exploit synergies between heterogeneous agents. Furthermore, current methods lack principled mechanisms for allocating compute under strict budget constraints. They often optimize within fixed inference structures or fail to treat inference as a trajectory planning problem over a combinatorial space of agent invocations. Consequently, systems may over-invest in low-leverage early steps or under-invest in critical later coordination steps, leading to suboptimal performance even when sufficient budget is available.

Methodology: FUTUREWEAVER

The paper proposes FUTUREWEAVER, a framework designed to optimize test-time compute allocation in multi-agent systems under fixed budgets. The framework integrates three core components:

1. Collaboration Modules

To move beyond sequential, one-agent-at-a-time execution, the authors introduce collaboration modules. These are modular, callable functions that encapsulate high-level coordination strategies among multiple agents (e.g., "search then browse" or "ensemble reasoning").

Abstraction: Modules are formalized as $m = (S, \kappa)$ , where $S$ is a subset of worker agents and $\kappa$ is a coordination strategy.
Discovery: Modules are not manually designed but are automatically induced via Self-Play Reflection. The system executes trajectories on validation tasks, identifies recurring interaction patterns that lead to success, and abstracts them into reusable modules.
Action Space: The orchestrator's action space is expanded to include both individual base agents and these collaboration modules ( $A' = A \cup M$ ).

2. Dual-Level Planning Architecture

To navigate the combinatorial space of agent/module invocations under a hard budget, FUTUREWEAVER employs a dual-level planning strategy inspired by A* search and speculative decoding:

Short-Horizon Planning (Local Gain): Evaluates the immediate promise of a candidate action $\alpha_t$ . It calculates a gain score $g(\alpha_t)$ based on:
- Self-Consistency (SC): Measures local consensus among sampled actions to gauge confidence.
- Performance Prior (PP): An empirical reliability score derived from the success rates of similar historical trajectories found in the experience buffer.
- The gain is computed as the geometric mean: $g(\alpha_t) = \sqrt{SC(\alpha_t) \cdot PP(\alpha_t)}$ .
Long-Horizon Planning (Global Feasibility): Performs abstract lookahead to estimate whether a candidate action can lead to a successful trajectory within the remaining budget.
- The orchestrator generates speculative trajectories symbolically (without executing agents) representing potential future sequences of modules.
- Using cost estimates derived from self-play, trajectories exceeding the remaining budget are filtered out.
- A feasibility score $h(\alpha_t)$ is calculated based on the proportion of candidate actions that admit budget-compliant continuations.
- This score actively guides the short-horizon planner, ensuring local decisions align with global feasibility.
Selection: The final utility is $f(\alpha_t) = g(\alpha_t) + h(\alpha_t)$ . The action with the highest utility is selected, balancing immediate progress with long-term budget compliance.

3. Self-Play Reflection

This offline, iterative process serves as the engine for the framework:

It generates execution trajectories on a subset of validation tasks to build an experience buffer.
It provides cost estimates (averaged across observed subtasks) and performance estimates (trajectory-level success rates) for both base agents and discovered modules.
It drives the discovery of collaboration modules by analyzing successful trajectories for recurring patterns.

Experimental Results

The authors evaluated FUTUREWEAVER on three benchmarks: GAIA (general AI assistant tasks), BrowseComp-Plus (web browsing), and BigCodeBench (coding). They compared against fixed workflows (ADAS, AFlow), standard ReAct with test-time scaling (Best-of-N, Iterative Verification), and ReAct with collaboration modules (Budget-Unaware/Aware).

Performance: FUTUREWEAVER consistently outperformed all baselines across diverse budget settings on all three benchmarks. For instance, on GAIA with Claude models, it achieved 48.15% accuracy at a $0.5 budget, compared to 38.27% for the best ReAct variant.
Budget Utilization: Unlike baselines that often underutilize available budgets (total cost plateauing well below the constraint), FUTUREWEAVER aggressively and effectively utilized the budget, translating compute resources directly into performance gains.
Component Analysis: Ablation studies showed that while short-term planning alone provided a boost, and long-term planning alone performed slightly better at higher budgets, the dual-level combination yielded the strongest results, confirming the necessity of integrating local and global signals.

Significance and Claims

The paper claims that FUTUREWEAVER addresses a critical gap in multi-agent systems: the lack of principled mechanisms for budget-constrained compute allocation and effective collaboration.

Key Contribution: The work formulates multi-agent optimization as a trajectory planning problem over a combinatorial space of agent and module invocations, rather than a simple resource allocation problem.
Innovation: By treating coordination as a function-calling problem with automatically induced modules and employing a dual-level planner that couples lookahead with candidate generation, the framework enables systems to dynamically decide when and how to invoke complex collaborations.
Outcome: The results demonstrate that structured collaboration and forward-looking planning are essential for converting fixed compute budgets into effective multi-agent performance, offering a promising direction for building more adaptable and compute-efficient systems.

The authors remain modest regarding future implications, focusing strictly on the validation of their framework's effectiveness in inference-time optimization for multi-agent collaboration under strict constraints.