💬 NLP

When the API Speaks the Wrong Language: Revisiting Post-Training for Multilingual Tool Use

This paper investigates the "Argument Language Mismatch" issue in multilingual LLMs for API calling and demonstrates that supervised fine-tuning serves as a strong baseline for ensuring argument language consistency, while reinforcement learning offers only incremental improvements primarily in generalization and multi-objective trade-offs.

Original authors: Siddharth Chauhan, Thomas Butler, Abhishek Singhania, Pankaj Porwal, Honey Gupta

Published 2026-08-13

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Siddharth Chauhan, Thomas Butler, Abhishek Singhania, Pankaj Porwal, Honey Gupta

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are teaching a super-smart robot to be a personal assistant. This robot, known as a Large Language Model (LLM), is incredibly good at chatting, writing stories, and answering questions in many different languages. But there's a catch: to be truly useful, this robot needs to do more than just talk; it needs to talk to other computer programs to get things done. Think of these programs as a vast library of tools—like a calculator, a weather app, or a flight booking system. To use them, the robot has to speak a very specific, rigid language called an "API call." It's like ordering a pizza: you can say "I want a pizza" in any language you like, but the kitchen only understands a specific ticket format with exact toppings and sizes.

The big problem this paper tackles is what happens when the robot gets the order right but messes up the ticket. If a Spanish speaker asks the robot to book a flight, the robot might correctly pick the "book flight" tool but then fill in the destination with the English word "Paris" instead of the Spanish "París." To a human, this seems like a tiny, harmless mistake. But to the computer program waiting for the order, it's a disaster. The system crashes or rejects the request because it's waiting for Spanish words. The paper calls this glitch "Argument Language Mismatch" (ALM). It's a frustrating bug where the robot understands what you want but fails to speak the language of the tool you're trying to use. The researchers wanted to figure out the best way to train these robots to stop making this specific mistake, especially when they are juggling many different languages at once.

The authors of this paper decided to play detective with two different training methods to see which one fixes this language glitch best. The first method is like a strict teacher showing the robot thousands of perfect examples of how to fill out the tickets. This is called Supervised Fine-Tuning (SFT). The second method is more like a video game: the robot tries to fill out the ticket, gets a score based on how well it did, and learns from its mistakes through trial and error. This is called Reinforcement Learning (RL). The researchers built a special test bench using a dataset of tool calls translated into five languages (Spanish, French, Italian, Dutch, and English) to see how well the robots could learn.

Here is the surprising twist they found: the "strict teacher" method (SFT) was actually the superstar. When they simply showed the robot examples of correct Spanish-to-Spanish tool calls, it fixed the vast majority of the language mismatch errors. In fact, for many tasks, the simple teacher method worked just as well as, or sometimes even better than, the complex video-game method. The paper suggests that the robot didn't need to "think" its way to a solution; it just needed to see enough examples to learn the pattern that "if the user speaks Spanish, the tool ticket must be in Spanish."

However, the video-game method (specifically a version called GRPO) did have a few special tricks up its sleeve. While it didn't always beat the teacher method at the basic task, it was better at two things: handling tools the robot had never seen before, and keeping its general reasoning skills sharp. The researchers found that the video-game method was like a more flexible student who could adapt to new situations without forgetting how to solve math problems. They also discovered that the "score" the robot got in the video game mattered a lot. If the score only said "Good job" or "Bad job," the robot didn't learn much. But if the score gave detailed feedback on which specific word was wrong, the robot learned much faster.

In the end, the paper concludes that we don't always need the most complicated, expensive training methods to fix these language glitches. A careful, well-designed training set with a simple teacher can solve most of the problem. The fancy video-game training is useful for polishing the robot's skills and making it more robust in tricky situations, but it's not the magic bullet we might have thought. The key takeaway is that for making robots speak the right language to their tools, sometimes the old-fashioned way of showing them the right examples is the most powerful tool in the box.

Technical Summary: When the API Speaks the Wrong Language

Problem Definition: Argument Language Mismatch (ALM)

Large Language Models (LLMs) increasingly interact with external systems via structured API calls. While recent advances have improved tool-use capabilities in English, reliability degrades significantly in multilingual settings. A specific, underexplored failure mode identified in this work is Argument Language Mismatch (ALM).

ALM occurs when a model correctly identifies the user's intent and selects the appropriate API tool but generates argument values in a language inconsistent with the user's input or system requirements. For example, a user asking in Spanish might receive an API call with arguments in English. While semantically correct, these outputs are operationally invalid in systems enforcing strict language constraints, leading to task failure. Standard API-calling metrics (e.g., AST matching) often treat these as generic invocation errors, obscuring the specific cause of failure.

Methodology

Benchmark Construction

To study ALM, the authors constructed a multilingual extension of the Berkeley Function Calling (BFC) benchmark.

