AI Research Assistant Workflow

Overview

The AI Research Assistant workflow automates the research process by leveraging AI agents to gather information, analyze sources, synthesize findings, and produce comprehensive research reports. This workflow is ideal for market research, competitive analysis, academic research, and technical investigation.

Difficulty: Medium

Tools Required

• CrewAI - For multi-agent research team orchestration
• Brave Search MCP - Web search for current information
• Perplexity - AI-powered search and answers
• Notion - Knowledge base and report storage
• Slack - Team collaboration and sharing
• Google Docs - Report formatting and collaboration

Workflow Steps

Step 1: Research Planning

The Planner Agent defines the research scope:

• Clarify research objectives and questions
• Identify key topics and subtopics
• Determine source types needed
• Set quality criteria for sources

def plan_research(topic, objectives):
    prompt = f"""
    Research Topic: {topic}
    Objectives: {objectives}
    
    Create a research plan including:
    1. Key research questions
    2. Topics to investigate
    3. Source types to prioritize
    4. Quality criteria
    """
    return llm.generate(prompt)

Step 2: Source Discovery

The Researcher Agent finds relevant sources:

• Search web for current information
• Identify authoritative sources
• Collect diverse perspectives
• Filter low-quality content

def discover_sources(plan):
    all_sources = []
    
    for topic in plan["topics"]:
        # Brave Search for web content
        results = brave_search(query=topic, count=20)
        all_sources.extend(results)
        
        # Perplexity for AI-summarized answers
        perplexity_results = perplexity.search(query=topic)
        all_sources.extend(perplexity_results)
    
    # Deduplicate and rank by quality
    return rank_sources(all_sources)

Step 3: Source Analysis

The Analyst Agent evaluates each source:

• Read and extract key information
• Assess credibility and bias
• Identify relevant quotes and data
• Cross-reference with other sources

def analyze_source(source):
    content = fetch_content(source["url"])
    
    analysis = llm.analyze(
        content=content,
        criteria=["credibility", "relevance", "bias", "timeliness"]
    )
    
    return {
        "source": source,
        "analysis": analysis,
        "key_points": extract_key_points(content),
        "quotes": extract_quotes(content),
        "data": extract_data(content)
    }

Step 4: Synthesis

The Synthesizer Agent combines findings:

• Identify patterns across sources
• Resolve conflicting information
• Build coherent narrative
• Highlight consensus and disagreements

def synthesize_findings(analyzed_sources):
    # Group by theme
    themes = group_by_theme(analyzed_sources)
    
    # For each theme, synthesize
    synthesis = {}
    for theme, sources in themes.items():
        synthesis[theme] = {
            "summary": llm.summarize(sources),
            "consensus": identify_consensus(sources),
            "disagreements": identify_disagreements(sources),
            "evidence": collect_evidence(sources)
        }
    
    return synthesis

Step 5: Report Generation

The Writer Agent produces the final report:

• Structure the report logically
• Write clear, concise sections
• Include citations and references
• Add executive summary

def generate_report(synthesis, format="markdown"):
    report = {
        "title": synthesis["topic"],
        "executive_summary": generate_executive_summary(synthesis),
        "sections": [],
        "references": []
    }
    
    for theme, data in synthesis["themes"].items():
        section = {
            "heading": theme,
            "content": write_section(theme, data),
            "citations": data["evidence"]["citations"]
        }
        report["sections"].append(section)
        report["references"].extend(data["evidence"]["sources"])
    
    return format_report(report, format)

Step 6: Review and Refine

The Editor Agent improves the report:

• Check for clarity and flow
• Verify citations are accurate
• Ensure consistent tone
• Add visual elements suggestions

def edit_report(report):
    improvements = []
    
    # Clarity check
    unclear_passages = find_unclear_passages(report)
    if unclear_passages:
        improvements.append({
            "type": "clarity",
            "suggestions": suggest_improvements(unclear_passages)
        })
    
    # Citation verification
    invalid_citations = verify_citations(report["references"])
    if invalid_citations:
        improvements.append({
            "type": "citations",
            "issues": invalid_citations
        })
    
    # Tone consistency
    tone_issues = check_tone_consistency(report)
    if tone_issues:
        improvements.append({
            "type": "tone",
            "suggestions": tone_issues
        })
    
    return {
        "report": report,
        "improvements": improvements
    }

Step 7: Distribution

The Distributor Agent shares the report:

• Post to Notion knowledge base
• Share with team via Slack
• Create summary for quick consumption
• Archive for future reference

def distribute_report(report, team_channels):
    # Create Notion page
    notion_page = notion.create_page(
        title=report["title"],
        content=report["content"],
        parent="Research Reports"
    )
    
    # Share with team
    for channel in team_channels:
        slack.post_message(
            channel=channel,
            text=f"📊 New Research Report: {report['title']}\nView: {notion_page['url']}"
        )
    
    # Create executive summary
    summary = create_executive_summary(report)
    slack.post_message(
        channel="#research-updates",
        text=summary
    )
    
    return {"notion_page": notion_page, "shared_to": team_channels}

