Mitigating Execution Hallucinations and Computational Inflation in Agentic RAG via Strict Protocol Boundaries

Abstract

The deployment of large language models as autonomous retrieval agents over unstructured knowledge bases gives rise to a persistent structural conflict between probabilistic neural generation and deterministic physical execution. While agentic paradigms facilitate complex multi-hop retrieval, their unconstrained generative nature frequently violates strict syntactic requirements. This systemic vulnerability directly triggers execution hallucinations, such as fabricated API parameters or malformed schemas. Consequently, these syntax-driven failures force systems into redundant trial-and-error recovery loops, resulting in severe computational inflation that degrades both token efficiency and inference latency. To resolve this reliability–efficiency dilemma, this paper proposes RAG-CoT-MCP, a neuro-symbolic architecture that orthogonally decouples probabilistic cognitive planning from deterministic tool execution. By integrating the Model Context Protocol (MCP) as a strict system-level validation boundary, the framework ensures that latent reasoning trajectories manifest exclusively as syntactically valid operations. Exhaustive empirical evaluations across four disparate datasets—incorporating a multi-dimensional LLM-as-a-Judge framework, rigorous ablation studies, and granular cost tracking—validate the proposed approach. The findings demonstrate that RAG-CoT-MCP compresses network-level execution error rates from 45.2% (in unconstrained baselines) to a mere 6.0%, yielding substantial enhancements in semantic comprehensiveness and logical coherence compared to existing baselines. Counterintuitively, by proactively intercepting malformed actions and redirecting computational resources from reactive error handling to valid causal deduction, the framework drastically reduces redundant token consumption and achieves the lowest overall inference latency. Ultimately, this study establishes that deterministic execution constraints do not hinder agentic flexibility; rather, they serve as a fundamental prerequisite for deploying robust, high-speed, and cost-effective knowledge retrieval systems.

1. Introduction

Large Language Models (LLMs) are undergoing a rapid transition from passive text generators into autonomous agents capable of executing complex, goal-oriented tasks by interacting with external environments [1,2]. In the domain of knowledge-intensive tasks, Retrieval-Augmented Generation (RAG) has emerged as the standard paradigm to mitigate parametric hallucinations by grounding model responses in external knowledge bases [3,4]. Nevertheless, as user queries transition from elementary fact-checking to intricate, multi-hop reasoning over unstructured academic texts or nested APIs, the demands placed on retrieval architectures have undergone a fundamental shift. It is evident that traditional dense vector-based RAG systems, which rely on single-step semantic matching, frequently suffer from attention diffusion and semantic drift when navigating deeply intertwined logical chains [5,6].

In order to surmount the limitations of static retrieval, recent advancements have introduced agentic reasoning paradigms, such as Chain-of-Thought (CoT) combined with action generation (e.g., ReAct) [7]. These approaches endow LLMs with the capacity to dynamically plan, execute searches, and adjust their trajectories based on intermediate observations. Notwithstanding their theoretical flexibility, the deployment of these unconstrained reasoning agents in production environments exposes a critical structural vulnerability: a fundamental misalignment between the probabilistic nature of neural generation and the deterministic requirements of physical computer systems. Unconstrained agents frequently exhibit “execution hallucinations”, which manifest as the fabrication of API endpoints, the generation of malformed JSON payloads, or the hallucination of arguments during complex deductions [8,9]. These syntax-driven failures compel the agent to engage in costly and time-consuming trial-and-error recovery loops [10]. Consequently, it has been demonstrated that the sophisticated reasoning process is often subject to degeneration, resulting in a cycle of handling server errors that is characterized by a high degree of inefficiency. This cycle has been shown to have a significant impact on inference latency and computational token costs, both of which are elevated to a considerable degree.

To resolve this reliability–efficiency dilemma, this paper proposes RAG-CoT-MCP, a neuro-symbolic architecture that orthogonally decouples probabilistic cognitive planning from deterministic tool execution. By “orthogonal decoupling,” we mean that the system structurally separates the language model’s unconstrained reasoning process from the rigid syntactic demands of external databases. We achieve this by integrating the Model Context Protocol (MCP) as a strict system-level validation boundary [11]. Instead of forcing the language model to directly generate perfect API code—which often leads to execution hallucinations—our framework allows the model to freely construct its Chain-of-Thought reasoning steps internally. Subsequently, before any external tool is invoked, the MCP layer intercepts the proposed action and verifies it against deterministic API schemas. If the action is malformed, the MCP layer blocks the execution and returns a deterministic error trace back to the model for correction. This ensures that reasoning trajectories are grounded exclusively in syntactically valid operations, neutralizing syntax-driven failures without sacrificing the depth of agentic reasoning.

The primary contributions of this paper are summarized as follows:

