TL;DR
LLMs guess when they should investigate. Hand a model a long text full of tangled facts and it grabs the first plausible story and runs off to prove it. Missed the link between two paragraphs? It quietly fills the gap with speculation and never notices. SABA is a framework that forbids the model from answering until it has audited its own understanding: first structure all the facts, then find what's Missing, then fill the gaps with hypotheses — and only then draw a conclusion.
The trouble with standard Chain-of-Thought is early lock-in. The model builds its reasoning like a narrative: it grabs the first plausible conclusion, and every later step works to confirm it. That's not a bug — it's how text generation works: each token continues the one before. Self-checking after the answer doesn't help either: the model doesn't revisit its premises, it re-justifies the conclusion it already reached in different words.
SABA fixes this with two phases inside a single prompt. Phase 1 — pull every fact out of the text, explicitly link them to each other and flag contradictions. Phase 2 — don't hunt for the answer, hunt for what's missing: each gap becomes a concrete question, each question becomes a hypothesis, and each hypothesis enriches the knowledge base. The loop repeats until no gaps are left — then, and only then, comes the final conclusion.
Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.
Method Blueprint
PHASE 1 — Information Fusion (one prompt or block)
STEP 1: Extract all facts → structured list of events with attributes
STEP 2: Link attributes to events → explicit connections between facts
STEP 3: Check for contradictions → flag conflicts and ambiguities
→ Output: a verified fact base (D_base)
PHASE 2 — Query-driven Structured Reasoning (a repeating loop)
STEP 4: Diagnosis → list of gaps: what we need to know but don't
STEP 5: Decomposition → each gap → a concrete question
STEP 6: Hypotheses → a hypothetical answer to each question from the available facts
STEP 7: Update the base → add questions and hypotheses to the knowledge
→ Repeat from STEP 4 while gaps remain
FINAL — Synthesis
STEP 8: Conclusion from the complete base → final answer with justification
Everything runs inside one prompt. The model works through the loop on its own.
Example in Practice
Task: A SaaS founder wants to understand why the product suddenly lost 40% of its users in two months. He has: emails from the support team, NPS data, threads with several customers who churned, internal feature reports. He pastes all of it into the prompt. The standard question "what went wrong?" produces a shallow answer — "bad UX" or "competitors." SABA forces the model to build the full picture first.
Prompt:
You are an investigator working a complex case. Your job is to NOT draw
any unproven conclusions. Follow the SABA protocol strictly.
TASK: {Why did the product lose 40% of its users in 2 months?}
MATERIALS FOR ANALYSIS:
{paste all available data here: emails, reviews, internal threads, reports}
---
SABA PROTOCOL:
## PHASE 1: LOCKING IN THE KNOWLEDGE BASE
### 1.1 Fact extraction
List ALL concrete facts from the materials. Don't interpret — facts only.
Format: [Source] → [Fact] → [Date/period if available]
### 1.2 Linking facts
For each fact: which other facts is it connected to, and how?
Pay special attention to non-obvious links between different sources.
Format: Fact A + Fact B → [Link: cause/effect/coincidence/contradiction]
### 1.3 Contradiction check
Find facts that contradict each other or raise doubts.
Format: ⚠️ [Fact] CONFLICTS WITH [Fact] → [What the discrepancy is]
---
## PHASE 2: WORKING THROUGH THE GAPS (repeat the loop)
### Loop 1
**2.1 Gap diagnosis**
What do you NOT know that is critical for answering the task?
Format: GAP: [What is unknown] → [Why it matters for the answer]
**2.2 Breaking gaps into questions**
Each gap → a concrete question that could, in principle, be answered.
Format: QUESTION: [Concrete question derived from the gap]
**2.3 Hypotheses from available facts**
For each question — a hypothesis based ONLY on facts already known.
Format: HYPOTHESIS: [Answer to the question] | BASIS: [Facts from the base]
**2.4 Updating the base**
Add the hypotheses to the knowledge base. Mark them as assumptions, not facts.
**Are there any critical gaps left?**
→ If YES — continue with Loop 2, 3...
→ If NO — move to the final step
---
## FINAL: CONCLUSION
Now — and only now — answer the task.
Structure of the conclusion:
1. Main cause (grounded in the fact base)
2. Chain of cause and effect
3. What remains unknown (be honest)
4. What to verify additionally
Result: The model works through phase 1 — producing a structured list of facts with explicit links and flagged contradictions. You'll see, for example, that complaints about "slow loading" in three different sources line up in time with the December update release. Then phase 2 — the model spells it out explicitly: "Unknown: whether the update was rolled back, and when", and forms a hypothesis from indirect evidence. The final step gives a conclusion with a concrete causal chain and an honest list of what still needs manual checking.
Why It Works
The LLM's weakness isn't "stupidity" — it's architecture. The model generates text sequentially: every word builds on the one before. If the conclusion "it's the competitor's fault" shows up early in the reasoning, every following token becomes its natural continuation. The model doesn't "reconsider" — it continues. That's exactly why standard CoT so often gives a confident but wrong answer.
The LLM's strength is following structured instructions. If you explicitly lay out a sequence of steps and forbid moving to a conclusion until the audit is done, the model will respect that constraint. The prompt structure literally changes the order of generation: facts first, then gaps, then hypotheses — and only then the answer.
SABA exploits this: it turns "answer the question" into "run the audit protocol; the conclusion is the last step." The key innovation is gaps as objects. Instead of "think harder," the model gets an instruction: find what's unknown → phrase it as a question → answer with a hypothesis built from facts. That turns unconscious speculation into an explicit, traceable part of the reasoning.
Control knobs: - Number of loop iterations → add a cap like "no more than 3 loops" for simple tasks to save tokens - Hypothesis strictness → add "each hypothesis must rest on at least 2 facts from the base" — less speculation - Adaptive skip of phase 2 → add to the prompt: "if there are no contradictions and the base is complete, go straight to the final step" - Gap format → swap the neutral "GAP" for categories: "GAP-CAUSE / GAP-TIMELINE / GAP-MOTIVE" — sharper for narrative tasks
Prompt Template
Follow the SABA protocol. Task: {task}
Materials: {text/data to analyze}
---
## PHASE 1: KNOWLEDGE BASE
### Fact extraction
List all concrete facts from the materials. Facts only, no interpretation.
Format: [Source] → [Fact]
### Linking facts
Explicitly mark the links between facts, especially non-obvious ones.
Format: Fact A + Fact B → [type of link]
### Contradictions and ambiguities
Flag conflicts and suspicious inconsistencies.
Format: ⚠️ [Fact] CONFLICTS WITH [Fact]
---
## PHASE 2: WORKING THROUGH THE GAPS
Run the loop while critical gaps remain:
**Diagnosis:** What is unknown but important for the task?
Format: GAP: [what] → [why it matters]
**Questions:** Each gap → a concrete question
Format: QUESTION: [question]
**Hypotheses:** For each question — a hypothesis from known facts
Format: HYPOTHESIS: [answer] | BASIS: [facts]
**Continue the loop?** If critical gaps remain — yes. If not — go to the final step.
---
## FINAL: CONCLUSION
Answer to the task: main conclusion + chain of causes + what remains unknown
Placeholders:
- {task} — the specific question you need answered
- {text/data to analyze} — emails, reports, threads, descriptions of the situation
🚀 Quick start — paste into the chat:
Here is a template for the SABA method — it helps untangle complex situations
by auditing facts and gaps instead of guessing the answer right away.
Adapt it to my task: [your task].
Ask me questions to fill in the fields.
[paste the template above]
The LLM will ask what materials you have and what problem you need to solve — because the method is built around a specific fact base and a specific question. It will take the structure from the template and adapt it to your case.
Limitations
⚠️ Simple tasks: For direct questions ("recommend a restaurant," "what does this term mean") SABA is overkill — a bloated protocol slows things down with no gain in quality. That's exactly why the authors added an adaptive skip of phase 2.
⚠️ Subjective judgments: The method shines where there's a "right answer" derivable from facts. For matters of taste and style ("rate my writing") it works worse — gaps there can't be closed with logical hypotheses.
⚠️ Short texts: If the material is small and self-contained, the structuring phase adds almost nothing. The value grows with the length and messiness of the input.
⚠️ Token cost: A detailed protocol with loops means long output. On short tasks that's wasteful.
How It Was Studied
Researchers from Jilin University picked a specific and tough test — detective puzzles: 1,000+ word texts with deliberately scattered clues, red herrings and hidden motives. Unlike standard benchmarks, here you can't guess from general knowledge — only careful analysis of the specific text works. That's the point: a detective puzzle exposes exactly the weakness SABA is designed to fix.
31 cases at three difficulty levels (easy / medium / hard) were compared against eight competitors: from basic CoT to advanced Graph-of-Thought and Self-Refine. A neat design detail — they measured not just answer correctness but also clue coverage: how thoroughly the model actually worked through the text rather than guessing the ending. That matters, because you can name the right suspect for the wrong reasons by pure luck.
The most telling result is on the hard cases with implicit clues and misinformation. The best competitor (Graph-of-Thought) reached ~70% accuracy. SABA hit ~79%. The more tangled the text, the bigger the gap: on easy tasks the advantage is smaller, on hard ones it's at its maximum. That suggests the method genuinely solves the problem of complex analytical tasks rather than just being "better on average."
In parallel they tested it on general benchmarks (HotpotQA, StrategyQA, Big-Bench Hard) to make sure the method wasn't overfitted to detective stories. SABA stays in first place there too, though the margin is more modest. The cost: roughly 9× more tokens than a direct prompt — but 4× cheaper than Graph-of-Thought, with better quality.
Adaptations and Extrapolations
1. One step instead of the full protocol → a quick incompleteness check
If you don't have time for full SABA, you can take just the core insight:
🔧 Technique: "Gaps first" → explicit diagnosis of an incomplete picture
Before any complex analysis, add an opening request:
Before answering the question {task}, list: 1. What you know for certain from the materials provided 2. What you don't know but need in order to answer 3. What assumptions you will make, and why Only after that — the answer.It's 20% of the SABA technique, but it often delivers 60% of the effect: the model stops passing off speculation as fact.
2. Combine with a role prompt → sharper gap diagnosis
An investigator role gives the model a clearer frame for phase 2:
You are a veteran homicide detective who never brings charges
without hard evidence. Before drawing a conclusion you MUST compile:
— a list of established facts
— a list of assumptions with their justification
— a list of questions that remain unanswered
Case: {description of the situation}
The role adds a "professional reflex" on top of the structure — the model hunts for gaps more sharply, because a detective can't afford to speculate.
Resources
Paper: Self-Awareness before Action: Mitigating Logical Inertia via Proactive Cognitive Awareness
Authors: Fulong Fan, Peilin Liu, Liu FengZhe, Shuyan Yang, Gang Yan
University: School of Software and School of Computer Science, Jilin University (China)
Related methods from the study: Chain-of-Thought (Wei et al., 2022), Self-Refine (Madaan et al., 2023), Graph-of-Thought (Besta et al., 2024), SELF-DISCOVER (Zhou et al., 2024), Reflexion (Shinn et al., 2023)