Cho các AI model tranh luận với nhau, rồi để Hermes phân xử

Có một câu hỏi mình hay bị ám ảnh mỗi khi dùng AI để giải quyết vấn đề kỹ thuật: Liệu câu trả lời này có thực sự đúng không, hay model đang tự tin hallucinate?

Vấn đề với việc chỉ dùng một AI model là bạn không có gì để so sánh. Model trả lời tự tin, bạn không có cơ sở để phản bác, và nếu nó sai thì bạn chỉ biết sau khi deploy lên prod rồi bị bug. Không hay chút nào.

Vậy là mình nảy ra ý tưởng: thay vì hỏi một model, tại sao không để nhiều model tranh luận với nhau về cùng một vấn đề, rồi dùng một model thứ ba để đánh giá xem ai đúng?

Setup ban đầu: Multi-model debate framework

Kiến trúc tổng thể khá đơn giản. Mình có hai model đóng vai "debater" tạm gọi là Model A và Model B. Chúng nhận cùng một prompt, generate ra response độc lập, sau đó được feed response của nhau để phản biện. Cuối cùng, Hermes (cụ thể là Hermes-3-Llama-3.1-70B) đóng vai judge để đánh giá và đưa ra verdict.

Flow trông như thế này:

1User Query
2    ↓
3[Model A] → Initial Response A
4[Model B] → Initial Response B
5    ↓
6[Model A nhận Response B] → Rebuttal A
7[Model B nhận Response A] → Rebuttal B
8    ↓
9[Hermes Judge] nhận tất cả → Final Verdict

Mình chọn Hermes làm judge vì theo kinh nghiệm của mình, Hermes-3 có khả năng reasoning và instruction-following khá tốt, đặc biệt là khi cần evaluate structured arguments. Nó ít bị bias về phía một câu trả lời "nghe có vẻ tự tin" hơn so với một số model khác.

Code thực tế

Mình dùng Ollama để chạy local, nhưng logic này hoàn toàn có thể áp dụng với OpenAI API hay bất kỳ provider nào.

1import ollama
2
3def get_initial_response(model: str, query: str) -> str:
4    response = ollama.chat(
5        model=model,
6        messages=[
7            {
8                "role": "system",
9                "content": "You are a knowledgeable assistant. Provide a clear, well-reasoned response."
10            },
11            {
12                "role": "user",
13                "content": query
14            }
15        ]
16    )
17    return response['message']['content']
18
19def get_rebuttal(model: str, query: str, own_response: str, opponent_response: str) -> str:
20    response = ollama.chat(
21        model=model,
22        messages=[
23            {
24                "role": "system",
25                "content": "You are in a debate. Review your opponent's response critically and defend or refine your position."
26            },
27            {
28                "role": "user",
29                "content": f"""Original question: {query}
30
31Your initial response: {own_response}
32
33Opponent's response: {opponent_response}
34
35Provide your rebuttal, pointing out any flaws in their reasoning while strengthening your own argument."""
36            }
37        ]
38    )
39    return response['message']['content']
40
41def judge_debate(query: str, debate_transcript: str) -> str:
42    response = ollama.chat(
43        model="hermes3",  # Hermes làm judge
44        messages=[
45            {
46                "role": "system",
47                "content": """You are an impartial judge evaluating a debate between two AI models.
48Analyze the arguments objectively and determine which position is better supported.
49Provide a clear verdict with reasoning."""
50            },
51            {
52                "role": "user",
53                "content": f"""Question being debated: {query}
54
55Debate transcript:
56{debate_transcript}
57
58As the judge, provide:
591. Which model presented stronger arguments
602. Key points that determined your decision
613. Your synthesized answer to the original question"""
62            }
63        ]
64    )
65    return response['message']['content']

Phần orchestration thì đơn giản hơn:

1def run_debate(query: str, model_a: str = "llama3.1", model_b: str = "mistral"):
2    print(f"🤔 Query: {query}\n")
3
4    # Round 1: Initial responses
5    print("📝 Getting initial responses...")
6    response_a = get_initial_response(model_a, query)
7    response_b = get_initial_response(model_b, query)
8
9    # Round 2: Rebuttals
10    print("⚔️ Getting rebuttals...")
11    rebuttal_a = get_rebuttal(model_a, query, response_a, response_b)
12    rebuttal_b = get_rebuttal(model_b, query, response_b, response_a)
13
14    # Compile transcript
15    transcript = f"""
16MODEL A - Initial Response:
17{response_a}
18
19MODEL B - Initial Response:
20{response_b}
21
22MODEL A - Rebuttal:
23{rebuttal_a}
24
25MODEL B - Rebuttal:
26{rebuttal_b}
27"""
28
29    # Judge
30    print("⚖️ Hermes is judging...")
31    verdict = judge_debate(query, transcript)
32
33    return {
34        "query": query,
35        "transcript": transcript,
36        "verdict": verdict
37    }