• Identification of Hidden Computational Inflation: We systematically quantify the system-level overhead caused by syntax-driven execution failures in unconstrained LLM agents. We demonstrate how reactive error handling and infinite recovery loops degrade overall system efficiency and inflate token consumption.
• Proposal of a Neuro-Symbolic Architecture: We introduce the RAG-CoT-MCP framework, which establishes a strict deterministic execution boundary for probabilistic agents. This protocol-level integration effectively neutralizes execution hallucinations at the source and maintains highly fluid state transitions during deep reasoning tasks.
• Comprehensive Multi-Dimensional Evaluation: Through rigorous benchmarking across four diverse datasets (Qasper, HotpotQA, 2WikiMultihopQA, and ToolBench), we empirically validate the proposed architecture. Utilizing a pairwise LLM-as-a-Judge evaluation framework and granular cost tracking, we prove that RAG-CoT-MCP achieves superior semantic comprehensiveness (e.g., up to an 89.8% win rate over vanilla RAG and a 67.5% win rate over unconstrained RAG-CoT on complex API tasks). Furthermore, by proactively intercepting malformed actions at the protocol level, the framework reduces the execution failure rate from 45.2% (unconstrained baseline) to a mere 6.0%. This structural constraint compresses the reactive token overhead by an order of magnitude (from 1845 to 185 tokens per query) and counterintuitively reduces the overall average inference latency to 21.97 s, proving its high efficiency.

2. Related Work

2.1. Semantic Drift in Static Retrieval Paradigms

The evolution of Retrieval-Augmented Generation was initially centered on dense passage retrieval and static semantic matching to ground language models in external corpora [4,5]. Whilst the “retrieve-and-read” paradigms have been proven to be effective in mitigating hallucination in single-hop factual queries, they have been shown to encounter severe limitations when applied to complex, multi-step deductive reasoning. As is evident in extant literature, static vector spaces are predicated on surface-level semantic similarity, a method that frequently fails to capture latent causal relationships spanning multiple independent documents [12]. Consequently, when addressing long-horizon academic or technical queries, these systems frequently suffer from attention diffusion and semantic drift. The retrieved context is subject to rapid contamination from topically related but logically irrelevant noise. This necessitates a structural shift from single-pass static retrieval to dynamic, iterative knowledge acquisition.

2.2. The Vulnerability of Unconstrained Agentic Reasoning

In order to surmount the limitations of static semantic matching, recent research has actively explored agentic reasoning frameworks, with the ReAct paradigm and various Chain-of-Thought planning implementations being the most prominent [7,13,14]. It is evident that these approaches confer a certain degree of conceptual empowerment upon language models. This empowerment is characterized by the models’ ability to engage in dynamic planning, generate intermediate search queries, and the evaluation of external observations. Ultimately, this enables the synthesis of a comprehensive final answer. However, the deployment of these autonomous agents over rigid external databases or APIs exposes a critical systemic vulnerability: the absence of deterministic execution constraints. It has been demonstrated by preceding studies that, despite their proficiency in high-dimensional semantic planning, large language models frequently demonstrate an inability to adhere to strict syntactic schemas when their underlying probabilistic generation mechanisms are analyzed [8,9]. This unconstrained generation of data inevitably gives rise to execution hallucinations, whereby agents fabricate API endpoints, invoke non-existent functions, or output malformed JSON structures. Consequently, the reasoning process is often subject to disruption by costly trial-and-error recovery cycles, which consequently renders the system unstable in production environments.

2.3. From Statistical Tool Learning to Neuro-Symbolic Protocols

Addressing the high failure rate of LLM–tool interaction has historically been approached through instruction tuning and domain-specific fine-tuning. Indeed, models have been specifically optimized for API calling [15,16,17,18]. While these weight-level optimisations enhance the statistical probability of generating valid syntax, they are unable to provide absolute mathematical guarantees. Despite meticulous calibration of the models, formatting anomalies invariably arise when substantial cognitive strain is imposed by complex, multi-hop reasoning tasks. Departing from the realms of statistical or prompt-engineering methodologies, contemporary neuro-symbolic research proponents advocate for the integration of strict, programmatic execution boundaries [19,20]. It is imperative to distinguish the proposed framework from conventional structured tool-use paradigms (e.g., standard API function-calling or program-aided LMs). While existing frameworks primarily rely on probabilistic instruction tuning to generate valid syntax, they remain inherently vulnerable to degeneration under heavy cognitive loads. Furthermore, traditional API validation typically acts as a unidirectional filter that simply catches exceptions. In contrast, the RAG-CoT-MCP architecture employs the protocol layer as an active, bidirectional neuro-symbolic interface. Rather than merely aborting malformed actions, the protocol intercepts them and generates deterministic, schema-grounded error traces ${ϵ}_{error}$. These traces function as symbolic corrective gradients that are immediately injected back into the cognitive state space, forcing the neural planner to explicitly adjust its subsequent latent reasoning trajectories. The Model Context Protocol (MCP) represents a significant advancement in this domain by functioning as a strongly typed interface between the neural planner and the physical environment. The present architecture builds upon this trajectory by fully decoupling latent cognitive planning from physical tool execution. Furthermore, the present study contributes to the extant body of research by methodically quantifying the latent computational inflation triggered by syntax errors. The present study lends support to the hypothesis that deterministic protocol boundaries serve a dual function: as protective guardrails and as pivotal catalysts for reducing inference latency and computational waste.

