acceptodds
Under review as a conference paper at ICLR 2027

AnyTool-Agent: API-Guided Tool Use for Data-Scarce Ecosystems via Execution-Grounded Policy Optimization

Abstract

Tool-using agents can perform well with familiar APIs, but adapting them to a new API ecosystem presents two challenges. First, demonstrations involving unfamiliar APIs are scarce, making it difficult to obtain successful trajectories for an initial policy. With binary outcome rewards, GRPO assigns zero advantages when all rollouts in a group fail, providing no outcome-based learning signal. Second, Vanilla GRPO applies a shared trajectory-level advantage across generated tokens, failing to distinguish necessary, redundant, and erroneous API calls within a multi-step trajectory. API specifications and existing environment entities guide demonstration construction, while sandbox feedback supports action-level credit assignment. We introduce AnyTool-Agent, which combines API-Guided Data Synthesis with Execution-Grounded Policy Optimization (EGPO). API-Guided Data Synthesis selects API combinations using their specifications and grounds them in existing environment entities to construct tasks bottom-up. Expert trajectories passing semantic completion checks provide supervised fine-tuning demonstrations, while their core API sequences, successfully re-executed in fresh sandboxes, provide verified references for reinforcement learning. EGPO scores actions through reference matching and deterministic execution feedback, with within-group scarcity weighting for infrequently visited reference APIs. These scores multiplicatively reweight the outcome advantage to produce action-level advantages, preserving its sign under positive reweighting factors while distinguishing action contributions. Under the same task-generation budget, API-Guided Data Synthesis covers as many distinct APIs as random exploration. On AppWorld and BFCL, EGPO improves avg@4 over Vanilla GRPO by 4.8–11.2 percentage points across two Qwen3 backbones with identical SFT initialization.

Primary area:
foundation or frontier models, including LLMs
Keywords:
tool-using LLM agents, GRPO, action-level credit assignment, agentic data synthesis

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_PdN1OpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
1
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes AnyTool-Agent for learning tool use in API ecosystems where there is a lack of API data. The authors propose API-guided trajectory synthesis and also propose Execution-Grounded Policy Optimization (EGPO), uses execution feedback and verified reference trajectories to reweight outcome-level advantages at the action level. Experiments cover AppWorld and BFCL with two Qwen3 backbones. With Qwen3-4B-Instruct, EGPO improves average success over GRPO from the same SFT initialization by 5.5 percentage points on AppWorld and 5.7 points on BFCL.

Critical strengths
  1. EGPO shows ~5-6 points gain on the two test sets over GRPO, while also outpeforming other GRPO variants like DAPO and GSPO, suggesting that execution feedback and action level re-weighting helps improve tool-calling performance in LLMs.
Critical weaknesses
  1. The API-guided synthesis contribution is not sufficientely ablated and evaulated compared to existing baselines. The paper presents targeted synthesis for unfamiliar, data-scarce APIs as a central contribution, but there are no experiments comparing their method to existing API-guided generation methods. The authors only include a comparision againt blind exploration in Figure 3 a. This does not establish an advantage over existing specification-guided synthesis methods or show that the additional coverage improves downstream learning. It is important to compare their synthesis method to existing baselines, for instance: APIGen (NeurIPS 2024) [1] and APIGen-MT (NeurIPS 2025) [2] and show how API-guided synthesis fairs against them in a constant data setting for initial SFT and how the SFT trained models perform after EGPO.

  2. For EGPO, the paper lacks controlled baseline comparisons against existing action-level advantage methods like SALT [3] and GiGPO [4]. These methods already assign step-level credit without training a separate process reward model, and SALT has also been evaluated on AppWorld. The main comparisons against GRPO, DAPO and GSPO do not establish whether EGPO improves over these existing action-level methods. A comparison should using the same SFT initialization, training tasks and evaluation setup would help establish the value of EGPO over these methods.

References

[1] APIGen: Automated PIpeline for Generating Verifiable and Diverse Function-Calling Datasets. NeurIPS 2024.

[2] APIGen-MT: Agentic Pipeline for Multi-Turn Data Generation via Simulated Agent-Human Interplay. NeurIPS 2025.

[3] SALT: Step-level Advantage Assignment for Long-horizon Agents via Trajectory Graph. Findings of EACL 2026.

[4] Group-in-Group Policy Optimization for LLM Agent Training. NeurIPS 2025.

