CrewAI Tutorial: Role-Based Multi-Agent Collaboration (2026)

pip install crewai crewai-tools langchain-openai python-dotenv

import os
from dotenv import load_dotenv
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool, FileReadTool
from langchain_openai import ChatOpenAI

load_dotenv()

# You can configure the LLM globally or per-agent
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")

# Optional: configure a search tool for the Researcher
search_tool = SerperDevTool()

# Agent 1: Researcher
researcher = Agent(
    role="Senior Research Analyst",
    goal="""Find accurate, current, and relevant information on the given topic.
    Prioritize primary sources, recent publications, and authoritative data.
    Always verify claims across multiple sources before including them.""",
    backstory="""You spent 10 years as an academic researcher before joining an AI-driven 
    content studio. You have a deep intolerance for unsourced claims and a habit of 
    fact-checking everything twice. You know how to find information that isn't on the 
    first page of Google.""",
    tools=[search_tool],
    verbose=True,
    allow_delegation=False,  # This agent focuses on its own task
    llm=ChatOpenAI(model="gpt-4o", temperature=0.1)
)

# Agent 2: Writer
writer = Agent(
    role="Content Writer",
    goal="""Transform research findings into engaging, well-structured articles.
    Write with clarity and authority. Use concrete examples. Vary sentence length.
    Target a technically informed but non-specialist audience.""",
    backstory="""You've written for major tech publications and know how to explain 
    complex topics without talking down to readers. You hate jargon for jargon's sake
    and always ask yourself whether the sentence earns its place in the piece.""",
    tools=[],
    verbose=True,
    allow_delegation=False,
    llm=ChatOpenAI(model="gpt-4o", temperature=0.4)  # Slightly warmer for creative output
)

# Agent 3: Editor
editor = Agent(
    role="Senior Editor",
    goal="""Review and improve written content for accuracy, clarity, and quality.
    Check facts against research findings. Improve structure where needed.
    Ensure the piece meets publication standards and serves the reader's needs.""",
    backstory="""You've edited technology content for 15 years. You have a sharp eye 
    for when an article buries the lede, relies on unsupported claims, or uses five 
    words where two would do. You improve without rewriting — you make the writer's 
    voice better, not different.""",
    tools=[],
    verbose=True,
    allow_delegation=False,
    llm=ChatOpenAI(model="gpt-4o", temperature=0.1)
)

research_task = Task(
    description="""Research the following topic thoroughly: {topic}
    
    Your research should cover:
    1. Current state of the field — what's true as of 2026
    2. Key statistics and data points (with sources)
    3. Notable examples, case studies, or implementations
    4. Common misconceptions or areas of debate
    5. Recent developments (past 12 months)
    
    Provide well-organized findings that a writer can immediately use.
    Include source URLs for all major claims.""",
    expected_output="""A structured research document with:
    - Executive Summary (2-3 sentences)
    - Key Facts & Statistics (bulleted, with sources)
    - Notable Examples (3-5 concrete cases)
    - Controversies or Open Questions
    - Source List (URLs with brief description)
    Minimum 600 words of findings.""",
    agent=researcher,
    output_file="research_findings.md"  # Optional: save to file
)

writing_task = Task(
    description="""Using the research findings, write a comprehensive article on: {topic}
    
    Article requirements:
    - 1500-2000 words
    - Clear introduction that hooks the reader
    - 4-5 main sections with descriptive H2 headers
    - At least one concrete example or case study per section
    - Cite key statistics with source attribution [Source: name/URL]
    - Conclusion with clear takeaways and next steps
    - Tone: informative but not academic; expert but accessible
    
    The article should be ready for editorial review.""",
    expected_output="""A complete article in Markdown format with:
    - Compelling title
    - All H2 and H3 headers in place
    - All statistics cited inline
    - Word count between 1500-2000 words
    - No placeholder text or TODO markers""",
    agent=writer,
    context=[research_task],  # This task gets researcher's output as context
)

