TL;DR
Haibu MMIA is an architecture that turns an LLM from an unreliable oracle into a verifiable reasoning engine. Instead of a single prompt, the model runs a loop: planning → execution → independent audit. Every claim is tied to a source, and every logical step is checked by a separate LLM instance. The result isn't just an answer but a provable chain, like a theorem in math.
LLMs produce plausible-sounding nonsense — that's not a bug, it's a fundamental property of probabilistic models. In medicine, law and finance, these "hallucinations" can be deadly. The usual fixes (RAG, fine-tuning, prompt engineering) lower the error rate but offer no verification mechanism. The problem isn't that the model makes mistakes; it's that its reasoning is a black box. You can't check HOW it reached its conclusion.
MMIA tackles this with recursive decomposition: it breaks a complex task into atomic steps until every step is checkable. Then an independent auditor (a separate LLM) checks: (1) does the decomposition make sense, (2) is every fact backed by a source, (3) are the conclusions valid. A claim not tied to a reliable source gets a flag. A logical leap gets a flag. The output is not only the answer but a detailed report of the check, pointing to specific errors.
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
MAIN LOOP (recursive):
1. Analyze → Is the task atomic? If yes → execute. If no → go to planning
2. Plan → Split into subtasks with dependencies
3. Execute → For each subtask, run the MAIN LOOP (recursion)
4. Aggregate → Combine subtask results into the final answer
VERIFICATION LAYER (after the main loop):
5. Execution log → Full record: plan, tools, prompts, sources, conclusions
6. Independent audit → A separate LLM checks:
- Does the decomposition make sense?
- Is every fact backed by a source?
- Are the conclusions valid?
7. Report → "Certified" or "Error at step X: [details]"The key twist: Successful chains are saved as "theorems." When a new task comes in, the system first looks for a similar theorem via RAG — if it finds one, it runs a quick match check instead of the expensive full loop. It evolves from high-cost reasoning to low-cost matching.
Example in Action
Task: Stress-test the business idea "healthy meal delivery for office workers" — find the logic holes and risks.
Prompt:
Check this business idea using a verifiable chain of reasoning:
IDEA: Healthy meal delivery to offices in Chicago. Target audience —
corporate clients with 20+ employees. Average ticket $15/meal.
Delivery twice a day. Rented kitchen.
INSTRUCTIONS:
1. Break the analysis into atomic questions: unit economics, logistics,
competition, regulation, operations
2. For each question:
- State a specific claim
- Name the source/reasoning behind it
- Rate the risk (low/medium/high)
3. Keep a detailed log of every step
4. After the main analysis — run an independent critique:
- Are there logical contradictions between the conclusions?
- Which claims rest on assumptions rather than facts?
- What's missing?
Final output: a list of critical risks with reasoning and recommendations.Result: The model will deliver a multi-stage analysis: first a decomposition (5-7 key aspects), then a detailed breakdown of each with explicit references to calculations or facts, then a critical audit where it catches contradictions (for example, "twice-daily delivery + rented kitchen = high logistics costs at a $15 average ticket" → the unit economics don't add up). At the end you get a structured report with a prioritized list of risks and concrete recommendations, where every conclusion traces back to the source data or calculations.
Why It Works
LLM weakness: Models generate text by probability, without understanding. They can lie convincingly and never notice. A single-step prompt = a single point of failure. If the model slips somewhere in the middle of its reasoning, it keeps generating on top of the mistake.
LLM strength: Models are great at decomposing complex tasks into simple ones and good at critiquing someone else's reasoning (even their own, if you feed it back as outside text).
How the method uses the strength to get around the weakness:
Recursive decomposition breaks a complex task into a chain of simple, checkable steps. Each step is an atomic operation with an explicit source (search, knowledge base, calculation). This pulls the reasoning out of the model's latent space and into a transparent log. Don't trust a conclusion? Look at which step it came from and where the data originated.
Independent audit uses a second LLM instance as a critic. It doesn't generate an answer from scratch; it checks a finished chain: "Is this fact backed by a source? Is the logic valid? Where's the leap?" That's easier and more reliable than generation. Critiquing is easier than creating — even for an LLM.
Iterative audit (running the check several times) lowers the chance of missing an error. If three independent audits agree, confidence goes up. If they disagree, it's a flag for a human.
Axiom base + RAG anchors reasoning to verified facts. The model doesn't improvise "off the top of its head"; it looks for support in a rule base. That slashes hallucinations.
Bootstrapping turns an expensive process into a cheap one: the first time, a task is solved with the full loop (expensive), but the result is saved. Similar tasks after that are solved by matching against the saved theorem (cheap). The evolution goes from "reasoner" to "match verifier."
Prompt Template
Base template for verifiable analysis:
Analyze {task} using a verifiable chain of reasoning.
STAGE 1: DECOMPOSITION
Break the task into 5-7 key questions. Each question must be
atomic — answerable with one specific fact or calculation.
STAGE 2: EXECUTION
For each question:
1. State the claim
2. Name the source/reasoning (calculation/search/knowledge base/assumption)
3. If it's an assumption — label it explicitly
4. Record it in the log
STAGE 3: AGGREGATION
Combine the conclusions from all steps into a final answer to the task.
STAGE 4: INDEPENDENT AUDIT
Check the chain of reasoning:
- Does the decomposition make sense?
- Is every claim backed by a source?
- Are there logical contradictions between the conclusions?
- What rests on assumptions rather than facts?
- Which critical questions were missed?
OUTPUT FORMAT:
1. Detailed log of every step
2. Final answer
3. Audit report: "Certified" or "Flags: [list of issues]"Parameters to adapt:
{task}— the specific task to analyze- Number of questions (5-7) — adjust to the complexity
- Sources — add specific sources if you have them (files, links, databases)
- Audit criteria — add domain-specific ones (for medicine, say: "compliance with clinical guidelines")
🚀 Quick start — paste into the chat:
Here's a template for verifiable analysis. Adapt it to my task: [your task].
Ask me questions to fill in all the fields.
[paste the template above]The LLM will ask about the task, the key aspects to analyze and the sources available — to fill in the decomposition and pick verification tools. It will take the structure from the template and tailor it to your specifics.
Limitations
⚠️ High cost: The multi-stage process (planning → execution → audit → iterations) burns 3-5x more tokens than a simple prompt. For simple tasks it's overkill.
⚠️ Takes discipline: Applying the principles by hand (keeping a log, checking every claim) takes effort. It's easy to get sloppy.
⚠️ The auditor makes mistakes too: A second LLM is no silver bullet. It can miss an error or raise a false flag. The mitigation is an iterative audit (several checks), but that costs even more.
⚠️ Not for creative tasks: The method is built for factual, logical and regulatory tasks, where there's a right answer and checkable claims. For creative work, brainstorming or fiction it's overkill.
⚠️ Full automation needs infrastructure: An automated planner/executor/auditor, RAG over a knowledge base, theorem storage — that's code, APIs and databases. In a chat, you do it by hand.
How They Tested It
The researchers built synthetic benchmarks for four high-stakes medical domains: DRG/DIP coding (100 discharge summaries, 20% with errors such as a diagnosis-procedure mismatch), regulatory documentation review for medical devices (100 document sets, 20% with contradictions between the instructions for use and the clinical data), quality control of electronic health records (100 scenarios, 25% with logic errors like prescribing an antibiotic for a virus or penicillin despite an allergy), and automated insurance policy processing (100 cases with nested conditions, 30% of which should be correctly denied).
Why synthetic data? In high-risk domains, real data is unlabeled — you can't tell what's right and what's an error. Generating cases with GPT-4 and programmatically injecting errors gives a controlled ground truth. Experts (coders, regulatory specialists, clinicians) validated a sample blind and confirmed the cases were realistic and the errors plausible.
What they compared: MMIA against a strong baseline — the same LLM with RAG over the same knowledge base, but without the explicit plan-execute-audit loop. The baseline tries to solve the task in a single prompt. This isolates the effect of the architecture, not the model.
What they measured:
- Error Detection Rate (recall) — how many real errors were caught
- False Positive Rate — how many correct cases were wrongly flagged
- Accuracy — the overall share of correct judgments
The results were striking: MMIA hit 98%+ error detection with <1% false positives across all four domains (p < 0.001). Baseline: 71-88% detection, 5-8% false positives. The gap is dramatic — a structured approach with an independent audit catches errors that a single-shot prompt systematically misses.
The logic: The baseline model tries to hold everything in its head at once — synthesizing an answer from many sources in a single pass. With complex logic (nested conditions, conflicting data, multi-step rules) it loses the thread. MMIA breaks things into atomic steps, checks each one separately, and then an independent critic catches inconsistencies. It's the difference between solving a problem in your head (baseline) and working through it methodically on a whiteboard (MMIA).
Efficiency: They simulated 200 DRG audit tasks. The first 100 ran the full loop (~3500 tokens/task). For the next 100, 80% were similar tasks solved via RAG matching against saved theorems (~500 tokens), and only 20% needed the full loop. Final average: ~1100 tokens — a 68% reduction with accuracy intact. Takeaway: the system pays for itself over time — expensive at first, cheap once the base builds up.
Practical insight: Explicit decomposition + independent critique isn't just "better results"; it's a qualitative leap in reliability. The price is tokens and complexity. Use it for critical tasks where mistakes are costly.
Resources
Haibu Mathematical-Medical Intelligent Agent: Enhancing Large Language Model Reliability in Medical Tasks via Verifiable Reasoning Chains — Zhang Y., Kong D., Zhejiang University, September 2025