MADKE (Multi-Agent Debate with Knowledge Enhancement)

An extension of Multi-Agent Debate that adds a shared knowledge pool so debating agents argue from the same set of facts.

Concept

MADKE extends Multi-Agent Debate with a shared knowledge pool to raise the quality of the debate.

Problems with plain Multi-Agent Debate

• Each agent has different background knowledge
• The same information is interpreted differently
• Debate quality degrades where domain knowledge is missing

An illustration of the problem

The numbers below are a hypothetical example used to explain the concept and do not reflect real values.

Agent A: "South Korea's GDP is about 1.6 trillion dollars."

Agent B: "No, it is 1.8 trillion dollars."

Agent C: "As far as I know it is 1.7 trillion dollars."

Each agent argues from data of a different vintage and a different source, producing an argument that never needed to happen.

The fix: a shared knowledge pool

Every agent connects to a shared knowledge pool of papers, facts, and domain expertise. Each agent operates as follows:

1. Retrieve relevant information from the pool — pull the data the debate requires.
2. Debate on top of that information — argue from a common evidence base.
3. Add new information back to the pool — share what the debate uncovered.

The core of MADKE is adaptive knowledge selection. Rather than every agent retrieving on every round, each agent decides for itself whether it needs external knowledge and retrieves selectively. That is where it departs from RAG-style approaches that retrieve for everyone at once.

Process

1. Receive the question — a question arrives from the user.
2. Retrieve relevant knowledge — each agent pulls from the pool selectively, as needed.
3. Debate over shared knowledge — the discussion proceeds from the same information.
4. Store new findings — new information found during the debate is added to the pool.
5. Derive the final answer — the debate result is synthesized into a response.

Plain debate vs MADKE

A MADKE debate example

The institutions and figures below are also a hypothetical example, used to show the mechanism.

Question: "What is the growth forecast for the South Korean economy in 2024?"

Knowledge pool retrieval: IMF report forecasts 2.3%, Bank of Korea forecasts 2.1%, OECD forecasts 2.2%

Agent A (knowledge-grounded response): "The IMF report projects 2.3%, while the Bank of Korea offers a more conservative 2.1%."

Agent B (supplementing): "Factoring in the OECD figure of 2.2%, the estimates converge on roughly 2.1-2.3%. There is no large gap between the major institutions."

Final answer: "Taken together, the major institutional forecasts put 2024 South Korean growth at roughly 2.1-2.3%. (Sources: IMF, Bank of Korea, OECD)"

What goes into the knowledge pool

Updating the knowledge pool

New information found during a debate is added to the pool:

During the debate — Agent A: "Recent research reports a new finding, X..."

Verification — Agent B: "I checked the source, and it is a credible paper."

Knowledge pool update — a new fact is added: "Phenomenon X observed (source: Nature 2024)"

Implementation structure

debate() builds the first responses from an initial retrieval. In each round after that, every agent retrieves additional knowledge and revises its answer with the other responses in view. New information found during the debate is added to the pool, and synthesize() merges the final answer at the end.

class MADKE:
    def __init__(self, agents, knowledge_pool):
        self.agents = agents
        self.knowledge_pool = knowledge_pool
 
    def debate(self, question, max_rounds=3):
        # 1. retrieve relevant knowledge
        relevant_knowledge = self.knowledge_pool.search(question)
 
        # 2. knowledge-grounded initial responses
        responses = {}
        for agent in self.agents:
            responses[agent.id] = agent.generate(
                question=question,
                context=relevant_knowledge
            )
 
        # 3. debate rounds
        for round in range(max_rounds):
            for agent in self.agents:
                # additional retrieval is allowed
                additional_knowledge = self.knowledge_pool.search(
                    agent.get_query()
                )
 
                responses[agent.id] = agent.respond(
                    question=question,
                    knowledge=relevant_knowledge + additional_knowledge,
                    others=responses
                )
 
                # add new findings to the pool
                if agent.has_new_finding():
                    self.knowledge_pool.add(agent.new_finding)
 
        # 4. final answer
        return self.synthesize(responses)

Here agent.get_query() composes the query for whatever the agent additionally wants to know. has_new_finding() decides whether this response produced anything worth adding to the pool. max_rounds caps how many rounds the debate repeats.

Strengths

1. Consistency: every agent works from the same information
2. Accuracy: external knowledge reduces hallucination
3. Transparency: sources can be cited
4. Scalability: capability grows as the pool grows

Limitations

1. Pool quality: bad information in the pool contaminates everything
2. Retrieval accuracy: the relevant knowledge may not be found
3. Maintenance cost: the pool has to be kept up to date

Summary

MADKE extends Multi-Agent Debate with a shared knowledge pool so that debating agents argue from the same set of facts. The central idea is adaptive knowledge selection: instead of every agent retrieving on every round, each one decides for itself whether external knowledge is needed. The result is fewer wasted arguments caused by mismatched background knowledge, and convergence on a consistent answer with cited sources. The benefit depends on the quality of the pool and the accuracy of retrieval, so it fits domains that can absorb the cost of maintaining that pool.

Related concepts

• Multi-Agent Debate: the underlying debate structure
• RAG: the knowledge retrieval technique
• LLM Agent Survey: cooperation structures