acceptodds
Under review as a conference paper at ICLR 2027

From Documentation to Action: Learning to Register Unseen Tools for LLM Agents

Abstract

Tool use extends the capabilities of large language models (LLMs) beyond text generation to interaction with external systems. Existing approaches primarily supply tool documentation through retrieval or learn to generate tool identifiers. Connecting document-based tool selection to argument generation through a compact interface remains a key challenge. To address this challenge, we introduce Unseen Tool Registration (UTR), a framework that compiles tool documentation into a continuous output embedding and a compact memory. The output embedding is scored against the request hidden state within the model's output layer, enabling a unified next-token decision over tools and text. The selected tool's memory then guides argument generation without placing the full documentation in the task context or requiring further training for newly registered tools. Two-stage training first learns to select tools using document-generated embeddings, then teaches the same decoder to generate arguments from memory while retaining selection ability. Both stages optimize components shared across tools, allowing unseen tools to be registered through one document encoding pass without parameter updates. Evaluations on STQ, ToolE, and ToolBench show that UTR matches or exceeds strong baselines in tool selection. On STQ, UTR achieves 93.43% tool exact match and 74.77% call exact match, improving the latter by 6.29 percentage points over the strong baseline, and reaches 84.67% top-1 selection accuracy on ToolE-OOD. UTR also demonstrates strong performance in large-scale tool selection across tool libraries of varying sizes.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Agentic tool use, Tool Registration

Reviews

Among:
Shape:
1234this paper, Bottom 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.25 over 4 reviews, above 49% of the others.
Reviewer_J7kGOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes UTR, which compiles API documentation into an output embedding for tool selection and a compact memory for argument generation. Two-stage training enables new tools to be registered without further parameter updates. UTR achieves 74.77% complete-call EM on STQ, 71.51% macro NDCG@5 on ToolBench with disjoint training APIs, and 80.55% Hit@3 on new-tool queries after adding 5K APIs without retraining.

Critical strengths
  1. UTR provides a coherent interface connecting document-based selection and invocation. Shared compilers let new APIs enter the output space and supply calling information without tool-specific optimization, addressing evolving tool inventories.

  2. The experiments probe both transfer and the role of memory. Disjoint-API and library-expansion tests evaluate new-tool registration, while controlled caller comparisons and memory interventions examine whether compressed tool information supports argument generation.

Critical weaknesses
  1. The practical value and design of compact memory need stronger justification. In the ToolBench control, memory reduces input length but yields lower gold-tool argument EM than full documents. Matched latency and total-cost comparisons are not reported, and the advantage of two compilers over a single shared compiler is not established.

  2. Reliable unseen-tool agent execution remains insufficiently validated. The large-scale end-to-end development study uses full documents and mixed API exposure, leaving compact-memory transfer untested in that setting. A compact-memory STQ reproduction invokes tools on all 32 synthetic requests answerable without tools, even when explicitly prompted to answer directly (Appendix C.4), indicating unreliable abstention in this diagnostic.

Questions for authors
  1. What motivates the two-compiler design? Is there evidence comparing it with a single shared compiler? For the existing memory/full-document comparisons, are matched latency and total costs, including training and registration, available?

  2. Are compact-memory end-to-end results available under strict API holdout? Given Appendix C.4, what training or calibration enables the model to answer directly when no tool is needed?

3 comments
AuthorsOpenReview ↗

Response to Reviewer J7kG (Part 1/2)

We sincerely thank you for your support. We greatly appreciate your description of UTR as "a coherent interface connecting document-based selection and invocation" and your recognition of our transfer and memory experiments. Your questions guided us to measure the full cost of compact memory, test a shared compiler, and evaluate memory end to end under a strict exposure split.

W1: The practical value and design of compact memory need stronger justification. In the ToolBench control, memory reduces input length but yields lower gold-tool argument EM than full documents. Matched latency and total-cost comparisons are not reported, and the advantage of two compilers over a single shared compiler is not established.

Q1: What motivates the two-compiler design? Is there evidence comparing it with a single shared compiler? For the existing memory/full-document comparisons, are matched latency and total costs, including training and registration, available?

1) What memory carries

On 997 unseen ToolBench calls, only 16 memory slots reach 42.1 argument EM, 80% of the 52.4 from full documents, with half the input. The information is tool-specific: another tool's memory gives 0.3, and the memory of the tool with the most similar parameter names is still 25.5 lower. UTR's caller accepts either memory or documents, so both can be used as needed.

2) Matched latency and total cost

A matched pair trained with the same recipe and measured on the same hardware:

Compact memoryFull document
Training, 500 steps, 2×A1005,386 s5,409 s
Registration per tool73 ms once, 128 KB—
Input per ToolBench call156315
End-to-end latency per call0.63 s0.72 s
Input per multi-step task4,3269,225
Prefill, reading 100 candidates301 ms4,255 ms

Training cost is the same, registration is a one-off 73 ms, and each step reads half the input or less; the saving grows with steps and candidates, and prefill is 14.1× faster at 100 candidates.

3) Two compilers vs. a shared compiler

The two representations sit at opposite ends of the decoder. Selection uses one vector in the output layer, scored with the LM head to single out the correct tool among many; calling uses several slots in the input embedding space to carry parameter names, types and required fields. Separate compilers let each be optimized for its own use.

