Generated Knowledge Prompting: 4 Recipes That Ship (2026)

> Quick answer (2026): Generated knowledge prompting means asking the model to write out a few relevant facts first, then answer the question using those facts as context. Two steps: generate knowledge, then integrate it. It helps most on commonsense and reasoning tasks where the model knows the facts but does not surface them on its own. It does not rescue a question where the model's facts are simply wrong, and it costs an extra call. Four paste-ready recipes below, each with the failure mode nobody prints.

Both Anthropic's prompting docs and OpenAI's prompting guide tell you to give the model context. Generated knowledge prompting is the trick for when you have no context to give: you make the model produce it first. The technique comes from the Generated Knowledge Prompting paper (Liu et al., 2021), which hit state of the art on three commonsense benchmarks by generating knowledge statements and feeding them back in as extra input. Below are four versions you can paste today.

Recipe 1: The one-call version

Do both steps in a single message. Cheapest, good enough for most tasks.

Answer the question in two steps.

Step 1. Write 3 to 5 short factual statements that are relevant to the question. One fact per line. No opinions, no answer yet.

Step 2. Draw a line, then answer the question using only the facts from Step 1. If a fact you need is missing, say so instead of guessing.

Question: Why does a car battery struggle more on a cold morning?

The two-step split is the whole point. Making the model list facts before it commits to an answer stops it from pattern-matching straight to a wrong-but-confident reply. The "answer using only the facts above" line keeps it honest about what it actually surfaced.

Recipe 2: The two-call version

This is the paper-faithful shape, and it wins on the hard questions. Call A generates knowledge. Call B answers with that knowledge pasted in. Splitting them lets you generate several independent knowledge sets and keep the best.

Call A:

List 5 distinct, specific facts relevant to this question. Each fact should stand on its own and be checkable. Do not answer the question.

Question: Is it safe to leave a lithium battery in a hot car?

Call B (run once per knowledge set, then take the most consistent answer):

Using only these facts, answer the question in 2 sentences. Note if the facts are insufficient.

Facts:
[paste the facts from Call A]

Question: Is it safe to leave a lithium battery in a hot car?

Why bother with two calls: the original method integrates each generated knowledge statement separately and keeps the highest-confidence result, rather than dumping everything in at once. In practice, generating knowledge in its own call gives you cleaner, more diverse facts than the model produces when it is already rushing toward an answer.

Recipe 3: Confidence-tagged knowledge

The upgrade that catches the failure mode before it reaches your answer. Make the model grade its own facts, then throw out the weak ones.

Step 1. Write 5 facts relevant to the question. After each fact, tag it (Certain), (Likely), or (Guess).

Step 2. Delete every fact tagged (Guess). If fewer than 2 facts remain, say the model does not have enough reliable knowledge and stop.

Step 3. Answer using only the (Certain) and (Likely) facts.

Question: What year did the first commercial lithium-ion battery ship, and who made it?

Ungraded generated knowledge is where this technique quietly goes wrong. A confident (Guess) that the model invented reads exactly like a real fact once it lands in Step 3. Forcing the tag, then pruning, turns a silent hallucination into a visible "not enough reliable knowledge" instead.

Recipe 4: The gate, and when not to use it

Generated knowledge prompting is not free and not always right. Skip it when:

• You can retrieve the real facts. If the answer lives in a doc, a database, or a search index, fetch it. GKP asks the model to recall from memory, which is worse than looking it up.
• The task is a lookup, a format change, or a rewrite. There is no reasoning gap to fill, so the extra call just burns tokens.
• The risk is a wrong fact, not a missing one. GKP grounds the answer in facts the model generated, so if those facts are hallucinated, it grounds the answer in garbage and makes it look sourced. When the danger is a wrong claim rather than a forgotten one, reach for chain-of-verification instead, which checks facts after the fact rather than trusting freshly generated ones.

The honest boundary: GKP helps when the model has the knowledge but does not recall it unprompted. It hurts when the model does not have the knowledge and invents it. Those look identical in the output, which is why Recipe 3's confidence tags exist. If you also want the answer's reasoning laid out, pair GKP with chain-of-thought: generate the facts, then reason over them step by step.

FAQ

What is generated knowledge prompting?
A two-step prompt technique (Liu et al., 2021): first ask the model to generate relevant facts, then ask it to answer the original question using those facts as extra context. It needs no external knowledge base and no fine-tuning.

Give a generated knowledge prompting example.
Ask "List 5 facts about how cold weather affects car batteries," then in the same or a follow-up prompt ask "Using those facts, explain why my car struggled to start this morning." The answer is now anchored to the stated facts instead of a cold guess.

Is generated knowledge prompting the same as RAG?
No. Retrieval-augmented generation pulls facts from a real external source (a search index or document store). Generated knowledge prompting pulls facts from the model's own parameters. RAG is more reliable when you have a corpus; GKP is the fallback when you do not.

Does it reduce hallucinations?
Sometimes. Surfacing facts explicitly can curb sloppy recall, but the generated facts can themselves be wrong. Grade them (Recipe 3) or verify them (chain-of-verification) if the stakes are real.

Generated knowledge prompting vs chain of thought, which one?
Chain of thought exposes the reasoning steps; generated knowledge exposes the facts the reasoning stands on. They stack: generate the knowledge, then reason over it. Use GKP when the model is missing facts, CoT when it has the facts but skips steps.

When should you not use generated knowledge prompting?
When you can retrieve the real answer, when the task is a lookup or rewrite with no reasoning gap, or when the model is likely to invent the facts it generates. In those cases the extra call adds cost and, worse, false confidence.

By Sam Q. Cost to test: about $0.01 for the one-call version; the two-call version in Recipe 2 runs roughly 2x that, and a bit more if you generate several knowledge sets and vote.