Build a Scientific Research Agent Group with AutoGen

Initialize the three core agent personas in your AutoGen configuration. The Researcher should be prompted to seek empirical evidence, the Critic to identify logical fallacies and data gaps, and the Synthesizer to mediate and create consensus. This separation of concerns is the foundation of the 'Debate' pattern, ensuring that no single model's bias dominates the final output.

Open your Python script and define the configurations:

config_list = [{'model': 'gpt-4o', 'api_key': 'YOUR_KEY'}]
researcher = autogen.AssistantAgent(
    name='Researcher',
    system_message='You focus on retrieving and summarizing empirical data.',
    llm_config={'config_list': config_list}
)
critic = autogen.AssistantAgent(
    name='Critic',
    system_message='Challenge every claim with counter-examples.',
    llm_config={'config_list': config_list}
)

Watch out: Vague system messages lead to 'echo chamber' behavior. Ensure the Critic is explicitly told to be 'hostile' to unsupported claims.

Register a function tool that allows the Researcher agent to query the Semantic Scholar API. This ensures the agents are working with real, peer-reviewed data rather than relying on their internal (and potentially outdated) knowledge base. The tool should accept a search query and return a list of paper titles, abstracts, and citation counts.

@user_proxy.register_for_execution()
@researcher.register_for_llm(description='Search for papers')
def search_papers(query: str):
    # API call logic to Semantic Scholar
    return results

Watch out: API rate limits on Semantic Scholar can trigger agent failures if you request too many papers at once. Implement a simple 'retry' decorator on your search function.

Create a GroupChat object and a GroupChatManager. This orchestrates the turn-taking between the Researcher, Critic, and Synthesizer. Use the 'round_robin' or 'auto' speaker selection method. The 'auto' method allows GPT-4o to decide who should speak next based on the flow of the debate, which is more efficient for complex negotiations.

groupchat = autogen.GroupChat(
    agents=[user_proxy, researcher, critic, synthesizer],
    messages=[],
    max_round=12
)
manager = autogen.GroupChatManager(groupchat=groupchat)

Watch out: Setting max_round too high can lead to infinite loops and high API costs. Start with 8-10 rounds for a standard research summary.

The Synthesizer agent must now take the conflicting outputs from the Researcher and Critic and find a middle ground. This step is where the 'Negotiation' pattern shines: the Synthesizer identifies points of agreement and highlights remaining uncertainties for the user to investigate manually. This ensures the final output isn't just a summary, but a verified analysis.

Watch out: The Synthesizer often defaults to being too polite. Instruct it to explicitly state if the Critic's objections were 'Resolved' or 'Unresolved' in the final report.

Save the entire chat history and the final synthesizer summary to a Markdown file. This provides a 'paper trail' for the research, showing exactly which agents challenged which points. This transparency is critical for scientific integrity and allows you to audit the AI's reasoning process later.

with open('research_report.md', 'w') as f:
    f.write(groupchat.messages[-1]['content'])

Watch out: AutoGen messages contain metadata. Ensure you only export the 'content' field of the final message for a clean report.