In the shared variant, the output row is pooled from the memory slots and projected, so the selection loss also trains the memory compiler. Both start from the same stage-1 checkpoint, where the shared output rows match the original ones at cosine ≥ 0.99999, so any difference comes from sharing alone. Both follow the matched setting of App. C.2.2 with 1,000 stage-2 steps and seed 17. STQ, 1,066 queries, 837 unseen APIs:

Hit@1Complete-call EMArgument EM
Two compilers94.0070.0874.11
Shared compiler93.1570.3674.20

Separate compilers are preferable for three reasons:

  • Better selection: Hit@1 is 0.84 higher, 95% CI [+0.19, +1.59], while calling differs only within ±0.3.
  • Selection matters most: it is the main source of UTR's end-to-end gain, +6.29 complete-call EM over BGE on STQ in Table 1, and +9.87 solve rate on the 47K tasks of Table 4 when only the candidates change.
  • Independent modules: selection does not depend on memory, so UTR's selection can feed a full-document caller, as in Fig. 5.
AuthorsOpenReview ↗

Response to Reviewer J7kG (Part 2/2)

W2: Reliable unseen-tool agent execution remains insufficiently validated. The large-scale end-to-end development study uses full documents and mixed API exposure, leaving compact-memory transfer untested in that setting. A compact-memory STQ reproduction invokes tools on all 32 synthetic requests answerable without tools, even when explicitly prompted to answer directly (Appendix C.4), indicating unreliable abstention in this diagnostic.

Q2: Are compact-memory end-to-end results available under strict API holdout? Given Appendix C.4, what training or calibration enables the model to answer directly when no tool is needed?

1) Compact memory end to end under a strict split

The paper's Table 4 uses full documents, where UTR solves 37.58% of tasks versus 17.25% for ToolRetriever. We now generate every argument from compact memory on the same 765 tasks, and also report the 240 tasks in which no API of any relevant provider was ever a positive training target, a stricter split than single-API holdout. Solve rate with 47,323 registered APIs:

ConfigurationAll 765 tasksProvider never a positive target (240)Hardest group, G3-instruction
Arguments from compact memory30.0031.0426.2
Full-document calling (Table 4 setup, re-run)34.8436.0426.2
Full-document calling, ToolRetriever's candidates24.9727.08—
  • No degradation under strict exposure: both versions score higher on the 240 tasks than on all 765, and tie at 26.2 on G3-instruction, the hardest group, where each task combines several tools from one collection.
  • UTR's selection gain also holds on the strict split: with the caller fixed, UTR's candidates lead ToolRetriever's by +9.87 overall and +8.96 on the 240 tasks.

The full-document row re-runs the Table 4 setup on the same hardware as the memory version; it gives 34.84 against 37.58 in the paper, a difference that is not significant per task.

2) Answering directly when no tool is needed

The paper's benchmarks require a tool for every request, so UTR learns which tool to call and how. To decide whether to call, we add a pre-call check, as in standard function calling: the backbone sees the request with UTR's top-1 tool and either calls it or answers directly. It needs no extra training, direct-answer data or threshold, and leaves UTR unchanged. We test it on a mixed set of 1,066 STQ tool queries and 1,950 direct-answer requests in 8 kinds (arithmetic, sorting, reversal, copying, parity, upper-casing, clarification, "no tool is available"):

RegistryFalse tool callsMissed tool callsCorrect direct answersAccuracy
837 APIs0 / 1,9509.57%83.177.2
1,836 APIs0 / 1,9509.85%83.176.4
  • Zero false calls: no direct-answer request triggers a tool, in any of the 8 kinds, and this still holds when the registry doubles.
  • The check is what enables abstention: mixed-set accuracy rises from 25.0 without it to 77.2.
  • Registration is unaffected: the check sits in front of UTR, so new tools are still registered by compiling their documents.

Thank you once more for your useful and precise questions. We will add the shared-compiler ablation, the cost table, the exposure split and the calibration study to the paper, and welcome any further discussion.

Thank you for the detailed response. Most of my concerns have been addressed. I will keep my score.

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

This paper proposes Unseen Tool Registration (UTR), a framework that enables LLM agents to use previously unseen tools directly from their documentation without retraining. UTR compiles each tool document into an output embedding for tool selection and a compact memory for argument generation, allowing the same decoder to both select and invoke new tools. Experiments on STQ, ToolE, and ToolBench show strong unseen-tool performance and efficient expansion to much larger tool libraries without parameter updates.

Critical strengths
  1. The paper provides meaningful tests of unseen-tool generalization rather than relying only on tool-identifier memorization. STQ separates 999 training APIs from 837 held-out test APIs, while ToolBench includes a zero-overlap training condition. The appendix also carefully audits remaining provider and template overlap, making the scope of the generalization claims relatively transparent.
  2. The document-compiled interface is technically coherent and supports efficient tool-library expansion. UTR converts tool documentation into a dynamic output embedding for selection and a compact memory for argument generation, avoiding tool-specific parameter optimization when new APIs are added. The approach performs strongly on STQ, ToolE, and ToolBench, and can register 2K or 5K additional APIs with frozen parameters while searching the full expanded library. Importantly, the paper also reports the trade-off at 15K, where ToolGen achieves higher NDCG@5 despite UTR’s better Hit@3.
  3. The experimental analysis is broad and unusually transparent about limitations. Beyond the main results, the paper reports expansion costs, overlapping and API-disjoint settings, memory-versus-full-document controls, and detailed exposure analysis. It also reports negative or nuanced findings, including the failure of the text/tool routing diagnostic and the task-dependent effect of memory perturbation, which help clarify where the proposed interface works and where its conclusions are less general.
