acceptodds
Under review as a conference paper at ICLR 2027

Agent-as-a-Tool for Service Providers: Capability Transfer and Token Savings at Scale

Abstract

As LLM-based agents increasingly rely on external tools, should the tools for a dedicated service be exposed directly to the client agent's LLM (Direct Tool Exposure, DTE), or should they be wrapped behind a capable inner agent to which the client delegates tasks (Agent-as-a-Tool, AaT)? Existing studies predominantly take the client's perspective: given a fixed tool set registered with the client agent, they measure whether multi-agent orchestration improves the client's performance compared with a single LLM orchestrator. On the other hand, no existing study has quantified the benefit from the provider's perspective: what does a client agent gain when a service provider offers a capable agent wrapper as a single registered tool instead of directly exposing all low-level tools? In this paper, we present the first systematic comparison of DTE and AaT from the provider's perspective through a dedicated, controlled experiment. Our central finding is that AaT's benefits are predominantly explained by capability transfer: wrapping tools behind a service agent enables the client agent to draw on the service agent's capabilities, largely independent of the client LLM's own capabilities. In addition, AaT offers a token-efficiency advantage because DTE's token cost grows more sharply as the tool surface scales.

Primary area:
other topics in machine learning (i.e., none of the above)
Keywords:
LLM agents, agent-as-a-tool, tool use, multi-agent systems, capability transfer, agent delegation, token efficiency, tool scaling

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_269KOpenReview ↗
Rating
3(+1)
Confidence
1
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper presents an empirical comparison of Direct Tool Exposure (DTE) and Agent-as-a-Tool (AaT) from the service provider's perspective. Through controlled experiments involving five LLMs and 250 synthetic document-management tasks, the authors investigate the effects of delegation, model capability, and tool scalability. The results suggest that AaT primarily benefits from capability transfer through stronger inner agents and can reduce token consumption as the number of exposed tools increases.

Critical strengths

S1. Systematic experimental design.

The paper conducts extensive experiments across multiple models, task complexities, and tool configurations. The same-model comparisons provide a useful approach to separating architectural effects from model capability differences.

S2. Practical relevance.

The study addresses a relevant design choice for tool-based agent systems. Its analysis of capability transfer and token efficiency provides useful insights for service providers considering different tool exposure strategies.

Critical weaknesses

W1. Limited novelty of the main findings.

The main findings suggest that weaker clients benefit from stronger inner agents and that AaT reduces tool-schema overhead. These results are largely intuitive, and the study provides limited insights beyond these expected observations.

W2. Insufficiently controlled architectural comparison.

Although same-model comparisons control for model capability, DTE and AaT still differ in inference overhead and context management. Without matching computational budgets, the effect of delegation itself cannot be fully isolated.

W3. Limited generalizability to real-world settings.

All experiments are conducted in a single synthetic document-management environment, and AaT is restricted to a single delegation call. It remains unclear whether the findings generalize to realistic multi-service workflows involving iterative interaction and replanning.

Questions for authors

Please see the critical weaknesses above.

3 comments
AuthorsOpenReview ↗

Response to Reviewer 269K

We thank the reviewer for recognizing the systematic design and its practical relevance.

W1. Limited novelty; findings are intuitive.

The finding that weaker clients benefit from a stronger inner agent is intuitive only if one assumes that the natural-language delegation boundary is nearly lossless. That assumption is exactly what the same-model controls highlighted in S1 test, and no prior work had measured it. With Opus as inner agent, the weakest client matches DTE(Opus) within ±5pp although its own hard-task success is 11.0%, and five clients with DTE baselines spanning 11–96% fall within 2.0pp of each other. The same controls also show where the assumption weakens (a −6.0pp, model-specific estimate for Sonnet), which an intuition-level argument cannot reveal.

W2. Computational budgets are not matched.

Both architectures share the same per-tier primitive tool-call budget, and it never binds.

  • Across the hard-tier same-model configurations, no run reaches the cap (maximum 42 calls against budgets of 60–70).
  • Both architectures execute the same median number of primitive tool calls (22 vs. 22 for Opus; 21 vs. 21 for Sonnet).

The residual difference is about three additional LLM calls and 18–21% more tokens for AaT, two of which are the client's delegation and summary. That difference is inherent to the boundary being measured, and it favors AaT. Same-model AaT still does not outperform DTE, so our "no intrinsic architectural advantage" conclusion is conservative with respect to compute.

Context handling is identical: both use the same agent loop without compaction, and the inner agent's context is the DTE context with the instruction replaced by the client's request. Capability transfer also does not rely on extra compute: AaT(Qwen→Opus) matches DTE(Opus) accuracy at slightly lower token cost (64K vs. 67K). We will add this compute breakdown to the appendix.

W3. Single synthetic domain; single delegation call.

