Apply to my task
arXiv:2507.03726 ★ 79 Jul 4, 2025

Three-step self-analysis: the model fixes your question before answering it

Key result

An LLM answers what you wrote, not what you meant. That's the root of half of all junk answers. The three-step self-analysis method gets you precise, personalized answers even from vague requests: the model finds the holes in your question and patches them before it starts answering. The trick: instead of spending hours polishing the prompt yourself, you delegate that work to the model, which plays critic, then editor, and only then executor. The "Analyze → Rephrase → Answer" structure turns a fuzzy request into a precise assignment before a single word of the answer is generated.

Agent-Based Detection and Resolution of Incompleteness and Ambiguity in Interactions withLargeLanguageModels

Key Aspects of the Research:

The paper proposes a system of several LLM agents that works as a "filter" in front of the main chatbot. The system first checks the user's question for incompleteness or ambiguity, then tries to fix it automatically, and only after that passes a clear, unambiguous question on for answer generation. This approach noticeably raises answer accuracy and cuts down on how often the user has to clarify things.

Key Result: Pre-analyzing and fixing fuzzy questions with a specialized agent before they reach the main LLM is an effective way to improve the quality and reliability of answers.


The Core Idea of the Method, Explained:

For an everyday user, the essence of the method is this: don't just ask the LLM a question, make it run a three-stage process inside a single prompt. Instead of hoping the model will guess what you want, you give it clear instructions for self-analysis.

The method looks like this: 1. Step 1: Classification (Analysis). You ask the LLM to first play the critic and analyze your own question. Is it complete? Is anything ambiguous? What data might be missing for an accurate answer? 2. Step 2: Resolution (Fixing). If problems turned up in step one, you tell the LLM to rewrite the original question so it becomes as clear and complete as possible. The model can offer several versions or ask clarifying questions. 3. Step 3: Answer. Only after the question has passed this "internal review" and been improved do you tell the model to answer the new, corrected version of the question.

In effect, you turn the LLM from a simple "answer machine" into a "thinking partner" that first helps you phrase the question properly and only then answers it. This drastically lowers the risk of getting generic, irrelevant or "hallucinated" answers to complex or poorly defined requests.


Practical Applicability Analysis:

  • Direct applicability: A user can apply this method right away by structuring the prompt as step-by-step instructions. Instead of "Write me a travel plan," you write a prompt that includes the steps "1. Analyze my request for gaps. 2. Ask clarifying questions. 3. Build the plan based on my answers." This carries the paper's logic straight into the chat.

  • Conceptual value: The main insight: an LLM can not only answer but also analyze the quality of the question itself, if you ask it to. This changes how you approach prompting: instead of polishing the prompt to perfection yourself, you can delegate part of that work to the model, using its own "intelligence" for self-correction.

  • Adaptation potential: The method adapts easily to any complex task where the original request may be missing details: business planning, writing a technical spec, building a marketing strategy, creating a personalized learning plan. The adaptation mechanism is simple: wrap any complex request in the three-step structure "Analyze -> Clarify/Fix -> Execute."


A Practical Example:

You are an experienced marketing strategist. Your task is to help me build a content plan.

**Context:**
I own a small coffee shop called "Morning Aroma" in a residential neighborhood. We serve classic coffee, signature drinks and fresh pastries. Our goal is to attract more regular customers from among local residents.

**Task:**
Before generating the content plan, complete the following steps:

**Step 1: Analyze my request for incompleteness and ambiguity.**
Carefully study my request and the context. Identify which critical information is missing to create a truly effective content plan. List the missing points as questions for me.

**Step 2: Reformulate the task.**
Based on the gaps you found, write an ideal, complete and unambiguous request for a content plan, as if a professional marketer were writing it.

**Step 3: Create the content plan.**
Answer the request you reformulated in Step 2. Create a detailed one-week social media content plan (specify which platforms) that will help me reach my goal. The plan should include post topics, formats (photo, video, stories) and calls to action.

Why This Works:

This prompt works because it stops the LLM from charging at the task head-on and makes it simulate the agent-based approach proposed in the paper:

  1. Imitating the "Classifier Agent" (Step 1): The instruction "Analyze my request" switches the model into critical-thinking mode. It stops being a mere executor and starts hunting for weak spots in the task (for example, "no promotion budget given," "target audience unclear: families with kids or freelancers?", "which social networks are already in use?").
  2. Imitating the "Resolver Agent" (Step 2): The command "Reformulate the task" uses the LLM's creative and structuring abilities to improve the original prompt. This ensures the final answer rests on a fuller, higher-quality problem statement.
  3. Answering a high-quality request (Step 3): The model generates the content plan while already "keeping in mind" all the potential problems and missing information. The answer isn't generic ("post photos of coffee") but specific and strategically sound, because it's based on the improved version of the request.