Critical weaknesses
  1. The unified tool/text decision is not well calibrated. all 32 direct-answer requests trigger a tool even when the prompt explicitly allows direct answers. Expanding the registry also reduces tool-query Top-1 accuracy. This suggests that the current interface does not yet reliably decide when not to call a tool. Moreover, The paper includes API-held-out memory-versus-document calling controls, but these use single-entity schemas. On the separate STQ memory-intervention panel, matching, wrong, and zeroed memories produce nearly identical results, whereas the stronger ToolBench intervention uses APIs seen during training.
  2. The large-scale efficiency and end-to-end comparisons are not fully matched. The expansion study does not include a frozen index-only baseline, and the 47K evaluation uses full-document calling rather than compact memory, mixed API exposure, and different caller configurations for UTR and ToolRetriever. Therefore, the end-to-end gain cannot be cleanly attributed to the proposed registration interface alone.
Questions for authors
  1. Can the authors evaluate tool-versus-text calibration on a mixed set of tool-required and direct-answer requests, reporting false tool calls, missed tool calls, and task accuracy?
  2. Can the compact-memory variant be evaluated on provider/template-disjoint unseen tools, with matching-memory, wrong-memory, zero-memory, and full-document controls?
  3. Can the expansion and 47K experiments include a frozen index-only baseline and more closely matched callers/training exposure? A matched comparison or more detailed distinction from ToolWeaver would also help establish the contribution.

Convincing answers to these questions would make me consider raising my score.

6 comments
AuthorsOpenReview ↗

Response to Reviewer fnNk (Part 1/4)

We sincerely thank you for the detailed and constructive review, and for recognizing our tests of unseen-tool generalization, the technical coherence of the document-compiled interface and the transparency of our analysis. Your three questions guided the new experiments below, which make the attribution of our gains much cleaner.

W1a: The unified tool/text decision is not well calibrated. all 32 direct-answer requests trigger a tool even when the prompt explicitly allows direct answers. Expanding the registry also reduces tool-query Top-1 accuracy. This suggests that the current interface does not yet reliably decide when not to call a tool.

Q1: Can the authors evaluate tool-versus-text calibration on a mixed set of tool-required and direct-answer requests, reporting false tool calls, missed tool calls, and task accuracy?

1) Direct-answer requests: zero false tool calls

Every request in the paper's three benchmarks (STQ, ToolE, ToolBench) requires a tool, so UTR is trained to decide which tool to call and how; App. C.4 notes that training contains no direct-answer data. The "whether to call" decision is added with a standard function-calling pre-call check: UTR retrieves its top-1 tool, and the backbone sees the request and this tool in the standard function-calling format and either emits a call or answers directly. No training, no threshold, and UTR itself is unchanged.

As requested, we built a mixed set of 3,016 requests: the 1,066 STQ test queries plus 1,950 direct-answer requests in 8 kinds (arithmetic, sorting, reversal, copying, parity, upper-casing, clarification, and "no tool is available"). Results under two registry sizes:

RegistryFalse tool calls, direct-answer requestsMissed tool calls, tool requestsComplete-call EM, 1,066 tool requestsCorrect direct answers, 1,950Task accuracy, 3,016
837 APIs0 / 1,9509.57%66.483.177.2
1,836 APIs0 / 1,9509.85%64.183.176.4

None of the 1,950 direct-answer requests triggers a tool, in any of the 8 kinds, and this still holds when the registry doubles. Mixed-set accuracy is 77.2, compared with 25.0 without the check, and stays at 76.4 with twice as many APIs.

2) Larger registry: UTR is the most stable selector

We now grow the registry from 837 to 1,836 APIs on the full STQ test set of 1,066 queries, and pass every selector's choice to the same caller (UTR's memory interface):

SelectorHit@1Complete-call EM
UTR94.09 → 89.5970.73 → 68.01
BGE-large82.93 → 75.3362.85 → 57.60
E5-large78.24 → 71.2958.54 → 53.94
BM2571.39 → 65.5753.00 → 48.50

A lower Top-1 under a larger registry is common to every method. UTR drops the least, and its lead over BGE grows from +11.2 to +14.3 Hit@1 and from +7.9 to +10.4 complete-call EM. In App. C.4 the correct tool stays in the Top-5 for all 64 tool queries when the registry grows, and Table 3 shows the highest new-tool Hit@3 of 78.64/80.55 at 12K/15K. We will add both studies to the paper.

AuthorsOpenReview ↗

Response to Reviewer fnNk (Part 2/4)

W1b: Moreover, The paper includes API-held-out memory-versus-document calling controls, but these use single-entity schemas. On the separate STQ memory-intervention panel, matching, wrong, and zeroed memories produce nearly identical results, whereas the stronger ToolBench intervention uses APIs seen during training.

Q2: Can the compact-memory variant be evaluated on provider/template-disjoint unseen tools, with matching-memory, wrong-memory, zero-memory, and full-document controls?

