Authors: Minhyeong Yu*, Wonduk Seo*, Seunghyun Lee
Affiliations: Enhans; University College London
*denotes equal contribution
Paper: DM-Call: Decision-Model-Guided Function Calling with Cumulative Verification Feedback
TL;DR
- A function call can meet its required format while selecting the wrong function or supplying arguments that conflict with the user’s request.
- DM-Call checks the function’s schema, then evaluates function selection and argument correctness separately before tool execution.
- Rejected calls and their verification feedback remain available to the generator during subsequent attempts.
- On BFCL, DM-Call with Jev improved gpt-5-nano’s function-calling accuracy from 64.12% to 74.63%. The gain came with additional inference cost, and results varied across generators and benchmarks.
Abstract
DM-Call verifies a proposed function call before an external tool is executed. It combines local schema validation with separate decision-model assessments of the selected function and its arguments. When a candidate is rejected, the generator receives feedback from the current and earlier attempts to guide its next proposal. The approach is evaluated on BFCL and an adapted API-Bank first-call benchmark.
A Valid Function Call Can Still Be Wrong
An AI agent uses function calling to turn a user’s request into a tool or API action. It selects a function and fills in the arguments needed to call it. A schema check can confirm that the function exists and that its required arguments have the expected types. The values can still conflict with what the user asked for.
Consider a request for the weather in Paris. The weather function may receive London as its city argument and still pass a schema check. If executed, it would return the weather for a city the user did not request.

In Figure 1, DM-Call assigns the weather function a high selection score of 0.94, while the arguments receive 0.19. The low argument score sends the call back for revision. The next candidate uses Paris as the city.
The same distinction applies when the argument values look reasonable but the agent has selected the wrong function. DM-Call checks both decisions before returning an accepted call.
How DM-Call Verifies and Repairs a Call
DM-Call separates the model that proposes a function call from the decision model that evaluates it. Each proposed call goes through three checks:
- Schema validity: Does the function exist, and are the required arguments present with the expected types?
- Function selection: Does the selected function match the user’s request?
- Argument correctness: Are the values supported by the request and assigned to the right parameters?
The decision model assesses function selection and argument correctness separately. A candidate is accepted when it passes the schema check and the applicable decision-model checks. A rejected candidate, its scores, and any schema errors are recorded. The generator receives that history when it produces another candidate. Feedback combines numerical scores with verbal assessments of correctness.
For example, asked how to cook sikhae, a generator first selected a general web search function. Its search terms were plausible, but the function choice received a low score. The next candidate selected a recipe search function and passed both checks.
Verification and repair take place without executing external tools. Within the configured repair limit, DM-Call returns the first candidate that passes. If no candidate passes, the method falls back to the initial proposal. An initial response that makes no call is returned without verification.
Experimental Setup
DM-Call was evaluated on two function-calling benchmarks with different scopes:

Four models generated candidate calls: gpt-5-nano, gpt-5.4-mini, claude-sonnet-5.5, and gemma-4-31b-it. Two decision models were tested as verifiers: Jev 1.13.0 and PPLX Decider v1.1 27B. Jev is therefore one of the verification models used to test DM-Call.
The comparisons included direct generation, Self-Refine, and two multi-agent approaches, MAD-FC and PF-FC. DM-Call used a verification threshold of 0.5 and allowed up to three repair attempts. The main results report the mean across three runs.
Results: Accuracy, Feedback, and Cost
On BFCL, DM-Call with Jev improved function-calling accuracy for each of the four generators:

The largest improvement was 10.51 percentage points for gpt-5-nano with Jev. The other three generators started at higher direct-call accuracy and saw smaller gains. On the adapted API-Bank test, gpt-5-nano rose from 61.32% to 64.32% with DM-Call and Jev, while the PF-FC comparison reached 70.09%. DM-Call did not lead every API-Bank comparison.
Keeping feedback from earlier rejections also affected the result. In a separate BFCL ablation test with gpt-5-nano and Jev, retaining only the latest rejection produced 73.05% call accuracy. Using the full rejection history produced 74.32%. This comparison isolates the contribution of cumulative feedback; it uses a separate set of runs from the main result above.
Each check and repair adds inference work. For gpt-5-nano, the reported total inference cost was $0.167 for direct generation and $0.525 for DM-Call with Jev in the evaluation. DM-Call improved accuracy while costing more than a direct call. Its cost was lower than several of the tested refinement approaches.
The repair limit also affects response time. With three repairs allowed, mean latency was 4.0 seconds, compared with 2.6 seconds for direct generation in the reported gpt-5-nano setting. Raising the repair limit from three to ten improved accuracy by a further 1.8 percentage points, while 95th-percentile latency rose from 9.7 to 24.3 seconds. The number of attempts therefore changes both the result and the time required to produce it.
Conclusion
DM-Call combines separate decision-model checks of function selection and argument correctness with iterative refinement informed by cumulative hybrid feedback. In the reported evaluations, it improved function-calling accuracy compared with direct generation. The gains varied by generator and benchmark, while verification added inference cost and latency.

in solving your problems with Enhans!
We'll contact you shortly!