Both are deliberate identification choices rather than oversights.

  • Single call. The object of study is the provider–client boundary for one service-local request. The single-call protocol defines that object and matches how Agent.as_tool(), MCP tools and Browser Use are invoked. Iterative replanning across services is a client-side orchestration question, which we deliberately separate (§4.2).
  • Synthetic domain. The testbed is synthetic only in its file format, chosen to prevent memorized workflows; its operations are ordinary document edits. As Appendix A.1 details, no existing benchmark on a real system jointly provides deterministic end states, controlled call depth, injectable recoverable errors, and the ability to wrap the same tools behind a provider-side agent, all of which this comparison requires.
  • Multi-service setting. The scaling study already places the service inside a 10-service catalog, where routing accuracy is 100%.

We therefore state our conclusions conditionally on service-local requests, and we regard replication in other domains as complementary future work rather than a gap in the present design. We will also soften the introduction's "without loss of generality" footnote to state the decomposition into atomic requests as a scope assumption.

Thank you for the detailed response. While some of my concerns have been addressed, I still think that the paper's main findings, particularly regarding capability transfer and token efficiency, are largely consistent with intuitive expectations, and thus offer relatively limited new insights. Additionally, the experiments are restricted to a single synthetic environment and a single-delegation setting, leaving the generalizability of the conclusions to more complex real-world workflows uncertain.

Nevertheless, I acknowledge the empirical value of this work. The experimental design is systematic, covering different model capabilities, task complexities, and tool configurations. The same-model comparisons and statistical analyses also provide meaningful support for the main conclusions. The authors' response further clarifies the rationale behind the experimental setup.

Overall, considering these points, I am willing to raise my rating from 2 to 3.

AuthorsOpenReview ↗

Reply to Reviewer 269K

We thank the reviewer again for recognizing the value of this work.

For a better clarification of the new insights of this paper, we would recommend the reviewer to check our latest reply to Reviewer 7PKA as well, and see whether the response can answer some of the remaining concerns regarding novelty and insights.

Again, thank you for your valuable feedback!

Reviewer_7PKAOpenReview ↗
Rating
3(+1)
Confidence
1(−1)
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper analyzes the effect of two alternative delegation of tool-calling in LLM agentic workflows. One is Direct Tool Exposure (DTE) where the LLM agent on the client side has direct access to the tools, and the other is Agent-as-a-Tool (AaT) where the service provider uses a client agent to wrap around the tools. Using a controlled document-management benchmark, this paper examines how delegation affects task success and token consumption across client and service models. The results suggest that AaT primarily benefits weaker clients by providing access to a stronger tool-executing model. A separate scaling experiment shows that encapsulating service-specific tools can reduce token consumption as the exposed tool catalog grows. The main contributions are the controlled comparison methodology, synthetic benchmark, and empirical characterization of capability access and tool-schema overhead.

Critical strengths
  1. The paper introduces an interesting perspective from the tool provider side. A provider deciding how to expose its service would benefit from understanding the accuracy and cost tradeoffs between different interfaces. I am not sure how truly critical this is in practice, but it sounds like a good perspective.
  2. The experiments meaningfully separate executor capability from delegation effects. Table 2 includes both stronger-inner and same-model comparisons. For example, comparing direct Opus with Opus delegating to Opus helps assess the delegation boundary, while Qwen delegating to Opus measures the benefit of accessing a stronger executor. These controls make the results more interpretable than a single comparison between two agent systems. The capability-transfer effect is also substantial and consistent across clients. In Table 2, delegating to Opus raises success on L4 and L5 from 11.0% to 94.7% for Qwen, from 33.3% to 95.0% for DeepSeek, and from 47.7% to 93.7% for Haiku. Conversely, Opus drops from 96.3% to 78.7% when delegating to Sonnet. Together, these results support the conclusion that the inner executor’s capability largely determines performance.
Critical weaknesses
  1. Figure 3 shows that AaT uses fewer tokens as the tool catalog grows, but the comparison gives the two systems different amounts of tool information during execution. DTE repeatedly receives every tool description, while AaT’s inner agent receives only its service’s tools. The savings may therefore come mainly from filtering irrelevant tools, which a direct agent could also do. A comparison with DTE that first retrieves the relevant tools would help establish whether delegation offers an additional efficiency benefit. Please correct me if my understanding is wrong.
  2. The evidence for negligible delegation cost is mixed. In Table 2, Opus performs similarly with and without delegation, but Sonnet’s success falls from 83.7% to 77.7% on the harder tasks. Section 5.1 acknowledges that the uncertainty is too large to determine whether this Sonnet decrease is meaningful. Consequently, the general claim that delegation has negligible impact on task success sounds stronger than the evidence supports. A breakdown of Sonnet’s failures could help explain whether delegation loses important instructions or changes execution behavior; a more qualified conclusion would also better reflect the current results.