1) Why the STQ intervention cannot separate the conditions

The paper provides initial evidence that memory matters: under API holdout, memory reaches 82.05 against 82.15 for full documents in Table 10 of App. C.2, and on ToolBench a wrong tool's memory drops argument EM from 54.47 to 16.60 (Fig. 6(a)). On STQ, however, all 2,835 tools share one schema, {"entity": string}, and 87.7% of reference values appear verbatim in the query. Whatever memory is given, the correct call can be copied from the query, which explains the identical outputs in App. C.3.

2) Four controls on provider/template-disjoint tools

As requested, we use 997 first-step ToolBench calls with diverse schemas: 499 with held-out APIs and 498 whose API, provider and template are all held out; every evaluated API, its provider and any duplicate API are excluded from all training stages. One model generates arguments directly, with no document and no plan, under each condition with greedy decoding. Argument EM:

ConditionAPI-unseenProvider/template-unseenAll unseenExact parameter names
Matching memory42.541.842.161.1
Wrong memory0.20.40.30.4
Zeroed memory12.213.312.716.1
Query only11.211.511.314.0
Full document51.353.452.488.5

Replacing the matching memory with another tool's memory drops EM from 42.1 to 0.3, and only 5 of 997 outputs stay identical. Zeroed memory and query only stay near 12, so the calls are not produced from the query and LoRA patterns alone.

3) Hard negatives

We also replace the memory with that of the tool sharing the most parameter names with the correct one, on the same 997 calls. Argument EM:

Memory given to the decoderAll 997 unseen calls523 calls needing a name the hard negative lacks
Matching memory42.127.7
Hard negative: most shared parameter names16.61.1

Matching memory still leads by +25.5 EM, and on the calls that need a name the hard negative lacks, the hard negative almost never succeeds: the decoder copies the exact names stored in memory, rather than guessing common names of similar tools.

These results confirm that, on tools disjoint from training in API, provider and template, the decoder reads tool-specific argument information from the memory slots. We thank the reviewer for this precise suggestion and will add the panel to the paper.

AuthorsOpenReview ↗

Response to Reviewer fnNk (Part 3/4)

W2a: The large-scale efficiency and end-to-end comparisons are not fully matched. The expansion study does not include a frozen index-only baseline.

Q3: Can the expansion and 47K experiments include a frozen index-only baseline and more closely matched callers/training exposure? A matched comparison or more detailed distinction from ToolWeaver would also help establish the contribution.

1) Frozen index-only baselines in the expansion study

The paper's Table 3 gives an initial comparison, where expansion without training reaches the quality of retrained methods: with no parameter update, UTR has the highest new-tool Hit@3 of 78.64/80.55 at 12K/15K, at a cost of 0.042 H100 hours versus about 15.4 H100 hours for retraining ToolGen. As suggested, we add frozen index-only baselines under the same setting as Table 3. New-tool queries on the full expanded library, all methods frozen:

Method12K Hit@112K Hit@315K Hit@115K Hit@3
PORTS (10K-trained)39.5554.0943.8258.00
ToolRetriever (10K-trained)46.8262.7347.6466.36
BM2544.0957.7349.2762.18
E5-large50.4565.9154.5569.82
BGE-large56.8270.9159.8274.00
UTR66.3679.0966.0081.82

With the same training scope, UTR leads ToolRetriever by +19.6/+18.4 Hit@1 and PORTS by +26.8/+22.2, and also leads every untrained retriever. UTR's numbers closely match the 65.00/66.18 in the paper's Table 3. On the original 10K queries UTR also leads ToolRetriever with 71.91 versus 63.27 Hit@1.

ToolRetriever and PORTS are retrained with their official recipes on the 10K library only, the same scope as UTR, and then frozen; new tools are only encoded into the index. BM25, E5 and BGE-large need no training.

2) Frozen index with a matched caller

In the registry-growth study of Part 1, the caller is fixed and only the selector changes on STQ: UTR reaches 70.73 complete-call EM versus 62.85 for BGE, and the gap grows with the registry. Registering a tool by compiling its document is thus clearly better than adding it to a frozen retrieval index, and the advantage carries over to complete calls.

3) Distinction from ToolWeaver

Based on the ToolWeaver paper, the two methods differ as follows:

ToolWeaverUTR
Tool representationsequence of shared discrete codescontinuous output row + 16-slot memory, compiled from the document
Built fromdocument + tool co-occurrence in usage trajectoriesdocument only
Vocabulary2×1,024 code tokens added, LLM fine-tunedno new tokens
New tool after trainingno procedure givenone forward pass (73 ms), no update
Argument generationdocument in contextmemory of the selected tool

A newly released tool has no usage record and hence no co-occurrence statistics, while UTR needs only its document, which is exactly the setting of the frozen-index study above.

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

This paper proposes Unseen Tool Registration (UTR), a framework that enables LLM agents to select and invoke unseen tools from their documentation without additional retraining. UTR introduces two components: an output compiler that converts tool documentation into dynamic output embeddings for tool selection, and a memory compiler that compresses documentation into latent memory tokens for argument generation. The framework adopts a two-stage training strategy to learn tool selection and invocation while keeping the backbone LLM frozen. Experiments on STQ, ToolE, and ToolBench demonstrate competitive performance in unseen-tool selection and calling.

