	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Agentic AI > Multi-Agent Coordination > Multi-Agent Debate and Verification

Multi-Agent Debate and Verification

Author: Venkata Sudhakar

Before ShopMax India publishes AI-generated product descriptions, two reviewer agents independently evaluate each draft for accuracy and tone. A judge agent then compares their verdicts and produces a final approved version. This debate pattern catches errors a single reviewer would miss and improves content quality across thousands of product listings without requiring human review on every item.

The debate pattern uses three agents in sequence: a generator produces a draft, two independent critics evaluate it from different angles, and a judge synthesizes their feedback into a final decision. LangGraph stores all drafts and critiques in the shared state so the judge has complete context. The pattern scales to any number of critics by simply adding more nodes before the judge.

The example below shows a product description debate for a ShopMax India listing where two critic agents review a draft and a judge produces the final approved version.

from typing import TypedDict, Annotated
from langgraph.graph import StateGraph, END
from langgraph.graph.message import add_messages
from langchain_openai import ChatOpenAI

class DebateState(TypedDict):
    product: str
    draft: str
    critique_a: str
    critique_b: str
    final: str
    messages: Annotated[list, add_messages]

llm = ChatOpenAI(model="gpt-4o-mini")

def generator_agent(state):
    draft = llm.invoke("Write a 2-sentence ShopMax product description for: " + state["product"]).content
    return {"draft": draft}

def critic_a(state):
    review = llm.invoke("Check factual accuracy of this ShopMax product description: " + state["draft"]).content
    return {"critique_a": review}

def critic_b(state):
    review = llm.invoke("Check tone and customer appeal of this ShopMax description: " + state["draft"]).content
    return {"critique_b": review}

def judge_agent(state):
    prompt = "Draft: " + state["draft"] + " Accuracy: " + state["critique_a"] + " Tone: " + state["critique_b"] + " Produce final approved description."
    final = llm.invoke(prompt).content
    return {"final": final}

builder = StateGraph(DebateState)
builder.add_node("generator_agent", generator_agent)
builder.add_node("critic_a", critic_a)
builder.add_node("critic_b", critic_b)
builder.add_node("judge_agent", judge_agent)
builder.set_entry_point("generator_agent")
builder.add_edge("generator_agent", "critic_a")
builder.add_edge("critic_a", "critic_b")
builder.add_edge("critic_b", "judge_agent")
builder.add_edge("judge_agent", END)
graph = builder.compile()

result = graph.invoke({"product": "Sony WH-1000XM5 Headphones", "draft": "", "critique_a": "", "critique_b": "", "final": "", "messages": []})
print(result["final"])

It gives the following output,

Final approved description:
Experience industry-leading noise cancellation with the Sony WH-1000XM5,
featuring 30-hour battery life and crystal-clear call quality.
Available on ShopMax India with free delivery across Mumbai, Delhi, Bangalore, and Chennai.

In production, run the two critic agents in parallel using async_execution to halve latency on each product listing. Add a confidence threshold in the judge: if both critics flag the same issue, send the listing to a human reviewer instead of auto-approving. Store all debate rounds in a database to train future classifier models on what separates high-quality ShopMax product copy from poor drafts.

Send your comments, suggestions or queries regarding this site to [email protected].