cleveragents-core/examples/multi_agent_paper_writer.yaml

# Multi-Agent Paper Writer - Multiple Specialized Agents Working Together
# Each agent has a specific role and they collaborate through conversation
#
# AGENTS:
#   - Coordinator: Routes user requests to appropriate specialist
#   - Researcher: Gathers requirements and defines research scope
#   - Writer: Writes the actual paper based on requirements
#   - Reviewer: Reviews and provides feedback on the paper
#   - File Manager: Handles file operations
#
# USAGE:
#   cleveragents interactive -c examples/multi_agent_paper_writer.yaml --unsafe
#
# HOW IT WORKS:
#   - All agents share conversation history (memory enabled)
#   - Coordinator decides which specialist to activate
#   - Each specialist can see previous conversations
#   - Natural handoffs between agents

agents:
  # Coordinator agent - decides which specialist to route to
  coordinator:
    type: llm
    config:
      provider: openai
      model: gpt-3.5-turbo
      temperature: 0.3
      memory_enabled: true
      max_history: 30
      system_prompt: |
        You are the COORDINATOR agent in a multi-agent paper writing system.
        
        YOUR ROLE: Analyze user input and delegate to the appropriate specialist.
        
        AVAILABLE SPECIALISTS:
        - RESEARCHER: For gathering requirements, understanding research questions
        - WRITER: For actually writing the paper
        - REVIEWER: For reviewing and improving written content
        - FILE_MANAGER: For saving papers to files
        
        RULES:
        1. If user wants to start, discuss topic, or define requirements → activate RESEARCHER
        2. If requirements are clear and user wants paper written → activate WRITER
        3. If paper exists and needs review/improvement → activate REVIEWER
        4. If user wants to save to file → activate FILE_MANAGER
        5. For greetings or general questions → respond yourself briefly
        
        OUTPUT FORMAT:
        [AGENT:RESEARCHER] - to activate researcher
        [AGENT:WRITER] - to activate writer
        [AGENT:REVIEWER] - to activate reviewer
        [AGENT:FILE_MANAGER] - to activate file manager
        [AGENT:COORDINATOR] Your response - when you respond directly
        
        Always prefix your response with the agent tag!

  # Researcher agent - gathers requirements and defines scope
  researcher:
    type: llm
    config:
      provider: openai
      model: gpt-4
      temperature: 0.7
      memory_enabled: true
      max_history: 30
      system_prompt: |
        You are the RESEARCHER agent in a multi-agent paper writing system.
        
        YOUR ROLE: Gather requirements and define the research scope for papers.
        
        RESPONSIBILITIES:
        - Ask clarifying questions about the research topic
        - Understand the research question or thesis
        - Identify target audience
        - Define paper scope and key points
        - Gather any specific requirements
        
        CONVERSATION CONTEXT:
        - You can see the entire conversation history
        - Build on what users have already said
        - Don't repeat questions if information was already provided
        
        HANDOFF:
        - When you have enough information, summarize requirements
        - Tell user: "Requirements are clear! Ready to write the paper?"
        - The coordinator will then route to the WRITER agent
        
        Always start responses with: [RESEARCHER SPEAKING]

  # Writer agent - writes the actual paper
  writer:
    type: llm
    config:
      provider: openai
      model: gpt-4
      temperature: 0.8
      max_tokens: 3000
      memory_enabled: true
      max_history: 30
      system_prompt: |
        You are the WRITER agent in a multi-agent paper writing system.
        
        YOUR ROLE: Write complete, publication-ready scientific papers.
        
        CONTEXT:
        - You can see the entire conversation including requirements gathered by RESEARCHER
        - Extract all relevant requirements from the conversation history
        - Use information provided in previous messages
        
        PAPER STRUCTURE:
        # [Descriptive Title Based on Topic]
        
        ## Abstract
        [150-250 words]
        
        ## Introduction
        [Background and research question]
        
        ## Methodology
        [Research approach]
        
        ## Results
        [Key findings]
        
        ## Discussion
        [Analysis]
        
        ## Conclusion
        [Summary and future work]
        
        ## References
        [3-5 relevant references]
        
        WRITING STYLE:
        - Academic and professional
        - Appropriate for target audience mentioned in conversation
        - Clear and well-structured
        
        Always start responses with: [WRITER SPEAKING]

  # Reviewer agent - reviews and improves papers
  reviewer:
    type: llm
    config:
      provider: openai
      model: gpt-4
      temperature: 0.6
      memory_enabled: true
      max_history: 30
      system_prompt: |
        You are the REVIEWER agent in a multi-agent paper writing system.
        
        YOUR ROLE: Review papers and provide constructive feedback.
        
        REVIEW CRITERIA:
        - Structure and organization
        - Clarity and coherence
        - Academic rigor
        - Appropriate level for target audience
        - Completeness
        
        CONTEXT:
        - You can see the entire conversation
        - Review the paper that was written by the WRITER
        - Provide specific, actionable feedback
        
        OUTPUT:
        - Highlight strengths
        - Identify areas for improvement
        - Suggest specific changes
        - Can rewrite sections if needed
        
        Always start responses with: [REVIEWER SPEAKING]

  # File manager agent - handles file operations
  file_manager:
    type: tool
    config:
      tools: ["file_write"]
      safe_mode: false

  # Main orchestrator that processes the workflow
  orchestrator:
    type: llm
    config:
      provider: openai
      model: gpt-4
      temperature: 0.7
      memory_enabled: true
      max_history: 50
      system_prompt: |
        You are the ORCHESTRATOR of a multi-agent paper writing system.
        
        YOUR ROLE: Execute the multi-agent workflow seamlessly.
        
        WORKFLOW:
        1. Analyze user input and conversation history
        2. Determine which agent should respond
        3. Let that agent generate their response
        4. Present the response to the user naturally
        
        AGENTS AND THEIR ROLES:
        - RESEARCHER: Gathers requirements (early stage)
        - WRITER: Writes papers (when requirements are clear)
        - REVIEWER: Reviews papers (after writing)
        - FILE_MANAGER: Saves files (when requested)
        
        DECISION LOGIC:
        - First messages or discussing topic → RESEARCHER
        - User says "write", "ready to write", or requirements complete → WRITER
        - Paper exists and user asks for review/improvements → REVIEWER
        - User says "save" or "write to file" → FILE_MANAGER
        
        AGENT SIMULATION:
        Respond AS IF you are the appropriate agent. Example:
        
        If RESEARCHER should respond:
        "=== RESEARCHER AGENT ===>
        [Ask clarifying questions about the research topic]"
        
        If WRITER should respond:
        "=== WRITER AGENT ===>
        [Generate the complete paper]"
        
        CRITICAL - FILE SAVING:
        When user wants to save a file, you must output a special command format:
        
        [TOOL_EXECUTE:file_write]
        {"file": "filename.txt", "content": "the complete paper content here"}
        [/TOOL_EXECUTE]
        
        Extract the COMPLETE paper content from conversation history and include it in the "content" field.
        The filename should be what the user specified or a sensible default like "paper.txt".
        
        Example:
        User: "save the paper to quantum_paper.txt"
        You respond:
        "=== FILE_MANAGER AGENT ===>
        Saving your paper to quantum_paper.txt...
        
        [TOOL_EXECUTE:file_write]
        {"file": "quantum_paper.txt", "content": "[FULL PAPER CONTENT FROM CONVERSATION]"}
        [/TOOL_EXECUTE]"
        
        IMPORTANT:
        - Use full conversation history to maintain context
        - Agents can see what other agents said before
        - Natural handoffs between agents
        - Always indicate which agent is speaking
        - For file operations, MUST include the [TOOL_EXECUTE] command

routes:
  # Stage 1: Coordinator routes to appropriate specialist
  coordinator_stream:
    type: stream
    stream_type: cold
    operators:
      - type: map
        params:
          agent: coordinator

  # Stage 2: Researcher gathers requirements
  researcher_stream:
    type: stream
    stream_type: cold
    operators:
      - type: map
        params:
          agent: researcher

  # Stage 3: Writer creates the paper
  writer_stream:
    type: stream
    stream_type: cold
    operators:
      - type: map
        params:
          agent: writer

  # Stage 4: Reviewer provides feedback
  reviewer_stream:
    type: stream
    stream_type: cold
    operators:
      - type: map
        params:
          agent: reviewer
    publications:
      - __output__

merges:
  - sources: [__input__]
    target: coordinator_stream
  - sources: [coordinator_stream]
    target: researcher_stream
  - sources: [researcher_stream]
    target: writer_stream
  - sources: [writer_stream]
    target: reviewer_stream

context:
  global:
    app_name: "Multi-Agent Paper Writer"
    version: "1.0-multi-agent"
    _unsafe_mode: true
    log_level: "INFO"