Questions for authors
  1. How does your method differ operationally from APIGen-MT’s verified blueprint construction? Under matched settings, does this distinction improve accepted trajectory yield or task success?

  2. What is the exact formula for aggregating multiple API calls into r_api^t?

  3. How sensitive is the additive baseline to its coefficient? Does EGPO retain its advantage over a tuned additive control using identical feedback?

9 comments
AuthorsOpenReview ↗

Response to Reviewer PdN1 [1/2]

Thank you for identifying the need for comparisons with established API-guided synthesis and action-level optimization methods. We added controlled APIGen-MT synthesis and learning experiments, together with GiGPO and SALT baselines, to clarify AnyTool's contribution beyond existing approaches.

W1 & Q1

How does API-guided synthesis compare with APIGen and APIGen-MT? Does its additional coverage lead to more verified demonstrations and stronger SFT and EGPO policies under comparable conditions?

Response

We adapted APIGen-MT to the same AppWorld sandboxes, API catalog, and verification procedure. We first compared generation efficiency with 1,500 candidates per method:

Matched generation comparisonAnyToolAPIGen-MT
Verified demonstrations399179
Distinct business APIs in verified trajectories194111
Provider-recorded tokens247.53M235.52M

AnyTool yields 2.23× more verified demonstrations and 1.75× more API coverage at comparable recorded token usage. Per recorded token, these become 2.12× the verified-demonstration yield and 1.66× the API coverage. We also report the original APIGen adaptation in the revised paper.

We then separately expanded the APIGen-MT corpus and compared 399 verified demonstrations from each method using the same Qwen3-4B backbone, supervised assistant-token budget, training updates, and evaluation protocol:

Source of 399 demonstrationsSFT avg@4 / best@4 (%)After EGPO avg@4 / best@4 (%)
APIGen-MT26.79 / 47.0251.04 / 70.83
AnyTool37.05 / 64.2955.36 / 75.60

AnyTool improves avg@4 by 10.26 points after SFT, and the advantage remains 4.32 points after EGPO. These results show that the synthesized examples improve actual task completion, not just API coverage.

Our synthesis method selects target API combinations before writing tasks, grounds each instruction in real sandbox entities, verifies task execution, and re-executes its core actions in a fresh sandbox. The full expert trajectory trains the initial policy through SFT; the verified core sequence also supplies action-level reference evidence during EGPO. This direct connection between data generation and subsequent policy optimization is a central contribution of AnyTool. Section 3.2 and Appendix F.2 (Tables 12–13) now give the complete comparison and protocol.

W2

EGPO should be compared with existing action-level credit methods such as GiGPO and SALT, using the same initial policy, training tasks, and evaluation setup.

Response

We added GiGPO and SALT to the AppWorld comparisons, alongside GRPO, DAPO, and GSPO. All action-level methods use the same Qwen3-4B SFT checkpoint, RL task pool, held-out evaluation, and executable-action interface, with a common mapping from action advantages to action tokens:

MethodAppWorld avg@4 (%)best@4 (%)
GRPO53.7275.00
GiGPO53.4270.83
SALT48.0768.45
EGPO56.2577.38

EGPO exceeds GiGPO by 2.83 / 6.55 points and SALT by 8.18 / 8.93 points in avg@4 / best@4, as measured by actual environment task success.

The difference lies in the action evidence used for learning. EGPO combines core API sequences verified during synthesis, deterministic execution feedback, and the frequency with which reference operations are reached by current rollouts. It uses these signals to redistribute the trajectory's final outcome advantage across individual actions, without training a separate process reward model. The controlled results show that this integration improves policy optimization beyond the tested action-level alternatives. Section 3.2 and Table 1 report the comparison, and Appendix F.1 documents the baseline adaptations.

AuthorsOpenReview ↗

Response to Reviewer PdN1 [2/2]

Q2

When an executable action contains multiple API calls, how are their call-level scores aggregated into one action-level API score?

Response

We score the calls within an executable action before computing one action-level API credit. Let st,js_{t,j} denote the credit for call jj in action tt, HtH_t the set of reference APIs first hit in that action, and ωc\omega_c the scarcity multiplier for API cc. For normal calls, the implemented aggregation is