Another Practical Example

You are an experienced HR consultant and career coach. Help me prepare for a job interview.

**Context:**
I'm applying for a "Product Manager" role at a tech company that builds a language-learning mobile app. I have 3 years of experience in an adjacent field (marketing), but this is my first attempt to move into product management.

**Task:**
Follow this strict sequence of actions:

**1. Analyze the request for ambiguity:**
Identify which aspects of my situation aren't covered in the request. What details about me, the company or the role do you need to give the most useful and personalized advice? Write these questions out.

**2. Clarify and expand the request:**
Imagine I've answered your questions. Write a new, expanded request that includes hypothetical but realistic answers (for example, "I have strong analytical skills but I'm weaker at technical project management; the company emphasizes gamification," etc.).

**3. Answer the clarified request:**
Based on the improved request from step 2, give me a detailed interview prep plan that includes:
- The 5 most likely questions I'll be asked, given my background.
- Recommendations on how best to present my marketing experience as an advantage for a product role.
- A list of topics I need to research about the company and its product.

Explaining the Mechanism: Why This Example Works.

This prompt is effective because it applies the same "analyze -> fix -> answer" logic to a different, very common task.

  1. Preventing generic advice (Step 1): Instead of producing a standard list of tips for any interview, the model is forced to stop and think first: "What makes this situation unique?" It identifies the key gaps: the candidate's strengths and weaknesses, the company's specifics, what the role emphasizes.
  2. Building a realistic scenario (Step 2): By making the model fill in the missing details itself, we get a far more specific and fleshed-out scenario. This skips the long back-and-forth of clarifications and goes straight to solving a realistic problem.
  3. A targeted, personalized answer (Step 3): The final answer isn't "for product managers in general" but "for someone moving from marketing into product management at an EdTech company focused on gamification." That's an order of magnitude more useful than any generic advice, and all of it happens within a single, well-structured prompt.

Usefulness Score: 85

02

