Apply to my task
arXiv:2507.17015 ★ 71 Jul 22, 2025

Forced Verification: the LLM Checks the Facts Before It Answers

Key result

LLMs lie with confidence because they rely on internal "memories" rather than real data. The forced verification method lets you make the model gather and lock in the facts first, and only then build its answer on them. The trick: split the task into two steps, 'find out' and 'report back', and the model stops being a know-it-all fantasist. The study showed that an LLM judge armed with search and a code interpreter grades other answers dramatically more accurately than one that judges "from memory".

Study 2507.17015

2 Why This Example Works.

This example runs on the same fundamental principle as the study, adapted for a task that demands accurate calculations, not just accurate facts.

  • Grounding in exact data: LLMs often slip up on math and mix up the calorie counts of foods. The prompt makes the model first "look up" and lock in the exact numbers in a table. That creates a foundation of verified information.
  • Simulating a "tool" (calculator/database): Step 1 mimics using an external tool, a calorie calculator. The model can't just pull numbers out of thin air.
  • Keeping the math separate from the creativity: The prompt cleanly splits the task into "find the numbers" and "build the menu". The instruction "Using the exact data you just found" forces the model to calculate from the locked-in values, which sharply improves the accuracy of the final plan and keeps it from fudging the numbers to fit the desired result. It's the equivalent of the agent in the study using the code interpreter's output to make its decision.

Key Aspects of the Study:

The study looks at whether the quality of LLM answer evaluation (when one model grades another) can be improved by giving the judge external tools: web search for fact-checking and a code interpreter for checking math and programs. The results show this approach significantly increases evaluation accuracy, especially on tasks that require factual accuracy and correctly executed code.

Key Result: External verification through tools is a powerful way to ground an LLM, making it rely on real data instead of its internal "knowledge", which drastically cuts errors and hallucinations.


The Core Idea of the Method:

The heart of the method, which you can adapt for everyday prompting, is forcing the answer-generation process into two stages: gathering/verifying information and synthesizing the answer.

Instead of just asking a question and hoping for the best, you use your prompt to make the LLM simulate the agent approach from the study:

  1. Assess the task and pick a "tool" (in your head): You recognize that your request requires exact facts (prices, dates, specs, scientific data) or calculations.
  2. Instruct it to "use the tool" (in the prompt): You explicitly order the model to perform a verification step first. Use phrasing that mimics external tool use:
    • "First, run a web search on..."
    • "Before answering, find up-to-date data on..."
    • "Write and mentally execute Python code to calculate..."
  3. Instruct it to make the "final decision" (in the prompt): You order the model to build its final answer based solely on the results of the previous step.
    • "Based on the facts you found, and only those, answer my question."
    • "Use the result of the calculation to form your conclusion."

This technique turns the LLM from a "know-it-all fantasist" into a "diligent research assistant". You're not asking the model to know; you're asking it to find out and report back. That dramatically increases the reliability and trustworthiness of the answer.


Practical Applicability Analysis:

  • Direct applicability: You can start using this method right away by building two-step logic into your prompts. For example, instead of "Which smartphone is better for photos?" you can write: "1. Find comparative camera reviews of the iPhone 15 Pro and Google Pixel 8 Pro from the last 3 months. 2. Based on those reviews, conclude which phone is better for photos and explain why, quoting the key arguments from the reviews."

  • Conceptual value: The main idea the study gets across is don't trust, verify (and make the LLM verify). It gives you a critically important understanding: LLMs are prone to fabrication by nature, and the best way to fight that is to ground their answers in external, verifiable data sources. That shifts your prompting from "asking" to "setting a task with mandatory verification".

  • Adaptation potential: The method is universal. You can adapt it to any task where accuracy matters:

    • Travel planning: "First check the current opening hours and ticket prices for the Louvre and the Eiffel Tower, then put together a plan for the day."
    • Medical information (with caution!): "Find information about the side effects of [drug] in authoritative medical sources (for example, Mayo Clinic, WebMD), then summarize them."
    • Essay writing: "Gather 3-5 key facts about the Industrial Revolution from academic sources, then use them to write the introduction to an essay."

The adaptation mechanism is simple: figure out which information in the request is critical and add a preliminary step to the prompt for finding and verifying it.


1 A Practical Example:

You are an experienced marketing analyst. Your job is to help me choose a CRM system for a small company (10 people) in the online education space.

**Task methodology (follow strictly):**

1.  **Step 1: Gather and verify data.**
    *   Simulate a web search to find 3 popular CRM systems that are a good fit for small businesses and integrate with education platforms (for example, Kajabi, Teachable).
    *   For each of the three systems, find current information on the following points:
        *   Approximate plan price for a team of 10 (per month).
        *   Key features useful for an online school (for example, funnel automation, messaging app integrations, sales analytics).
        *   One main pro and one main con according to user reviews from the past year.

2.  **Step 2: Synthesis and analysis.**
    *   Present the information gathered in Step 1 as a comparison table.
    *   Based **only on the data in this table**, write a short conclusion and give your recommendation on which system is the best choice and why.

