MedLA: A Logic-Driven Multi-Agent Framework for Complex Medical Reasoning with Large Language Models

MedLA is a logic-driven multi-agent framework that enhances complex medical reasoning by organizing agent inference into explicit syllogistic trees and iteratively refining them through graph-guided discussions to resolve inconsistencies, thereby achieving state-of-the-art performance on medical benchmarks.

The Gist

Imagine you are trying to solve a very tricky medical mystery, like a detective trying to figure out why a patient is sick. You have a team of doctors, but instead of just letting them shout out their best guesses, you want them to work together like a highly organized, logical committee.

That is exactly what MedLA (Medical Logic-Driven Agents) does. It's a new computer system designed to help Artificial Intelligence (AI) answer complex medical questions without making up facts or getting confused.

Here is how it works, broken down into simple analogies:

1. The Problem: The "Shouting Match"

Most current AI systems that try to solve medical problems are like a group of people in a room shouting their opinions.

• The Old Way: You ask a group of AI "doctors" a question. They each give an answer based on their training. Then, the system just takes a vote. If 3 out of 5 say "It's the flu," the system says "It's the flu."
• The Flaw: If all 5 doctors are wrong because they all misunderstood the same clue, the vote doesn't help. They might agree on a wrong answer because they are all following the same bad logic. They don't actually check each other's work; they just repeat their conclusions.

2. The Solution: The "Logic Tree"

MedLA changes the game. Instead of just shouting answers, every AI agent in the system is forced to draw a Logic Tree.

Think of a Logic Tree like a family tree, but for reasons instead of people.

• The Root (The Conclusion): This is the final answer (e.g., "The patient has pneumonia").
• The Branches (The Premises): To get to the root, you need branches.
  • Major Premise: A general rule (e.g., "All patients with high fever and cough might have pneumonia").
  • Minor Premise: The specific fact about this patient (e.g., "This patient has a high fever and a cough").
  • The Connection: If the rule and the fact match, the branch holds up.

In MedLA, every AI agent builds its own tree. They don't just say "It's pneumonia." They say, "I think it's pneumonia because of Rule A and Fact B."

3. The Process: The "Peer Review Party"

Once the agents build their trees, they don't just vote. They hold a multi-round discussion where they compare their trees.

• The Critic: One agent looks at another agent's tree and says, "Wait a minute. Your 'Major Premise' (Rule A) is actually outdated. You're using an old medical guideline."
• The Fix: The other agent realizes the mistake, cuts that branch off its tree, and grows a new, correct branch.
• The Consensus: They keep doing this—checking, critiquing, and fixing—until all the trees look solid and agree with each other.

It's like a group of editors working on a book. Instead of just guessing the ending, they check every single sentence to make sure the story makes sense before they publish the final chapter.

4. The Agents: The Specialized Team

MedLA uses different types of "AI workers" to do specific jobs, just like a hospital has different departments:

• The Premise Agent: The "Fact Finder." It scans the patient's story to pull out the specific details (the minor premises) and finds the medical rules (the major premises).
• The Decompose Agent: The "Project Manager." It breaks a huge, scary question into tiny, manageable steps so the team doesn't get overwhelmed.
• The Medical Agents: The "Doctors." They build the logic trees and try to solve the puzzle.
• The Credibility Agent: The "Quality Control Inspector." It checks every step of the logic tree to see if it's strong or weak. If a step is shaky, it flags it for the team to fix.

Why This Matters

The paper shows that MedLA is much better at solving hard medical puzzles than previous methods.

• It's Transparent: You can see exactly why the AI made a decision because you can look at the tree. You aren't just trusting a "black box."
• It's Self-Correcting: If one agent makes a mistake, the others catch it during the discussion.
• It Works Without Extra Training: Unlike other systems that need to be re-taught thousands of times with new data, MedLA is smart enough to figure it out just by using better logic.

In short: MedLA turns AI medical reasoning from a "guessing game" into a "structured debate." By forcing the AI to build a logical tree and argue with itself, it finds the truth much more reliably, making it a safer and smarter tool for doctors and patients.

Technical Summary

1. Problem Statement

While Large Language Models (LLMs) have shown promise in medical question answering (QA), they face significant challenges in complex clinical reasoning. Current approaches suffer from two main limitations:

• Hallucination and Logical Flaws: LLMs often generate plausible-sounding but factually incorrect diagnoses, misapply guidelines, or create invalid causal links due to a lack of structured reasoning.
• Limitations of Existing Multi-Agent Systems: Current multi-agent frameworks typically rely on fixed role-playing (e.g., assigning agents as "radiologist" or "pathologist") or shallow interaction prompts. These systems often engage in positional debates without deeply analyzing the underlying logical structure, making it difficult to detect fine-grained inconsistencies, resolve contradictions, or trace the root cause of errors.

The core problem is the need for a framework that moves beyond simple knowledge retrieval or static role aggregation to enable structured, transparent, and iterative logical reasoning capable of handling the nuance of differential diagnosis.