Main Evaluation Criteria

  • Preliminary filter: The research is entirely focused on processing text requests and improving conversational interaction. It doesn't deal with visual or audio content. Evaluation continues.
  • A. Relevance to prompting techniques: High. Although the paper describes an automated architecture, its core idea (classify -> fix -> answer) translates directly into a powerful prompt-structuring technique.
  • B. Improving the quality of conversational answers: High. This is the main goal and the confirmed result of the research: higher answer accuracy through pre-processing of unclear requests.
  • C. Direct practical applicability: Low if taken literally (a user can't build a "transducer agent"). However, very high if you treat it as adapting the principle into a prompt. The user can make the LLM simulate this process.
  • D. Conceptual value: Very high. The paper gives users a new "mental model" for handling complex requests. It explains why LLMs get fuzzy questions wrong and how to fix that by making the model first "think about the question" and then "answer."
  • E. New useful practice: The work falls into three clusters at once:
    • Cluster 1 (Phrasing techniques): Offers a meta-algorithm to include in a prompt.
    • Cluster 3 (Structure optimization): Shows the value of multi-step, structured instructions.
    • Cluster 7 (Reliability and stability): The method directly targets errors caused by incomplete and ambiguous requests.
  • Practicality checklist (+15 points): Yes, the work provides a basis for building prompt constructions, shows how to structure complex requests, reveals non-obvious behavior (the LLM's ability to self-analyze a question when instructed) and offers a way to improve accuracy. +15 points to the base score.
03

Numerical Usefulness Score

Arguments for a score of 85: The research offers a fundamentally new and powerful approach to writing complex prompts. The idea of making the LLM first analyze and rephrase the question itself before answering is a breakthrough concept for the everyday user. It directly tackles one of the biggest LLM problems: confident but irrelevant answers to fuzzy requests. Although a user can't build the "agent architecture" described in the paper, they can easily simulate it with a structured prompt, which gives a huge boost in answer quality. This is conceptual knowledge with a direct practical payoff.

Counterarguments: * Why could the score be lower? The paper is written for engineers and describes a software architecture (agents, transducers), not a ready-made prompting technique. To get value out of it, the user has to be resourceful and "translate" the idea from the language of system design into the language of prompt instructions. It's not a copy-and-paste recipe, which reduces direct applicability. * Why could the score be higher? Once a user understands and masters this principle, the quality of their interaction with LLMs jumps to a new level. It's not just a "trick" but a full methodology for solving complex, multi-part tasks. For advanced users its significance is comparable to Chain-of-Thought, so it could arguably claim 90+ points.


Research digest

Key result

An LLM answers what you wrote, not what you meant. That's the root of half of all junk answers. The three-step self-analysis method gets you precise, personalized answers even from vague requests: the model finds the holes in your question and patches them before it starts answering. The trick: instead of spending hours polishing the prompt yourself, you delegate that work to the model, which plays critic, then editor, and only then executor. The "Analyze → Rephrase → Answer" structure turns a fuzzy request into a precise assignment before a single word of the answer is generated.

Principle

Three roles in one prompt, and no magic. First the critic: the model takes your request apart and honestly says what's missing or could be read two ways. It doesn't guess; it asks outright. Then the editor: it takes the original request and rephrases it, filling the gaps with sensible assumptions. You get version 2.0, specific and unambiguous. Finally the executor: it answers the improved version, not the original. The point: the model stops guessing your intent. It clarifies it first, then delivers.

Why it works

By default an LLM behaves like a student in an exam: gets the question, starts writing immediately. Guesses the meaning as best it can, fills the gaps with whatever. Never asks for clarification, because nobody asked it to. But the model is perfectly able to scan text for logical holes, including the incoming request. The ability is there; it just stays quiet by default. The moment you explicitly say "first find what's unclear," the model switches from execution mode to audit mode. The answer is built not on the original fuzzy request but on its improved version. Hence precision and specifics instead of platitudes.

When to apply

Any task where the first request is bound to be incomplete: writing a technical spec, building a marketing strategy, preparing for a negotiation, career advice, business planning, especially when you're not yet entirely sure what you want. It's most useful when the task is complex and multi-layered: the more details there are to account for, the more likely the original request has holes. NOT for simple factual questions. Running "what's the capital of France" through three-step self-analysis is just extra work.

Mini recipe

1. Give a role and context: assign the model a professional role and describe the situation in two or three sentences: who you are, what's going on, what you need 2. The "Analyze" step: explicitly ask it to find what's incomplete or ambiguous in the request and have it write specific questions for you: task critic 3. The "Rephrase" step: ask it to write an improved version of the request, filling the gaps with realistic assumptions, not waiting for your answers but completing the picture on its own 4. The "Answer" step: say explicitly that the final answer must address the rephrased version, not the original

Examples

[BAD]: `Help me make a plan for my business` [GOOD]: `You are an experienced business consultant. Context: I run a small coffee shop in a residential neighborhood and want to attract regular customers among local residents. Step 1: analyze my request: what's missing, what's ambiguous, what details you need for a useful answer; write a list of questions. Step 2: rephrase the task: write an improved version of the request with realistic assumptions, without waiting for my answers. Step 3: answer the rephrased version: give me a concrete action plan for the next month.`

In plain words

The problem is that modern LLMs try way too hard to be helpful and charge into a task even when it's phrased like a fever dream. This is a fundamental bug: the model tries to read your mind instead of admitting that the input is incomplete or ambiguous. You end up with a confident but totally useless answer, because the model just invented the context for you and, most likely, missed.

It's like walking into a doctor's office and saying: "Something hurts, give me a pill," and instead of asking where and how, the doctor silently writes you a prescription for a laxative. Technically, they helped, but in practice they made things worse. The paper proposes turning AI from an obedient executor into a meticulous agent that first diagnoses your request and only then opens its mouth.

The method that actually does the work here is agent-based uncertainty detection: the model first runs the request through a sniff test. It looks for gaps in the data (what's missing to solve this?) and ambiguity (could this phrase be read two ways?). If the filter trips, a clarification mechanism kicks in: the AI asks you specific questions, narrowing things down until the picture is crystal clear. This saves a ton of time, because answering one clarifying question beats redoing a botched result five times.

Although it was tested on complex technical tasks, the principle is universal for any interaction with AI models. Whether you're writing code, drafting a legal contract or planning a vacation, anywhere there's a risk of hallucinations caused by things left unsaid, this approach saves the day. You just add an instruction to your prompt: "first check whether everything is clear to you," and the guesswork gives way to real work.

Bottom line: stop counting on AI telepathy, it's a dead end. You need to build a request verification step into every serious workflow. If a model doesn't ask any questions before tackling a complex task, it's probably messing up right now. Asking for clarification isn't an AI weakness, it's a sign it's working properly, and that's exactly what separates a toy from a real work tool.

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 Three-step self-analysis: the model fixes your question before answering it arXiv:2507.03726

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.