**Answer format:**
First present the table, then your conclusion and recommendation.

2 Why It Works:

This prompt works because it directly implements the principles from the study, making the LLM act like an agent with external tools:

  • Forced verification: The prompt doesn't let the model "make up" an answer right away. It forces it through a mandatory data gathering and verification stage ("simulate a web search"). That grounds the answer in fresh, relevant information instead of stale training data.
  • Task decomposition: The complex task "recommend a CRM" is broken into simple, checkable subtasks: find, extract specific facts (price, features), compare, recommend. That lowers the model's cognitive load and reduces the chance of error.
  • Control over the source of the answer: The instruction "Based only on the data in this table" forces the LLM to build its final conclusion not on its internal "impressions" but on information it just "gathered". That significantly boosts the trustworthiness and objectivity of the recommendation.

1 Another Practical Example

You are an experienced nutritionist and fitness coach. I need a 1-day meal plan for weight loss (target: 1800 kcal). I want the plan to include salmon and avocado.

**Your methodology (mandatory):**

1.  **Step 1: Fact-checking and calculations.**
    *   Using public nutrition databases (simulate a search), find the exact calories and protein, fat and carbs (macros) per 100 g for the following foods:
        *   Salmon (fillet, baked)
        *   Avocado
        *   Brown rice (cooked)
        *   Chicken breast (boiled)
        *   Olive oil
    *   Present this data as a small reference table.

2.  **Step 2: Build the plan.**
    *   Using **the exact calorie data you just found**, design a menu for the day (breakfast, lunch, dinner) with the weight of each food.
    *   The plan's total calories should be as close as possible to 1800 kcal.
    *   Be sure to include salmon and avocado.
    *   For each meal and for the day as a whole, calculate total calories and macros.

**Output format:**
First the calorie reference table, then the detailed meal plan by meal.

Usefulness Score: 85

02

