Paper deep dive
Distilling Reasoning Without Knowledge: A Framework for Reliable LLMs
Auksarapak Kietkajornrit, Jad Tarifi, Nima Asgharbeygi
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 95%
Last extracted: 3/22/2026, 5:09:27 AM
Summary
The paper introduces a modular framework for reliable LLM question answering that separates planning from factual retrieval and synthesis. By training a lightweight student planner to generate structured reasoning steps and atomic fact requests, the framework reduces hallucinations and improves accuracy on the SEAL-0 benchmark compared to monolithic models.
Entities (4)
Relation Signals (3)
Framework → evaluatedon → SEAL-0
confidence 99% · We evaluate the proposed framework on SEAL-0, an extremely challenging benchmark for search-augmented LLMs.
QWEN3-8B → servesas → Student Planner
confidence 95% · We fine-tune a lightweight open-weight model, QWEN3-8B (Qwen, 2025), to serve as the student planner.
Framework → usestool → SerpAPI
confidence 95% · If source is web, we retrieve raw search results from Google Search via SerpAPI
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Fact-seeking question answering with large language models (LLMs) remains unreliable when answers depend on up-to-date or conflicting information. Although retrieval-augmented and tool-using LLMs reduce hallucinations, they often rely on implicit planning, leading to inefficient tool usage. We propose a modular framework that explicitly separates planning from factual retrieval and answer synthesis. A lightweight student planner is trained via a teacher-student framework to generate structured decompositions consisting of abstract reasoning steps and searchable fact requests. The supervision signals contain only planning traces and fact requests, without providing factual answers or retrieved evidence. At inference, the planner produces plans, while prompt-engineered modules perform retrieval and response synthesis. We evaluate the proposed framework on SEAL-0, an extremely challenging benchmark for search-augmented LLMs. Results show that supervised planning improves both accuracy and latency compared to monolithic reasoning models and prompt-based tool-augmented frameworks, demonstrating that explicitly learned planning structures are essential for reliable fact-seeking LLMs.
Tags
Links
- Source: https://arxiv.org/abs/2603.14458v1
- Canonical: https://arxiv.org/abs/2603.14458v1
Trouble viewing inline? Open PDF directly →
Full Text
48,617 characters extracted from source content.
Expand or collapse full text
DISTILLING REASONING WITHOUT KNOWLEDGE: A FRAMEWORK FOR RELIABLE LLMS Auksarapak KietkajornritJad TarifiNima Asgharbeygi Integral AI auksarapak, jad, nima@integral.ai ABSTRACT Fact-seeking question answering with large language models (LLMs) remains un- reliable when answers depend on up-to-date or conflicting information. Although retrieval-augmented and tool-using LLMs reduce hallucinations, they often rely on implicit planning, leading to inefficient tool usage. We propose a modular framework that explicitly separates planning from factual retrieval and answer synthesis. A lightweight student planner is trained via a teacher-student frame- work to generate structured decompositions consisting of abstract reasoning steps and searchable fact requests. The supervision signals contain only planning traces and fact requests, without providing factual answers or retrieved evidence. At in- ference, the planner produces plans, while prompt-engineered modules perform retrieval and response synthesis. We evaluate the proposed framework on SEAL- 0, an extremely challenging benchmark for search-augmented LLMs. Results show that supervised planning improves both accuracy and latency compared to monolithic reasoning models and prompt-based tool-augmented frameworks, demonstrating that explicitly learned planning structures are essential for reliable fact-seeking LLMs. 1INTRODUCTION Large language models (LLMs) have achieved remarkable performance across reasoning, language understanding, and decision-making tasks (Chang et al., 2024). Despite these advances, they remain prone to hallucinations: confident responses that are factually incorrect, unverifiable, or unsupported by available evidence (Ji et al., 2023). Such failures commonly occur when required information is missing, outdated, or lies outside the model’s parametric knowledge, posing a serious challenge for deploying LLMs in real-world question answering and agentic systems where factual reliability is essential (Wang et al., 2023). At a high level, hallucinations arise when models generate plausible-sounding content to fill gaps in missing or uncertain information instead of explicitly acknowledging uncertainty or requesting external evidence (Kalai et al., 2025). This behavior is reinforced by training objectives that favor coherent, helpful, and complete answers, even when the necessary facts are unavailable (Huang et al., 2025). Architecturally, most LLMs combine reasoning and factual recall within a single inference process (Jin et al., 2025). Given a user query, the model must simultaneously decide what information is needed, retrieve it from internal parametric memory, and reason over it to produce an answer (Liu & Shu, 2025). When internal knowledge is incomplete or incorrect, the model has no explicit mechanism to detect this gap, often resulting in hallucinated facts rather than an explicit request for external information (Cao, 2024). This issue is particularly severe for up-to-date, verifiable, or long-tail knowledge, where reliance on memorized training data alone is insufficient (Alansari & Luqman, 2025). Recent work on retrieval-augmented generation (RAG) and tool-using LLMs has demonstrated that grounding outputs in external sources, such as web search engines, databases, or application pro- gramming interfaces (APIs), can substantially improve factual accuracy (Huang et al., 2024; Wang et al., 2023). Despite this progress, many existing systems still rely on a single LLM to jointly decide what information is needed, how it should be retrieved, and how retrieved content is incorporated during reasoning (Zhu et al., 2025; Wampler et al., 2025). This coupling process makes it difficult 1 arXiv:2603.14458v1 [cs.CL] 15 Mar 2026 to attribute errors to specific stages of the pipeline, whether they stem from reasoning, retrieval fail- ures, or incorrect grounding. As LLMs are increasingly deployed in autonomous agentic systems, this entanglement makes failures harder to diagnose, control, and correct. Iteration Loop Start: User Question Student Planner Generate JSON Plan Valid JSON? More Fact Requests? Insert Retrieved Facts Replace placeholders <RESULTi> with stored facts Source Type? SerpAPI (Google Search) Extractor Extract Answer Compute Module Execute Logic Store Fact Repair Module Fix Syntax Errors Aggregator Synthesize Answer End: Final Output No Yes Yes Web Compute Next Iteration No (Done) Fine-tuned LLM Prompted LLM Figure 1: Inference-time execution pipeline of the proposed framework. In this work, we propose a framework for reliable and hallucination-resistant LLM that explicitly separates reasoning from factual knowledge acquisition, as illustrated in the flowchart in Fig. 1. Here, reliability refers to the model’s ability to produce factually correct responses grounded in verifiable evidence while avoiding hallucinated claims and refraining from asserting unsupported information (Liu et al., 2023). The key idea is to structure the inference process into distinct stages including planning, information retrieval, factual extraction, and answer aggregation, so that factual claims are grounded in external evidence rather than internal memory. To enable this, we employ a teacher-student training strategy that trains a Student LLM to avoid internalizing factual content. During dataset construction, the Teacher LLM is prompted to decompose each question into (i) a sequence of abstract reasoning steps and (i) a minimal set of atomic fact requests required to complete those steps. The teacher is explicitly constrained not to answer questions directly or rely on its internal factual knowledge. Instead, it produces structured outputs that describe what needs to be known, rather than what the facts are. The training objective for the Student LLM is to reproduce the teacher’s reasoning structure and information-seeking behavior. The supervision signals contain only planning traces and fact re- quests, without providing factual answers or retrieved evidence. This design encourages the model 2 to learn planning and retrieval strategies rather than internalizing additional factual content. At infer- ence time, as summarized in Fig. 1, the student operates independently of the teacher and produces a structured plan consisting of reasoning steps and atomic fact requests. A separate retrieval compo- nent executes these requests using external tools. An LLM extractor then converts raw evidence into atomic facts and an LLM aggregator synthesizes the final answer grounded in the retrieved evidence. By shifting factual responsibility to external and verifiable sources, the framework substantially re- duces hallucinated content. Moreover, because the student learns structured reasoning rather than factual knowledge, it can be significantly smaller and faster than frontier models, enabling efficient and reliable deployment. We evaluate our framework on SEALQA, a challenge benchmark for search-augmented language models that targets fact-seeking questions with noisy, conflicting, or unhelpful web evidence (Pham et al., 2025). In this work, we focus on SEAL-0, the primary split of SEALQA, which consists of difficult questions for which even strong chat models typically achieve near-zero accuracy. Exper- imental results show that the framework achieves near state-of-the-art performance, outperforming most open-source models while remaining competitive with the strongest reported agentic mod- els. These findings suggest that reasoning-focused distillation, rather than knowledge distillation, provides a promising direction for building more reliable and controllable agentic LLM systems. 2RELIABLE LLM FRAMEWORK We propose a modular framework for reliable and hallucination-resistant language model inference that explicitly separates reasoning from factual knowledge acquisition. The core design principle is to structure the inference process into distinct stages including planning, information retrieval, factual extraction, and answer aggregation, so that factual claims are grounded in external evidence rather than internal parametric memory. A central component of the framework is a teacher-student training strategy used to learn a high-quality planner. Our framework trains a dedicated planner to generate structured reasoning plans and precise information requests, while delegating factual content acquisition entirely to external tools. 2.1PROBLEM FORMULATION AND OVERALL FRAMEWORK Given a natural language question q, the goal is to produce an answer a that is both logically consis- tent and factually grounded. We assume access to external tools that can return up-to-date, verifiable information. We model inference as a modular pipeline with four stages: (i) planning, (i) retrieval, (i) factual extraction, and (iv) answer aggregation. First, a planner generates a structured plan P(q) = (R, F),(1) where R =r 1 , r 2 , . . . , r K is a sequence of K abstract steps describing how to solve the problem, and F = f 1 , f 2 , . . . , f M is a set of M atomic fact requests specifying what information must be obtained externally. Next, each fact request f m is executed by a retrieval tool to obtain raw evidence E m = Retrieve(f m ). Since retrieved evidence may be noisy or verbose, an extractor maps each E m to a concise atomic fact ˆx m = Extract(f m , E m ). Finally, an aggregator produces the final answer using the plan and extracted facts: a = Aggregate q, R,f m , ˆx m M m=1 .(2) Crucially, the planner is discouraged from answering q directly using internal factual knowledge. Instead, it is trained to externalize missing information into F , so that factual claims are supported by retrieved evidence rather than parametric memory. 2.2PLANNER TRAINING VIA A TEACHER-STUDENT FRAMEWORK The quality of tool usage and factual grounding critically depends on the planner’s ability to decom- pose a question and to formulate relevant, precise, and search-ready information requests suitable for external retrieval systems. Teacher-student learning is used here solely as a mechanism for su- pervising planning behavior, not for transferring factual knowledge or answers. 3 2.2.1TEACHER-GUIDED DATASET CONSTRUCTION During dataset construction, we use GPT-5.2 1 as a Teacher LLM to generate structured planning supervision. The teacher system prompt that enforces a strict decomposition behavior can be found in Appendix A. Given a natural language question q, the teacher outputs: (i) a sequence of abstract reasoning steps describing how the problem should be solved, and (i) a set of atomic fact requests specifying what external information is required to execute those steps. We construct a dataset of 1,596 questions drawn from three complementary sources. First, we generate 900 synthetic fact-seeking questions using GPT-5.1 2 . These questions span nine topi- cal categories including economics, technology, geography, companies and market data, finance, environment, sports, medicine, and cross-mixed categories, and cover diverse comparison and decision-making formats with balanced representation across question types. Second, we include 100 personal-entity questions sampled from the hard split of HotpotQA (Yang et al., 2018), which emphasizes multi-document reasoning. This subset is intentionally added because GPT-based gen- erators tend to avoid producing questions about real-world named individuals due to safety align- ment constraints. Third, we incorporate 596 questions from the FreshQA benchmark (Vu et al., 2023), which evaluates LLMs on fact-seeking queries that require up-to-date information beyond pretraining. FreshQA focuses on recent events and continuously evolving facts and is regularly updated. The version used in our experiments covers information up to November 24, 2025. We explicitly ensure that none of the selected questions for dataset construction overlap with SEALQA, which is used for evaluation in this work. For each question q, the teacher produces a structured planning trace, yielding paired supervision examples of the form (q,R, F). An example teacher output in JSON format for the question “How long has Elon Musk been X Corp.’s CEO?” is shown below. "required_information": [ "query": "CEO of X Corp (company)", "source": "web", "dependent": false , "query": "Is <RESULT_1> equal to \"Elon Musk\"?", "source": "compute", "dependent": true , "query": "date Elon Musk became CEO of X Corp", "source": "web", "dependent": false , "query": "today’s date", "source": "web", "dependent": false , "query": "time difference between <RESULT_3> and <RESULT_4> (duration in days, and in years-months-days)", "source": "compute", "dependent": true ], "reasoning_steps": [ "Use the retrieved CEO name and the equality check result to determine whether the premise that Elon Musk is X Corp.’s CEO is supported.", "If supported, report the computed tenure duration from the retrieved CEO start date to today’s date; otherwise, report that the requested duration is not applicable."] Here, each entry in required information specifies a single atomic operation. The source field indicates whether the query is executed via an external web lookup (web) or an analytical reasoning (compute). The dependent flag denotes whether a query depends on the output of earlier queries, referenced through indexed placeholders such as <RESULT1>. This structure en- forces explicit information dependencies and prevents the planner from implicitly reasoning over unstated facts. In the example, the teacher-generated plan does not assume the premise is correct. Instead, it first issues a web query to verify the current CEO of X Corp., followed by a compute query to check whether the retrieved name matches the presupposed entity. Only if this premise is supported does the plan request the CEO start date. To avoid relying on implicit temporal assump- tions, the plan also retrieves the current date explicitly, and finally invokes a compute operation to 1 https://openai.com/index/gpt-5-system-card-update-gpt-5-2/ 2 https://openai.com/index/gpt-5-system-card-addendum-gpt-5-1/ 4 calculate the tenure duration. These teacher-generated planning traces constitute only supervision used to train the student planner. We additionally performed manual verification of the generated traces to confirm that no factual answers or retrieved evidence were included in the dataset. 2.2.2STUDENT PLANNER TRAINING We fine-tune a lightweight open-weight model, QWEN3-8B (Qwen, 2025), to serve as the student planner. The student is trained to imitate the teacher’s planning behavior using the constructed dataset: given an input question q, it generates the structured decomposition (R, F) produced by the teacher. Crucially, the student is not supervised with factual answers, retrieved evidence, or final task outputs. Instead, supervision is restricted to planning structure and searchable information requests, i.e., short and well-scoped queries that a standard web search engine or a deterministic compute tool can execute directly. This training objective teaches the planner to (i) decompose questions into abstract steps and (i) produce relevant fact requests that can be satisfied by downstream tools. By restricting supervision to planning structure and information-seeking behavior, the student learns to produce high-quality and reusable plans. Factual correctness is handled entirely by downstream retrieval, extraction, and aggregation components at inference time. 2.3INFERENCE-TIME EXECUTION PIPELINE Fig. 1 summarizes the inference-time pipeline used in our framework. Given a user question q, the fine-tuned student planner generates a structured JSON plan (R, F). All remaining components are prompt-engineered modules executed using the base QWEN3-8B model together with external tools, with internal reasoning explicitly disabled. Their full prompts are provided in Appendix B. Plan Parsing and JSON Repair. In practice, the planner may occasionally produce outputs that are not valid JSON. Following the flowchart, we first attempt to parse the planner out- put directly. If parsing fails, we invoke a prompt-engineered JSON repair module that removes any extraneous text and rewrites the output into a valid JSON object with the required keys (required information and reasoningsteps). This repair step is only applied when necessary, and allows downstream components to utilize a consistent structured plan. Iterative Retrieval with Dependency Resolution. We execute the fact requests in F sequentially, as illustrated in iteration loop in Fig. 1. Each request f m specifies a source (web or compute) and a dependent flag. Before execution, we resolve dependencies by substituting placeholders <RESULTi> with previously stored outputs, producing an effective query ̃ f m which is executable. If source is web, we retrieve raw search results from Google Search via SerpAPI 3 , which provides real-time, structured access to the search engine results page (SERP). If source is compute, we prompt the base QWEN3-8B model to perform analytical reasoning over previously retrieved results. This step handles operations such as numerical comparisons, arithmetic aggregation, and date calculations, ensuring the process relies solely on the provided context without introducing new external information. Each executed step yields a stored fact ˆx m , which is appended to the fact list and becomes available for later dependent requests. Factual Extraction from Web Evidence. Web search results are returned as raw SerpAPI JSON and often contain noisy content. For each web request, we apply a prompt-engineered extraction module that reads only the SerpAPI JSON and outputs a concise answer. The extractor is explicitly constrained not to rely on external knowledge beyond the provided JSON and to avoid guessing. When the retrieved evidence contradicts the request premise, it is instructed to state that directly. This step produces the factual value used by subsequent dependent queries and the final aggregator. Answer Aggregation. After all required items are processed, an aggregator synthesizes the final answer. The aggregator receives the original question q, the planner-provided reasoning steps R, and the full list of retrieved facts (query-answer pairs f m , ˆx m ). It is prompt-engineered to use only these retrieved facts to generate the final response, and to explicitly indicate the answer is unknown or cannot be determined if the available evidence is insufficient. This design ensures that factual claims in the final answer are grounded in the retrieved evidence rather than parametric memory. 3 https://serpapi.com/search-api 5 3EXPERIMENTS 3.1EXPERIMENTAL SETUP Training Setup. Fine-tuning is performed via supervised instruction tuning with label masking using an effective batch size of 16 via gradient accumulation, a learning rate of 5× 10 −5 with a cosine schedule, and training proceeds until validation loss converges on a single NVIDIA L40S GPU with 48GB of VRAM. To reduce training cost, we adopt parameter-efficient fine-tuning with QLoRA on top of a 4-bit quantized base model (Dettmers et al., 2023). Inference Configuration and Implementation Details. At inference time, the planner generates a structured JSON plan consisting of reasoning steps and atomic fact requests. All subsequent components, including retrieval, factual extraction, computation, JSON repair, and answer aggrega- tion, are prompt-engineered and use a frozen base QWEN3-8B model. Web retrieval is performed using the Google Search Engine Results API via SerpAPI, while analytical reasoning for computa- tion tasks is executed using prompted compute agents. All experiments are conducted on a single NVIDIA L40S GPU with 48 GB of VRAM. To ensure reproducibility and to isolate planning and retrieval behavior, all language model generations during inference are performed with determin- istic decoding. This setting prevents stochastic variation in planner outputs, tool queries, and final answers, allowing consistent evaluation across runs. Baselines. We compare the following systems: (i) Monolithic Base LLM (Reasoning Enabled). The base QWEN3-8B model is queried directly to answer each question, without access to external tools, with its native reasoning capability enabled. (i) Our Framework without Fine-Tuned Plan- ner (Prompted). The same base QWEN3-8B model is integrated into our modular framework via prompting to replace the student planner, enabling external search. The planner is prompted using the same system prompt as the teacher planner shown in Appendix A. We evaluate two planner prompt variants: one that allows internal reasoning and one that explicitly suppresses reasoning, to isolate the effect of reasoning under identical tool access. (i) Our Framework with Student Planner. A fine-tuned QWEN3-8B student model is trained to generate structured plans. The student is not trained on reasoning traces and therefore does not rely on internal reasoning. Evaluation Benchmarks. All experiments are conducted on the SEAL-0 split of SEALQA, a small but exceptionally challenging benchmark designed to evaluate search-augmented LLMs on fact-seeking questions. We use the SEAL-0 (v260105) release throughout our experiments. SEAL- 0 consists of 111 carefully curated questions for which even frontier models with browsing capabil- ities consistently fail. Each question is iteratively refined until multiple strong models achieve zero accuracy across repeated attempts, hence the “0” in the name (Pham et al., 2025). To illustrate the difficulty, example questions include: • How many of the top 50 most-followed Instagram accounts belong to individuals or entities based in the United States? • How many NBA players have scored 60 or more points in a regular season game since 2023? Metrics. We report answer accuracy and average latency per question. Answer accuracy is eval- uated based on whether the model produces the correct factual answer, following the same grading protocol and evaluation template used in the SEALQA benchmark to ensure direct comparability with prior results in Pham et al. (2025). Average latency is measured end-to-end per question and also broken down into planner, retrieval, and aggregation components where relevant. 3.2EXPERIMENTAL RESULTS Table 1 reports the performance of different system configurations on the SEAL-0 benchmark in terms of accuracy and average latency. The evaluated configurations differ in both how the base lan- guage model is used (monolithic versus tool-augmented) and how planning is performed (prompted versus fine-tuned). We analyze the results with respect to these metrics and relate our findings to previously reported results on SEAL-0 (Pham et al., 2025). Example question and outputs produced by each configuration are provided in Appendix C. 6 Table 1: Performance comparison of system configurations on the SEAL-0 benchmark. ConfigurationTypeAccuracy Avg latency per question QWEN3-8B Without search Reasoning 1.8%159.9 s Our framework (Prompted planner) With search No reasoning 6.3%41.1 s With search Reasoning 3.6%107.9 s Our framework (Student planner) With search No reasoning 10.8%27.8 s Accuracy. As reported in the SEALQA benchmark study, models such as GPT-4.1 and GPT- 4O consistently obtain 0% accuracy on this split despite access to built-in search. Consistent with these findings, the monolithic QWEN3-8B baseline achieves only 1.8% accuracy when answering questions directly using parametric reasoning. Qualitative examples reveal the cause of this fail- ure. Without external tools, the base model either hallucinates facts or becomes trapped in repet- itive reasoning loops until reaching the generation limit (Appendix C-1). Using our framework with prompted planning and external search improves accuracy to 6.3%, highlighting the benefit of tool-oriented execution (Appendix C-2). However, enabling internal reasoning within the prompted planner reduces accuracy to 3.6%, as the model often produces malformed or ambiguous plans and then becomes trapped in reasoning loops (Appendix C-3). Our proposed framework with the student planner achieves the highest accuracy among our eval- uated system configurations at 10.8%. This performance gain stems from the student’s ability to generate robust multi-step decompositions (Appendix C-4). Although absolute accuracy remains low due to the extreme difficulty of SEAL-0, our result compares favorably with previously re- ported performance in Pham et al. (2025). In that study, most closed-source and open-weight models achieved between 0% and 5.4% accuracy on this split, even when equipped with browsing capabili- ties. The only notably higher reported score (17.1%) is obtained by O3-MEDIUM using ChatGPT’s built-in search. Thus, our framework highlights the critical benefit of explicitly supervising planning structure beyond simple search augmentation. Latency. Latency varies substantially across configurations. The monolithic baseline is the slow- est (159.9 s), reflecting long internal reasoning traces. The prompted framework reduces latency when reasoning is disabled (41.1 s), but incurs significant overhead when reasoning is enabled (107.9 s), due to increased generation length, repeated planning attempts, and frequent invocation of the JSON repair module. The proposed student planner achieves the lowest latency (27.8 s), in- dicating more efficient inference. In addition to producing concise, well-scoped fact requests and avoiding unnecessary internal reasoning, the student planner outputs valid structured plans, elimi- nating the need for costly JSON repair steps and further reducing end-to-end execution time. 4RELATED WORK Teacher-Student Learning Frameworks. Teacher-student learning, often formalized as knowl- edge distillation (KD), was established as a paradigm for transferring knowledge from a large, high- capacity teacher model to a smaller student model (Hinton et al., 2015). Recent research has adapted the framework for specific capabilities such as factual consistency and hallucination mitigation. Gekhman et al. (2023) utilized a teacher model to label model-generated summaries for factual consistency, creating synthetic datasets to train a student. Unlike conventional KD, this approach focused on consistency rather than directly transferring answers or reasoning traces. Building on the idea of refining supervision, McDonald et al. (2024) demonstrated that distilling softened or structured supervision from a teacher can effectively reduce erroneous or overconfident outputs in student models, while maintaining computational efficiency. 7 More recently, Xia et al. (2025) proposed a framework where the teacher first produces candidate annotations reflecting uncertainty, and the student is trained to distill these candidates into a sin- gle prediction. Their findings suggest that distilling structured outputs improves robustness com- pared to using single annotations. Similarly addressing robustness, Nguyen et al. (2025) introduced smoothed KD, where the teacher provides soft token-level supervision to reduce overconfidence from hard labels. This approach improves output calibration and reduces hallucinations in summa- rization tasks while implicitly transferring factual content. While these approaches and other distillation-based frameworks (Tonmoy et al., 2024; Yang et al., 2024) primarily aim to transfer factual knowledge, supervision signals, or compress the teacher’s knowledge, our work adopts a fundamentally different strategy. Rather than distilling answers, labels, or probability distributions, we use the teacher exclusively during dataset construction to generate structured problem decompositions. The student is trained to reproduce reasoning structure and information-seeking behavior, with factual content explicitly excluded from training. Modular Planning and Tool-Using Frameworks. LLM-based agents that combine task planning with external tool usage have been widely studied to mitigate limitations such as outdated knowledge and hallucinations (Gao et al., 2023). To assess these capabilities, Ruan et al. (2023) proposed a structured framework for evaluating Task Planning and Tool Usage in both one-step and sequential workflows. Their analysis highlighted persistent weaknesses in agentic behaviors, such as failing to follow formats, over-utilizing single tools, and weak summarization, motivating the need for improved planning and query formulation. Subsequent work argued that addressing these weaknesses requires moving beyond monolithic mod- els. Kambhampati et al. (2024) emphasized that robust planning requires explicit structure, advocat- ing for interaction patterns where candidate solutions are generated and iteratively refined through verification loops. This shift is evident in recent systems, as Li (2025) reviewed architectures that formally separate planning, query generation, evidence retrieval, and verification. In specialized domains like mathematics, Luo et al. (2025) demonstrated that decomposing inference into action selection and tool execution substantially improves reliability. Similarly, Trinh et al. (2025) ap- plied multi-agent frameworks to fact-checking, relying on planners to generate search queries or sub-questions at inference time. Our work builds on these modular directions but targets a specific bottleneck they exposed: the planner’s ability to ask the right questions. While frameworks like Trinh et al. (2025) often relied on untrained or monolithic planners to guide information seeking, we train a dedicated planner to produce structured decompositions consisting of abstract reasoning steps and atomic fact requests. This design focuses explicitly on generating relevant and high-quality queries, strengthening the planning component that upstreams the entire tool-using pipeline. 5CONCLUSION This work presented a framework for reliable fact-seeking question answering that separates plan- ning from factual retrieval. By training a lightweight student planner on a teacher-guided dataset, we enable the generation of structured, searchable information requests without exposure to factual answers. Evaluations on the SEAL-0 benchmark demonstrate that supervised planning approach improves both accuracy and efficiency compared to monolithic reasoning models and prompt-based tool-augmented baselines. Despite the difficulty of the benchmark, the proposed framework achieves competitive performance relative to models previously reported on the SEAL-0 benchmark, while maintaining low inference latency through more efficient tool usage. These results demonstrate that explicitly learned planning structure, rather than internal reasoning or search access alone, is crit- ical for reliable search-augmented language models. However, the proposed framework remains bounded by the quality and availability of external search results, and retrieval failures can directly propagate to the final answer. Although the student planner reduces unnecessary tool calls, inference latency is still dominated by external search and extraction, which may limit scalability in high- throughput or real-time settings. In addition, while our evaluation focuses on SEAL-0 benchmark, further experiments on easier yet time-sensitive factual benchmarks would help better characterize the framework’s performance across a broader range of real-world scenarios. 8 REFERENCES Aisha Alansari and Hamzah Luqman. Large language models hallucination: A comprehensive survey. arXiv preprint arXiv:2510.06265, 2025. Lang Cao. Learn to refuse: Making large language models more controllable and reliable through knowledge scope limitation and refusal mechanism. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, p. 3628–3646, 2024. Yupeng Chang, Xu Wang, Jindong Wang, Yuan Wu, Linyi Yang, Kaijie Zhu, Hao Chen, Xiaoyuan Yi, Cunxiang Wang, Yidong Wang, et al. A survey on evaluation of large language models. ACM transactions on intelligent systems and technology, 15(3):1–45, 2024. Tim Dettmers, Artidoro Pagnoni, Ari Holtzman, and Luke Zettlemoyer. Qlora: Efficient finetuning of quantized llms, 2023. URL https://arxiv.org/abs/2305.14314. Yunfan Gao, Yun Xiong, Xinyu Gao, Kangxiang Jia, Jinliu Pan, Yuxi Bi, Yixin Dai, Jiawei Sun, Haofen Wang, and Haofen Wang. Retrieval-augmented generation for large language models: A survey. arXiv preprint arXiv:2312.10997, 2(1), 2023. Zorik Gekhman, Jonathan Herzig, Roee Aharoni, Chen Elkind, and Idan Szpektor. Trueteacher: Learning factual consistency evaluation with large language models.arXiv preprint arXiv:2305.11171, 2023. Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network, 2015. URL https://arxiv.org/abs/1503.02531. Lei Huang, Weijiang Yu, Weitao Ma, Weihong Zhong, Zhangyin Feng, Haotian Wang, Qianglong Chen, Weihua Peng, Xiaocheng Feng, Bing Qin, and Ting Liu. A survey on hallucination in large language models: Principles, taxonomy, challenges, and open questions. ACM Trans. Inf. Syst., 43(2), January 2025. ISSN 1046-8188. doi: 10.1145/3703155. URL https://doi.org/ 10.1145/3703155. Zhongzhen Huang, Kui Xue, Yongqi Fan, Linjie Mu, Ruoyu Liu, Tong Ruan, Shaoting Zhang, and Xiaofan Zhang. Tool calling: Enhancing medication consultation via retrieval-augmented large language models. arXiv preprint arXiv:2404.17897, 2024. Ziwei Ji, Nayeon Lee, Rita Frieske, Tiezheng Yu, Dan Su, Yan Xu, Etsuko Ishii, Ye Jin Bang, Andrea Madotto, and Pascale Fung. Survey of hallucination in natural language generation. ACM Computing Surveys, 55(12):1–38, March 2023. ISSN 1557-7341. doi: 10.1145/3571730. URL http://dx.doi.org/10.1145/3571730. Mingyu Jin, Weidi Luo, Sitao Cheng, Xinyi Wang, Wenyue Hua, Ruixiang Tang, William Yang Wang, and Yongfeng Zhang. Disentangling memory and reasoning ability in large language mod- els. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), p. 1681–1701, 2025. Adam Tauman Kalai, Ofir Nachum, Santosh S Vempala, and Edwin Zhang. Why language models hallucinate. arXiv preprint arXiv:2509.04664, 2025. Subbarao Kambhampati, Karthik Valmeekam, Lin Guan, Mudit Verma, Kaya Stechly, Siddhant Bhambri, Lucas Paul Saldyt, and Anil B Murthy. Position: LLMs can’t plan, but can help planning in LLM-modulo frameworks. In Forty-first International Conference on Machine Learning, 2024. URL https://openreview.net/forum?id=Th8JPEmH4z. Xinzhe Li. A review of prominent paradigms for LLM-based agents: Tool use, planning (includ- ing RAG), and feedback learning. In Owen Rambow, Leo Wanner, Marianna Apidianaki, Hend Al-Khalifa, Barbara Di Eugenio, and Steven Schockaert (eds.), Proceedings of the 31st Interna- tional Conference on Computational Linguistics, p. 9760–9779, Abu Dhabi, UAE, January 2025. Association for Computational Linguistics. URL https://aclanthology.org/2025. coling-main.652/. Lihui Liu and Kai Shu. Unifying knowledge in agentic llms: Concepts, methods, and recent ad- vancements. ACM SIGKDD Explorations Newsletter, 27(2):88–96, 2025. 9 Yang Liu, Yuanshun Yao, Jean-Francois Ton, Xiaoying Zhang, Ruocheng Guo, Hao Cheng, Yegor Klochkov, Muhammad Faaiz Taufiq, and Hang Li. Trustworthy llms: a survey and guideline for evaluating large language models’ alignment. arXiv preprint arXiv:2308.05374, 2023. Haipeng Luo, Huawen Feng, Qingfeng Sun, Can Xu, Kai Zheng, Yufei Wang, Tao Yang, Han Hu, Yansong Tang, and Di Wang. Agentmath: Empowering mathematical reasoning for large language models via tool-augmented agent. arXiv preprint arXiv:2512.20745, 2025. Daniel McDonald, Rachael Papadopoulos, and Leslie Benningfield. Reducing llm hallucination using knowledge distillation: A case study with mistral large and mmlu benchmark. Authorea Preprints, 2024. Hieu Nguyen, Zihao He, Shoumik Atul Gandre, Ujjwal Pasupulety, Sharanya Kumari Shivakumar, and Kristina Lerman. Smoothing out hallucinations: Mitigating llm hallucination with smoothed knowledge distillation, 2025. URL https://arxiv.org/abs/2502.11306. Thinh Pham, Nguyen Nguyen, Pratibha Zunjare, Weiyuan Chen, Yu-Min Tseng, and Tu Vu. Sealqa: Raising the bar for reasoning in search-augmented language models, 2025. URL https:// arxiv.org/abs/2506.01062. Qwen. Qwen3 technical report, 2025. URL https://arxiv.org/abs/2505.09388. Jingqing Ruan, Yihong Chen, Bin Zhang, Zhiwei Xu, Tianpeng Bao, Hangyu Mao, Ziyue Li, Xingyu Zeng, Rui Zhao, et al. Tptu: Task planning and tool usage of large language model-based ai agents. In NeurIPS 2023 Foundation Models for Decision Making Workshop, 2023. SMTI Tonmoy, SM Zaman, Vinija Jain, Anku Rani, Vipula Rawte, Aman Chadha, and Amitava Das. A comprehensive survey of hallucination mitigation techniques in large language models. arXiv preprint arXiv:2401.01313, 6, 2024. Tam Trinh, Manh Nguyen, and Truong-Son Hy. Towards robust fact-checking: A multi-agent system with advanced evidence retrieval, 2025. URL https://arxiv.org/abs/2506.17878. Tu Vu, Mohit Iyyer, Xuezhi Wang, Noah Constant, Jerry Wei, Jason Wei, Chris Tar, Yun-Hsuan Sung, Denny Zhou, Quoc Le, and Thang Luong. Freshllms: Refreshing large language models with search engine augmentation, 2023. URL https://arxiv.org/abs/2310.03214. Dean Wampler, Dave Nielson, and Alireza Seddighi. Engineering the rag stack: A comprehensive review of the architecture and trust frameworks for retrieval-augmented generation systems. arXiv preprint arXiv:2601.05264, 2025. Cunxiang Wang, Xiaoze Liu, Yuanhao Yue, Xiangru Tang, Tianhang Zhang, Cheng Jiayang, Yunzhi Yao, Wenyang Gao, Xuming Hu, Zehan Qi, et al. Survey on factuality in large language models: Knowledge, retrieval and domain-specificity. arXiv preprint arXiv:2310.07521, 2023. Mingxuan Xia, Haobo Wang, Yixuan Li, Zewei Yu, Jindong Wang, Junbo Zhao, and Runze Wu. Prompt candidates, then distill: A teacher-student framework for llm-driven data annotation, 2025. URL https://arxiv.org/abs/2506.03857. Ling Yang, Zhaochen Yu, Tianjun Zhang, Minkai Xu, Joseph E Gonzalez, Bin Cui, and Shuicheng Yan. Supercorrect: Advancing small llm reasoning with thought template distillation and self- correction. arXiv preprint arXiv:2410.09008, 2024. Zhilin Yang, Peng Qi, Saizheng Zhang, Yoshua Bengio, William W. Cohen, Ruslan Salakhutdinov, and Christopher D. Manning. Hotpotqa: A dataset for diverse, explainable multi-hop question answering, 2018. URL https://arxiv.org/abs/1809.09600. Yutao Zhu, Huaying Yuan, Shuting Wang, Jiongnan Liu, Wenhan Liu, Chenlong Deng, Haonan Chen, Zheng Liu, Zhicheng Dou, and Ji-Rong Wen. Large language models for information retrieval: A survey. ACM Transactions on Information Systems, 44(1):1–54, 2025. 10 ATEACHER SYSTEM PROMPT FOR PLANNER SUPERVISION Teacher System Prompt (Planner Supervision) You are a decomposition-only reasoning planner. Your role is to break down every user question into: • short, realistic, atomic factual queries that a standard web search engine or a simple compute tool could execute directly, and • abstract reasoning steps that describe how to combine only those retrieved facts. You must never answer the question directly. Critical Design Principles (Most Important) A. Realistic Search Principle Each factual query must be something that a real user could reasonably type into a web search engine and expect a direct factual answer from the top results. B. Minimality Principle If a question can be answered by one well-phrased factual query, you must not decompose it further. C. No-Conceptual-Reasoning Principle You must not ask definitional, philosophical, or yes/no questions. Conceptual reasoning must be avoided entirely; only concrete facts may be retrieved. When to Decompose You must decompose only when the question requires: • comparison of two or more factual values • date arithmetic or age calculation • counting or aggregation • combining facts from multiple sources • resolving relative time expressions (e.g., today, latest ) You must not decompose when: • a single factual entity or fact can be directly retrieved • decomposition would introduce definitions or logic shortcuts Your Task • Analyze the user question. • Identify the minimum set of external facts required. • Express each required fact as a short, concrete, independently executable query. • Avoid unnecessary intermediate reasoning or conceptual checks. Output Format (Strict) You must output exactly one JSON object with the following structure: "required_information": [ "query": "<atomic factual query>", "source": "web or compute", "dependent": false , "query": "<atomic query involving <RESULT_1>>", "source": "web or compute", "dependent": true ], "reasoning_steps": [ "<abstract reasoning step>", "<abstract reasoning step>" ] 11 Rules for requiredinformation 1. Atomicity (Mandatory) • Each query must retrieve or compute exactly one factual result. • Do not request lists, tables, or enumerations. • Do not include reasoning or comparisons inside queries. • Do not combine multiple facts in one query. 2. Web Queries • Use only for direct real-world factual lookups. • Queries must be short, concrete, and directly searchable. • Queries must not be yes/no questions or request explanations. 3. Compute Queries • Use only for deterministic operations such as comparison, counting, or date arith- metic. • Compute queries must depend on previously retrieved results. • Inputs must be referenced via placeholders such as <RESULT 1>. 4. Dependent Queries • If a query is dependent, it must explicitly reference prior results using indexed place- holders. • The query must become executable after placeholder substitution. 5. Time Handling • Relative expressions such as today or latest require first retrieving the current date. • The current date must never be assumed. 6. Plan Completeness • The required information must be sufficient to resolve the user question. • Requested entities or values must be explicitly retrieved if they exist. 7. Invalid Premises • If a presupposed entity may not exist, existence must be verified first. • If it does not exist, the reasoning steps must conclude non-existence. Rules for reasoning steps • Use only facts retrieved in required information. • Describe logical operations abstractly. • Do not include factual values or final answers. Global Rules • Output only valid JSON. • No explanations, notes, or markdown. • No trailing commas. 12 BINFERENCE-TIME SYSTEM PROMPTS Extractor System Prompt You are a precise extraction agent. You will be given: 1. A factual sub-question. 2. Raw web search results returned by an external search engine in JSON format. Your task: - Use ONLY the information contained in the provided JSON. - If the JSON clearly contains the answer, extract it verbatim. - If the JSON indicates that the premise of the sub-question is false, state this explicitly. Rules: - Do NOT use any external knowledge beyond the given JSON. - Do NOT guess, infer, or invent missing information. - Output ONLY the final extracted answer as plain text. Compute System Prompt You are a deterministic computation agent. You will be given: 1. A compute-style instruction that may reference previously retrieved results. Your task: - Perform only logical, mathematical, or date-based operations explicitly requested. - Use ONLY the provided inputs. - Do NOT retrieve new information or assume external facts. Output: - Return ONLY the final computed value or a concise phrase representing the result. Aggregator System Prompt You are a careful and faithful answer synthesis agent. You will be given: 1. The original user question. 2. A sequence of planner-generated reasoning steps. 3. A list of retrieved atomic facts, each paired with its originating query. Your task: - Answer the original question using ONLY the provided facts. - Do NOT introduce new information or rely on prior knowledge. - If the facts are insufficient to answer the question, explicitly state what information is missing. Output: - Produce a clear, concise natural-language answer grounded in the retrieved facts. JSON Repair System Prompt You are a JSON repair assistant. You will be given raw text output that is intended to represent a single JSON object with the following keys: - required information - reasoningsteps Your task: - Remove any internal reasoning traces or markup if present. - Repair syntax errors so that the output becomes valid JSON. - Ensure the output contains exactly one JSON object with the required keys. Rules: - Output ONLY valid JSON. - Do NOT add explanations, comments, or formatting. 13 CEXAMPLE QUESTION AND OUTPUTS ACROSS CONFIGURATIONS Test Question (Tested on Jan 7, 2026) Q: What is the current age of the youngest grandmaster of chess? Expected Answer: 16 years old 1. QWEN3-8B (BASE MODEL) Internal Reasoning Trace (Truncated) <think> Okay, so I need to find out the current age of the youngest grandmaster in chess... I remember that there have been some young players... Sergey Karjakin. Wait, wasn’t he a child prodigy? ... Another name is Hikaru Nakamura... Wait, there was a player named Magnus Carlsen... ...Wait, let me check. Magnus Carlsen was born in 1990... Wait, no, I think Karjakin was born in 1990... So Karjakin is younger. But then there’s another player... Abhimanyu Khatri... Wait, but I’m not sure if that’s accurate... ...So, let’s list the known youngest grandmasters: 1.Magnus Carlsen...2.Sergey Karjakin... 6. Others... Wait, but Karjakin was born in 1990... Wait, this is confusing. ...Alternatively, maybe the youngest grandmaster is the one who became a grandmas- ter at the earliest age...But I need to check if there are any players who became grandmasters at the same age as Karjakin but were born later... Wait, but the youngest grandmaster in terms of current age would be the one who became a grandmaster at... (The full output exceeds several hundred lines and is omitted here for brevity.) Total Latency: 255.2 s (Generation Limit Reached) Final Answer: (None produced) 2. OUR FRAMEWORK (PROMPTED PLANNER - NO REASONING) Prompted Planner (No Reasoning) Output Reasoning Steps: 1. Identify the youngest chess grandmaster ever. 2. Retrieve the date of birth of the identified grandmaster. 3. Retrieve today’s date. 4. Calculate the age in full years between the two dates. Plan Generated: 1. SEARCH: ”youngest chess grandmaster ever” 2. SEARCH: ”date of birth of<RESULT 1>” 3. SEARCH: ”today’s date” 4. COMPUTE: ”age in full years between<RESULT2> and<RESULT3>” Execution Trace: • Fact 1 (Web): ”Abhimanyu Mishra” • Fact 2 (Web): ”February 5, 2009” 14 • Fact 3 (Web): ”January 7, 2026” • Fact 4 (Compute): ”16 years old” Latency Breakdown: Planning (11.6s) + Execution (21.3s) + Aggregation (1.8s) = 34.6s Final Answer: The current age of the youngest grandmaster of chess, Abhimanyu Mishra, is 16 years old. (Correct) 3. OUR FRAMEWORK (PROMPTED PLANNER - REASONING) Prompted Planner (Reasoning) Output Reasoning Steps: 1. Retrieve birth date of the youngest chess grandmaster. 2. Retrieve current date to calculate age. 3. Compute age difference between current date and birth date. Plan Generated: 1. SEARCH: ”youngest chess grandmaster’s date of birth” 2. SEARCH: ”today’s date” 3. COMPUTE: ”age in full years between<RESULT 1> and<RESULT2>” Execution Trace: • Fact 1 (Web): ”29 May 2006” (Incorrect Entity Fetched) • Fact 2 (Web): ”January 7, 2026” • Fact 3 (Compute): ”19 years old” Latency Breakdown: Planning (12.8s) + Execution (19.4s) + Aggregation (0.9s) = 33.1s Final Answer: The current age of the youngest grandmaster of chess is 19 years old. (Incorrect) 4. OUR FRAMEWORK (STUDENT PLANNER) Student Planner Output Reasoning Steps: 1. Use the retrieved name of the youngest current chess grandmaster. 2. Retrieve the birth date of that individual. 3. Retrieve today’s date. 4. Compute the age in full years as of today’s date for the birth date retrieved. Plan Generated: 1. SEARCH: ”youngest grandmaster of chess” 2. SEARCH: ”date of birth of<RESULT1>” 3. SEARCH: ”today’s date” 4. COMPUTE: ”age in full years on<RESULT3> for someone born on<RESULT2>” 15 Execution Trace: • Fact 1 (Web): ”Abhimanyu Mishra” • Fact 2 (Web): ”February 5, 2009” • Fact 3 (Web): ”Wednesday, January 7, 2026” • Fact 4 (Compute): ”16” Latency Breakdown: Planning (8.9s) + Execution (20.6s) + Aggregation (1.3s) = 30.8s Final Answer: The current age of the youngest grandmaster of chess, Abhimanyu Mishra, is 16 years old. (Correct) 16