Questions for authors
  1. Could you address weakness 1?
  2. Could you address weakness 2?
4 comments
AuthorsOpenReview ↗

Response to Reviewer 7PKA

We thank the reviewer for the precise reading of Table 2 and the constructive suggestions.

W1. Is the token saving just tool filtering?

Your understanding is correct: the saving comes from scoping the schema. Our 21-tool DTE anchor is effectively DTE with perfect service-level retrieval, and it costs 36K tokens per run versus 47–51K for AaT at 200 tools, so ideal retrieval removes the token advantage. We will state this explicitly.

The distinction is control. Retrieval is a client-side optimization whose recall the provider can neither assume nor control. It depends on the client's whole catalog (which may hold overlapping tool sets for the same service) and must hold across multi-step trajectories (in our error tiers, the required recovery tools are not named in the instruction). AaT localizes the schema on the provider side regardless of client sophistication, in addition to transferring capability. We will reframe Contribution 3 accordingly.

W2. Evidence for negligible delegation cost is mixed. We agree, and we will qualify the claim. The delegation cost is practically negligible for Opus (−1.0pp; equivalent within ±5pp) and uncertain for Sonnet (−6.0pp, CI [−12.7, 0.7]). We will retitle §5.1 and state the two models separately.

Following your suggestion, we traced Sonnet's failures on L4–L5 (300 runs per configuration).

Delegation does not lose instructions.

  • Request fidelity is identical in failed and successful AaT(Sonnet→Sonnet) runs (similarity 0.68 vs. 0.68).
  • Every client→Sonnet configuration falls below DTE(Sonnet), including clients that forward the task nearly verbatim. Qwen3 32B (similarity 0.96) is in fact the lowest.
  • The deficit therefore follows the inner Sonnet agent, not the client's paraphrase.

Execution behavior changes in one specific way. The gap is concentrated in a single failure mode: appending content without a separator, which fuses it onto the previous line (e.g., ...unidoc.Diagram from..., or a mermaid code fence that no longer starts a line and so no longer renders).

  • Sonnet shows this under DTE too (25 failed runs).
  • It occurs more often when Sonnet is the inner agent (38 runs, plus 14 combined with other errors).
  • Opus never produces it under either architecture.
  • Excluding this failure mode, the Sonnet same-model gap is −1.7pp.

We will add this breakdown as an appendix case study alongside the existing Opus analysis, and revise the conclusion to "small and model-dependent" rather than "negligible."

Reviewer_7PKAOpenReview ↗

Response to rebuttal

I thank the authors for the response. While the response partially address my concerns, I still have some concerns with respect to the overall scope and topic of this paper. I would ask the authors to further clarify what this paper adds to the literature, who they expect the main audience is, and what people would learn from this paper. At this stage, I do not feel convinced to flip the switch to a weak accept.

AuthorsOpenReview ↗

Response to the new clarification questions raised from Reviewer 7PKA

We thank the reviewer for the engagement and address the three questions directly.

What the paper adds. To our knowledge, this is the first rigorous quantitative evaluation of multi-agent delegation from the service provider's perspective. Recent client-side studies (e.g., MAST; budget-matched single- vs. multi-agent comparisons) largely find that multi-agent architecture does not improve accuracy, whereas agents-as-tools are widely deployed in practice. Our results reconcile the two. Holding the model fixed, natural-language delegation adds no accuracy, consistent with that literature. But the boundary is a nearly lossless channel for capability: with Opus as the inner agent, clients whose own hard-task success ranges from 11% to 96% all land within 2pp of each other. Prior studies hold the model fixed and therefore cannot observe this. The value of exposing an agent depends on which model is behind the boundary, not on the topology. Some of these findings agree with practitioner intuition, but that intuition had not been tested. Measuring it is what shows where it holds (Opus) and where it does not (a model-specific boundary cost for Sonnet). We also contribute an evaluation method that separates the effect of the delegation boundary from capability transfer (same-model vs. cross-capability controls), and a testbed for provider-side evaluation.

Audience. (i) Service providers (e.g., SaaS companies) choosing whether to expose primitive tools or an agent interface, a choice they face today (e.g., Playwright MCP, which exposes raw browser-interaction tools, vs. Browser Use, which exposes a browsing agent as a tool); (ii) designers of agent protocols and SDKs (MCP, A2A, Agent.as_tool()) that standardize this contract and support agent-to-agent delegation; (iii) researchers evaluating multi-agent systems, who can reuse the controlled evaluation setup.