Critical strengths
  1. The paper addresses the relevant problem of integrating unseen tools into LLM agents without tool-specific retraining, which is useful for dynamically evolving tool libraries.
  2. The proposed framework provides a straightforward way to connect document-based tool selection and argument generation through a shared decoder. The overall design and two-stage training procedure are clearly described and easy to follow.
Critical weaknesses
  1. The proposed framework largely combines two established techniques: tool-as-token prediction for tool selection and latent-token-based compression.The paper does not sufficiently clarify what fundamentally new capabilities arise from this particular combination.
  2. It remains questionable whether the memory compiler actually preserves tool-specific information and whether the decoder meaningfully utilizes it. In Appendix C.3, replacing the correct memory with an incorrect tool's memory produces identical output sequences for 199 out of 200 STQ examples, with no change in argument or complete-call accuracy. This raises concerns that argument generation may rely primarily on the input query and calling patterns learned through LoRA rather than the information stored in memory slots.
  3. Once the correct tool has been selected, directly providing its documentation to the decoder is a simple and reasonable alternative. The memory compiler primarily reduces the input context length, but the absolute savings appear relatively modest in the reported STQ experiments (51.86 vs. 96.27 input positions), while introducing additional training and architectural complexity. The paper does not provide sufficient evidence that these savings translate into meaningful inference efficiency improvements. Moreover, the large-scale end-to-end evaluation uses full-document calling rather than the proposed compact-memory interface, further weakening the practical justification for this component.
Questions for authors
  1. Could the authors provide a direct comparison with a baseline that uses tool-as-token prediction for tool selection and full documentation for argument generation, under matched training and evaluation settings? This would help isolate the contribution of the document-derived output compiler and clarify its advantages over existing tool-as-token approaches.
  2. Could the authors provide a more comprehensive comparison between compact-memory calling and full-document calling, including training cost, inference latency, GPU memory usage, and token consumption? While the paper reports reductions in input positions, it remains unclear whether these savings justify the additional training cost and complexity introduced by the memory compiler, especially when only the selected tool's documentation needs to be processed.
10 comments
AuthorsOpenReview ↗

Response to Reviewer 6o8k (Part 1/4)

We sincerely thank you for the careful review. We greatly appreciate your recognition of the importance of integrating unseen tools without retraining and the clarity of our design. Your questions guided us to test the memory on tools with diverse schemas, to measure its costs in full, and to compare directly with tool-as-token selection under the same caller, which shows more directly what each component contributes.

W1: The proposed framework largely combines two established techniques: tool-as-token prediction for tool selection and latent-token-based compression. The paper does not sufficiently clarify what fundamentally new capabilities arise from this particular combination.

1) The problem and the framework

UTR addresses a problem that neither technique solves alone: a tool never seen in training is both selected and called from its document only, with no training. The same document goes through two compilers, giving an output row in the decoder's output layer and a 16-slot memory at its input. What each approach needs for a new tool:

Select a new toolCall a new toolTraining per new tool
Tool-as-token (ToolkenGPT, ToolGen)learned tokendocument in contextrequired
Latent compression onlynot covered (external retriever)compressed context—
UTRoutput row compiled from the documentmemory compiled from the same documentnone (73 ms per tool)

Only UTR both selects and calls a new tool from its document alone, with no training per tool: tool-as-token methods must train a token for each new tool, and latent compression still needs an external retriever to select it.

2) Three capabilities, each verified in the paper

CapabilityEvidence in the paper
Select and call unseen tools accuratelyLeads on every metric for 837 unseen STQ APIs, with complete-call EM 74.77 versus 68.48 for BGE, and reaches NDCG@5 91.47 versus 82.63 for PORTS on ToolE-OOD (Table 1)
Select directly in a large libraryReaches NDCG@5 71.51 on 10K ToolBench APIs disjoint from training, outperforming ToolRetriever by 18.76 (Table 2)
Expand without trainingReaches the highest new-tool Hit@3 of 78.64/80.55 at +2K/+5K APIs with no parameter update, costing 0.042 H100 hours versus about 15.4 for retraining ToolGen (Table 3)

Beyond these capabilities, UTR also works end to end: with 47K registered APIs, it solves 37.58% of multi-step tasks versus 17.25% for ToolRetriever (Table 4).

3) New experiments confirm both modules

Two new experiments test each module on tools unseen in training:

  • Output compiler: trained on 10K APIs and then frozen, it reaches new-tool Hit@1 of 66.4/66.0 at 12K/15K, versus 46.8/47.6 for ToolRetriever trained and frozen the same way.
  • Memory compiler: on 997 calls disjoint from training in API, provider and template, matching memory gives 42.1 argument EM, while another tool's memory gives only 0.3 (Part 2).

UTR is thus a new tool-registration framework rather than a combination, and we will state these capabilities more prominently in the revision.

AuthorsOpenReview ↗

Response to Reviewer 6o8k (Part 2/4)

W2: It remains questionable whether the memory compiler actually preserves tool-specific information and whether the decoder meaningfully utilizes it. In Appendix C.3, replacing the correct memory with an incorrect tool's memory produces identical output sequences for 199 out of 200 STQ examples, with no change in argument or complete-call accuracy. This raises concerns that argument generation may rely primarily on the input query and calling patterns learned through LoRA rather than the information stored in memory slots.