3. Methodology

We formalize the LLM-based multi-hop retrieval task as a sequential decision-making process within a semi-structured environment. To clarify the scope of our approach, the proposed RAG-CoT-MCP architecture encompasses the entire closed-loop system illustrated in Figure 1. It consists of three interconnected modules:

Figure 1. The CoT-MCP Collaborative Framework.

• User and Client (Initiation, left panel): This acts as the entry point, capturing the user’s initial natural language query and routing it through the MCP Host App controller.
• LLM Brain (Cognition and Planning, central blue panel): This is the neural core of the framework. It receives the query and generates latent Chain-of-Thought (CoT) trajectories to dynamically plan and formulate candidate tool calls.
• MCP Standard System (Execution and Tools, right panel): This serves as the deterministic physical boundary. It receives the proposed tool calls, rigorously validates them against predefined API schemas, and either executes valid actions against external resources (e.g., File Systems, Databases) or returns precise error traces for malformed requests.

The proposed architecture adheres to a neuro-symbolic paradigm by orthogonally decoupling probabilistic cognitive planning (Module 2) from deterministic tool execution (Module 3). To maintain strict architectural consistency and isolate the impact of the protocol layer during empirical evaluation, GLM-4.7 is deployed as the singular foundational reasoning engine across all neural planning phases.

3.1. Cognitive Planning Phase

Operating exclusively within the ‘LLM Brain’ module (the central blue component of Figure 1), the cognitive planning phase is driven by a large language model parameterized by $\theta$ (specifically, GLM-4.7) [21], which acts as the central reasoning agent. Given a user query $q$ passed from the Initiation module and the interaction history at step $t-1$ denoted as $H_{t-1}$, the neural planner first samples a reasoning trajectory—the latent Chain-of-Thought variable $z_t$—within the latent space:

$$z_t ~ P\_\theta \left(z_t\right|q,H_{t-1})$$

(1)

Unlike traditional direct-action frameworks that eagerly generate API calls based on shallow context matching, this latent variable $z_t$ serves as an explicit cognitive prior. Conditioned on this structured reasoning trace, the model subsequently generates a candidate tool action $a_t$ rom the unconstrained action space $A$:

$${\widehat{a}}_t~P\_\theta \left(a\right|q,H_{t-1},z_t)$$

(2)

By explicitly defining $\theta$ as the GLM-4.7 engine throughout both the latent reasoning and action generation stages, the architecture ensures that complex semantic parsing relies on a consistent parametric memory before being subjected to symbolic validation.

3.2. Symbolic Protocol Layer

The candidate action $a_t$ generated by the neural planner is inherently probabilistic and prone to syntax errors. In conventional software engineering, malformed executions are typically handled via rigid exception-catching mechanisms. However, such unidirectional error handling fails to address the root cause of the neural planner’s hallucinations. To elevate this process from a mere engineering patch to a neuro-symbolic architecture, the Model Context Protocol (MCP) functions as an active, bidirectional symbolic boundary.

We define the valid action space $A_{m_{CP}}$ as the strict subset of operations that perfectly conform to the pre-defined schemas of the target database APIs. The protocol layer applies a deterministic validation function $V(a_t)$:

