Build Reasoning Agent

Build Reasoning Agent

You are an expert at building AG2 reasoning agents. When the user wants enhanced reasoning capabilities:

1. Understand the Requirements

Ask the user:

• What kind of problem? (Mathematical, analytical, creative, coding)
• How much reasoning depth is needed? (Simple → beam search, Complex → MCTS/LATS)
• Is there a grading/evaluation component? (Use a separate grader LLM config)

2. Basic Reasoning Agent

import os
from autogen import LLMConfig, UserProxyAgent
from autogen.agents.experimental import ReasoningAgent

llm_config = LLMConfig(
    {"model": "gpt-4o-mini", "api_key": os.environ["OPENAI_API_KEY"]}
)

# ReasoningAgent explores multiple reasoning paths using tree-of-thought
reasoning_agent = ReasoningAgent(
    name="reasoner",
    llm_config=llm_config,
    reason_config={
        "method": "beam_search",  # Explore multiple paths in parallel
        "beam_size": 3,           # Number of parallel reasoning paths
        "max_depth": 4,           # Maximum reasoning steps
    },
)

user = UserProxyAgent(
    name="user",
    human_input_mode="NEVER",
    code_execution_config=False,
)

result = await user.a_run(
    reasoning_agent,
    message="What is the probability of getting exactly 3 heads in 5 coin flips?",
)
await result.process()

3. Reasoning Methods

Beam Search (Default)

reason_config = {
    "method": "beam_search",
    "beam_size": 3,           # Parallel paths (default: 3)
    "max_depth": 4,           # Max reasoning steps (default: 3)
    "answer_approach": "pool", # "pool" combines paths, "best" picks top one
}

MCTS (Monte Carlo Tree Search)

reason_config = {
    "method": "mcts",
    "nsim": 10,               # Number of simulations (default: 3)
    "exploration_constant": 1.41,  # UCT exploration parameter
    "max_depth": 4,
}

LATS (Language Agent Tree Search)

reason_config = {
    "method": "lats",
    "nsim": 5,
    "forest_size": 3,         # Number of independent trees
    "max_depth": 4,
}

4. Separate Grader Model

Use a different (possibly stronger) model for grading reasoning paths:

grader_config = LLMConfig(
    {"model": "gpt-4o", "api_key": os.environ["OPENAI_API_KEY"]}
)

reasoning_agent = ReasoningAgent(
    name="reasoner",
    llm_config=llm_config,
    grader_llm_config=grader_config,  # Stronger model evaluates paths
    reason_config={"method": "beam_search", "beam_size": 5},
)

5. ReasoningAgent in Group Chat

from autogen import ConversableAgent
from autogen.agentchat import run_group_chat
from autogen.agentchat.group.patterns import RoundRobinPattern

reasoner = ReasoningAgent(
    name="reasoner",
    llm_config=llm_config,
    reason_config={"method": "beam_search", "beam_size": 3, "max_depth": 3},
    description="Performs deep reasoning on complex problems.",
)

executor = ConversableAgent(
    name="executor",
    system_message="You take the reasoner's solution and implement it step by step.",
    llm_config=llm_config,
    human_input_mode="NEVER",
    description="Implements the reasoned solution.",
)

user = ConversableAgent(name="user", llm_config=False, human_input_mode="NEVER")

result = run_group_chat(
    pattern=RoundRobinPattern(
        initial_agent=reasoner,
        agents=[reasoner, executor],
        user_agent=user,
    ),
    messages="Design an algorithm to find the shortest path in a weighted graph with negative edges.",
    max_rounds=8,
)

6. Rules

• Import from autogen.agents.experimental, not autogen.agentchat
• beam_size and answer_approach as top-level params are deprecated — use reason_config dict instead
• Higher beam_size / nsim = better reasoning but more LLM calls and cost
• Use grader_llm_config with a stronger model for better path evaluation
• Start with beam_search (simplest), move to mcts/lats if needed
• Set max_depth to limit reasoning depth — deeper isn't always better
• forest_size > 1 runs multiple independent reasoning trees (more diverse solutions)