Search Strategies

Debate and Multi-Agent

N nodes take opposing positions, each critiques the others, and a judge synthesizes the verdict. For tasks with legitimate opposing arguments.

Shape and when to use

Shape: N nodes take opposing positions, each critiques the others, a judge picks the winner or synthesizes a balanced verdict.

When to use: questions with legitimate opposing arguments (policy, ethics, design tradeoffs, investment decisions). Less useful for factual questions where one position is simply correct.

Cost: 2N + 1 LLM calls (positions plus rebuttals plus judge). Latency: 3 LLM rounds deep.

Config sketch

yaml

steps:
  - id: positions
    type: normal
    nodes: 2                                # pro and con
    fields:
      - { name: Context, type: text, from: input.context }
      - { name: Side, type: nodeInfo }
    systemPrompt: |
      Argue position {Side} of 2. Node 1 = strongly in favor.
      Node 2 = strongly against. Make the strongest case for your side.

  - id: rebuttals
    type: normal
    nodes: 2
    fields:
      - { name: Own Position, type: ingest, from: { stepId: positions, loopRef: current, nodeRef: current } }
      - name: Opposing Views
        type: multi_ingest
        from:
          - { stepId: positions, loopRef: current, nodeRef: accumulate }
    systemPrompt: "Address the strongest points from the opposing views."

  - id: judge
    type: normal
    fields:
      - name: Debate
        type: multi_ingest
        from:
          - { stepId: positions,  loopRef: current, nodeRef: accumulate }
          - { stepId: rebuttals,  loopRef: current, nodeRef: accumulate }
    systemPrompt: |
      Weigh both sides of the debate. Synthesize a balanced verdict
      that acknowledges the strongest arguments on each side.

Variants

N-way debate. Set nodes: 4 (or higher) with a system prompt that assigns distinct stakeholder perspectives. Common 4-way setup: user, business, legal, engineering.

Adversarial verification. Use the debate pattern as a verifier: argue "the answer is correct" versus "the answer is incorrect" and let the judge decide. Can be more effective than self-consistency on verification tasks.

Multi-round debate. Add additional rebuttal rounds. Each round's rebuttals ingest prior rounds via nodeRef: accumulate. Cost grows linearly with rounds; quality gains diminish around 2 to 3 rounds.