1) The paper's evidence and why STQ shows no change

Two results in the paper indicate that the decoder utilizes memory: under API holdout, calling from memory matches calling from full documents, 82.05 versus 82.15 (Table 10, App. C.2), and on ToolBench a wrong tool's memory lowers argument EM from 54.47 to 16.60 (Fig. 6(a)). The identical outputs in App. C.3 come from STQ itself: all 2,835 tools share the schema {"entity": string}, and 87.7% of values appear verbatim in the query, so whatever memory is given, the correct call can be copied from the query.

2) Intervention on tools with diverse schemas

We use 997 first-step ToolBench calls disjoint from training: 499 are disjoint in API, and 498 in API, provider and template. Another 500 calls with seen APIs serve as reference. Arguments are generated directly from memory, with no document and no plan. Argument EM:

Input to the decoderUnseen (997)Exact parameter names, unseenSeen (500)
Matching memory42.161.145.6
Another tool's memory0.30.40.4
Zeroed memory12.716.112.6
Query only11.314.011.8

The decoder meaningfully utilizes memory: with another tool's memory, EM falls from 42.1 to 0.3, and just 5 of the 997 outputs remain unchanged. Generation does not rely primarily on the query and the calling patterns learned through LoRA, since zeroed memory and the query-only input reach just 12.7 and 11.3.

The memory preserves tool-specific information: against the tool sharing the most parameter names, matching memory still leads by +25.5, and from 16 slots alone the model decodes the complete parameter-name set of 42.0% of unseen tools. We are grateful for this question, which led to a clearer test of the memory, and will add the panel to the paper.

AuthorsOpenReview ↗

Response to Reviewer 6o8k (Part 3/4)

W3: Once the correct tool has been selected, directly providing its documentation to the decoder is a simple and reasonable alternative. The memory compiler primarily reduces the input context length, but the absolute savings appear relatively modest in the reported STQ experiments (51.86 vs. 96.27 input positions), while introducing additional training and architectural complexity. The paper does not provide sufficient evidence that these savings translate into meaningful inference efficiency improvements. Moreover, the large-scale end-to-end evaluation uses full-document calling rather than the proposed compact-memory interface, further weakening the practical justification for this component.

Q2: Could the authors provide a more comprehensive comparison between compact-memory calling and full-document calling, including training cost, inference latency, GPU memory usage, and token consumption? While the paper reports reductions in input positions, it remains unclear whether these savings justify the additional training cost and complexity introduced by the memory compiler, especially when only the selected tool's documentation needs to be processed.

1) Token consumption and latency

The paper reports the input reduction: from 96.3 to 51.9 positions on STQ in Table 11, and −26.9% on ToolBench in Fig. 5. Below we compare a matched pair trained with the same recipe; inference is measured on one L20 with the same requests:

Compact memoryFull document
Training, 500 steps, 2×A1005,386 s, peak 25.8 GB5,409 s, peak 25.6 GB
Registration per tool73 ms once, 128 KB—
Input per ToolBench call, mean / p90156 / 173315 / 466
Prefill / end-to-end latency per call56 ms / 0.63 s75 ms / 0.72 s
Peak inference memory, one callsamesame
Input per multi-step task (765 tasks)4,3269,225

Prefill when reading k candidate tools, 100 requests:

k15102050100
Memory54 ms56 ms72 ms98 ms170 ms301 ms
Document73 ms180 ms323 ms667 ms1,898 ms4,255 ms
Speed-up1.3×3.2×4.5×6.8×11.1×14.1×

Training cost is unchanged, and the saving grows with document length and with the number of candidates read per step; STQ documents are short. Even when only the selected tool is processed, memory halves the input and cuts latency by 13%. An agent reads several candidates at each step, so a multi-step task needs less than half the input, and at k = 100 prefill is 14.1× faster with 16.95 vs. 22.42 GiB peak memory.

2) Compact memory end to end

With 47,323 registered APIs, arguments generated only from memory solve 30.00% of the 765 tasks and 31.04% of the 240 tasks in which no API of the relevant providers was ever a positive training target; on G3-instruction, the hardest group with multi-tool tasks within one collection, memory and full documents both reach 26.2.

Reviewer_XHGFOpenReview ↗
Rating
1
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes Unseen Tool Registration (UTR), a framework that enables large language model (LLM) agents to register and invoke previously unseen tools directly from their documentation without tool-specific retraining. The central idea is to compile each tool’s documentation into two complementary representations: (1) a continuous output embedding that allows the model to select tools through its next-token prediction mechanism, and (2) a compact memory representation that guides argument generation without inserting the full documentation into the context. The framework employs a two-stage training procedure. The first stage aligns user requests with document-derived tool embeddings for selection, while the second stage trains the model to generate arguments from the selected tool’s memory while preserving its selection ability.

Critical strengths
  1. Interesting integration of tool selection and argument generation. The proposed framework connects document-based tool representations with the language model’s output layer, enabling direct tool selection through next-token prediction. The additional compact memory provides an interface for argument generation, offering a unified approach to two closely related aspects of tool use.
  2. Efficient registration of unseen tools. A key strength is that newly introduced tools can be registered through a single document-encoding pass without additional parameter updates. This design is appealing for dynamic tool ecosystems and potentially reduces the computational overhead associated with maintaining large tool libraries.
  3. Useful analysis of compact memory. The ablation studies investigate the effectiveness of document-derived memory, including comparisons with full-document calling, memory perturbations, and different memory capacities.