Main Evaluation Criteria

  • A. Relevance to prompting techniques: High. Although the study doesn't give users ready-made phrasing, it reveals a fundamental principle: to make answers more reliable, you have to make the LLM perform external verification (fact-checking, code execution). That directly shapes how you should build complex prompts.
  • B. Better conversational answers: High. Applying the study's principles (simulating fact-checking or code execution in the prompt) leads directly to more accurate, trustworthy and factually correct answers, especially in complex domains.
  • C. Direct practical applicability: Medium. You can't directly use the agent framework with tools described in the paper. However, you can adapt and simulate the approach in your prompts, making the model verify information first and answer second.
  • D. Conceptual value: Very high. The study brilliantly illustrates a key limitation of LLMs: they're unreliable with facts, math and code without an external "anchor". It gives you the right mental model: an LLM isn't a knowledge base but an information processor that needs to be fed verified data or made to go find it.
  • E. New useful practice (clustering): The work falls into several key clusters at once:
    • Cluster 1 (Phrasing techniques): Shows the value of task decomposition (verify, then answer).
    • Cluster 2 (Behavioral patterns): Shows that without external verification LLMs are prone to errors and bias (for example, they favor code that looks stylistically like their own, even when it's wrong).
    • Cluster 6 (Context and memory): Essentially proposes an advanced form of RAG (Retrieval-Augmented Generation), where "retrieval" means active search or code execution.
    • Cluster 7 (Reliability and stability): This is the core of the study. The whole method is aimed at reducing hallucinations and increasing factual accuracy.
  • Practicality checklist (+15 points): Yes, the work shows how to structure complex requests, reveals non-obvious LLM behavior and offers ways to improve answer accuracy.
03

2 Numeric Usefulness Score

The score of 85 reflects the study's enormous conceptual value for any advanced LLM user. It doesn't hand you ready-made "magic spells", but it equips you with a fundamental understanding of why and how to build reliable prompts for tasks that demand accuracy.

Arguments for the score: * A fundamental principle: "Verify before you answer" is one of the most powerful prompt-engineering techniques for fighting hallucinations. The study gives it a scientific basis. * Setting the right expectations: Once you understand this paper, you'll stop blindly trusting LLM answers and learn to phrase requests that minimize the risk of misinformation. * Direct adaptation: The principle adapts easily into prompts via instructions like "First find the facts online, then answer based on them".

Counterarguments (why the score could be lower): * A high barrier to entry: The paper is written in dense academic language and focuses on a specific task (LLM-as-a-Judge), not on helping the everyday user. To get value from it, you have to "translate" the findings into the language of practical prompting. * No ready-made solutions: You don't get copy-paste templates. You have to digest the principle yourself and build it into your requests.

Counterarguments (why the score could be higher): * Strategic value: Understanding this principle matters more than knowing a dozen small tricks. It's the shift from "guessing" a working prompt to deliberately designing reliable requests. For someone aiming to use LLMs professionally, the value is close to 100.


Research digest

Key result

LLMs lie with confidence because they rely on internal "memories" rather than real data. The forced verification method lets you make the model gather and lock in the facts first, and only then build its answer on them. The trick: split the task into two steps, 'find out' and 'report back', and the model stops being a know-it-all fantasist. The study showed that an LLM judge armed with search and a code interpreter grades other answers dramatically more accurately than one that judges "from memory".

Principle

The standard approach: ask, get an answer. The problem is that the model answers from what it "remembers", and its memory is leaky and out of date. This method works differently. Split the request into two explicit stages: first 'find and lock in the data', then 'answer based only on that data'. It works like separating the roles of detective and judge. The detective collects evidence. The judge rules only on the evidence, not on rumors and guesses. When one model tries to do both at once, it bends the facts to fit the conclusion. When the stages are separated, there's nothing to bend.

Why it works

A model isn't a search engine. It doesn't store facts; it stores patterns. When you ask "how many calories are in an avocado", it doesn't check a database; it recalls that avocado has appeared next to a number around 150-160. It might guess right. It might not. Forced verification removes the 'guess the number' step: the model first locks the data into a table or list, and only then works with it as input for calculations. Its own "memories" stop influencing the conclusion; instead there are concrete numbers the model just "found". That's exactly what gave the LLM judge its accuracy jump in the study: the external tool took away the option of judging on gut feeling.

When to apply

Any task where accuracy matters, not just smooth prose. Especially: - Planning with numbers (budget, calories, schedule): one bad data point breaks the whole plan - Comparing products, services, tools: otherwise the model will "remember" specs from training that are long outdated - Writing code with calculations: a two-step prompt forces it to 'run' the algorithm first, then describe the result - Researching a topic: "find the arguments, then draw a conclusion" instead of "give me the conclusion" directly NOT a fit for purely creative tasks like writing poems, brainstorming or idea generation. Fact-checking isn't needed there and only gets in the way.

Mini recipe

1. Identify what could be wrong: does your request contain numbers, facts, specs, prices, dates? If so, they're candidates for verification. 2. Write Step 1 in the prompt: explicitly ask the model to find and lock in that data first. Use phrasing like: Step 1: find up-to-date data on... or Simulate a search and present the result in a table. 3. Write Step 2 in the prompt: forbid using anything except the data from step one. Literally: Using only the data in the table above, draw a conclusion / build a plan / make a recommendation. The phrase "only this data" is the key. 4. Set the output format: ask it to show the data table first, then the final answer. That way you can check what the model based its conclusion on, and catch the error if it still pulled something "from memory".

Examples

[BAD]: `Which CRM is best for a small 10-person online school?` [GOOD]: `You are a marketing analyst. Work strictly in two steps. Step 1. Find 3 CRM systems for small businesses that integrate with education platforms. For each, list: plan price for 10 people per month, key features for an online school, one pro and one con from reviews in the past year. Present this as a table. Step 2. Using only the data in the table above, with no additional information, write a recommendation and explain your choice.`

In plain words

Here's the deal: when you ask a model to evaluate or choose something, it often starts hallucinating or slacking off, giving you vague phrases instead of facts. The study shows that to make an LLM stop talking nonsense, you have to force it into external validation mode. That means the model doesn't just pull an answer out of its head; it first goes out into the world (or simulates that trip), collects hard facts and only then delivers a verdict. In effect, we turn the "judge" from an overconfident amateur into a meticulous detective with real evidence on the desk.

It's like hiring a site inspector to sign off on a contractor's work. A regular LLM just glances at the wall and says "Looks straight enough". But hand it a level and a laser measure and make it log the measurements in a table, and it gets a lot harder to fib. That's the trick: when the model has a structure with concrete numbers it just found itself right in front of it, its final decision gets dramatically more sensible. It literally slaps its own hand before inventing features or prices that don't exist.

In the CRM-picking prompt, this works through a two-stage check. First we make the model do the "grunt work": find three specific systems, pull their pricing and real reviews. That's the data gathering and verification step. The key point: we forbid it from drawing conclusions right away. First comes the table, a dry summary of facts. Only once the facts are locked in does the model move on to analysis. That rules out the scenario where the model invents an answer first and then bends reality to fit it, the classic trap for lazy models.

The example is about picking software, but this method is a universal cure for nonsense. It works everywhere: from reviewing legal contracts to analyzing medical symptoms or choosing a hotel. The key is to make the LLM use external tools (search, a calculator, a database) and lock in the result in an intermediate step. If you don't give the model solid data to lean on, you get an "opinion" that's worth nothing. With validation, you get expertise on steroids.

Bottom line: stop taking the LLM at its word and make it gather evidence first. The study confirms that a "gather data, build a table, draw a conclusion" structure is head and shoulders above a regular chat. If you want quality results, turn your prompt into a verification algorithm where the model does the legwork first and only then switches on its brain. Otherwise you risk getting advice that sounds great but is actually pure BS and fantasy.

AI lab assistant

Apply this study to your task

Describe what you're working on. AI takes the method and the measured results from this paper and adapts them to your case, or writes a ready prompt built on them.

Based on Forced Verification: the LLM Checks the Facts Before It Answers arXiv:2507.17015

Sign in to apply this study New accounts get 50 free credits.

Get the week’s best papers by email

One email on Sundays with the highest-rated new techniques. Unsubscribe with one click.