Kết quả thực tế Khi nào nó thực sự hữu ích?

Mình đã test với nhiều loại câu hỏi khác nhau. Anh em lưu ý là không phải lúc nào cũng cần đến cái framework phức tạp này nó shine nhất trong một số trường hợp cụ thể:

Một ví dụ mình thấy thú vị: khi hỏi về việc nên dùng Redis hay Memcached cho một use case cụ thể, Model A argue mạnh cho Redis với lý do persistence và data structures, Model B lại argue cho Memcached với lý do simplicity và pure caching performance. Hermes sau đó synthesize ra một câu trả lời khá balanced và đặt ra những câu hỏi clarifying mà mình cần trả lời trước khi quyết định. Cái đó thực sự valuable hơn là một câu trả lời một chiều.

Hermes làm judge tốt đến mức nào?

Mình thấy cái này hay ở chỗ Hermes không chỉ đơn giản là "chọn bên" nó thường synthesize điểm mạnh từ cả hai và đưa ra một perspective tổng hợp. Điều này khác với những gì mình expect ban đầu.

Tuy nhiên cũng có limitation rõ ràng: Hermes vẫn là một LLM, nên nó cũng có thể bị bias hoặc đưa ra judgment sai. Mình không nên treat verdict của nó như ground truth tuyệt đối nó chỉ là một data point thêm vào quá trình ra quyết định của mình.

Theo kinh nghiệm của mình, cái framework này hiệu quả nhất khi bạn dùng nó như một tool để explore solution space rộng hơn, không phải để thay thế critical thinking của bản thân.

Latency và cost Cái giá phải trả

Nói thẳng ra thì approach này tốn resource hơn nhiều so với single model query:

• 2 initial responses
• 2 rebuttals
• 1 judge response

Tổng cộng là 5 LLM calls cho một query. Nếu bạn dùng API có tính phí, cái này đắt hơn 5x. Nếu chạy local như mình thì latency sẽ là vấn đề một debate cycle có thể mất vài phút tùy model size.

Vì vậy mình chỉ dùng nó cho những quyết định thực sự quan trọng, không phải cho mọi câu hỏi hàng ngày.

Mở rộng thêm: Async debate

Một optimization mình đang experiment là chạy initial responses song song thay vì tuần tự:

1import asyncio
2
3async def run_debate_async(query: str, model_a: str, model_b: str):
4    # Chạy song song để tiết kiệm thời gian
5    response_a, response_b = await asyncio.gather(
6        asyncio.to_thread(get_initial_response, model_a, query),
7        asyncio.to_thread(get_initial_response, model_b, query)
8    )
9
10    # Rebuttals cũng có thể chạy song song
11    rebuttal_a, rebuttal_b = await asyncio.gather(
12        asyncio.to_thread(get_rebuttal, model_a, query, response_a, response_b),
13        asyncio.to_thread(get_rebuttal, model_b, query, response_b, response_a)
14    )
15
16    # Judge vẫn phải chạy sau
17    transcript = compile_transcript(response_a, response_b, rebuttal_a, rebuttal_b)
18    verdict = judge_debate(query, transcript)
19
20    return verdict

Cái này giảm được latency khá đáng kể thay vì 5 calls tuần tự, bạn có 3 "rounds" với round 1 và 2 chạy parallel.

Khi nào nên dùng pattern này?

Mình không recommend dùng debate framework cho mọi thứ. Nhưng nếu bạn đang:

• Đưa ra một architecture decision quan trọng mà bạn muốn có nhiều góc nhìn
• Review một security design và muốn adversarial thinking
• Evaluate trade-off giữa các technical approaches
• Cần một "second opinion" có cấu trúc hơn là chỉ hỏi lại cùng một model

...thì cái pattern này đáng để thử. Nó không magic, không thay thế được domain expertise của bạn, nhưng nó là một cách thú vị để squeeze thêm value từ các LLM mà bạn đang có sẵn.

Code đầy đủ khá straightforward để implement nếu bạn đã quen với Ollama hay OpenAI SDK thì chỉ mất khoảng một buổi chiều để có một prototype chạy được. Mình nghĩ cái thú vị nhất không phải là kết quả cuối cùng mà là quá trình đọc hai model argue với nhau đôi khi bạn học được nhiều hơn từ cái transcript đó so với bất kỳ câu trả lời đơn lẻ nào.