m_t=\begin{cases} \max_{c\in H_t}\omega_c,&H_t\ne\varnothing,\\ 1,&H_t=\varnothing, \end{cases} \qquad r_{\mathrm{api}}^{(t)}=m_tq_t.$$ When no API is called, $q_t$ is initialized to zero. Taking the maximum call credit avoids increasing the action score simply by putting more calls in the same code block. When the action first hits one or more reference APIs, the largest corresponding scarcity multiplier is applied; the call giving the maximum credit need not be the call associated with that multiplier. Error and unsupported-constant rules are applied as specified by the execution scorer, while repetition and formatting feedback are handled in their respective score terms. The resulting action score is clipped, centered within the trajectory, and used to reweight the final outcome advantage. This **call aggregation followed by scarcity weighting** is the implemented rule. We have made the order explicit in Section 2.3 and Appendix F.4, Equation (6), including the case with no reference hit. ### **Q3** *How sensitive is fixed-scale additive action feedback to its coefficient, and does EGPO improve upon these controls when execution feedback is held constant?* ### **Response** We compared five fixed-addition coefficients using the same SFT initialization, execution-derived action scores, and AppWorld evaluation. For clarity, the table separates fixed-scale addition, a multiplicative-only control, and the complete EGPO configuration: | Training configuration | avg@4 (%) | best@4 (%) | | --- | ---: | ---: | | GRPO / $\lambda=0$ | 53.72 | 75.00 | | Fixed addition, $\lambda=0.06$ | 52.53 | 73.21 | | Fixed addition, $\lambda=0.2$ | 53.42 | 72.62 | | Fixed addition, $\lambda=0.4$ | 49.11 | 70.83 | | Fixed addition, $\lambda=0.6$ | 52.00 | 73.30 | | Multiplicative-only, $\alpha=0.6$, no scarcity | 54.17 | 75.00 | | **Full EGPO, $\alpha=0.6$** | **56.25** | **77.38** | The strongest tested nonzero fixed-addition coefficient reaches **53.42% avg@4**, compared with **54.17%** for the multiplicative-only version and **56.25%** for EGPO. A separate matched round-60 scarcity ablation measures **53.27% / 73.81% without scarcity** and **56.25% / 77.38% with scarcity**. For the same centered action score $d_t$, magnitude-scaled addition is precisely equivalent to the multiplicative form when $\lambda=\alpha$: $$A_o+\lambda|A_o|d_t=A_o\bigl(1+\lambda\operatorname{sgn}(A_o)d_t\bigr).$$ This equation explains the advantage of scaling action feedback with the final outcome: EGPO adjusts credit among actions in proportion to the trajectory advantage rather than adding an outcome-independent offset. **The coefficient sweep and the full EGPO results demonstrate stronger task completion than the tested fixed-addition alternatives.** Section 2.3, Section 3.4, and Appendix F.3 (Table 14) now present the mechanism and comparisons together.

Thank you for adding the APIGen-MT comparison. The improved generation yield and downstream SFT performance are encouraging. However, I still do not understand which specific methodological difference explains these gains. APIGen-MT already samples APIs and environment context, constructs task blueprints, and verifies execution and semantic correctness.

Could you clarify:

  1. What exactly differs between the two synthesis procedures? A side-by-side example would help explain how your API selection and entity grounding differ from APIGen-MT.
  2. Why does APIGen-MT accept only 179 candidates versus your 399? Please break down where candidates fail and clarify whether both methods use the same models, retry budgets, and verification criteria.
  3. Does the subsequent EGPO comparison use identical RL tasks and references? Otherwise, it combines differences in SFT data and RL supervision. These details would help establish what makes the synthesis method better beyond the reported performance difference.
Reviewer_4gJ6OpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

This paper proposes AnyTool-Agent, which constructs training tasks and reference trajectories through API-Guided Data Synthesis and uses EGPO to perform fine-grained credit assignment across actions in rollouts. On AppWorld and BFCL, EGPO outperforms GRPO on both Qwen3 backbone models and shows positive results in API coverage, task completion, and redundant tool calls.

Critical strengths
  1. API-Guided Data Synthesis constructs tasks through targeted API combinations, achieving 2.4 times the API coverage of random exploration under the same task-generation budget.
  2. EGPO combines reference trajectories with execution feedback for action-level credit assignment and outperforms GRPO across both backbone models and both benchmarks.
Critical weaknesses
  1. The paper evaluates primarily on the Qwen3 model family. It remains unclear whether EGPO can achieve similar gains on newer, more capable backbone models with stronger tool-use capabilities.
  2. Scarcity weighting assumes that reference APIs with lower hit rates in rollouts should receive higher optimization weights, but the paper does not sufficiently validate whether a low hit rate indicates that an API is more important for task completion. A low hit rate may instead reflect that the API is harder to predict or invoke, rather than that it contributes more to task success.