editing_task = Task(
    description="""Edit and finalize the article on: {topic}
    
    Editorial review checklist:
    1. Fact accuracy: verify key claims against the research findings
    2. Structure: does the flow make sense? Is the lede buried?
    3. Clarity: identify any confusing passages and improve them
    4. Conciseness: cut redundant sentences or sections
    5. Tone consistency: ensure voice is consistent throughout
    6. Citation completeness: ensure all statistics are attributed
    
    Make specific improvements. Track your changes and reasoning.""",
    expected_output="""The final edited article with:
    - All issues from review resolved
    - Editorial notes appended as a separate section titled '## Editorial Notes'
    - Final word count
    - Quality rating: Excellent / Good / Needs Revision""",
    agent=editor,
    context=[research_task, writing_task],  # Editor sees both research and draft
    output_file="final_article.md"
)

content_crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.sequential,  # Tasks execute in order
    verbose=True,
    memory=True,  # Enable memory for context retention
    max_rpm=10,   # Rate limit: 10 requests per minute (prevents API throttling)
    share_crew=False
)

# Run with a specific topic
result = content_crew.kickoff(inputs={
    "topic": "How multi-agent AI systems are being used in enterprise software development in 2026"
})

print("\n" + "="*60)
print("CREW EXECUTION COMPLETE")
print("="*60)
print(result.raw)  # Final task output
print(f"\nToken usage: {result.token_usage}")

from crewai.memory import ShortTermMemory, LongTermMemory, EntityMemory

content_crew_with_memory = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.sequential,
    memory=True,  # Enables all memory types
    verbose=True,
)

# For persistent long-term memory across crew runs:
from crewai.memory.storage.ltm_sqlite_storage import LTMSQLiteStorage

long_term_crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.sequential,
    memory=True,
    long_term_memory=LongTermMemory(
        storage=LTMSQLiteStorage(db_path="./crew_memory.db")
    ),
)

# Add a manager agent
crew_manager = Agent(
    role="Content Production Manager",
    goal="Coordinate the research, writing, and editing team to produce high-quality content efficiently.",
    backstory="You manage a content team and are excellent at knowing when work meets standards and when it needs revision.",
    llm=ChatOpenAI(model="gpt-4o", temperature=0),
    allow_delegation=True  # Manager CAN delegate
)

hierarchical_crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.hierarchical,
    manager_agent=crew_manager,  # Specify the manager
    verbose=True,
)

import os
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv

load_dotenv()

def create_content_crew(topic: str) -> str:
    search_tool = SerperDevTool()
    llm_precise = ChatOpenAI(model="gpt-4o", temperature=0.1)
    llm_creative = ChatOpenAI(model="gpt-4o", temperature=0.4)
    
    researcher = Agent(
        role="Senior Research Analyst",
        goal="Find accurate, current information with verifiable sources.",
        backstory="Rigorous academic researcher who never includes an unverified claim.",
        tools=[search_tool], verbose=True, llm=llm_precise
    )
    
    writer = Agent(
        role="Content Writer",
        goal="Transform research into engaging, well-structured articles.",
        backstory="Tech journalist who makes complex topics accessible.",
        verbose=True, llm=llm_creative
    )
    
    editor = Agent(
        role="Senior Editor",
        goal="Review for accuracy, clarity, and quality.",
        backstory="15-year veteran editor with a sharp eye for unclear writing.",
        verbose=True, llm=llm_precise
    )
    
    research = Task(
        description=f"Research this topic thoroughly: {topic}\nFind key facts, examples, and recent developments.",
        expected_output="Structured research with bullet points, statistics, and source URLs.",
        agent=researcher
    )
    
    draft = Task(
        description=f"Write a 1500-word article on: {topic}",
        expected_output="Complete Markdown article with headers and inline citations.",
        agent=writer, context=[research]
    )
    
    final_edit = Task(
        description=f"Edit and finalize the article on: {topic}",
        expected_output="Final article with editorial notes. Quality rating included.",
        agent=editor, context=[research, draft]
    )
    
    crew = Crew(
        agents=[researcher, writer, editor],
        tasks=[research, draft, final_edit],
        process=Process.sequential,
        verbose=True
    )
    
    result = crew.kickoff()
    return result.raw

# Run it
output = create_content_crew("The impact of AI agents on software engineering teams in 2026")
print(output)