Critical weaknesses
  1. The methodological novelty relative to existing approaches could be better established. The central idea of encoding tool documentation into reusable representations is closely related to previous work on tool embeddings, hidden-state matching, and generative tool retrieval.
  2. The comparison with existing baselines raises questions about fairness and experimental consistency. On STQ, baseline methods select tools and pass candidates to a Qwen3-8B caller, whereas UTR generates arguments through its learned memory interface. The paper also reports different generation budgets for the two settings. This makes it difficult to determine whether improvements in complete-call accuracy come from better tool selection, the proposed memory representation, or differences in the calling configuration.
  3. Limited investigation of generalization across backbone models and tool domains. The experiments primarily use Qwen3-8B as the backbone. It remains unclear whether the proposed document compilers and memory representations transfer effectively to other model architectures, model sizes, or instruction-tuning configurations.
Questions for authors
  1. Novelty and relationship to existing methods. Could the authors further clarify the methodological novelty of UTR compared with ToolkenGPT, CoTools, Toolscaler, and ToolWeaver?
  2. Fairness of baseline comparisons.
4 comments
AuthorsOpenReview ↗

Response to Reviewer XHGF (Part 1/3)

We sincerely thank you for the careful review, and for recognizing the integration of tool selection and argument generation, the efficient registration of unseen tools and our analysis of compact memory. Your questions guided us to position UTR against each related method, add stricter fairness controls and train on new backbones.

W1: The methodological novelty relative to existing approaches could be better established. The central idea of encoding tool documentation into reusable representations is closely related to previous work on tool embeddings, hidden-state matching, and generative tool retrieval.

Q1: Novelty and relationship to existing methods. Could the authors further clarify the methodological novelty of UTR compared with ToolkenGPT, CoTools, Toolscaler, and ToolWeaver?

1) The problem and the framework

Encoding documents into representations is common ground; UTR's contribution is the problem it solves and the framework built for it. A tool never seen in training is both selected and called from its document only, with no parameter update. UTR compiles the document into two representations at two positions of one decoder: an output row scored in the same softmax as the vocabulary for selection, and a 16-slot input memory for argument generation. Comparison based on each method's paper:

MethodRepresentationTraining-free registrationOutput-layer selectionDocument-free calling
ToolkenGPTlearned toolken embeddingNo, trains embeddingYesNo, demos / document
ToolGenvocabulary token per APINo, fine-tunesYesNo, fine-tuned tools only
CoToolshidden state + matcherYesNo, external matchingNo, document in context
ToolScalershared discrete codesYes, existing codebookYesNo, document in context
ToolWeavercodes + co-occurrenceNot statedYesNo, document in context
UTRrow + memory compiled from documentYes, 73 msYesYes, 16 memory slots

As you note among the strengths, UTR registers a new tool "through a single document-encoding pass without additional parameter updates". Among the methods above, it is the only one that does so while also selecting in the decoder's own output layer and generating arguments without the document in context.

2) What these differences enable

  • Training-free registration: expansion costs 0.042 H100 h versus about 15.4 for retraining ToolGen (Table 3). In a new experiment with all methods frozen, new-tool Hit@1 is 66.4/66.0 at 12K/15K versus 46.8/47.6 for ToolRetriever trained on the same 10K data.
  • Output-layer selection: on 10K ToolBench with disjoint training and candidate APIs, NDCG@5 is +18.76 over ToolRetriever (Table 2).
  • Document-free calling: in a new experiment on 997 calls disjoint in API, provider and template, matching memory gives 42.1 EM versus 0.3 for another tool's memory, and +25.5 over the tool with the most similar parameter names, so memory distinguishes close tools rather than acting as a category code.
  • All three together: +6.29 complete-call EM over the strongest baseline on STQ unseen APIs (Table 1), and 37.58 vs. 17.25 with 47K APIs (Table 4).

We will add this comparison and these results to the related-work discussion.

AuthorsOpenReview ↗

Response to Reviewer XHGF (Part 2/3)

W2: The comparison with existing baselines raises questions about fairness and experimental consistency. On STQ, baseline methods select tools and pass candidates to a Qwen3-8B caller, whereas UTR generates arguments through its learned memory interface. The paper also reports different generation budgets for the two settings. This makes it difficult to determine whether improvements in complete-call accuracy come from better tool selection, the proposed memory representation, or differences in the calling configuration.

Q2: Fairness of baseline comparisons.

1) The paper's design separates the three factors

STQ compares two paradigms: "retrieve, then call" and UTR's unified interface. A retriever only selects, so it needs a caller; all baselines use Qwen3-8B, the same backbone as UTR, as stated in Sec. 4.1. To make each contribution visible, Table 5 reports selection, arguments and complete calls separately, plus Qwen3-8B given the correct tool's document. The paper's Table 5 on STQ, with 837 unseen APIs and normalized EM:

MethodCorrect toolCorrect argumentsComplete call
BM25 + Qwen3-8B82.0876.0863.23
E5-large + Qwen3-8B87.0576.9267.82
PORTS + Qwen3-8B87.5276.5567.92
BGE-large + Qwen3-8B88.8476.8368.48
UTR93.4379.1774.77
Qwen3-8B with correct document (reference)99.7277.2076.92