What readers learn. (1) For service providers and their customers: under an agent interface, the quality of service customers receive is set by the provider's inner model and is largely independent of the customer's own model. (2) For service providers: the wrapper itself buys no accuracy, and its boundary cost is model-specific, so providers should measure it for their own inner agent. Agent exposure also costs 7–27% extra tokens on a small catalog, and pays off in schema localization when clients load large tool catalogs without retrieval. (3) For researchers evaluating multi-agent systems: reported multi-agent gains should be decomposed with same-model controls; otherwise capability transfer can be mistaken for an architectural benefit.

These results also raise a question we do not test. Because service quality is set by the inner model, a provider might post-train a small model dedicated to its own service that matches or exceeds the most capable general models at lower cost. We see this as a future direction suggested by our results which can inpire future studies, not a recommendation of the paper.

Actions for revision. Assuming the above answers your questions sufficiently, we will revise the introduction to state the audience and these takeaways explicitly in the next revision.

Reviewer_7PKAOpenReview ↗

Response to clarifications

Ok I seem more persuaded now. I would encourage the authors to tell the story in a clearer manner in the camera ready version. I have increased my rating to 3.

Reviewer_ET9jOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper compares direct tool exposure with Agent-as-a-Tool delegation from a service provider’s perspective through controlled experiments in a synthetic document-management environment. The results suggest that accuracy gains primarily arise from stronger inner models, while isolating service-specific tool schemas reduces total token consumption as the tool catalog grows.

Critical strengths
  1. The research question is useful and offers a service-provider perspective.
  2. The controlled experiments are clear and thorough. Cross-model pairings help distinguish gains from stronger models from those due to delegation.
  3. The paper provides a valuable insight: tool encapsulation does not necessarily improve accuracy, but can reduce tool-schema token costs as the catalog grows. This offers practical guidance for service interface design.
Critical weaknesses
  1. The blog “Where to use sub-agents versus agents as tools” (Google, 2025), already discusses encapsulation and context isolation, limiting the paper’s conceptual novelty. Its contribution therefore lies mainly in controlled experiments and quantitative analysis. However, near-complete delegation to a stronger model yielding performance close to that model is expected. The paper should clarify what new understanding emerges beyond this observation.
  2. The token-efficiency comparison uses DTE with the full tool catalog exposed at every turn, without baselines using tool retrieval, on-demand loading, or service-level filtering. These approaches could also reduce tool-schema costs, leaving unclear how much of the benefit specifically requires agent encapsulation.
Questions for authors

Does AaT retain its token advantage when DTE uses tool retrieval or loads only the tools relevant to the selected service?

1 comment
AuthorsOpenReview ↗

Response to Reviewer ET9j

We thank the reviewer for the careful reading and the pointer to related practitioner guidance.

W1. Novelty relative to the Google blog; capability transfer is "expected."

We will cite the blog post "Where to use sub-agents versus agents as tools" and position our work against it. The Googe blog post offers qualitative design guidance, whereas we provide controlled, quantitative evidence. More importantly, the uplift from a stronger inner model is not an expected priori. It follows only if the natural-language delegation boundary loses is verified to be little, and no prior work, including the blog, measures that loss. Our same-model and cross-capability controls do:

  • With Opus as inner agent, the weakest client (Qwen3 32B) matches DTE(Opus) within a ±5pp equivalence margin (TOST), although its own DTE success on hard tasks is 11.0%.
  • Same-model Opus delegation costs −1.0pp (95% CI [−3.7, 1.3]), equivalent within ±5pp.
  • With a fixed Opus inner agent, five clients whose DTE baselines span 11–96% land within 2.0pp of each other.
  • The boundary is not universally free. For Sonnet the same-model estimate is −6.0pp (CI [−12.7, 0.7]); we trace it to one specific execution failure mode, not to information lost in delegation, and will add this analysis to the appendix.

These results are what make capability transfer a measured property rather than an assumption. We will consolidate them in the introduction.

W2 / Question. Would tool retrieval or on-demand loading give the same token advantage?

The reviewer is right that the saving comes from scoping the tool schema, and we will state this explicitly. Our own data shows the boundary. The 21-tool DTE anchor in the scaling study is effectively DTE with perfect service-level retrieval, and it costs 36K tokens per run, versus 47–51K for AaT at 200 tools. So against a client with ideal retrieval, AaT does not retain a token advantage.

The difference lies in who controls that scoping. Retrieval is a client-side optimization. A provider cannot assume that downstream clients implement it, nor control its recall:

  • recall depends on the client's whole catalog, which may contain several overlapping tool sets for the same service (an official server alongside a community wrapper or an older version);
  • recall must hold across a multi-step trajectory, and in our error-recovery tiers the required media tools are not mentioned in the instruction.

AaT moves schema localization to the provider side, independent of the client's sophistication, and it delivers capability transfer, which retrieval cannot. We will revise Contribution 3 from a "purely mechanical token-saving advantage" to "schema localization without requiring client-side retrieval infrastructure," and add the oracle-retrieval comparison to the scaling section.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.