Self-Ask Prompting (Let the Model Interrogate Itself)

TL;DR: Self ask prompting has a model explicitly decompose your question into its own follow-up sub-questions, answer each one in turn, and only then answer your original question, instead of reasoning through it in one continuous pass. It comes from a real 2022 paper, published at Findings of EMNLP 2023, and its own benchmark tables show it beating both direct prompting and chain-of-thought on multi-hop questions.

What Is Self-Ask Prompting?

Self-ask prompting is a technique where, instead of answering your question directly or reasoning through it in one continuous chain, the model first decides whether it needs to ask itself any follow-up questions, then asks and answers each one explicitly, and finally combines those answers into a final answer to your original question. It is built on top of chain-of-thought prompting, but it demarcates each step: the sub-question, its answer, and the final answer all appear as separate, labeled parts of the output rather than one undifferentiated block of reasoning. You will also see it called the self ask technique, or described more loosely as a self questioning prompt, though the paper that introduced it just calls the method self-ask.

That demarcation is the whole point. A plain chain-of-thought response can wander through a paragraph of reasoning with no clear seams, which makes it hard to tell where the model actually made its key decision, or to intervene on just one part of it. Self-ask forces the model to name each sub-question before answering it, which is also what makes the technique easy to extend: because the sub-questions are clearly marked, you can route them somewhere other than the model itself, a search engine, for instance, which is exactly what the paper that introduced the technique goes on to demonstrate.

Where Does Self-Ask Prompting Come From?

Self-ask is not a folk technique assembled from blog posts; it comes from a specific paper: "Measuring and Narrowing the Compositionality Gap in Language Models", by Ofir Press, Muru Zhang, Sewon Min, Ludwig Schmidt, Noah A. Smith, and Mike Lewis, first submitted to arXiv on October 7, 2022, and published at Findings of EMNLP 2023.

The paper is not really about self-ask as an isolated trick. Self-ask is the fix it proposes for a problem it first has to name. The authors introduce what they call the compositionality gap, defined in their own words as "the fraction of compositional questions that the model answers incorrectly out of all the compositional questions for which the model answers the sub-questions correctly." In plain terms: a model can often answer each individual fact behind a two-part question correctly, and still fail to combine them into the right final answer. The paper's central finding is that this gap does not close as models get bigger; it reports that the compositionality gap "remains at a roughly constant 40% between different model sizes and training techniques, with no apparent improvement from scale". As one historical data point from the paper itself, not a claim about today's models, it also reports a compositionality gap "estimated at 42.9% for ChatGPT and 23.0% for GPT-4" for the specific, now long-superseded versions of those two systems available when the paper was written.

The paper's own fix for that gap is self-ask. As its abstract states directly: "We present a new method, self-ask, that further improves on chain of thought. In our method, the model explicitly asks itself (and answers) follow-up questions before answering the initial question."

How Does Self-Ask Actually Work?

Mechanically, self-ask needs a one- or few-shot prompt demonstrating the pattern, followed by your real question. The paper's own description of the method is direct: "Our method builds on chain of thought prompting, but, instead of outputting a continuous undemarcated chain-of-thought, our prompt has the model explicitly state the next follow-up question it wants to ask before answering it."

Four labeled pieces of scaffolding carry the whole technique. The prompt ends with the line Are follow up questions needed here:. If the model decides sub-questions are needed, it outputs Yes., then states a Follow up: question, answers it on an Intermediate answer: line, and repeats that Follow up and Intermediate answer pair as many times as it decides it needs, before closing with So the final answer is: and the answer itself. That final line is deliberately parseable: whatever comes after the last colon is the answer, which matters if you are extracting the result programmatically rather than just reading it.

Here is one of the paper's own worked demonstrations, from its Musique prompt appendix, used to show the model the pattern before its real question:

Question: What is the current official currency in the country
where Ineabelle Diaz is a citizen?

Are follow up questions needed here: Yes.
Follow up: Which country is Ineabelle Diaz a citizen of?
Intermediate answer: Ineabelle Diaz is from Peurto Rico, which is
in the United States of America.
Follow up: What is the current official currency in the United
States of America?
Intermediate answer: The current official currency in the United
States is the United States dollar.
So the final answer is: United States dollar.

The spelling of Puerto Rico as "Peurto Rico" above is in the paper's own published prompt, reproduced as printed, not a typo introduced here.

What Do The Actual Numbers Say?

Here is Table 1 from the paper, comparing methods on Davinci-002 across three benchmarks: Bamboogle, a dataset of 125 hand-written two-hop questions built specifically to be unanswerable by a search engine's featured snippet; 2WikiMultiHopQA; and Musique.

Source: Press et al., "Measuring and Narrowing the Compositionality Gap in Language Models", Table 1, arxiv.org/abs/2210.03350, accessed 3 September 2026.

Self-ask beats plain chain-of-thought on every benchmark in that table, by the widest margin on Bamboogle (46.4% to 57.6%). A search engine queried directly, with no model in the loop at all, performs badly on its own (0.0% to 2.2%), which is the paper's own evidence that these questions are not simple lookups a search box could answer without reasoning. To build Bamboogle in the first place, the authors read random Wikipedia articles and combined two unrelated facts about the same topic into one question, filtering out anything a search engine already answered correctly. Their own example, reading the article for Voyager 2 and learning it was the first probe to approach Uranus and that it launched on a Titan IIIE rocket, produced the question "What rocket was the first spacecraft that ever approached Uranus launched on?"