Questions for authors
  1. Could the authors provide experimental results for EGPO on newer, more capable backbone models with stronger tool-use capabilities, such as Qwen-3.5/3.8, to verify whether its performance gains generalize to stronger models?
  2. What is the basis for assuming that APIs with lower hit rates in rollouts are more important for task completion? Can the current experiments distinguish between the model genuinely learning API-use behaviors that help complete tasks and the effects of the reward mechanism's additional weighting of low-hit-rate APIs?
2 comments
AuthorsOpenReview ↗

Response to Reviewer 4gJ6

Thank you for suggesting evaluation on a stronger backbone and a direct test of scarcity weighting. We added a controlled Qwen3.5-9B experiment and a matched scarcity-removal ablation, both evaluated using environment task success.

W1 & Q1

Does EGPO retain its advantage over GRPO on a newer, stronger tool-use backbone under matched training and evaluation conditions?

Response

We trained EGPO and GRPO from the same Qwen3.5-9B SFT checkpoint, using the same reinforcement-learning task pool and AppWorld evaluation protocol. We also include the original 4B comparison:

Backbone and methodAppWorld avg@4 (%)best@4 (%)
Qwen3-4B + GRPO53.7275.00
Qwen3-4B + EGPO56.2577.38
Qwen3.5-9B, SFT only55.2180.95
Qwen3.5-9B + GRPO75.1591.67
Qwen3.5-9B + EGPO80.3692.26

On Qwen3.5-9B, EGPO exceeds the matched GRPO baseline by 5.21 percentage points in avg@4 and 0.59 points in best@4. From the shared SFT initialization, EGPO improves avg@4 by 25.15 points; the matched GRPO comparison identifies the additional benefit of EGPO within that RL improvement. These results demonstrate that EGPO continues to improve tool-use performance on a substantially stronger starting policy, rather than depending on the original 4B setting. The new experiment is included in Section 3.2 and Table 1, with the shared initialization and evaluation configuration in Appendix F.1.

W2 & Q2

Why emphasize reference APIs with low hit rates? Does scarcity weighting improve the learned policy's task completion rather than merely increasing the score assigned to rare calls?

Response

Scarcity weighting is designed to emphasize verified reference operations that the current policy has difficulty reaching consistently, not to assume that rarely called APIs are intrinsically more important. EGPO first identifies APIs used in a successful verified reference, then uses their hit rates within the rollout group to emphasize operations reached by relatively few rollouts. This focuses action-level feedback on potential learning bottlenecks while retaining execution feedback and the final task outcome in the advantage update.

To measure its contribution, we removed scarcity weighting while keeping the other EGPO components and compared the policies at the same round-60 evaluation point:

MethodAppWorld avg@4 (%)best@4 (%)
EGPO without scarcity53.2773.81
EGPO with scarcity56.2577.38
Difference+2.98 pp+3.57 pp

The metrics measure held-out task completion through the environment's success checks, not the process score used for training. The gains therefore show that scarcity weighting helps the trained policy complete more tasks, rather than merely increasing its internal reward. By emphasizing verified operations the model seldom reaches, scarcity weighting makes action-level learning more effective in the evaluated setting. We have clarified this mechanism in Section 2.3 and added the matched ablation to Section 3.4 and Appendix F.3 (Table 14).

Thank you for the response. My concerns have been addressed and I confirm my original decision.

Reviewer_gHuROpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary
  1. AnyTool-Agent addresses adaptation to API ecosystems without manually annotated demonstrations. It selects API combinations first, constructs tasks grounded in existing environment entities, and generates expert executions for supervised fine-tuning.
  2. Accepted trajectories pass execution and semantic checks, and their core calls are re-executed in fresh sandboxes. EGPO then uses reference-API matches, execution penalties, and within-group scarcity to score actions and multiplicatively reweight GRPO outcome advantages.
  3. Experiments use two Qwen3 backbones on AppWorld and BFCL. The study compares API coverage, downstream task completion, policy-optimization methods from a shared SFT checkpoint, and ablations of action scoring and advantage reweighting.
Critical strengths
  1. Selecting API combinations before generating tasks gives coverage a concrete role in data construction. The reported 325 versus 135 distinct APIs at the same candidate budget is a useful result. Grounding entities and rerunning core trajectories also address practical failure modes that specification-only task generation can leave unresolved.
  2. The main policy comparisons control several important factors: SFT initialization, RL task pool, and rollout protocol are shared. EGPO improves over GRPO on both benchmarks and backbones, including 49.7% to 55.2% avg@4 for the 4B model on AppWorld. This makes the gains more persuasive than a comparison between separately constructed full pipelines.
  3. The reweighting rule is simple enough to inspect, and the paper states its limits fairly. Sign preservation requires positive weights, zero outcome advantages remain zero, and mean preservation is at the action level rather than the token-weighted level. The component ablations and reduced redundant-loop rate provide useful empirical support beyond the algebraic properties.