$$V(a_t)=\left\{\begin{array}{c}{a}_t , \mathrm{if} a_t\in A_{m_{CP}}\wedge \mathrm{S}\mathrm{c}\mathrm{h}\mathrm{e}\mathrm{m}\mathrm{a}\mathrm{C}\mathrm{h}\mathrm{e}\mathrm{c}\mathrm{k}\left(a_t\right)=\mathrm{True}\hfill \\ {ϵ}_{error},\mathrm{otherwise}\hfill \end{array}\right.$$

(3)

Crucially, when validation fails, the MCP layer does not merely abort the operation. Instead, it generates a deterministic, schema-grounded error trace ${ϵ}_{error}$. This trace acts as a symbolic corrective signal—functionally analogous to a semantic gradient—that is immediately injected back into the cognitive state space:

$$H_t = H_{t-1}\oplus ⟨z_t,a_t,{ϵ}_{error}⟩$$

(4)

Consequently, during the subsequent planning phase, the new latent variable $z_{t+1}$ is mathematically forced to condition on this absolute physical constraint:

$$z_{t+1}\sim P_{\theta }\left(z_{t+1}\right|q,H_t)$$

(5)

This bidirectional feedback loop ensures that the symbolic protocol actively reshapes the neural planner’s reasoning trajectory, effectively bridging the gap between approximate neural generation and exact symbolic logic.

3.3. Theoretical Bounds and System Stability

A fundamental limitation of existing autonomous agents is the lack of mathematical guarantees regarding execution stability. To address this, we formalize the execution cost and establish strict theoretical bounds using a bounded retry mechanism, parameterized by a maximum retry threshold ${\tau }_{\mathrm{m}\mathrm{a}\mathrm{x}}$ = 3.

Let $P_e\in \left(0, 1\right)$ denote the empirical probability of the neural planner generating a syntactically invalid tool call at any given reasoning step. In an unconstrained generative framework permitting infinite retries, the expected number of execution attempts $E\left[k\right]$ follows a geometric distribution:

$$E[k]=\sum _{k=1}^{\infty } k\cdot (1-p_e)p_e^{k-1}={\displaystyle \frac{1}{1-p_e}}$$

(6)

During complex cognitive loads where parameter hallucination is severe, as $P_e\to 1$, the expected execution cost $E\left[k\right]\to \infty$. This mathematical property directly explains the catastrophic infinite recovery loops observed in baseline models. By enforcing the strict upper bound ${\tau }_{\mathrm{m}\mathrm{a}\mathrm{x}}$, our architecture deterministically caps the maximum number of interactions per logical step. Consequently, the probability of a systemic abort—defined as the system failing to produce a valid action after exhausting all retries—is strictly bounded by an exponential decay function:

$$P\left(abort\right)=(p_e{)}^{{\tau }_{max}}$$

(7)

Given an empirical baseline failure rate of $P_e\approx$ 0.28 (as observed in prompt-constrained models), the integration of the protocol layer combined with ${\tau }_{\mathrm{m}\mathrm{a}\mathrm{x}}$ = 3 exponentially compresses the theoretical abort probability to approximately 0.021.

Furthermore, assuming an entire multi-hop task requires a reasoning trajectory of length $N$, the worst-case time complexity of the RAG-CoT-MCP architecture is strictly constrained to $O(N\cdot {\tau }_{max})$. This formulation provides a rigorous mathematical guarantee that the inference latency remains strictly linear with respect to the reasoning depth, effectively eradicating the $O\left(\mathrm{\infty }\right)$ instability inherent in unconstrained LLM agents.

4. Experiments

In order to provide a comprehensive evaluation of the effectiveness and generalizability of the proposed RAG-CoT-MCP architecture, a rigorous evaluation protocol was established. The objective of the experiments was twofold: firstly, to assess the framework in terms of retrieval accuracy; and secondly, to evaluate its execution robustness and computational efficiency under complex, multi-hop reasoning conditions.

4.1. Experimental Setup

4.1.1. Evaluation Datasets

To move beyond simplistic, single-hop question-answering tasks and rigorously stress-test the agentic execution boundaries, we curated a benchmark comprising four diverse datasets:

• Qasper: A dataset designed for deep, multi-hop reasoning over complex academic full-text papers [22]. We constructed a local knowledge base consisting of 1585 full-text scientific papers to evaluate the model’s capacity for granular document navigation.
• HotpotQA: A standard benchmark for open-domain multi-hop retrieval [23], utilized to evaluate the system’s cross-domain reasoning robustness.
• 2WikiMultihopQA: A dataset emphasizing structured logical chains across multiple entities [24]. This was introduced to test the architecture’s resilience against semantic drift during extended reasoning trajectories.
• ToolBench (Subset): A dataset tailored for complex API interactions [17]. This subset was specifically incorporated to challenge the agent’s ability to handle strict schema constraints and diverse tool invocations, directly evaluating the efficacy of the Model Context Protocol (MCP) layer.

In order to ensure the reproducibility of the experiments and to prevent selection bias, a stratified sampling strategy was employed in order to construct the evaluation subsets. Instead of utilizing simple random sampling, the original datasets were stratified based on reasoning complexity, namely the depth of the logical chains (e.g., 2-hop, 3-hop, and 4+ hop dependencies) and the diversity of the required tool schemas. Precisely 500 sample complex queries were extracted from each dataset, thereby ensuring an equitable distribution across all levels of difficulty. This rigorous sampling protocol guarantees that the evaluated subsets accurately reflect the long-horizon reasoning challenges inherent in the full corpora, while maintaining computational feasibility for extensive pairwise comparisons.

4.1.2. Baseline Architectures

The proposed framework was then compared against three established paradigms in order to isolate the impact of different architectural constraints. In order to facilitate a fair comparison and to isolate the architectural impact, GLM-4.7 was utilized as the foundational reasoning engine across all configurations.

• Vanilla RAG: Employs standard dense vector-based retrieval (e.g., utilizing BGE-large embeddings) [5,25] and synthesizes answers through static semantic similarity search, serving as the fundamental non-agentic baseline.
• RAG-CoT (Unconstrained): Enables the LLM to perform autonomous reasoning and multi-step search via the ReAct paradigm. However, it operates without any strict protocol-level execution constraints, allowing for unconstrained API parameter generation.
• ReAct (Prompt-Constrained): An enhanced variant of RAG-CoT where the LLM is explicitly guided via meticulous system prompts to output API calls within a predefined JSON schema. This serves as an intermediate baseline to evaluate the efficacy of prompt engineering versus system-level protocol enforcement.
• RAG-CoT-MCP (Ours): The proposed neuro-symbolic architecture, which integrates latent Chain-of-Thought reasoning at the planning level and enforces deterministic MCP-based schema validation at the execution boundary. For reproducibility, the GLM-4.7 foundational reasoning engine was strictly configured with a temperature of 0.1 to prioritize deterministic and logical outputs, a top_p of 0.9, and a maximum output token length of 2048. All experiments were conducted using a fixed random seed of 42. Furthermore, to bridge the gap between our mathematical formulations and practical implementation, a detailed algorithmic representation of the execution loop and sample MCP tool schemas are provided in our public open-source repository.

4.1.3. Evaluation Metrics

In order to mitigate the potential for evaluator bias and to capture both execution stability and human-perceived reasoning quality, a hybrid evaluation metric system was adopted. This system comprises deterministic execution metrics and an LLM-as-a-Judge framework.

• Objective Execution Metrics: We utilized Exact Match (EM) and macro F1 Score to quantify final retrieval accuracy. Furthermore, the stability of agentic execution was explicitly quantified by the Tool Success Rate (TSR). TSR is defined as the ratio of syntactically valid and successfully executed atomic tool calls to the total number of attempted tool invocations during a given reasoning trajectory.
• Multi-dimensional LLM-as-a-Judge Evaluation: Traditional rigid metrics frequently struggle to capture the nuance of long-form multi-hop reasoning. Inspired by recent advanced evaluation protocols, we introduced a multi-dimensional pairwise comparison framework utilizing a strong evaluator model (e.g., GPT-4o) [26]. To strictly mitigate evaluator bias and ensure reproducibility, the judge model was configured with a temperature of 0.0. Furthermore, we implemented a bidirectional ‘Position Swapping’ protocol to neutralize position bias. Every answer pair was evaluated twice (Model A preceding Model B, and vice versa). A definitive ‘Win’ was only aggregated into the final metrics if the evaluator consistently preferred the same model across both positional permutations; otherwise, the comparison was strictly recorded as a ‘Tie.’ To minimize prompt sensitivity, the evaluator was constrained by dimension-specific rubrics rather than open-ended preference prompts. The generated responses were evaluated blind across four primary dimensions:
  • Comprehensiveness: The extent to which the response covers all necessary multi-hop evidence and implicit relationships required by the query.
  • Factuality and Accuracy: The strict adherence to retrieved contextual evidence, specifically penalizing parametric hallucinations or fabricated tool execution results.
  • Logical Coherence: The soundness and fluidity of the reasoning chain connecting the initial query to the final synthesis.
  • Overall Preference: A holistic judgment determining the superior response based on the cumulative performance of the preceding three criteria.

4.2. Accuracy and Execution Robustness

As detailed in Table 1, the evaluated architectures exhibit a clear stepwise stratification. The performance of vanilla RAG highlights the inherent limitations of shallow semantic matching, achieving an F1 score of only 0.523 on Qasper. Pure vector retrieval frequently provides fragmented context to the neural planner, triggering semantic drift in multi-hop scenarios.

Table 1. Win rates (%) of baselines versus the proposed RAG-CoT-MCP architecture across four datasets and four evaluation dimensions.

Dataset	Evaluation Dimension	Vanilla RAG vs. Ours	RAG-CoT vs. Ours	ReAct vs. Ours
Qasper	Comprehensiveness	18.5/81.5	35.2/64.8	42.1/57.9
	Accuracy/Factuality	45.2/54.8	22.4/77.6	38.6/61.4
	Logical Coherence	28.6/71.4	41.5/58.5	45.0/55.0
	Overall Preference	24.3/75.7	31.8/68.2	40.2/59.8
HotpotQA	Comprehensiveness	22.0/78.0	40.5/59.5	46.2/53.8
	Accuracy/Factuality	48.5/51.5	28.6/71.4	41.5/58.5
	Logical Coherence	33.4/66.6	45.0/55.0	48.0/52.0
	Overall Preference	31.2/68.8	36.4/63.6	44.1/55.9
2Wiki	Comprehensiveness	15.4/84.6	38.2/61.8	44.5/55.5
	Accuracy/Factuality	42.1/57.9	19.8/80.2	35.4/64.6
	Logical Coherence	25.5/74.5	39.6/60.4	42.8/57.2
	Overall Preference	22.8/77.2	29.5/70.5	39.8/60.2
ToolBench	Comprehensiveness	10.2/89.8	32.5/67.5	38.4/61.6
	Accuracy/Factuality	35.6/64.4	15.2/84.8	28.5/71.5
	Logical Coherence	18.5/81.5	35.5/64.5	41.2/58.8
	Overall Preference	6.4/83.6	25.8/74.2	34.5/65.5

A thorough examination of the evaluation dimensions has exposed a variety of distinct failure modes among the baselines. This finding serves to further emphasize the structural advantages of neuro-symbolic coupling.

With regard to the Comprehensiveness dimension, the proposed architecture demonstrates significant superiority over Vanilla RAG, achieving an 81.5% win rate on the Qasper dataset and 89.8% on ToolBench. Evidence from Evaluator logs indicates that traditional vector-based retrieval frequently suffers from attention diffusion when processing lengthy academic texts or nested API descriptions. The RAG-CoT-MCP framework is a retrieval approach that utilizes latent CoT planning to decompose complex queries into atomic retrieval intents. This ensures that implicit multi-hop evidence is systematically captured, thereby mitigating the semantic drift commonly observed in static retrieval approaches.

A critical divergence is also observed in the Accuracy/Factuality metric when a comparison is made against the unconstrained RAG-CoT baseline. The unconstrained model is heavily penalized when operating without protocol constraints. The proposed architecture achieves a 77.6% win rate on Qasper and an 84.8% win rate on ToolBench. Unconstrained autonomous agents have been observed to demonstrate a marked tendency to hallucinate API parameters or fabricate file paths during complex logical deductions. This phenomenon results in the generation of answers that are contingent on fabricated execution results. The integration of the Model Context Protocol functions as a strict schema validation boundary. It is mathematically proven that reasoning trajectories are exclusively grounded in syntactically valid operations. This, in turn, neutralizes execution hallucinations at the source.

Finally, in terms of logical coherence, while the Prompt-Constrained ReAct baseline mitigates parameter hallucination to a certain degree through instructional tuning, it remains highly susceptible to logical fragmentation. In the context of profound cognitive exercises, reliance on natural language prompts alone is inadequate in ensuring the complete prevention of syntax errors. This forces the prompt-constrained model into erratic trial-and-error loops, frequently leading to broken reasoning chains. The proposed architecture is predicated on the principle of delegating the entirety of schema validation to the deterministic MCP layer. This approach is intended to ensure the maintenance of a highly fluid and unbroken state transition throughout the reasoning process. The present study has demonstrated that systemic stability is reflected by consistent dominance across all four datasets, ranging from 55.9% to 65.5% in overall win rates.

4.3. Ablation Studies

To rigorously validate the necessity and individual contribution of each neuro-symbolic component within the proposed architecture, an ablation study was conducted. We derived three simplified variants of the RAG-CoT-MCP framework by systematically removing core systemic constraints. The average performance across all four datasets was evaluated using Exact Match (EM), macro F1 Score, and Tool Success Rate (TSR).

The empirical results in Table 2 demonstrate that the removal of any systemic component results in a significant degradation of both execution stability and reasoning accuracy.

Table 2. Ablation study results: Average performance metrics across all evaluation datasets.

Architecture Variant	F1 Score (%)	Exact Match (%)	Tool Success Rate (TSR) (%)
RAG-CoT-MCP (Full Architecture)	68.4	52.7	94.0
Baseline RAG-CoT	51.2	38.5	64.2
Direct Action	55.7	42.1	89.4
Unbounded Retry	65.1	50.3	82.6

The reversion to the baseline RAG-CoT, following the removal of the deterministic Model Context Protocol layer, resulted in the most severe performance collapse, with the system being forced to rely entirely on the LLM’s intrinsic capacity to format tool calls. In this configuration, while the F1 score decreased by 17.2%, the Tool Success Rate (TSR) experienced a precipitous decline from 94% to 64.2%. In the absence of a stringent schema validation boundary, the model exhibited a proclivity for generating malformed JSON strings, fabricating non-existent API endpoints, or hallucinating missing arguments. The present empirical evidence confirms the hypothesis that probabilistic natural language models are incapable of reliably sustaining deterministic execution states in long-horizon tasks in the absence of external symbolic constraints.

Further analysis reveals the essential impact of the cognitive planning phase. When the latent variable generation $\left(z_t\right)$ was ablated, the model was compelled to execute a Direct Action ($a_t$) based solely on the current context. This variant maintained a relatively high TSR (89.4%), primarily because the MCP layer was still actively filtering syntax errors. However, its task-solving metrics degraded significantly, with the F1 score falling to 55.7%. Evaluator logs revealed that without explicit intermediate reasoning, the agent suffered from severe semantic drift during complex multi-hop queries, frequently invoking irrelevant tools or terminating the search prematurely. This proves that decoupling cognitive planning from physical execution is critical for maintaining logical coherence.

Finally, examining the system’s boundary conditions, we evaluated an Unbounded Retry setting by removing the strict systemic retry threshold (${\tau }_{max}=3$). Under this configuration, the model was permitted infinite attempts to recover from errors or unanswerable queries. Counterintuitively, granting the model unlimited retries did not improve accuracy; instead, the TSR dropped to 82.6%, and the F1 score slightly declined to 65.1%. Without bounded termination, the agent frequently fell into infinite recovery loops, repeatedly attempting to brute-force a solution when the required knowledge was genuinely missing from the database (e.g., in Miss-Answer scenarios). The bounded retry mechanism is thus proven crucial not only for capping inference latency but also for forcing the model to acknowledge knowledge boundaries gracefully.

4.4. Model Cost and Execution Efficiency

We define the valid action space $A_{m_{CP}}$ as the discrete set of atomic operations strictly permitted by the MCP server specifications. The protocol layer enforces a staged validation function $V\left(a_t\right)$, which acts as an uncompromising gatekeeper between the neural and symbolic components:

$$Cost=T_{planning}+\sum _{i=1}^C \left(T_{recovery}^{\left(i\right)}+L_{API}\right)$$

(8)

where $T_{planning}$ represents the base token generation time for the initial cognitive planning, $C$ denotes the number of failed API execution attempts, $T_{recovery}$ is the token overhead spent on error analysis and prompt re-generation, and $L_{API}$ is the network latency incurred by redundant API calls. Based on this formulation, we tracked the average resource consumption per query across the agentic baselines, with the comparative results detailed in Table 3.

Table 3. Comparison of execution cost and efficiency metrics per query.

Architecture Variant	Avg. API Calls	Failed API Rate (%)	Avg. Token Overhead	Avg. Latency (s)
Baseline RAG-CoT	8.4	45.2	1845	34.50
Prompt-Constrained ReAct	6.2	28.6	1120	28.15
RAG-CoT-MCP (Ours)	3.1	6.0	185	21.97

As illustrated in Table 3, examining the interaction with external interfaces reveals a stark contrast in API utilization efficiency. The Baseline RAG-CoT model exhibits a highly inefficient retrieval pattern, averaging 8.4 API calls per query with a failure rate of 45.2%. Evaluator logs indicate that a substantial portion of these calls are wasted on resolving 400 Bad Request or 500 Internal Server Error responses caused by malformed JSON payloads. While the Prompt-Constrained ReAct model partially mitigates this issue through instructional tuning, it still suffers from a 28.6% failure rate. In contrast, by enforcing deterministic schema validation prior to network execution, the proposed RAG-CoT-MCP architecture compresses the average API calls down to 3.1 and virtually eliminates syntax-driven network failures, effectively minimizing the ${\Sigma }_{L_{API}}$ component of the cost equation.

To address potential ambiguities regarding the 6.0% network failure rate achieved by the proposed architecture, it is imperative to strictly delineate the statistical definition of an API failure within this study. The reported failure metric exclusively quantifies syntactic execution aborts—such as malformed JSON payloads, hallucinated endpoints, or missing mandatory arguments that trigger 400 Bad Request or 500 Internal Server Error responses. Conversely, valid semantic null-returns resulting from exploratory logical errors (e.g., querying a non-existent document ID returning a 404 Not Found, or triggering a server-side rate limit warning) are categorically classified as successful network executions. These null returns provide deterministic, valid observations that the latent cognitive planner utilizes to update its state space and formulate alternative search strategies. The profound reduction in the failure rate is therefore not a result of filtering complex environmental edge cases, but rather demonstrates that the Model Context Protocol effectively shields the network layer from the generative syntax chaos inherent in unconstrained baselines.

The minimization of network errors directly translates into a dramatic reduction in computational waste, specifically regarding token overhead ($T_{recovery}$). When conventional agentic systems encounter an API failure, they are forced to consume large amounts of context window to parse the error trace and generate self-reflective corrections (e.g., generating tokens to explain the syntax error before attempting a new call). This reactive error handling process costs the Baseline RAG-CoT an average of 1845 redundant tokens per query. By proactively intercepting invalid actions at the protocol layer, the MCP framework ensures that the LLM’s token generation capacity is invested exclusively in valid causal reasoning, reducing the token overhead to a negligible 185 tokens.

This architectural efficiency leads to a counterintuitive but highly advantageous outcome regarding overall inference latency. It is typically assumed that introducing an additional protocol validation layer would inflate system latency. However, empirical data demonstrate the opposite. Although the MCP layer introduces a marginal local validation overhead (approximately 0.37 s per query), it fundamentally eradicates the protracted trial-and-error loops that plague unconstrained models. As a result, the RAG-CoT-MCP architecture achieves the lowest average latency at 21.97 s, proving that strict systemic constraints are not computational burdens, but rather the prerequisite for deploying high-speed, cost-effective LLM agents.

5. Discussion

The primary objective of this study is to resolve the structural contradiction between probabilistic neural generation and deterministic physical execution in autonomous knowledge retrieval. The introduction of the Model Context Protocol (MCP) as a strict neuro-symbolic interface has been demonstrated to result in a significant reduction in network-level execution error rates to an almost imperceptible level. From the perspective of dual-process cognitive theory, this orthogonal decoupling carries profound implications [27]. The conventional static vector retrieval process functions in a manner analogous to System 1 thinking, relying on rapid, heuristic pattern matching. This approach is particularly vulnerable to semantic drift when traversing complex texts. In contrast, latent chain-of-thought reasoning augmented by protocol constraints endows the agent with deliberate, System 2-like cognitive capacities. In this framework, the protocol layer functions as a stringent logical gatekeeper, enabling the language model to concentrate exclusively on high-dimensional causal deduction without exhausting valuable context window resources on low-dimensional syntax correction.

Moreover, the empirical findings call into question prevailing intuitive assumptions in the realm of distributed system design. It is a commonly held belief that the implementation of an additional protocol validation layer would inevitably result in an increase in overall system latency. However, detailed cost tracking reveals a significant phenomenon of “hidden computational inflation” within unconstrained agentic models, where a substantial quantity of generation tokens is wasted on processing invalid server responses and executing iterative self-correction loops [28]. The proactive interception mechanism of the deterministic protocol layer has been shown to disrupt this irrational trial-and-error cycle. By implementing front-loaded systemic constraints, computational resources are efficiently reallocated towards the exploration of valid knowledge, thereby establishing a critical pathway for the low-latency, cost-effective deployment of LLM agents in cloud environments.

Notwithstanding the considerable advantages in terms of semantic accuracy and resource utilization, the practical implementation of the RAG-CoT-MCP architecture gives rise to specific theoretical and engineering challenges. Firstly, the uniform application of this computationally onerous System 2 framework to all queries contravenes the cognitive principle of least effort. Specifically, under conditions involving simple, single-hop factoid queries or scenarios with intrinsically low error rates, the mandatory execution of latent Chain-of-Thought planning and protocol-level validation introduces unnecessary token generation costs and latency overhead. This results in an overall irrational allocation of resources for elementary questions. It is imperative that future research addresse this issue by developing an adaptive, entropy-driven routing mechanism that is capable of dynamically toggling between standard System 1 RAG and the System 2 MCP framework. Furthermore, the current empirical evaluation was deliberately constrained to a singular foundational reasoning engine to strictly isolate the architectural impact of the protocol layer. Consequently, performance variations when deploying different families of Large Language Models (e.g., varying parameter scales or open-source versus proprietary models) as the cognitive planner remain unexplored. Investigating the framework’s model-agnostic robustness and potential prompt sensitivity across diverse LLMs constitutes a vital direction for future research. Secondly, the present cognitive planning phase is reliant upon an autoregressive, sequential generation process, which fails to fully exploit the concurrency of contemporary cloud platforms. Exploring speculative concurrent retrieval could further minimize latency [29]. Finally, the delegation of execution validation entirely to the deterministic MCP layer necessitates the rigorous pre-definition of API schemas, which severely degrades zero-shot adaptability in unknown environments. Because the protocol relies on static structural rules to intercept hallucinations, the system currently lacks the capacity to interact with dynamically mutating APIs or strictly open-world toolsets where schemas are unmapped. In order to achieve a reconciliation between the strictness of deterministic execution and open-world exploratory flexibility, it is essential that subsequent studies direct their attention to the fields of dynamic schema induction (e.g., enabling the LLM to autonomously parse OpenAPI specifications on the fly to configure the MCP server dynamically) and automated protocol discovery mechanisms.

6. Conclusions

The present paper addresses the critical reliability and efficiency bottlenecks encountered when deploying Large Language Models as autonomous multi-hop retrieval agents over complex knowledge bases. In order to address the fundamental structural gap between probabilistic neural generation and deterministic physical execution, the RAG-CoT-MCP neuro-symbolic architecture was proposed. The successful neutralization of syntax-driven execution hallucinations at their source is achieved by orthogonally decoupling latent cognitive planning from physical tool invocation and enforcing the Model Context Protocol as a rigorous system-level validation boundary.

Comprehensive empirical evaluations across four diverse datasets demonstrate that the proposed architecture establishes a new standard for agentic retrieval. The framework enhances semantic comprehensiveness and logical coherence, while also resolving the prevalent systemic issue of hidden computational inflation. The deterministic interception of malformed actions prevents the agent from entering protracted trial-and-error recovery loops. This, in turn, has the effect of dramatically reducing redundant API calls and wasteful token consumption. The architecture achieves lower overall inference latency, despite the addition of a strict protocol validation layer, a result that may appear counterintuitive at first glance.

The findings of this research establish that programmatic execution constraints do not hinder agentic flexibility; rather, they serve as a fundamental prerequisite for deploying robust, high-speed, and cost-effective LLM agents in production environments. Whilst the current limitations regarding strict schema maintenance dependencies persist, future explorations into dynamic protocol discovery and speculative concurrent retrieval mechanisms will further advance the scalability and zero-shot adaptability of neuro-symbolic intelligent systems.