2. Methodology: The MedLA Framework

MedLA (Medical Logic Agent) is a multi-agent framework that organizes reasoning into explicit logical trees based on classical syllogisms (Major Premise, Minor Premise, Conclusion). Instead of generating free-text answers, agents construct and debate structured inference paths.

Core Components

The framework consists of four specialized agent types working in a three-stage pipeline:

1. Premise Agent (P-Agent):

   • Extracts Major Premises (general medical rules/guidelines) and Minor Premises (patient-specific facts) from the input query and external knowledge bases.
   • Serves as the seed for subsequent syllogistic reasoning.

2. Decompose Agent (D-Agent):

   • Breaks down complex diagnostic problems into atomic sub-questions or sub-problems.
   • Uses an elimination-based strategy (for multiple-choice) or hypothesis generation (for open-ended) to create a tree of sub-tasks.

3. Medical Agents (M-Agents):

   • Multiple M-Agents run in parallel to generate logical trees.
   • Each agent constructs a tree where leaf nodes are premises, internal nodes are intermediate inferences, and the root is the final conclusion.
   • They perform recursive reasoning, linking premises to conclusions via syllogistic triads.

4. Credibility Agent (C-Agent):

   • Evaluates the confidence of each syllogism node in the generated trees.
   • Assigns credibility scores (High, Medium, Low) to identify weak links or potential errors.

The Reasoning Workflow

The system operates through three distinct phases:

• Phase A (Extraction & Decomposition): The P-Agent extracts premises, and the D-Agent splits the problem into sub-questions.
• Phase B (Generation, Calibration, & Discussion):
  • M-Agents generate provisional logical trees.
  • The C-Agent flags low-confidence nodes.
  • Graph-Guided Discussion: Agents exchange their logical trees. They compare reasoning paths, specifically focusing on flagged low-confidence nodes. Agents iteratively revise their trees based on peer feedback, correcting factual errors or logical gaps.
• Phase C (Decision): The system synthesizes the consensus logical tree to generate the final answer and a detailed explanation.

3. Key Contributions

1. Explicit Logical Tree Representation: MedLA is the first multi-agent framework to represent each agent's thought process as an explicit syllogistic logical tree. This enables fine-grained traceability of inferences and allows agents to pinpoint conflicts at the premise level rather than just debating final conclusions.
2. Iterative, Graph-Guided Correction: Unlike static voting mechanisms, MedLA introduces a multi-round discussion mechanism where agents iteratively compare and revise their logical trees. This leads to robust cross-agent error correction and convergence toward self-consistent reasoning structures.
3. State-of-the-Art Performance without Fine-Tuning: MedLA achieves superior results on complex medical benchmarks using zero-shot prompting on both open-source (e.g., LLaMA 3.1) and commercial (e.g., DeepSeek) backbones, without requiring additional data fine-tuning or external retrieval augmentation (RAG).

4. Experimental Results

The authors evaluated MedLA on three comprehensive benchmarks: MedDDx (differential diagnosis), Multi-choice Medical QA (MMLU-Med, MedQA-US, BioASQ), and MedXpertQA (expert-level reasoning).

• MedDDx Performance: MedLA achieved an average accuracy of 44.3% on the MedDDx benchmark, outperforming the best baseline (MDAgents) by 7.4 percentage points. It showed particularly strong gains on "Expert" tier questions (+11.1 pp over the base LLaMA 3.1 model), demonstrating its ability to handle semantically similar distractors.
• General QA Performance: On standard medical QA benchmarks, MedLA achieved 69.9% average accuracy, surpassing the baseline LLaMA 3.1 (64.2%) and RAG-based methods by a significant margin.
• Scalability: The framework proved effective across different model sizes (8B to 70B parameters) and both open-source and commercial LLMs.
• Ablation Studies: Removing the "Revision Loop" or "Credibility Agent" caused measurable performance drops, confirming that the iterative correction and confidence calibration are critical to the system's success.
• Efficiency: While MedLA involves more inference steps than simple majority voting, it avoids the high computational costs of offline fine-tuning (required by some baselines like KGAREVION) and external retrieval latency.

5. Significance and Impact

• Trustworthiness in Healthcare: By making the reasoning process transparent and auditable via logical trees, MedLA addresses the "black box" nature of LLMs, which is crucial for clinical adoption.
• Paradigm Shift: It moves the field from "role-playing" agents to "logic-driven" agents, proving that structured reasoning mechanisms can outperform both static models and unstructured multi-agent debates.
• Generalizability: The framework offers a generalizable paradigm for trustworthy reasoning in other high-stakes domains (e.g., law, finance) where logical consistency and error correction are paramount.
• Cost-Effectiveness: It demonstrates that complex medical reasoning can be significantly improved through architectural innovation (logic trees and multi-agent collaboration) rather than expensive model retraining or massive retrieval systems.