Example Usage

Scenario: Market Research

Researcher: "Research the current state of AI agent frameworks for enterprise use"

AI Workflow:
1. ✅ Planner: Defines scope (market size, key players, trends, challenges)
2. ✅ Researcher: Finds 50+ sources from tech blogs, reports, forums
3. ✅ Analyst: Evaluates credibility, extracts key data points
4. ✅ Synthesizer: Identifies market leaders, emerging trends, pain points
5. ✅ Writer: Produces 15-page comprehensive report
6. ✅ Editor: Refines for clarity, verifies all citations
7. ✅ Distributor: Posts to Notion, shares to #research and #product teams

Scenario: Competitive Analysis

Researcher: "Analyze our top 3 competitors' AI features"

AI Workflow:
1. ✅ Planner: Identifies competitors and comparison dimensions
2. ✅ Researcher: Gathers product docs, reviews, news
3. ✅ Analyst: Extracts feature lists, pricing, user feedback
4. ✅ Synthesizer: Creates comparison matrix, identifies gaps
5. ✅ Writer: Produces competitive analysis report
6. ✅ Editor: Ensures objective tone, accurate claims
7. ✅ Distributor: Shares to #strategy and leadership

CrewAI Agent Definitions

from crewai import Agent, Task, Crew

# Planner Agent
planner = Agent(
    role='Research Planner',
    goal='Define comprehensive research scope and plan',
    backstory='Expert research methodology specialist with 10+ years of experience',
    verbose=True,
    allow_delegation=False
)

# Researcher Agent
researcher = Agent(
    role='Information Researcher',
    goal='Find and collect high-quality sources on the topic',
    backstory='Skilled researcher with expertise in web research and source evaluation',
    verbose=True,
    allow_delegation=True
)

# Analyst Agent
analyst = Agent(
    role='Source Analyst',
    goal='Evaluate sources and extract key information',
    backstory='Critical thinker with strong analytical skills and attention to detail',
    verbose=True,
    allow_delegation=False
)

# Synthesizer Agent
synthesizer = Agent(
    role='Research Synthesizer',
    goal='Combine findings into coherent insights',
    backstory='Expert in pattern recognition and information synthesis',
    verbose=True,
    allow_delegation=True
)

# Writer Agent
writer = Agent(
    role='Technical Writer',
    goal='Produce clear, well-structured research reports',
    backstory='Professional technical writer with expertise in research documentation',
    verbose=True,
    allow_delegation=False
)

# Tasks
plan_task = Task(
    description='Create detailed research plan for: {topic}',
    expected_output='Research plan with questions, topics, and criteria',
    agent=planner
)

research_task = Task(
    description='Find and collect sources based on the plan',
    expected_output='List of 20+ high-quality sources with URLs',
    agent=researcher,
    context=[plan_task]
)

# Create crew
crew = Crew(
    agents=[planner, researcher, analyst, synthesizer, writer],
    tasks=[plan_task, research_task, analysis_task, synthesis_task, writing_task],
    verbose=True
)

result = crew.kickoff(inputs={"topic": "AI agent frameworks for enterprise"})

Configuration

Brave Search API

export BRAVE_API_KEY=your-api-key

Perplexity API

export PERPLEXITY_API_KEY=your-api-key

Notion Integration

export NOTION_INTEGRATION_TOKEN=secret_xxx
export NOTION_DATABASE_ID=your-database-id

Slack Integration

export SLACK_BOT_TOKEN=xoxb-xxx

Pros

• ✅ Comprehensive Research: Covers multiple angles and sources
• ✅ Time Savings: Reduces research time by 70%+
• ✅ Consistent Quality: Standardized evaluation criteria
• ✅ Citation Tracking: Automatic reference management
• ✅ Team Collaboration: Easy sharing and feedback
• ✅ Reusable Process: Same workflow for different topics

Cons

• ❌ API Costs: Multiple AI calls can be expensive
• ❌ Source Quality: Depends on search engine results
• ❌ Bias Risk: AI may introduce subtle biases
• ❌ Complexity: Multi-agent setup requires configuration
• ❌ Time: Full workflow takes 15-30 minutes

When to Use

Choose this workflow when:

• You need comprehensive research on a topic
• You're doing market or competitive analysis
• You need to produce professional research reports
• You want consistent research quality across your team

Consider alternatives when:

• You need quick, simple answers (use Perplexity directly)
• You're doing academic research requiring strict methodology
• You have very specific source requirements

Resources

• CrewAI Docs: https://docs.crewai.com/
• Brave Search API: https://brave.com/search/api/
• Perplexity API: https://docs.perplexity.ai/
• Notion API: https://developers.notion.com/

---

Last updated: May 2026