Selection is the main source of the +6.29 complete-call gain, since UTR picks the correct tool 4.59 points more often than BGE. UTR's memory also reaches 79.17 argument EM, above the 77.20 of Qwen3-8B reading the correct document, with half the input.

2) Generation budgets

96 and 128 are only output caps. We re-generated and checked lengths: no output of UTR or Qwen3-8B reaches 96 tokens, and scores are identical under caps of 96, 128 and 512. The two settings are therefore equivalent.

3) A stricter control: one caller for all selectors

Following the reviewer's feedback, we pass the tools chosen by each selector to the same caller (UTR's memory interface), with the same prompt, budget and scoring. STQ, 1,066 queries:

SelectorHit@1Complete call, strictComplete call, normalizedArguments when correct
UTR94.0970.7374.0278.66
BGE-large82.9362.8565.6779.19
E5-large78.2458.5461.1678.18
BM2571.3953.0055.5377.79

With identical argument generation, complete calls follow selection exactly and UTR leads BGE by +7.88 strict EM. The UTR row is identical to the reference in App. C.3. On 47K multi-step tasks with a fixed caller, UTR's selection raises the solve rate from 24.97 to 34.84, a gain of +9.87.

The paper's comparison follows the standard setting for retrieval methods, and the stricter controls reach the same conclusion: UTR's gains come from the method itself. We will add these controls and state the setting more prominently.

AuthorsOpenReview ↗

Response to Reviewer XHGF (Part 3/3)

W3: Limited investigation of generalization across backbone models and tool domains. The experiments primarily use Qwen3-8B as the backbone. It remains unclear whether the proposed document compilers and memory representations transfer effectively to other model architectures, model sizes, or instruction-tuning configurations.

UTR does not depend on a specific backbone: the two compilers use only the decoder's input embeddings and output layer, which every decoder-only LLM has. To confirm this, we trained UTR on a larger model (Qwen3-14B) and on an earlier-generation, instruction-tuned model with a different hidden size (Qwen2.5-7B-Instruct). We used the paper's two-stage recipe with 2,000 steps per stage instead of 6,550 (about 30%), and the paper's protocol on STQ, with 1,066 queries and 837 unseen APIs:

BackboneSteps per stageHit@1Argument EMComplete-call EM
Qwen3-8B (paper)6,55094.0974.5870.73
Qwen3-8B (control)2,00092.9674.6770.54
Qwen3-14B2,00093.1575.8971.67
Qwen2.5-7B-Instruct2,00093.2575.8971.39

With 30% of the steps, both new backbones exceed the fully trained Qwen3-8B, covering model size, architecture generation and instruction tuning. For tool domains, the paper covers STQ, ToolE and ToolBench; the new panel adds tools whose providers and templates never appear in training, where matching memory reaches 42.1 EM versus 0.3 for a wrong one, and expansion adds 2K/5K APIs with new-tool Hit@1 of 66.4/66.0.

Every LLM faces the same problem when new tools arrive, and UTR applies to them without modification. We thank the reviewer for this point, which showed us that other backbones reach better results with fewer training steps. We will further extend UTR to larger models and other model families, and add these results to the main experiments.

We are grateful for your thorough review, which helped us clarify the novelty and fairness of our evaluation. We hope these results resolve your concerns and would be glad to discuss any remaining questions.

AuthorsOpenReview ↗

Follow-up to Reviewer XHGF

Dear Reviewer XHGF,

Thank you again for your constructive review. As the discussion period is drawing to a close, we understand that this is a busy time and you may not yet have had the chance to return to our response. To save your time, please allow us to summarize it briefly, together with one additional experiment.

Novelty. Among ToolkenGPT, ToolGen, CoTools, ToolScaler and ToolWeaver, UTR is the only method that registers a tool never seen in training from its document alone, with no parameter update, selects it in the decoder's own output layer, and calls it without the document in context. Fairness. With every selector passed to the same caller, prompt, budget and scoring, UTR still leads BGE by +7.88 complete-call EM on STQ, and by +9.87 solve rate on the 47K multi-step tasks; generation caps of 96, 128 and 512 give identical scores.

Additional experiment: another model family. Beyond Qwen3-14B and Qwen2.5-7B-Instruct, we trained UTR on Llama-3.1-8B-Instruct with the same recipe (2,000 steps per stage) and the paper's STQ protocol, 1,066 queries and 837 unseen APIs:

BackboneSteps per stageHit@1Argument EMComplete-call EM
Qwen3-8B (paper)6,55094.0974.5870.73
Qwen3-8B (control)2,00092.9674.6770.54
Qwen3-14B2,00093.1575.8971.67
Qwen2.5-7B-Instruct2,00093.2575.8971.39
Llama-3.1-8B-Instruct2,00093.0677.3972.89

UTR transfers across model families without modification: with the same 2,000 steps, Llama-3.1-8B-Instruct matches or exceeds Qwen3-8B on all three metrics, and its argument and complete-call EM are the highest among all backbones.

We would greatly value your thoughts on whether our response and this addition resolve your concerns, and we would be glad to discuss or clarify anything further in the remaining time. Thank you again for the comments that have made our paper stronger.

Best regards,

The Authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.