The gain also holds against a different zero-shot baseline. On the paper's separate Compositional Celebrities dataset, a plain "think step by step" instruction, the zero-shot chain-of-thought method from a separate 2022 paper by Kojima and colleagues, rather than the few-shot chain-of-thought in the table above, scored 45.7% and 1.1% across two model variants, while self-ask scored 79.6% and 54.2% on the same two models.

Does Self-Ask Get Better With a Search Engine?

Yes, and the paper's own design for this is the more interesting half of the technique. Because self-ask clearly labels the start and end of every sub-question, you can swap the model's own answer for a real search result without changing the prompt at all. The mechanism, per the paper: once the model outputs Follow up: and then Intermediate answer:, the researchers stop the model, send the sub-question itself to a search engine API, and feed the returned answer back into the prompt as if the model had produced it.

That swap is what pushes the numbers from 57.6% to 60.0% on Bamboogle and, more dramatically, from 30.0% to 40.1% on 2WikiMultiHopQA, per the same table above. It also requires almost no engineering. The paper states plainly: "This method is implementable in only a few lines of code." The exact same prompt works for both the plain self-ask version and the search-engine version, no retraining and no special syntax required.

The trade-off is that this variant needs an actual search integration to run, which a single chat window does not give you. Plain self-ask, run entirely inside one conversation, is the version anyone can use today without wiring anything up; self-ask plus search is the version that requires you to build something.

A Copy-Paste Self-Ask Template

The paper's own version needs a few worked examples ahead of your real question, the way the Musique demonstration above shows the pattern. For a single chat message without that setup, this compressed version keeps the same labeled structure and lets the model supply its own examples of the pattern as it goes:

Answer the following question. First, decide whether you need to
ask yourself any follow-up questions to answer it correctly. Use
exactly this format:

Are follow up questions needed here: [Yes/No]
Follow up: [a sub-question, if needed]
Intermediate answer: [your answer to that sub-question]
(repeat Follow up / Intermediate answer as many times as needed)
So the final answer is: [your final answer]

Question: [your actual question]

Swap "question" for whatever unit fits your task, decision, claim, plan, and the scaffold still applies. The value is not the exact wording; it is forcing the model to name each sub-question before it answers it, instead of folding the whole thing into one paragraph you cannot inspect.

Where Does Self-Ask Fall Short?

Three limits are worth naming plainly. First, cost: extra labeled steps mean more output tokens and slower responses than a single direct answer, for a benchmark gain the paper's own table puts mostly in the low single digits to low double digits of accuracy, depending on the dataset. Second, the technique was validated specifically on multi-hop factual question answering, Bamboogle, 2WikiMultiHopQA, Musique, and the paper's own Compositional Celebrities dataset, not on open-ended writing, planning, or subjective tasks, so treat gains outside that shape as unverified rather than assumed. Third, the paper's fully tested version needs a few-shot demonstration prompt to work reliably; the simplified zero-shot template above is a practical compression of that method, not the exact version its benchmark numbers describe.

How Is Self-Ask Different From Step-Back, Analogical Prompting, and Asking ChatGPT to Ask You Questions First?

Four techniques share a neighborhood here, and it is worth being precise about which does what rather than treating them as interchangeable.

Step-back prompting has the model ask one broader, more abstract question, get an answer grounded in a general principle, then reason from that principle to your specific question. It moves up a level of abstraction, once. Analogical prompting has the model generate its own worked examples of similar problems and solve those first, reaching sideways for a precedent rather than a principle. Self-ask does neither of those; it moves through your actual question, breaking it into a sequence of sub-questions and answering each one before combining them, decomposition rather than abstraction or analogy.

Getting ChatGPT to ask you questions first sounds closest to self-ask by name, and points in the opposite direction. That technique has the model interview you: it identifies gaps in what you told it and asks you to fill them before it starts. Self-ask never leaves the conversation. Every follow-up question is one the model asks and answers itself, using knowledge it already has, with nothing sent back to you. One technique closes gaps in your prompt; the other closes gaps in the model's own path to an answer.

Self-ask also sits near two techniques that interrogate a draft rather than a question. Reflexion and self-critique prompting grades an already-written answer against a rubric, structure, tone, logic, after the fact. Verification prompting specifically re-checks the factual claims in a draft, ideally independently of the context that produced them. Self-ask's questions happen before any answer exists; those two happen after one does. Combining self-ask with either is reasonable, decompose the question first, then verify the sub-answers, since neither covers what the other checks.

Make Self-Ask a Habit, Not a One-Off Prompt

A technique like this only pays off if it is reachable the moment a question actually needs it, which in practice means saving the template above somewhere other than memory. Retyping the scaffold from recall is how it quietly degrades back into a single, undemarcated paragraph, the exact failure mode self-ask was built to avoid.

If you are building a broader prompting toolkit rather than reaching for one technique at a time, how to write better ChatGPT prompts is the foundation this sits on top of, and chain-of-thought prompting is the reasoning style self-ask extends. Prompt Architects keeps templates like this one synced across ChatGPT, Claude, Gemini, and the other platforms the extension supports, so the exact scaffold that works is one click away instead of a half-remembered rewrite.