Critical weaknesses
  1. Reference-API membership is only a rough measure of action usefulness. Matching a name does not establish that the arguments or ordering are correct, and another valid solution may use different APIs. Removing the API-hit term changes AppWorld avg@4 only from 55.2 to 54.8, although best@4 drops more noticeably. The evidence for reference-based credit is therefore less clear than the evidence for the complete scoring-and-reweighting system.
  2. The additive baseline uses a fixed coefficient of 0.6, whereas EGPO's modulation depends on the outcome advantage. Their comparison changes both sign behavior and effective scale. The gap does not isolate which property matters, and the observed sign-flip rate cannot establish that preventing those flips causes better learning. A tuned, scale-matched additive control would strengthen the central optimization claim.
  3. The synthesis comparison matches candidate counts rather than overall generation cost. Appendix B reports roughly 90,000 expert API calls and 670M tokens for the AppWorld generation stage. This expense does not invalidate the results, but it matters for the practical benefit of targeted synthesis. Coverage per candidate does not establish coverage or downstream quality per generation token, especially when acceptance rates and trajectory lengths can differ.
Questions for authors
  1. How does EGPO compare with a tuned additive baseline whose action modulation scales with the magnitude of the outcome advantage?
  2. On successful trajectories using alternative API sets, how often do necessary calls miss reference credit? Does using multiple valid references materially change the result?
4 comments
AuthorsOpenReview ↗

Response to Reviewer gHuR [1/2]

Thank you for examining the use of verified execution references and the advantage-combination rule. In response, we added an additive-coefficient sweep, an audit of alternative successful API paths, and a cost-aware synthesis comparison. These additions strengthen the evidence for both the data synthesis procedure and EGPO's action-level optimization.

W1 & Q2

Reference-API matching does not by itself establish correct arguments or execution order, and successful solutions may use different APIs. How does EGPO handle such paths, how often do they miss reference credit, and what does the API-hit signal contribute?

Response

Reference matching provides positive action-level guidance; it is not the criterion for task success. A reference API has been used in a verified successful solution, while execution feedback identifies invalid calls, errors, and unproductive repetition, and the environment's final success check determines whether the trajectory completes the task. EGPO combines these signals rather than requiring the policy to reproduce one reference sequence. In particular, a different API path is not penalized solely for differing from the reference, although its unmatched calls do not receive reference-hit credit.

The original AppWorld component ablation measures the contribution of reference matching within the scoring system:

Original component ablationWith reference-API creditWithout reference-API credit
avg@4 (%)55.254.8
best@4 (%)77.472.6

Reference credit increases best@4 by 4.8 percentage points in this ablation, showing its contribution to finding successful solutions across repeated attempts. These historical component-study checkpoints are distinct from the updated main result of 56.25% avg@4.

We also manually examined 100 randomly sampled successful trajectories from round-70 rollouts. Three contained a necessary deletion operation performed by an API outside the single reference set. In each case, the reference compressed and deleted a directory in one call, whereas the successful rollout compressed it first and then used delete_directory. In two cases the deletion occurred in a separate executable action and received no reference-hit credit; in the third, the combined action still received reference credit for its compression call. All three trajectories passed the environment's task-success check. This audit identifies the exact situations in which a valid action can miss the reference signal, without treating a trajectory-level count as a call-level rate.

The results show the value of combining verified reference guidance with actual execution and final task outcomes: reference matches help reinforce operations demonstrated to work, while the policy can still complete tasks through other valid API sequences. Section 2.3 clarifies this division of roles, Table 2b reports the component ablation, and Appendix F.5 (Table 15) presents the successful alternative paths.

AuthorsOpenReview ↗

Response to Reviewer gHuR [2/2]

W2 & Q1

The additive comparison changes both the scale and sign behavior of action advantages. How does EGPO compare with tuned fixed-addition coefficients and with addition scaled by the magnitude of the outcome advantage?

Response

The proposed magnitude-scaled additive form is algebraically the same update as EGPO's multiplicative rule when both use the same centered action score dtd_t and coefficient λ=α\lambda=\alpha:

