arXiv:2606.16813v1 [cs.AI] 15 Jun 2026
GIST-CMTF: Goal-State Inference for Causal Minimal Tool Filtering in LLM Agents Rahul Suresh Babu
Rohit Shukla
Independent Researcher United States of America [email protected]
Independent Researcher United States of America [email protected]
Abstract—Tool-augmented LLM agents rely on runtime filtering to decide which tools should be visible at each step. Causal Minimal Tool Filtering (CMTF) reduces tool-choice confusion by exposing only the next causally necessary tool frontier, but it assumes that the user request has already been mapped to a symbolic goal state. In practice, requests such as “handle my appointment” or “take care of this email” may correspond to multiple possible goals. This creates wrong-goal execution, where an agent follows a valid causal tool path for an unintended objective. We introduce GIST-CMTF, a goal-state inference layer that predicts candidate symbolic goals over the same statetransition vocabulary used by CMTF, estimates ambiguity, and either applies CMTF or exposes clarification as a causal action that produces missing goal or state variables. We evaluate GISTCMTF across seven model backends, six filtering methods, and 120 controlled tool-use tasks. GIST-CMTF achieves 97.0% task success, compared with 80.1% for top-goal CMTF and 82.9% for semantic-goal CMTF. It reduces wrong-goal execution from 19.4% under top-goal CMTF to 2.5%, while preserving the onetool exposure of causal filtering and using substantially fewer tokens than all-tools exposure. These results suggest that reliable tool-augmented agents should validate goal state, not only tool relevance, before exposing external actions. Index Terms—Tool-augmented LLM agents, goal-state inference, causal tool filtering, Causal Minimal Tool Filtering, intent disambiguation, clarification, wrong-goal execution, symbolic task state, preconditions and effects, function calling, tool selection, LLM reliability, multi-step tool use, agent orchestration
I. I NTRODUCTION Tool access has become a central mechanism for extending large language models (LLMs) beyond text generation. Modern LLM agents can interleave reasoning with external actions, invoke APIs, search information sources, operate over files, update calendars, draft emails, execute code, and interact with structured systems [1]–[4]. As tool ecosystems grow, however, agents face a runtime interface problem: before the model can use a tool correctly, the system must decide which tools should be visible at the current step. Function-calling benchmarks and tool-use evaluations measure whether models can select APIs, construct arguments, and complete multi-step tasks, but they often assume that the visible tool interface has already been defined [5], [6]. Recent work on Causal Minimal Tool Filtering (CMTF) addresses this tool-exposure problem by treating tool visibility as a causal state-transition problem rather than a semantic relevance problem [7]. In CMTF, each tool is represented
by a lightweight contract consisting of preconditions, effects, optional cost, and optional risk. Given a current symbolic task state and a target goal state, CMTF identifies a minimal causal path and exposes only the next causally necessary frontier. This reduces ToolChoiceConfusion: failures caused by exposing tools that are semantically plausible but unnecessary, premature, or non-goal-directed at the current step. Recent contract-learning work studies how such precondition-effect contracts can be inferred, but even accurate contracts still require a target goal state [8]. This requirement exposes a critical upstream assumption: the user request has already been mapped to a well-defined symbolic goal. In practical agent workflows, this assumption is often unrealistic. Users issue requests that are ambiguous, underspecified, or compatible with multiple possible goals. For example, “handle my dentist appointment” could mean finding the appointment, summarizing it, rescheduling it, canceling it, or asking the user what they want done. Similarly, “take care of this email” could mean summarizing it, drafting a reply, sending a reply, archiving it, deleting it, or flagging it for later. A causal filter can only expose the right next tool if it is optimizing toward the right goal. Thus, even a perfect causal tool filter can fail if it is given the wrong goal. This paper studies goal-state inference as the missing upstream layer for causal tool filtering. We identify wrong-goal execution as a distinct failure mode in tool-augmented agents. In wrong-goal execution, the system may expose and execute a causally valid sequence of tools, but for a goal the user did not intend. This differs from ordinary wrong-tool selection: the tool path may be internally valid relative to the inferred goal, yet externally incorrect relative to the user’s intended objective. A system that maps “take care of this email” directly to an email-deletion goal, for instance, may execute a valid causal path to deletion while violating the user’s actual intent. We introduce GIST-CMTF, a goal-state inference layer for Causal Minimal Tool Filtering. GIST-CMTF formulates goal inference as structured prediction over the same symbolic state-transition vocabulary used by CMTF. Given a naturallanguage request, current task state, and tool contract graph, GIST-CMTF predicts candidate symbolic goal states, estimates goal ambiguity, and decides whether to apply CMTF or expose a clarification action. The goal is not merely to classify the user’s intent into a natural-language label, but to infer the
symbolic end state that downstream causal filtering should optimize toward. A central design choice in GIST-CMTF is to model clarification as a causal action. When the user request is ambiguous or missing necessary goal parameters, the correct next step may not be an external API call. It may be a clarification question that produces a missing goal variable, entity variable, or confirmation variable. For example, a clarification action may transform an ambiguous-goal state into a goal-specified state. This allows clarification to be represented within the same precondition-effect framework as external tools, rather than being treated as an ad hoc fallback outside the agent’s causal model. This framing extends causal tool filtering from tool selection to goal selection. Prior CMTF work asks: given a current state and a goal, which tool should be exposed next? GIST-CMTF asks an earlier question: is the goal sufficiently specified to expose a downstream tool path at all? If the inferred goal is confident and sufficiently specified, GIST-CMTF passes that goal to CMTF. If the goal is ambiguous, missing required variables, or would commit the agent to a risky or irreversible path without sufficient intent evidence, GIST-CMTF exposes a clarification action instead. We evaluate GIST-CMTF on controlled multi-step tool-use tasks containing explicit, ambiguous, missing-variable, and clarification-required requests across workflow domains such as calendar, email, files, contacts, and authorization. We measure both goal-layer behavior and downstream agent behavior, including task success, wrong-goal execution, clarification behavior, visible-tool exposure, and token cost. Across seven model backends, six filtering methods, and 120 controlled tooluse tasks, GIST-CMTF achieves 97.0% task success, compared with 80.1% for top-goal CMTF and 82.9% for semantic-goal CMTF. It reduces wrong-goal execution from 19.4% under topgoal CMTF and 16.7% under semantic-goal CMTF to 2.5%, while preserving the one-tool exposure of causal filtering. This paper makes the following contributions:
II. BACKGROUND A. Tool-Augmented LLM Agents Tool use has become a central mechanism for extending large language models beyond text generation. Agentic systems can interleave reasoning and acting, invoke external APIs, retrieve information, operate over files, update calendars, draft emails, execute code, and interact with structured services [1]–[3]. This capability has motivated benchmarks for function calling and tool-augmented dialogue, including evaluations of API selection, argument construction, multi-step tool use, and agent task completion [4]–[6]. These works establish tool use as a core capability for LLM agents, but they often assume that the visible tool interface has already been constructed. Reliabilityoriented orchestration work further studies how agent runtimes can detect failures, apply bounded recovery actions, verify recovered trajectories, and record observability traces in toolaugmented LLM systems [9]. B. Tool Exposure and Causal Minimal Tool Filtering As tool libraries grow, the visible tool menu becomes an important runtime control surface. Exposing all available tools can increase context cost and selection burden, while relevancebased retrieval may expose tools that are semantically related to the user request but inappropriate for the current step. Causal Minimal Tool Filtering (CMTF) addresses this problem by representing each tool as a lightweight state transition with preconditions and effects [7]. Given a current symbolic state st , a goal state g, and a tool library T , CMTF constructs a dependency graph and exposes only the next causally necessary frontier. This shifts tool filtering from semantic relevance to causal sufficiency: a tool should be visible when its effects help advance the current state toward the goal. Related work on capability minimization extends this least-privilege view by treating risk-aware causal gating as a safety primitive for limiting agent capabilities before external actions are exposed [10]. C. Tool Contracts and State-Transition Semantics
CMTF relies on lightweight tool contracts. A tool ti can be 1) We formulate goal-state inference as a missing upstream represented as problem in causal tool filtering for LLM agents. ti = (di , Ri , Ei , ci , ρi ), (1) 2) We identify wrong-goal execution as a distinct failure mode, where an agent follows a causally valid tool path where di is a natural-language description, Ri is the set for an unintended goal. 3) We introduce GIST-CMTF, a framework that predicts of required state variables, Ei is the set of produced state symbolic goal states over the same state-transition vocab- variables, ci is an optional cost, and ρi is an optional risk label. ulary used by CMTF and uses clarification as a causal This abstraction is related to classical planning formalisms such as STRIPS and PDDL, which represent actions using action when the goal is ambiguous or underspecified. 4) We evaluate GIST-CMTF across explicit, ambiguous, preconditions and effects [11], [12]. In tool-augmented LLM missing-variable, and clarification-required tool-use tasks, agents, however, the objective is not to replace the model with measuring both goal-layer behavior and downstream a symbolic planner, but to shape the action interface exposed to the model at each step. agent reliability. Recent contract-learning work studies how these precondiOverall, GIST-CMTF suggests that reliable tool use requires tions, effects, and risk annotations can be inferred from tool more than selecting the right tool for the current state. Before names, descriptions, schemas, documentation, and execution exposing external actions, an agent must first validate which traces [8]. This reduces the burden of manually writing symbolic goal it is pursuing. contracts for large or changing tool ecosystems. However,
even with accurate contracts, causal filtering still requires a target goal state. D. Goal-State Inference as the Missing Upstream Layer Existing causal filtering methods typically assume that the user’s request has already been mapped to a symbolic goal state. In practice, this assumption may fail. A request such as “handle my appointment” may correspond to finding, summarizing, rescheduling, canceling, or asking for clarification about an event. Similarly, “take care of this email” may imply summarizing, drafting, sending, archiving, deleting, or flagging the message. These alternatives correspond to different symbolic goals and therefore different causal tool paths. This paper studies goal-state inference as the missing upstream layer before causal tool filtering. The central challenge is not only to identify a natural-language intent label, but to infer the symbolic end state that downstream CMTF should optimize toward. When the goal is ambiguous or underspecified, the correct next action may be clarification rather than external tool execution. GIST-CMTF therefore extends causal filtering from selecting the next tool given a goal to first validating whether the goal itself is sufficiently specified. III. P ROBLEM F ORMULATION We study goal-state inference for tool-augmented LLM agents that use causal tool filtering. Let T = {t1 , t2 , . . . , tn } denote a tool library and let X denote the vocabulary of symbolic task-state variables. Each tool ti ∈ T is represented by a lightweight contract: ti = (di , Ri , Ei , ci , ρi ),
(2)
where di is a natural-language description, Ri ⊆ X is the set of required state variables, Ei ⊆ X is the set of produced state variables, ci is an optional cost, and ρi is an optional risk label. This precondition-effect representation follows the causal tool-filtering view introduced in prior CMTF work and is compatible with learned-contract approaches. At runtime, the agent observes a natural-language user request q, a current symbolic task state st ⊆ X, and the available tool library T . Standard CMTF assumes that the target goal state g ⊆ X is known. Under that assumption, the filtering method selects a visible tool set: Vt = F (st , g, T ),
(3)
where F exposes the next causally sufficient tool frontier for advancing from st toward g. In realistic settings, however, the goal state is not directly observed. The same request may correspond to multiple possible symbolic goals. For example, the request “handle my appointment” may be compatible with: g1 = {event details f ound},
(4)
g2 = {event summarized},
(5)
g3 = {event updated},
(6)
g4 = {event deleted}.
(7)
These goals imply different causal tool paths and different exposure decisions. We therefore define a goal-state inference module H that maps the user request, current state, and tool-contract context to a ranked set of candidate goals: H(q, st , T ) = {(g1 , p1 ), (g2 , p2 ), . . . , (gk , pk )},
(8)
where each gi ⊆ X is a candidate symbolic goal state and pi is a confidence score. Let g ⋆ denote the highest-confidence candidate goal: g ⋆ = arg max pi . (9) gi
The system must decide whether g ⋆ is sufficiently specified to support downstream tool filtering. We define a goal-aware filtering policy: ( F (st , g ⋆ , T ), if A(q, st , Gq ) = 0, Π(q, st , T ) = (10) {aclarif y }, if A(q, st , Gq ) = 1, where Gq = H(q, st , T ) is the candidate goal set, A is an ambiguity detector, and aclarif y is a clarification action. We model clarification as a causal action rather than an external fallback. A clarification action has its own preconditions and effects: aclarif y = (dc , Rc , Ec , cc , ρc ),
(11)
where Rc may include variables such as {ambiguous goal} or {missing entity}, and Ec may include variables such as {goal specif ied}, {entity identif ied}, or {permission conf irmed}. This allows clarification to be represented within the same state-transition framework as external tools. We define wrong-goal execution as the failure mode in which the agent executes a causally valid tool sequence for an inferred goal ĝ that does not match the intended goal g true . Formally, wrong-goal execution occurs when: ĝ ̸= g true
(12)
and the agent reaches ĝ through a valid causal path. This differs from wrong-tool selection: the tool sequence may be valid relative to ĝ, but incorrect relative to the user’s intended objective. The objective of GIST-CMTF is to preserve the reliability and efficiency benefits of causal tool filtering while reducing wrong-goal execution. Ideally, the system should infer the intended symbolic goal when the request is clear, ask for clarification when the goal is ambiguous or underspecified, and avoid exposing downstream tools before the goal is sufficiently validated. IV. M ETHOD : GIST-CMTF GIST-CMTF extends Causal Minimal Tool Filtering with an upstream goal-state inference layer. Standard CMTF assumes that the target symbolic goal state is known before filtering begins. GIST-CMTF relaxes this assumption by first inferring candidate goal states from the user request and then deciding
whether the request is sufficiently specified to expose a downstream tool frontier. If the goal is clear, GIST-CMTF applies CMTF using the inferred goal. If the goal is ambiguous or underspecified, it exposes a clarification action instead.
the top candidate has low confidence; multiple candidate goals have similar confidence; • required goal parameters are missing; • the request contains vague action verbs such as “handle,” “fix,” or “take care of”; • accepting the goal would commit the agent to a write, send, delete, share, or otherwise externally visible action. In the simplest implementation, ambiguity can be decided using a confidence threshold τ and a margin threshold δ: h i A(q, st , Gq ) = I p⋆ < τ ∨ (p⋆ − p(2) ) < δ , (19) • •
A. Overview Figure 1 illustrates the overall GIST-CMTF execution flow. Goal-state inference precedes causal tool filtering, allowing the system to determine whether clarification is required before exposing downstream actions. This separates goal validation from tool selection and prevents the system from committing to an incorrect symbolic objective before the user intent is where p⋆ is the top confidence score and p(2) is the secondsufficiently specified. Given a user request q, current symbolic state st , and tool highest confidence score. More generally, A may incorporate missing-variable checks, risk-sensitive rules, and learned ambilibrary T , GIST-CMTF proceeds in four stages: guity classifiers. 1) generate candidate symbolic goal states; 2) estimate goal confidence and ambiguity; D. Clarification as a Causal Action 3) expose a clarification action when the goal is underspecIf the goal is ambiguous, GIST-CMTF exposes a clarification ified; action instead of a downstream external tool. Clarification is 4) otherwise apply CMTF using the selected goal. represented as a tool-like causal action: This design separates goal selection from tool selection. The aclarif y = (dc , Rc , Ec , cc , ρc ), (20) goal-inference layer decides what end state the agent should pursue, while CMTF decides which tool should be visible next where Rc contains the ambiguity or missing-information once that goal is accepted. condition and Ec contains the state variable produced by B. Candidate Goal Generation clarification. For example: The first stage maps the natural-language request q into a ranked set of candidate symbolic goal states. Let X be the statevariable vocabulary used by the tool contracts. GIST-CMTF a : {ambiguous goal} → {goal specif ied}, (21) g predicts: ae : {missing entity} → {entity identif ied}, (22) Gq = {(g1 , p1 ), (g2 , p2 ), . . . , (gk , pk )}, (13) a : {missing permission} → {permission conf irmed}. p
where each gi ⊆ X is a candidate goal and pi is its confidence score. The candidate goals are drawn from the same symbolic vocabulary used by downstream causal filtering. This is important because GIST-CMTF does not predict only a naturallanguage intent label; it predicts the symbolic end state that determines the causal path over the tool graph. For example, the request “take care of this email” may yield candidate goals such as: g1 = {email summarized},
(14)
g2 = {draf t created},
(15)
g3 = {email sent},
(16)
g4 = {email archived}.
(17)
C. Goal Confidence and Ambiguity Detection After candidate generation, GIST-CMTF determines whether the top goal is sufficiently reliable for downstream tool exposure. Let g ⋆ denote the highest-confidence goal: g ⋆ = arg max pi . gi ∈Gq
(18)
The ambiguity detector considers both confidence and structural signals. A request may be treated as ambiguous when:
(23) Here, ag , ae , and ap denote goal, entity, and permission clarification actions, respectively. This representation keeps clarification inside the same precondition-effect framework as external tool use. The system does not treat clarification as an ad hoc fallback; it treats clarification as the causally appropriate next action when the goal or required state is underspecified. E. Goal-Aware Causal Filtering If the goal is accepted, GIST-CMTF applies CMTF using g ⋆ . The visible tool set is: Vt = F (st , g ⋆ , T ),
(24)
where F is the CMTF filtering function that returns the next causally sufficient frontier. The overall policy is: ( F (st , g ⋆ , T ), if A(q, st , Gq ) = 0, Π(q, st , T ) = (25) {aclarif y }, if A(q, st , Gq ) = 1. After a clarification action is executed, the user’s response updates the task state and goal state. GIST-CMTF then reruns goal inference or directly applies CMTF if the clarification resolves the ambiguity.
Clarification action ambiguous / underspecified
User request and current state
Goal-state inference
Ambiguity and missing-variable check
goal accepted CMTF with accepted goal
Minimal causal tool frontier
LLM action
Symbolic state update
Fig. 1. Overview of GIST-CMTF. The system first infers candidate symbolic goal states, checks whether the goal is ambiguous or underspecified, and either exposes a clarification action or applies CMTF using the accepted goal.
Algorithm 1 GIST-CMTF Require: User request q, current state st , tool library T , goal generator H, ambiguity detector A, CMTF filter F Ensure: Visible action set Vt 1: Gq ← H(q, st , T ) 2: g ⋆ ← arg maxgi ∈Gq pi 3: if A(q, st , Gq ) = 1 then 4: return {aclarif y } 5: else 6: Vt ← F (st , g ⋆ , T ) 7: return Vt 8: end if
TABLE I B ENCHMARK COMPOSITION BY REQUEST TYPE .
Request type Explicit goal Ambiguous goal Missing variable Clarification required Total
F. Algorithm Algorithm 1 summarizes GIST-CMTF. G. Failure Modes Addressed GIST-CMTF targets a failure mode that is distinct from wrong-tool selection. In wrong-tool selection, the agent chooses an incorrect tool relative to a known goal. In wrong-goal execution, the agent may choose tools that are causally valid relative to an inferred goal, but the inferred goal itself is not the user’s intended objective. By validating the goal before exposing the downstream tool frontier, GIST-CMTF reduces the chance that the agent executes a coherent but unintended workflow.
Tasks 40
Purpose Clear objective; no clarification needed. 40 Multiple plausible symbolic goals. 30 Required information is absent. 10 Clarification is the correct next action. 120 Full evaluation suite.
causal tool-filtering work, where tools have preconditioneffect contracts, execution is deterministic, and task state is represented symbolically [7]. This allows us to measure whether failures arise from goal inference, tool exposure, or downstream tool selection.
A. Evaluation Tasks We construct a focused evaluation suite across common workflow domains: calendar, email, files/documents, contacts, and authorization or confirmation workflows. Each task consists of a natural-language user request, an initial symbolic state, a set of candidate symbolic goals, an intended goal when one is specified, and a downstream gold tool path after the goal is known. H. Implementation Variants The evaluation includes four request classes. Explicit-goal We consider three implementation variants: requests directly specify the intended goal, such as moving • Top-goal GIST-CMTF: always use the highest-confidence a calendar event or drafting an email reply. Ambiguous-goal inferred goal. requests use underspecified verbs such as “handle,” “take care • Thresholded GIST-CMTF: use confidence and margin of,” or “deal with,” and are compatible with multiple goals. thresholds to decide whether to clarify. Missing-variable requests specify an action but omit required • Risk-sensitive GIST-CMTF: require stronger goal con- information, such as the file to share, the intended recipient, fidence before exposing write, send, delete, share, or or the permission level. Clarification-required requests are externally visible tool paths. cases where the correct next action is to ask the user for These variants allow us to separate the value of goal additional information before exposing downstream tools. inference from the value of clarification and ambiguity-aware Table I summarizes the 120-task evaluation suite. Each task is tool exposure. evaluated under six filtering methods and seven model backends, yielding 5,040 total runs. V. E XPERIMENTAL S ETUP We evaluate whether goal-state inference improves causal B. Compared Methods We compare GIST-CMTF against the following baselines: tool filtering under ambiguous and underspecified user requests. The evaluation is designed to isolate the effect of the upstream • All tools: exposes the full tool registry at each step. goal layer rather than introduce a new benchmark. We build • State-aware filtering: exposes tools whose preconditions on the controlled multi-step tool-use setting used in prior are satisfied by the current symbolic state.
Gold-goal CMTF: applies CMTF using the annotated • Wrong-tool calls: number of selected tools that differ intended goal. This serves as an upper-bound causal from the gold next tool for the intended goal. filtering baseline. • Tools exposed per step: average visible action-set size. • Top-goal CMTF: infers a goal and always applies • Trajectory length and token cost: number of model-tool CMTF using the highest-confidence candidate, without steps and total token usage per task. clarification. E. Analysis Plan • Semantic-goal CMTF: selects the goal whose naturalThe main analysis tests whether GIST-CMTF reduces wronglanguage description is most similar to the user request, goal execution without sacrificing the efficiency benefits then applies CMTF. of CMTF. We compare performance separately on explicit, • GIST-CMTF: infers candidate symbolic goals, estimates ambiguity, and either applies CMTF using the selected ambiguous, missing-variable, and clarification-required requests. We also analyze the confidence threshold used by GIST-CMTF, goal or exposes a clarification action. This comparison separates three questions: whether causal measuring the tradeoff between unnecessary clarification and filtering helps once the goal is known, whether naive goal in- wrong-goal execution. Finally, we report whether clarification ference is sufficient, and whether ambiguity-aware clarification reduces premature exposure of write, send, delete, share, or other goal-committing actions. improves downstream reliability. The results are organized around four questions: (1) whether C. Execution Protocol goal-state inference improves downstream task success, (2) Each run proceeds in a bounded step-by-step tool-use loop. whether ambiguity-aware clarification reduces wrong-goal At the first step, a method receives the user request, current execution, (3) how clarification affects tool exposure and token symbolic state, and tool-contract context. Methods that require cost, and (4) whether the benefits generalize across model goal inference first select or infer a target goal. If GIST-CMTF families. detects that the goal is ambiguous or underspecified, it exposes VI. R ESULTS a clarification action rather than a downstream external tool. Once the goal is specified, CMTF exposes the next causally We evaluate six filtering methods across seven model necessary tool frontier. backends and 120 tasks, producing 5,040 completed runs. The At each step, the tool-calling model selects one visible action. final dataset contains no duplicate model–method–task rows, no The environment returns a deterministic mocked observation zero-token rows, and no remaining infrastructure-level provider and updates the symbolic state according to the selected tool’s errors. Table II reports aggregate downstream performance, and effects. The run terminates when the intended goal is reached, Figure 2 summarizes the main tradeoffs. an incorrect or invalid tool path is executed, a wrong-goal outcome is reached, no valid action is exposed, or the maximum A. Aggregate Downstream Performance step limit is exceeded. GIST-CMTF achieves strong downstream performance without assuming access to the gold goal state. Across all runs, D. Metrics GIST-CMTF reaches 97.0% task success, compared with 53.5% We report metrics that capture both goal-layer behavior and for all-tools exposure, 56.4% for state-aware filtering, 80.1% downstream tool-use outcomes. for top-goal CMTF, and 82.9% for semantic-goal CMTF. The Goal-layer metrics characterize how the filtering policy oracle upper bound, gold-goal CMTF, reaches 99.5% success. handles goal uncertainty: Thus, GIST-CMTF closes most of the gap between practical • Goal correctness: whether the accepted goal matches the inferred-goal filtering and gold-goal causal filtering. intended goal when a goal is selected. The strongest non-oracle comparison is against the two goal• Ambiguity handling: whether the method asks for clari- inference baselines. Both top-goal CMTF and semantic-goal fication when the request is ambiguous or underspecified. CMTF expose a minimal one-tool frontier after selecting an • Missing-variable handling: whether the system asks for inferred goal, but they commit to that goal without ambiguityclarification when required entities, permissions, or goal aware validation. GIST-CMTF improves success by 16.9 parameters are absent. percentage points over top-goal CMTF and 14.2 percentage • Unnecessary clarification: whether clarification is re- points over semantic-goal CMTF, showing that the gains come quested for clear requests. from goal validation and clarification rather than from smaller Downstream metrics measure agent behavior after goal tool menus alone. inference and filtering: B. Wrong-Goal Execution • Task success: whether the intended goal is reached within the step limit. Wrong-goal execution is the central failure mode targeted • Wrong-goal execution: whether the agent reaches a by GIST-CMTF. Top-goal CMTF has a wrong-goal execution causally valid but unintended goal. rate of 19.4%, and semantic-goal CMTF has a wrong-goal • Premature tool exposure: whether downstream tools are execution rate of 16.7%. GIST-CMTF reduces this rate to 2.5%, exposed before the goal or required variables are specified. corresponding to an 87.1% relative reduction versus top-goal •
A. Task success
1.0
0.175 Wrong-goal execution
Task success
0.8 0.6 0.4 0.2 0.0
B. Wrong-goal execution
0.200 0.150 0.125 0.100 0.075 0.050 0.025
ls
oo All t
are MTF ld-goaTlF goal goal e-aw Top-CMTFmantic-CMTF GIST-C Go CM Stat Se
0.000
are ools MTF ld-goaTlF goal goal All t e-aw Top-CMTFmantic-CMTF GIST-C Go CM Stat Se
C. Visible tools per step
D. Token usage
25 20
Avg. tokens
Avg. visible tools
30
15 10 5 0
ools
All t
e Stat
re
-awa
MTF ld-goaTlF goal goal Top-CMTFmantic-CMTF GIST-C Go CM Se
4000 3500 3000 2500 2000 1500 1000 500 0
TF oal oal oal are ools op-CgMTF antic-CgMTF GIST-CM Gold-CgMTF All t e-aw T t a t S Sem
Fig. 2. Aggregate downstream performance across six filtering methods. GIST-CMTF substantially improves task success and reduces wrong-goal execution while preserving the one-tool exposure of causal filtering. TABLE II AGGREGATE DOWNSTREAM PERFORMANCE BY FILTERING METHOD . H IGHER TASK SUCCESS IS BETTER ; LOWER WRONG - GOAL EXECUTION , VISIBLE TOOLS , PREMATURE EXPOSURE , UNNECESSARY CLARIFICATION , AND TOKEN COST ARE BETTER . Method All tools State-aware Top-goal CMTF Semantic-goal CMTF GIST-CMTF Gold-goal CMTF
Success 0.535 0.564 0.801 0.829 0.970 0.995
Wrong-goal 0.000 0.000 0.194 0.167 0.025 0.000
Tools 32.000 8.123 1.000 1.000 1.000 1.000
CMTF and an 85.0% relative reduction versus semantic-goal CMTF.
Wrong tools 0.788 0.844 0.642 0.533 1.051 0.332
Prem. exp. 3.539 0.000 0.000 0.000 0.000 0.000
Clarif. 0.337 0.468 0.331 0.283 0.660 0.167
Unnec. clarif. 0.000 0.017 0.000 0.000 0.056 0.000
Tokens 4152 2084 1077 700 1186 689
C. Request-Type Breakdown and Clarification Behavior
Table III breaks performance down by request type. The largest gains occur on ambiguous-goal requests, where the This result supports the main hypothesis of the paper: causal user request is compatible with multiple symbolic goals. On filtering is not sufficient when the target goal state is inferred these tasks, top-goal CMTF reaches 52.9% success with 46.8% incorrectly. Top-goal CMTF, semantic-goal CMTF, and GIST- wrong-goal execution, and semantic-goal CMTF reaches 50.0% CMTF all expose one tool per step on average, but only success with 50.0% wrong-goal execution. GIST-CMTF reaches GIST-CMTF substantially reduces wrong-goal execution. The 97.5% success and reduces wrong-goal execution to 2.1%. This difference is therefore not simply a tool-exposure effect; it directly validates the goal-state inference layer: when the user comes from validating whether the inferred symbolic goal is request is ambiguous, clarification prevents the agent from sufficiently specified before exposing downstream actions. executing a valid causal path for the wrong objective.
TABLE III P ERFORMANCE BY REQUEST TYPE FOR KEY METHODS . GIST-CMTF PROVIDES THE LARGEST GAINS ON AMBIGUOUS - GOAL REQUESTS , WHERE NAIVE GOAL INFERENCE FREQUENTLY COMMITS TO THE WRONG SYMBOLIC GOAL . Request type Ambiguous goal Ambiguous goal Ambiguous goal Ambiguous goal Ambiguous goal Clarification required Clarification required Clarification required Clarification required Clarification required Explicit goal Explicit goal Explicit goal Explicit goal Explicit goal Missing variable Missing variable Missing variable Missing variable Missing variable
Method All tools Top-goal CMTF Semantic-goal CMTF GIST-CMTF Gold-goal CMTF All tools Top-goal CMTF Semantic-goal CMTF GIST-CMTF Gold-goal CMTF All tools Top-goal CMTF Semantic-goal CMTF GIST-CMTF Gold-goal CMTF All tools Top-goal CMTF Semantic-goal CMTF GIST-CMTF Gold-goal CMTF
On clarification-required tasks, GIST-CMTF reaches 100.0% success with no wrong-goal execution, while requesting clarification in 91.4% of runs. On missing-variable tasks, GIST-CMTF reaches 98.6% success and clarifies in 81.0% of runs, reflecting that the method often detects absent entities, permissions, or goal parameters before exposing downstream tools. The main cost of GIST-CMTF is occasional over-clarification on clear requests. On explicit-goal tasks, GIST-CMTF reaches 94.6% success, while semantic-goal CMTF reaches 98.9% and gold-goal CMTF reaches 100.0%. GIST-CMTF requests unnecessary clarification on 16.8% of explicit-goal runs, and 5.6% of all runs overall. This indicates a reliability–friction tradeoff: ambiguity-sensitive filtering substantially reduces wrong-goal execution, but can sometimes ask for clarification when the user goal was already clear. D. Tool Exposure and Token Cost GIST-CMTF preserves the minimal-exposure property of causal filtering. It exposes 1.0 visible tool per step on average, matching top-goal CMTF, semantic-goal CMTF, and gold-goal CMTF. In contrast, state-aware filtering exposes 8.1 tools per step, and all-tools exposure presents the full 32-tool registry. Token usage follows the same pattern. GIST-CMTF uses 1,186 tokens per task on average, compared with 4,152 tokens for all-tools exposure and 2,084 tokens for state-aware filtering. GIST-CMTF is more expensive than semantic-goal CMTF and gold-goal CMTF because it performs ambiguity handling and clarification, but this additional cost buys a large reduction in wrong-goal execution and a substantial improvement in task success.
Success 0.714 0.529 0.500 0.975 0.993 0.943 0.900 1.000 1.000 1.000 0.300 0.904 0.989 0.946 1.000 0.471 0.995 0.995 0.986 0.990
Wrong-goal 0.000 0.468 0.500 0.021 0.000 0.000 0.100 0.000 0.000 0.000 0.000 0.086 0.000 0.050 0.000 0.000 0.005 0.000 0.005 0.000
Clarif. 0.518 0.314 0.125 0.975 0.000 0.057 0.729 0.900 0.914 0.000 0.000 0.000 0.000 0.168 0.000 0.638 0.662 0.667 0.810 0.667
Tokens 3371 1015 585 1239 608 2454 1015 717 1066 462 5559 1060 690 1114 691 3882 1201 860 1251 870
E. Robustness Across Model Backends Table IV reports task success by model and method. GISTCMTF is consistently strong across all seven model backends. It reaches 100.0% success with Claude Opus 4.8 and Claude Sonnet 4.6, 98.3% with Claude Haiku 4.5, 96.7% with GPTOSS-120B, 97.5% with Nova Premier, 89.2% with Nova 2 Lite, and 97.5% with Nova Pro. In every model family, GIST-CMTF substantially outperforms all-tools exposure and state-aware filtering, and it is consistently closer to gold-goal CMTF than the naive goal-inference baselines. For the final seven-model aggregate, we use Nova Pro v1 in place of the unavailable Nova 2 Pro preview profile. We report the model identifier explicitly in Table IV for reproducibility. F. Error Analysis After cleaning infrastructure-corrupted rows, the final dataset contains no zero-token rows and no remaining provider-side infrastructure errors. The remaining errors are benchmark-level outcomes: 128 precondition failures, 24 tool-parse errors, 14 empty-text responses, 3 goal-parse errors, and 1 invalid-toolselection error. These errors are retained because they reflect downstream agent behavior under the evaluated filtering policies rather than failed experiment execution. VII. D ISCUSSION A. Goal Validation as a Missing Layer in Tool Filtering The results show that reliable tool filtering is not only a tool-selection problem; it is also a goal-validation problem. CMTF is effective when the target goal is known, but practical user requests often arrive before that goal has been specified. In such cases, exposing a minimal causal frontier is not sufficient
TABLE IV TASK SUCCESS BY MODEL AND METHOD . GIST-CMTF REMAINS CLOSE TO GOLD - GOAL CMTF ACROSS SEVEN MODEL BACKENDS . Model Claude Opus 4.8 Claude Sonnet 4.6 Claude Haiku 4.5 GPT-OSS-120B Nova Premier Nova 2 Lite Nova Pro v1
All tools 0.975 0.883 0.292 0.642 0.383 0.258 0.308
State-aware 0.983 0.883 0.400 0.475 0.475 0.358 0.375
Top-goal 0.883 0.867 0.775 0.892 0.708 0.683 0.800
Semantic-goal 0.833 0.833 0.833 0.808 0.825 0.833 0.833
GIST-CMTF 1.000 1.000 0.983 0.967 0.975 0.892 0.975
Gold-goal 1.000 1.000 1.000 0.975 0.992 1.000 1.000
if the frontier is computed for the wrong inferred goal. GIST- E. Implications for Runtime Agent Mediation CMTF addresses this upstream gap by validating whether the GIST-CMTF suggests that tool-augmented agents should symbolic goal is clear enough before downstream tools are mediate three decisions before acting: whether the goal is valid, exposed. whether the required state variables are present, and whether a candidate tool is causally appropriate for the accepted goal. B. Wrong-Goal Execution Is Distinct from Wrong-Tool Selec- This architecture shifts the runtime from tool retrieval toward tion goal-aware action mediation. Rather than asking only which tools are semantically relevant to the request, the agent runtime Wrong-goal execution is more subtle than ordinary wrongasks whether it should expose any downstream tool path at tool selection. In wrong-tool selection, the agent chooses an all. This is especially important for ambiguous or irreversible action that is incorrect relative to a known goal. In wrong-goal workflows, where a fluent but wrongly directed agent can be execution, the agent may follow a coherent and causally valid more harmful than one that asks for clarification. tool path, but for an unintended objective. This distinction explains why top-goal CMTF and semantic-goal CMTF can VIII. L IMITATIONS AND T HREATS TO VALIDITY expose only one tool per step while still producing much This study uses a controlled benchmark with synthetic toolhigher wrong-goal execution than GIST-CMTF. The failure is use tasks and mocked tool execution. This design allows us to not excessive tool exposure; it is premature commitment to the isolate goal inference, clarification, tool exposure, and wrongwrong symbolic goal. goal execution under known symbolic states and intended goals. However, real agent deployments may involve noisier C. Clarification as a First-Class Causal Action user requests, incomplete state, changing APIs, authorization A key design choice in GIST-CMTF is to treat clarification constraints, nondeterministic tool outputs, and irreversible side as a causal action rather than an external fallback. When effects. GIST-CMTF assumes that user requests, tool preconditions, the request is ambiguous, missing an entity, or missing a permission variable, the correct next action may be to ask tool effects, and candidate goals can be represented in a shared the user for more information. Representing clarification symbolic state vocabulary. This assumption is useful for causal with preconditions and effects allows it to participate in the filtering, but defining and maintaining the right vocabulary same state-transition framework as external tools. This makes is itself a design challenge. Different domains may require clarification a principled runtime action: it transforms an different abstraction levels, and future work should study how underspecified state into one where causal filtering can proceed these symbolic goal and state representations can be learned, updated, or transferred across tool ecosystems. safely. The current evaluation tests goal inference over a controlled candidate-goal set. This lets us measure wrong-goal execution D. The Reliability–Friction Tradeoff precisely, but it does not fully address open-world goal GIST-CMTF improves reliability by reducing wrong-goal discovery, where users may express goals not present in the execution, but it introduces some additional friction. It asks candidate set. Similarly, clarification is modeled as an action more clarifying questions and uses more tokens than simpler that resolves a missing goal, entity, permission, or state variable. one-tool baselines such as semantic-goal CMTF. This tradeoff Real clarification dialogues may require multiple turns and may is expected: ambiguity-sensitive systems must sometimes spend produce incomplete, ambiguous, or conflicting user responses. interaction cost to avoid committing to the wrong goal. The Although GIST-CMTF reduces wrong-goal execution and important practical implication is that clarification thresholds premature commitment in the evaluated setting, we do not should depend on domain risk. For low-risk read-only actions, claim full production safety for high-risk tools. Actions such as a system may tolerate more aggressive goal inference. For send, sending, deleting, sharing, purchasing, or externally modifying delete, share, update, or externally visible actions, stronger goal state require additional safeguards, including authorization evidence and more conservative clarification are justified. checks, policy enforcement, auditability, and human review
where appropriate. Goal validation should be viewed as one layer in a broader runtime mediation stack. Finally, while the results are consistent across seven model backends, model behavior may change with new versions, prompting strategies, tool-calling APIs, or deployment environments. We report token usage, but do not directly measure latency, monetary cost, or user satisfaction under clarification. Future work should evaluate GIST-CMTF with real users, real APIs, multi-turn clarification, larger dynamic tool registries, and risk-sensitive deployment policies. IX. C ONCLUSION This paper introduced GIST-CMTF, a goal-state inference layer for Causal Minimal Tool Filtering in tool-augmented LLM agents. The central motivation is that causal filtering can only expose the right next tool if the system is pursuing the right symbolic goal. In realistic requests, the intended goal may be ambiguous, underspecified, or missing required variables. GIST-CMTF addresses this upstream problem by inferring candidate symbolic goals, detecting ambiguity, and representing clarification as a causal action before downstream tools are exposed. Across seven model backends, six filtering methods, and 120 tasks, GIST-CMTF achieved 97.0% task success and reduced wrong-goal execution to 2.5%, compared with 19.4% under top-goal CMTF. It preserved the one-tool exposure of causal filtering while substantially improving reliability under ambiguous and underspecified requests. These results suggest that reliable tool-augmented agents need more than tool selection: they need runtime mediation of goal validity, state readiness, and causal tool exposure before acting. ACKNOWLEDGMENT The authors thank colleagues for helpful feedback. This work was conducted in the authors’ personal capacity. The views expressed in this paper are solely those of the authors and do not necessarily reflect the views of their employers. This work did not receive external funding. The authors declare no conflicts of interest.
A RTIFACT AVAILABILITY The benchmark, tool registry, filtering implementations, evaluation scripts, prompts, and analysis utilities used in this study are publicly available at: https://github.com/R-Suresh/ GIST-CMTF. The repository contains task definitions, evaluation harnesses, and scripts required to reproduce the reported results. R EFERENCES [1] S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y. Cao, “ReAct: Synergizing reasoning and acting in language models,” in International Conference on Learning Representations, 2023. [2] T. Schick, J. Dwivedi-Yu, R. Dessi, R. Raileanu, M. Lomeli, E. Hambro, L. Zettlemoyer, N. Cancedda, and T. Scialom, “Toolformer: Language models can teach themselves to use tools,” in Advances in Neural Information Processing Systems, 2023. [3] Y. Qin, S. Liang, Y. Ye, K. Zhu, L. Yan, Y. Lu, Y. Lin, X. Cong, X. Tang, B. Qian, S. Zhao, R. Tian, R. Xie, J. Zhou, M. Gerstein, D. Li, Z. Liu, and M. Sun, “ToolLLM: Facilitating large language models to master 16000+ real-world apis,” in International Conference on Learning Representations, 2024. [4] M. Li, Y. Zhao, B. Yu, F. Song, H. Li, H. Yu, Z. Li, F. Huang, and Y. Li, “API-Bank: A comprehensive benchmark for tool-augmented llms,” in Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, 2023. [5] S. G. Patil, T. Zhang, X. Wang, and J. E. Gonzalez, “The berkeley function-calling leaderboard,” in Proceedings of Machine Learning Research, 2025. [6] X. Liu, H. Yu, H. Zhang, Y. Xu, X. Lei, H. Lai, Y. Gu, H. Ding, K. Men, K. Yang, S. Zhang, X. Deng, A. Zeng, Z. Du, C. Zhang, S. Shen, T. Zhang, Y. Su, H. Sun, M. Huang, Y. Dong, and J. Tang, “AgentBench: Evaluating llms as agents,” in International Conference on Learning Representations, 2024. [7] R. S. Babu and L. G. Iyer, “ToolChoiceConfusion: Causal minimal tool filtering for reliable llm agents,” arXiv preprint arXiv:2606.06284, 2026. [8] ——, “Contract2Tool: Learning preconditions and effects for reliable tool-augmented llm agents,” 2026. [Online]. Available: https://arxiv.org/ abs/2606.07904 [9] R. S. Babu and A. Agrawal, “Self-healing agentic orchestrators for reliable tool-augmented large language model systems,” 2026. [Online]. Available: https://arxiv.org/abs/2606.01416 [10] L. G. Iyer and R. S. Babu, “Capability minimization as a safety primitive: Risk-aware causal gating for least-privilege llm agents,” 2026. [Online]. Available: https://arxiv.org/abs/2606.13884 [11] R. E. Fikes and N. J. Nilsson, “STRIPS: A new approach to the application of theorem proving to problem solving,” Artificial Intelligence, vol. 2, no. 3–4, pp. 189–208, 1971. [12] D. McDermott, M. Ghallab, A. Howe, C. Knoblock, A. Ram, M. Veloso, D. Weld, and D. Wilkins, “PDDL: The planning domain definition language,” Yale Center for Computational Vision and Control, Tech. Rep., 1998.