Languages: The dataset covers Spanish (training and evaluation), Italian, Dutch, and French (evaluation only).
Translation Protocol: A rule-based translation protocol was designed to ensure coherence between translated user utterances and the resulting argument values. Canonical identifiers and API-enforced formats remained unchanged, while user-provided natural language arguments were translated.
Evaluation Splits: Two splits were created to test different capabilities:
- Split-1 (Learnability): Moderate API overlap between training and test sets.
- Split-2 (Generalization): Minimal API overlap, testing transfer to unseen APIs and argument structures.

Evaluation Metrics

The authors propose a hierarchical evaluation framework to isolate ALM from other errors:

Tool Invocation Detection (TID): Correctly determining an API call is needed.
Tool Selection Accuracy (TSA): Selecting the correct API function.
Argument Completion Accuracy (ACA): Generating all required argument names.
Argument Language Consistency (ALC): Ensuring textual argument values match the user's language.
Function Call Match (FCM): Exact or semantic match of the complete API call.
These metrics form a strict hierarchy ( $FCM \le ALC \le ACA \le TSA \le TID$ ), allowing the isolation of language-specific failures.

Post-Training Strategies

The study compares three post-training approaches:

Supervised Fine-Tuning (SFT): A baseline approach maximizing the likelihood of ground-truth structured outputs.
Reinforcement Learning (RL): Specifically Proximal Policy Optimization (PPO) and Group Relative Policy Optimization (GRPO).
- Reward Design: The authors designed three reward models (RM) to test the impact of reward granularity:
  - RM-1 (Sparse): Binary rewards for perfect execution vs. failure.
  - RM-2 (Hierarchical): Intermediate rewards based on the depth of the evaluation hierarchy achieved.
  - RM-3 (Argument-Factorized): Continuous, argument-level rewards that assign specific scores to individual argument values based on language match quality.
- Token Weighting: An investigation into upweighting argument-value tokens during optimization to focus the learning signal.
Warm-Start: RL training was initialized from a model that underwent one epoch of SFT to ensure the generation of structurally correct candidates.

Key Results

1. SFT as a Strong Baseline

Supervised Fine-Tuning alone resolves a large fraction of ALM errors.

SFT substantially improves both Argument Language Consistency (ALC) and end-to-end Function Call Match (FCM) compared to base models.
Under controlled conditions (best validation checkpoint selection), SFT achieves performance comparable to, and in some cases (Split-1 FCM), exceeds more complex RL-based approaches.
This suggests that much of the performance in multilingual API grounding can be achieved through careful supervised training and model selection, without requiring complex optimization objectives.

2. Incremental Gains from RL

Reinforcement Learning provides additional, but incremental, benefits over SFT.

Generalization: RL (particularly GRPO) shows stronger generalization to unseen APIs and languages compared to SFT. It appears to learn an abstract rule ("match argument language to user locale") rather than memorizing surface forms.
Reasoning Preservation: A critical finding is the trade-off between task performance and general reasoning. The best-performing SFT model showed a significant drop in English reasoning ability (MGSM benchmark), whereas RL methods (GRPO) maintained reasoning performance while achieving competitive API accuracy.
Reward Granularity: Performance improved monotonically as reward granularity increased from RM-1 to RM-3. Argument-factorized rewards (RM-3) were essential for fine-grained credit assignment, enabling the model to distinguish between partially correct and nearly perfect outputs.

3. Optimization Dynamics

GRPO vs. PPO: GRPO consistently outperformed PPO in both ALC and FCM. The authors attribute this to GRPO's group-relative normalization, which stabilizes learning when rewards are sparse or localized to specific tokens (argument values), whereas PPO's batch-level normalization proved sensitive to high-variance rewards.
Token Weighting: Upweighting argument-value tokens improved GRPO performance but destabilized PPO, highlighting an interaction between reward shaping and optimization algorithms.

Significance and Claims

The paper claims three primary contributions:

Formalization of ALM: It identifies and formalizes Argument Language Mismatch as a distinct, practically important failure mode in multilingual agentic systems that is often masked by standard metrics.
Re-evaluation of Post-Training: It challenges the assumption that increasingly complex objectives are necessary for structured multilingual generation. The results demonstrate that strong supervised baselines (SFT) can achieve the majority of performance gains, with RL offering targeted, incremental improvements rather than fundamental shifts.
RL for Multi-Objective Trade-offs: While SFT is sufficient for many cases, the paper argues that RL (specifically with argument-aware rewards and GRPO) is valuable for scenarios requiring robust generalization and the preservation of general reasoning abilities alongside task-specific performance.

The authors conclude that for structured multilingual generation, understanding the limits of supervised learning is critical. Not all alignment problems require complex optimization; however, when generalization to unseen structures or multi-objective balancing is required, structured reinforcement learning remains a necessary refinement tool.