=A_o\bigl(1+\lambda\operatorname{sgn}(A_o)d_t\bigr).$$ Thus, a scale-matched version of this additive expression is not a separate optimization rule. The substantive comparison is with fixed-scale addition, $A_o+\lambda d_t$, which adds an action-score term independently of the magnitude of the outcome advantage. In EGPO, the action adjustment follows $|A_o|$ and is zero when $A_o=0$. Under positive reweighting factors, the resulting action advantages also retain the sign of $A_o$. To test fixed-scale addition, we evaluated $\lambda\in\{0,0.06,0.2,0.4,0.6\}$ with the same SFT initialization, execution-derived action scores, and AppWorld protocol. We also evaluated the multiplicative rule alone and the complete EGPO design, both with $\alpha=0.6$: | Training configuration | AppWorld avg@4 (%) | best@4 (%) | | --- | ---: | ---: | | GRPO ($\lambda=0$) | 53.72 | 75.00 | | Fixed addition, $\lambda=0.06$ | 52.53 | 73.21 | | Fixed addition, $\lambda=0.2$ | 53.42 | 72.62 | | Fixed addition, $\lambda=0.4$ | 49.11 | 70.83 | | Fixed addition, $\lambda=0.6$ | 52.00 | 73.30 | | Multiplicative-only, $\alpha=0.6$, without scarcity | 54.17 | 75.00 | | **Full EGPO, $\alpha=0.6$** | **56.25** | **77.38** | Among the tested nonzero fixed-addition coefficients, $\lambda=0.2$ gives the highest avg@4 at 53.42%; the multiplicative-only configuration reaches 54.17%, and full EGPO reaches **56.25%**. We also isolate scarcity weighting in a separate, matched round-60 ablation: **53.27% / 73.81% without scarcity versus 56.25% / 77.38% with scarcity**. The multiplicative-only result and the round-60 scarcity ablation are distinct controls and are reported separately. Taken together, these experiments support the central EGPO design: **execution-derived action evidence can improve learning when used to redistribute the final outcome advantage, and scarcity weighting adds further task-completion gains**. Sign preservation describes a property of the update; the controlled task-success comparisons establish its practical effectiveness. Section 2.3 and Appendix E.2–E.3 explain the update, while Section 3.4 and Appendix F.3 (Table 14) report the additional controls. ### **W3** *Matching the number of synthesized candidates does not control generation cost. Does targeted synthesis produce more useful demonstrations and API coverage per generation token, and do those demonstrations improve downstream learning?* ### **Response** We added a direct comparison with an AppWorld-adapted **APIGen-MT**, using the same sandbox snapshot, API catalog, and final-demonstration verification. In a separate matched experiment with **1,500 generated candidates per method**, we measured provider-recorded tokens for generation and verification, including rejected candidates and teacher executions: | Synthesis comparison | AnyTool | APIGen-MT | | --- | ---: | ---: | | Verified multi-turn demonstrations | **399** | 179 | | Distinct business APIs invoked in verified demonstrations | **194** | 111 | | Provider-recorded tokens | 247.53M | 235.52M | | Verified demonstrations per recorded token (relative) | **2.12×** | 1.00× | | API coverage per recorded token (relative) | **1.66×** | 1.00× | At just 5.1% more recorded tokens, AnyTool produces **2.23× as many verified demonstrations** and covers **1.75× as many distinct business APIs**. The normalized results show that its advantage persists when useful output is measured against recorded generation resources, rather than candidate count alone. We then tested their value for learning. We generated more APIGen-MT data so that **both methods provided 399 verified demonstrations**. We matched the 4B backbone, supervised assistant-token budget, and training updates: | Source of 399 demonstrations | After SFT avg@4 / best@4 (%) | After EGPO avg@4 / best@4 (%) | | --- | ---: | ---: | | APIGen-MT | 26.79 / 47.02 | 51.04 / 70.83 | | **AnyTool** | **37.05 / 64.29** | **55.36 / 75.60** | AnyTool improves avg@4 by **10.26 points after SFT** and **4.32 points after EGPO** under these matched training budgets. These comparisons answer complementary questions: how efficiently useful examples are produced and how well they train the policy. Together, they establish the contribution of **targeted, execution-verified synthesis to both training-data efficiency and downstream task completion**. Section 3.2, Figure 4b–c, and Appendix F.2 (Tables 12–13) provide the protocol and results, including the scope of provider-recorded token usage.

I thank authors for their response and additional experiment results. I will retain my positive score.

Thank you for considering our responses and additional results. We appreciate your support for the paper.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.