Tool-Calling Presentation

• Tool-Calling Presentation is a method that enables LLM agents to invoke external tools through natural language decisions rather than strict JSON schemas.
• It uses a modular pipeline—consisting of selector, parser, and responder stages—to decouple tool selection from execution, enhancing workflow flexibility.
• Empirical findings reveal that this approach boosts accuracy by 18.4 percentage points and reduces variance by 70% compared to structured methods.

Tool-Calling Presentation

Tool-calling is a foundational capability in LLM agents, enabling models to invoke external functions, services, and APIs. This augmentation transforms LLMs from passive text generators into agentic systems able to mediate and automate real-world workflows. Tool-calling protocols, strategies, and architectures have evolved rapidly to address concerns including accuracy, latency, security, training efficiency, and robustness under distributional shifts. Tool-calling research has crystalized around benchmarking, modeling (structured vs natural language selection), prompting, and system integration practices. This article surveys core principles and recent empirical findings, focusing on the Natural Language Tools (NLT) framework, which introduces a natural-language interface to tool selection, yielding robust and scalable improvements over conventional schema-constrained approaches (Johnson et al., 16 Oct 2025).

1. Structured Tool-Calling vs. Natural Language Tools (NLT)

Traditional tool-calling is implemented as a "structured tool-calling" paradigm, where LLMs emit outputs strictly conforming to JSON schemas specifying tool-calls and their arguments. This approach requires models to map user inputs into schema-compliant programmatic requests, as in: $correct_i = 1$0 Schema-driven calling is tightly coupled with function-calling APIs, forcing models to interleave selection logic, syntax generation, and downstream response planning. It entails significant probability mass overhead on meeting format constraints and error modes dominated by misformatted or incomplete calls (Johnson et al., 16 Oct 2025).

NLT rearchitects this workflow by decoupling tool selection from programmatic generation. The core design consists of a selector model that, in natural language, evaluates each candidate tool, issuing YES/NO decisions. These decisions are parsed (via simple regex/string-matching) to select tools, which are then executed, and their outputs are subsequently composed into final responses by the responder model. This removes the requirement for rigid schema generation during selection—greatly isolating logic, reducing context burden, and enabling application with LLMs that lack native JSON function-calling support.

2. Architectural and Algorithmic Details

The NLT pipeline is modular:

1. Selector Stage: Given a user query, the selector model outputs a tool-specific YES/NO list with optional reasoning, e.g., $correct_i = 1$1
2. Parser Stage: A lightweight parser extracts tool names with YES, which are executed via external APIs or functions.
3. Responder Stage: The response model consumes (user query, tool outputs) and generates a natural-language answer.

The pseudocode formalization is: $correct_i = 1$2 This separation yields architectural tractability and allows the isolation and independent optimization of tool-selection and response synthesis (Johnson et al., 16 Oct 2025).

3. Evaluation Metrics, Empirical Results, and Robustness

Two principal metrics quantify tool-calling performance:

• Tool-Calling Accuracy: For each trial $i$, $correct_i = 1$ if the selected tools match the ground truth exactly, else $0$. Empirical accuracy is:

$$\mathrm{Accuracy} = \frac{1}{N} \sum_{i=1}^N correct_i$$

• Output Variance: For binary outcomes, variance is $p(1-p)$ where $p$ is the empirical accuracy.

Table 1: Average Performance Across 6,400 Trials (Johnson et al., 16 Oct 2025)

Model Family	Structured Acc.	NLT Acc.	Δ (pp)	Var_structured	Var_NLT
All (avg)	69.1%	87.5%	+18.4	0.0411	0.0121
Closed-weight	79.6%	90.2%	+10.6	0.0202	0.0127
Open-weight	58.7%	84.8%	+26.1	0.0535	0.0139

NLT yields an aggregated absolute gain of 18.4 percentage points and a relative 70% variance reduction. Maximal improvement is observed for open-weight models (e.g., Kimi-K2: 39.69% → 90.00%). These gains are consistent across domains (customer service, mental health), with context reduction (~47%) and substantially lowered computational overhead.

Robustness analysis shows NLT improvements remain under perturbed prompts: e.g., non-perturbed accuracy rises from 68.4% (structured) to 89.6% (NLT), variance drops by 80%; under prompt perturbation, a 15.4-point accuracy gain and 58% variance reduction persist. Critically, NLT enables tool-calling for models lacking any native tool interface, achieving, for instance, 94.1% accuracy with DeepSeek-R1 (structured not applicable).

4. Illustrative Dialogues and Workflow Comparison

Typical customer service and mental health agent interactions demonstrate the contrast between structured and NLT presentation:

Customer Service Example

• Structured JSON
  • LLM: "User requests human agent and past purchases."
  • Output:
  • $correct_i = 1$3
• NLT
  • Selector Output:
  • $correct_i = 1$4
  • Both approaches effectuate the same API calls, but NLT enables the selector to operate using natural language, decoupling the selection format from execution (Johnson et al., 16 Oct 2025).

Mental Health Example

• Structured: system triggers check_safety_call() in JSON.
• NLT: selector issues 'Safety Call – YES; End Conversation – NO'.

5. Training Implications and Model Fine-Tuning

Structured tool-calling requires models to allocate probability mass to low-prevalence, schema-specific SFT/RLHF signals, limiting transfer from broader language modeling pretraining. This can impede the exploitation of linguistic priors and inflates model capacity overhead for syntactic compliance.

NLT aligns the selection task with overwhelmingly prevalent natural language data, fostering a cross-training effect and improving transfer—especially in open-weight models calibrated with general natural language SFT or RLHF. The NLT-specific training loss decomposes into two parts:

$$\mathcal{L}_{\text{NLT}} = \mathbb{E}_{(x,T,y)}[-\log p(T^*|x)] + \mathbb{E}_{(x,T^*,y)}[-\log p(y|x,T^*)]$$

where $x$ is user input, $T^*$ correct natural language tool selection, $y$ is the final response. RLHF reward is proposed to emphasize accuracy of natural language tool selection, not JSON compliance.

6. Systematic Impacts, Generalization, and Future Work

The NLT approach achieves several system-level advantages of high practical importance:

• Universality: Extends tool-calling to models without built-in schemas.
• Context/compute efficiency: Cuts prompt length and associated compute.
• Robustness: Maintains gains under prompt variation and in diverse application domains.
• Modular training: Encourages allocation of SFT/RLHF budget to language-based selection, simplifies interface adaptation, and reduces need for multi-stage schema pressure.
• Path for further research: parameter-passing, multi-turn integration, and extension to broader agentic workflows.

NLT functions effectively as an abstraction boundary, enabling parallel advances in selector architectures, parser robustness, and response model design, independent of restrictive schema constraints (Johnson et al., 16 Oct 2025).

7. Summary of Findings

Natural Language Tools establish a new paradigm in tool-calling presentation:

• Modularizes the pipeline: selector → parser → responder.
• Achieves +18.4 percentage points accuracy and 70% variance reduction.
• Robust to prompt perturbations and extends to otherwise unsupported models.
• Reduces context and compute; optimizes for both closed- and open-weight models.
• Suggests a shift in SFT/RLHF tuning towards natural language grounding of tool decisions.

These findings support the routine adoption of natural language selectors in forthcoming agentic LLM deployments, broadening applicability and simplifying training integrations (Johnson et al., 16 Oct 2025).