Think-Augmented Function Calling: Improving LLM Parameter Accuracy Through Embedded Reasoning

Large language models (LLMs) have demonstrated remarkable capabilities in function calling for autonomous agents, yet current mechanisms lack explicit reasoning transparency during parameter generation, particularly for complex functions with interdependent parameters. While existing approaches like chain-of-thought prompting operate at the agent level, they fail to provide fine-grained reasoning guidance for individual function parameters. To address these limitations, we propose Think-Augmented Function Calling (TAFC), a novel framework that enhances function calling accuracy through explicit reasoning at both function and parameter levels. Our method introduces a universal “think” parameter augmentation that enables models to articulate their decision-making process, with dynamic optimization for parameter descriptions to improve reasoning quality. For complex parameters, TAFC automatically triggers granular reasoning based on complexity scoring, ensuring appropriate justification for critical decisions. Additionally, we propose reasoning-guided optimization to align generated reasoning with human expectations. TAFC requires no architectural modifications to existing LLMs while maintaining full API compatibility. Evaluation on ToolBench across proprietary and open-source models demonstrates significant improvements in parameter generation accuracy and reasoning coherence for multi-parameter functions, while providing enhanced interpretability for debugging AI agent behaviors.

💡 Research Summary

The paper introduces Think‑Augmented Function Calling (TAFC), a framework that adds explicit reasoning to large language model (LLM) function calls without modifying the underlying model architecture. The core idea is to augment every function signature with an optional “think” parameter that holds a natural‑language trace of the model’s reasoning before actual parameter values are produced. Formally, the generation process is factorized as P(think | input, context) × P(parameters | input, context, think), ensuring that reasoning precedes and informs the concrete arguments.

For functions with multiple inter‑dependent arguments, TAFC computes a complexity score ψ(p) for each parameter based on dependency depth, type difficulty, and constraint strictness. Parameters whose score exceeds a threshold τ (set to 0.6 in the experiments) are transformed into reasoning‑augmented tuples {think_i: r_i, value_i: v_i}, where r_i is a fine‑grained justification and v_i is the actual value. This selective granularity allows the model to provide separate justifications for, e.g., a database table name versus filter conditions, thereby reducing ambiguous or contradictory assignments.

Two complementary optimization stages are proposed. First, the description of the think parameter itself is tuned either via a meta‑LLM that iteratively refines textual prompts (discrete optimization) or by learning continuous prompt embeddings H_think that maximize the likelihood of correct parameters (continuous optimization). Second, the overall tool description is aligned with human‑annotated reasoning using a multi‑component loss L_align = λ₁L_sem + λ₂L_logic + λ₃L_action. L_sem measures semantic similarity (cosine distance) between generated and reference reasoning, L_logic penalizes low likelihood of the reference reasoning, and L_action combines binary cross‑entropy for parameter correctness with an L2 penalty on reasoning deviation. Black‑box optimization iteratively updates the tool description until the alignment loss stabilizes.

Experiments are conducted on the ToolBench benchmark, which contains over 16 k real‑world REST APIs across 49 categories. Three instruction types are evaluated: I1‑Inst (single‑tool), I2‑Inst (intra‑category multi‑tool), and I3‑Inst (cross‑category multi‑tool). Models tested include proprietary GPT‑4o and Claude‑3.5‑Sonnet, as well as open‑source Qwen2.5 (7 B, 32 B, 72 B) and Llama‑3.1 (8 B, 70 B). All experiments keep the prompting template identical except for the TAFC reasoning augmentations, ensuring a fair comparison.

Results show consistent improvements across the board. Pass Rate (task success under a fixed call budget) rises by 1.6‑2.5 percentage points, while Win Rate (pairwise preference judged by a LLM) improves by 2.1‑2.5 points for every model. Smaller models (7‑8 B) benefit the most, gaining 2.4‑2.5 % in Pass Rate and 2.9‑3.1 % in Win Rate, indicating that explicit reasoning compensates for limited intrinsic tool‑use capabilities. The gains are even larger on the hardest I3‑Inst scenarios, confirming that TAFC’s fine‑grained reasoning is especially valuable for complex tool orchestration.

A dedicated parameter‑quality assessment using GPT‑4o as an LLM‑as‑judge reveals that TAFC‑generated arguments win over standard function calling in 62‑76 % of cases, with the highest win rates (≈76 %) observed for the smallest open‑source models. Qualitative analysis shows that TAFC reduces omission and type‑mismatch errors by roughly 38 %, produces more context‑appropriate values, and better respects inter‑parameter constraints. The only notable failure mode occurs on trivial single‑parameter calls where the added reasoning introduces unnecessary verbosity.

The authors emphasize that TAFC requires no changes to the LLM’s weights or inference pipeline; it merely augments the API signature and adds a lightweight post‑processing filter that strips the think fields before actual execution. This makes the approach instantly deployable in existing ReAct‑style agents. Limitations include the need to tune the complexity scoring coefficients (α₁, α₂, α₃) and the threshold τ for new domains, and the potential increase in token usage when reasoning traces become long. Future work could explore learned, data‑driven complexity estimators, reasoning compression techniques, and supervised fine‑tuning on human‑annotated reasoning datasets.

In summary, Think‑Augmented Function Calling provides a practical, model‑agnostic method to make LLM‑driven tool use more transparent and accurate. By forcing the model to articulate “why” before “what,” it offers a clear debugging handle, improves parameter correctness—especially for resource‑constrained models—and maintains full compatibility with existing tool‑calling APIs, paving the way for more reliable autonomous agents in critical applications.