update

docs/guides/crews/first-crew.mdx

@@ -0,0 +1,313 @@
+---
+title: Build Your First Crew
+description: Step-by-step tutorial to create a collaborative AI team that works together to solve complex problems.
+icon: users-gear
+---
+
+# Build Your First Crew
+
+In this guide, we'll walk through creating a research crew that will help us research and analyze a topic, then create a comprehensive report. This is a practical example of how AI agents can collaborate to accomplish complex tasks.
+
+
+
+Before starting, make sure you have:
+
+1. Installed CrewAI following the [installation guide](/installation)
+2. Set up your OpenAI API key in your environment variables
+3. Basic understanding of Python
+
+## Step 1: Create a New CrewAI Project
+
+First, let's create a new CrewAI project using the CLI:
+
+```bash
+crewai create crew research_crew
+cd research_crew
+```
+
+This will generate a project with the basic structure needed for your crew. The CLI automatically creates:
+
+- A project directory with the necessary files
+- Configuration files for agents and tasks
+- A basic crew implementation
+- A main script to run the crew
+
+<Frame caption="CrewAI Framework Overview">
+  <img src="../../crews.png" alt="CrewAI Framework Overview" />
+</Frame>
+
+
+## Step 2: Explore the Project Structure
+
+Let's take a moment to understand the project structure created by the CLI:
+
+```
+research_crew/
+├── .gitignore
+├── pyproject.toml
+├── README.md
+├── .env
+└── src/
+    └── research_crew/
+        ├── __init__.py
+        ├── main.py
+        ├── crew.py
+        ├── tools/
+        │   ├── custom_tool.py
+        │   └── __init__.py
+        └── config/
+            ├── agents.yaml
+            └── tasks.yaml
+```
+
+This structure follows best practices for Python projects and makes it easy to organize your code.
+
+## Step 3: Configure Your Agents
+
+Let's modify the `agents.yaml` file to define two specialized agents: a researcher and an analyst.
+
+```yaml
+# src/research_crew/config/agents.yaml
+researcher:
+  role: >
+    Senior Research Specialist for {topic}
+  goal: >
+    Find comprehensive and accurate information about {topic}
+    with a focus on recent developments and key insights
+  backstory: >
+    You are an experienced research specialist with a talent for
+    finding relevant information from various sources. You excel at
+    organizing information in a clear and structured manner, making
+    complex topics accessible to others.
+  llm: openai/gpt-4o-mini
+
+analyst:
+  role: >
+    Data Analyst and Report Writer for {topic}
+  goal: >
+    Analyze research findings and create a comprehensive, well-structured
+    report that presents insights in a clear and engaging way
+  backstory: >
+    You are a skilled analyst with a background in data interpretation
+    and technical writing. You have a talent for identifying patterns
+    and extracting meaningful insights from research data, then
+    communicating those insights effectively through well-crafted reports.
+  llm: openai/gpt-4o-mini
+```
+
+## Step 4: Define Your Tasks
+
+Now, let's modify the `tasks.yaml` file to define the research and analysis tasks:
+
+```yaml
+# src/research_crew/config/tasks.yaml
+research_task:
+  description: >
+    Conduct thorough research on {topic}. Focus on:
+    1. Key concepts and definitions
+    2. Historical development and recent trends
+    3. Major challenges and opportunities
+    4. Notable applications or case studies
+    5. Future outlook and potential developments
+
+    Make sure to organize your findings in a structured format with clear sections.
+  expected_output: >
+    A comprehensive research document with well-organized sections covering
+    all the requested aspects of {topic}. Include specific facts, figures,
+    and examples where relevant.
+  agent: researcher
+
+analysis_task:
+  description: >
+    Analyze the research findings and create a comprehensive report on {topic}.
+    Your report should:
+    1. Begin with an executive summary
+    2. Include all key information from the research
+    3. Provide insightful analysis of trends and patterns
+    4. Offer recommendations or future considerations
+    5. Be formatted in a professional, easy-to-read style with clear headings
+  expected_output: >
+    A polished, professional report on {topic} that presents the research
+    findings with added analysis and insights. The report should be well-structured
+    with an executive summary, main sections, and conclusion.
+  agent: analyst
+  context:
+    - research_task
+  output_file: output/report.md
+```
+
+## Step 5: Configure Your Crew
+
+Now, let's modify the `crew.py` file to set up our research crew:
+
+```python
+# src/research_crew/crew.py
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+from crewai_tools import SerperDevTool
+
+@CrewBase
+class ResearchCrew():
+    """Research crew for comprehensive topic analysis and reporting"""
+
+    @agent
+    def researcher(self) -> Agent:
+        return Agent(
+            config=self.agents_config['researcher'],
+            verbose=True,
+            tools=[SerperDevTool()]
+        )
+
+    @agent
+    def analyst(self) -> Agent:
+        return Agent(
+            config=self.agents_config['analyst'],
+            verbose=True
+        )
+
+    @task
+    def research_task(self) -> Task:
+        return Task(
+            config=self.tasks_config['research_task']
+        )
+
+    @task
+    def analysis_task(self) -> Task:
+        return Task(
+            config=self.tasks_config['analysis_task'],
+            output_file='output/report.md'
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        """Creates the research crew"""
+        return Crew(
+            agents=self.agents,
+            tasks=self.tasks,
+            process=Process.sequential,
+            verbose=True,
+        )
+```
+
+## Step 6: Set Up Your Main Script
+
+Let's modify the `main.py` file to run our crew:
+
+```python
+#!/usr/bin/env python
+# src/research_crew/main.py
+import os
+from research_crew.crew import ResearchCrew
+
+# Create output directory if it doesn't exist
+os.makedirs('output', exist_ok=True)
+
+def run():
+    """
+    Run the research crew.
+    """
+    inputs = {
+        'topic': 'Artificial Intelligence in Healthcare'
+    }
+
+    # Create and run the crew
+    result = ResearchCrew().crew().kickoff(inputs=inputs)
+
+    # Print the result
+    print("\n\n=== FINAL REPORT ===\n\n")
+    print(result.raw)
+
+    print("\n\nReport has been saved to output/report.md")
+
+if __name__ == "__main__":
+    run()
+```
+
+## Step 7: Set Up Your Environment Variables
+
+Create a `.env` file in your project root with your API keys:
+
+```
+OPENAI_API_KEY=your_openai_api_key
+SERPER_API_KEY=your_serper_api_key
+```
+
+You can get a Serper API key from [Serper.dev](https://serper.dev/).
+
+## Step 8: Install Dependencies
+
+Install the required dependencies using the CrewAI CLI:
+
+```bash
+crewai install
+```
+
+This command will:
+1. Read the dependencies from your project configuration
+2. Create a virtual environment if needed
+3. Install all required packages
+
+## Step 9: Run Your Crew
+
+Now, run your crew using the CrewAI CLI:
+
+```bash
+crewai run
+```
+
+Your crew will start working! The researcher will gather information about the specified topic, and the analyst will create a comprehensive report based on that research.
+
+## Step 10: Review the Output
+
+Once the crew completes its work, you'll find the final report in the `output/report.md` file. The report will include:
+
+1. An executive summary
+2. Detailed information about the topic
+3. Analysis and insights
+4. Recommendations or future considerations
+
+## Exploring Other CLI Commands
+
+CrewAI offers several other useful CLI commands for working with crews:
+
+```bash
+# View all available commands
+crewai --help
+
+# Run the crew
+crewai run
+
+# Test the crew
+crewai test
+
+# Reset crew memories
+crewai reset-memories
+
+# Replay from a specific task
+crewai replay -t <task_id>
+
+# View the latest task outputs
+crewai log-tasks-outputs
+```
+
+## Customizing Your Crew
+
+You can customize your crew in several ways:
+
+1. **Add more agents**: Create additional specialized roles like a fact-checker or editor
+2. **Modify the process**: Change from `Process.sequential` to `Process.hierarchical` for more complex workflows
+3. **Add custom tools**: Create and add specialized tools for your agents
+4. **Change the topic**: Update the `topic` parameter in the `inputs` dictionary to research different subjects
+
+## Next Steps
+
+Now that you've built your first crew, you can:
+
+1. Experiment with different agent configurations
+2. Try more complex task structures
+3. Implement custom tools for your agents
+4. Explore [CrewAI Flows](/guides/flows/first-flow) for more advanced workflows
+
+<Check>
+Congratulations! You've successfully built your first CrewAI crew that can research and analyze any topic you provide.
+</Check>

docs/guides/flows/first-flow.mdx

@@ -0,0 +1,528 @@
+---
+title: Build Your First Flow
+description: Learn how to create structured, event-driven workflows with precise control over execution.
+icon: diagram-project
+---
+
+# Build Your First Flow
+
+In this guide, we'll walk through creating a powerful CrewAI Flow that generates a comprehensive learning guide on any topic. This tutorial will demonstrate how Flows provide structured, event-driven control over your AI workflows by combining regular code, direct LLM calls, and crew-based processing.
+
+## Prerequisites
+
+Before starting, make sure you have:
+
+1. Installed CrewAI following the [installation guide](/installation)
+2. Set up your OpenAI API key in your environment variables
+3. Basic understanding of Python
+
+## Step 1: Create a New CrewAI Flow Project
+
+First, let's create a new CrewAI Flow project using the CLI:
+
+```bash
+crewai create flow guide_creator_flow
+cd guide_creator_flow
+```
+
+This will generate a project with the basic structure needed for your flow.
+
+<Frame caption="CrewAI Framework Overview">
+  <img src="../../flows.png" alt="CrewAI Framework Overview" />
+</Frame>
+
+## Step 2: Understanding the Project Structure
+
+The generated project has the following structure:
+
+```
+guide_creator_flow/
+├── .gitignore
+├── pyproject.toml
+├── README.md
+├── .env
+├── main.py
+├── crews/
+│   └── poem_crew/
+│       ├── config/
+│       │   ├── agents.yaml
+│       │   └── tasks.yaml
+│       └── poem_crew.py
+└── tools/
+    └── custom_tool.py
+```
+
+We'll modify this structure to create our guide creator flow.
+
+## Step 3: Add a Content Writer Crew
+
+Let's use the CrewAI CLI to add a content writer crew:
+
+```bash
+crewai flow add-crew content-crew
+```
+
+This command will automatically create the necessary directories and template files.
+
+## Step 4: Configure the Content Writer Crew
+
+Now, let's modify the generated files for the content writer crew:
+
+1. First, update the agents configuration file:
+
+```yaml
+# src/guide_creator_flow/crews/content_crew/config/agents.yaml
+content_writer:
+  role: >
+    Educational Content Writer
+  goal: >
+    Create engaging, informative content that thoroughly explains the assigned topic
+    and provides valuable insights to the reader
+  backstory: >
+    You are a talented educational writer with expertise in creating clear, engaging
+    content. You have a gift for explaining complex concepts in accessible language
+    and organizing information in a way that helps readers build their understanding.
+  llm: openai/gpt-4o-mini
+
+content_reviewer:
+  role: >
+    Educational Content Reviewer and Editor
+  goal: >
+    Ensure content is accurate, comprehensive, well-structured, and maintains
+    consistency with previously written sections
+  backstory: >
+    You are a meticulous editor with years of experience reviewing educational
+    content. You have an eye for detail, clarity, and coherence. You excel at
+    improving content while maintaining the original author's voice and ensuring
+    consistent quality across multiple sections.
+  llm: openai/gpt-4o-mini
+```
+
+2. Next, update the tasks configuration file:
+
+```yaml
+# src/guide_creator_flow/crews/content_crew/config/tasks.yaml
+write_section_task:
+  description: >
+    Write a comprehensive section on the topic: "{section_title}"
+
+    Section description: {section_description}
+    Target audience: {audience_level} level learners
+
+    Your content should:
+    1. Begin with a brief introduction to the section topic
+    2. Explain all key concepts clearly with examples
+    3. Include practical applications or exercises where appropriate
+    4. End with a summary of key points
+    5. Be approximately 500-800 words in length
+
+    Format your content in Markdown with appropriate headings, lists, and emphasis.
+
+    Previously written sections:
+    {previous_sections}
+
+    Make sure your content maintains consistency with previously written sections
+    and builds upon concepts that have already been explained.
+  expected_output: >
+    A well-structured, comprehensive section in Markdown format that thoroughly
+    explains the topic and is appropriate for the target audience.
+  agent: content_writer
+
+review_section_task:
+  description: >
+    Review and improve the following section on "{section_title}":
+
+    {draft_content}
+
+    Target audience: {audience_level} level learners
+
+    Previously written sections:
+    {previous_sections}
+
+    Your review should:
+    1. Fix any grammatical or spelling errors
+    2. Improve clarity and readability
+    3. Ensure content is comprehensive and accurate
+    4. Verify consistency with previously written sections
+    5. Enhance the structure and flow
+    6. Add any missing key information
+
+    Provide the improved version of the section in Markdown format.
+  expected_output: >
+    An improved, polished version of the section that maintains the original
+    structure but enhances clarity, accuracy, and consistency.
+  agent: content_reviewer
+  context:
+    - write_section_task
+```
+
+3. Now, update the crew implementation file:
+
+```python
+# src/guide_creator_flow/crews/content_crew/content_crew.py
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+
+@CrewBase
+class ContentCrew():
+    """Content writing crew"""
+
+    @agent
+    def content_writer(self) -> Agent:
+        return Agent(
+            config=self.agents_config['content_writer'],
+            verbose=True
+        )
+
+    @agent
+    def content_reviewer(self) -> Agent:
+        return Agent(
+            config=self.agents_config['content_reviewer'],
+            verbose=True
+        )
+
+    @task
+    def write_section_task(self) -> Task:
+        return Task(
+            config=self.tasks_config['write_section_task']
+        )
+
+    @task
+    def review_section_task(self) -> Task:
+        return Task(
+            config=self.tasks_config['review_section_task'],
+            context=[self.write_section_task]
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        """Creates the content writing crew"""
+        return Crew(
+            agents=self.agents,
+            tasks=self.tasks,
+            process=Process.sequential,
+            verbose=True,
+        )
+```
+
+## Step 5: Create the Flow
+
+Now, let's create our flow in the `main.py` file. This flow will:
+1. Get user input for a topic
+2. Make a direct LLM call to create a structured guide outline
+3. Process each section in parallel using the content writer crew
+4. Combine everything into a final document
+
+```python
+#!/usr/bin/env python
+import json
+from typing import List, Dict
+from pydantic import BaseModel, Field
+from crewai import LLM
+from crewai.flow.flow import Flow, listen, start
+from guide_creator_flow.crews.content_crew.content_crew import ContentCrew
+
+# Define our models for structured data
+class Section(BaseModel):
+    title: str = Field(description="Title of the section")
+    description: str = Field(description="Brief description of what the section should cover")
+
+class GuideOutline(BaseModel):
+    title: str = Field(description="Title of the guide")
+    introduction: str = Field(description="Introduction to the topic")
+    target_audience: str = Field(description="Description of the target audience")
+    sections: List[Section] = Field(description="List of sections in the guide")
+    conclusion: str = Field(description="Conclusion or summary of the guide")
+
+# Define our flow state
+class GuideCreatorState(BaseModel):
+    topic: str = ""
+    audience_level: str = ""
+    guide_outline: GuideOutline = None
+    sections_content: Dict[str, str] = {}
+
+class GuideCreatorFlow(Flow[GuideCreatorState]):
+    """Flow for creating a comprehensive guide on any topic"""
+
+    @start()
+    def get_user_input(self):
+        """Get input from the user about the guide topic and audience"""
+        print("\n=== Create Your Comprehensive Guide ===\n")
+
+        # Get user input
+        self.state.topic = input("What topic would you like to create a guide for? ")
+
+        # Get audience level with validation
+        while True:
+            audience = input("Who is your target audience? (beginner/intermediate/advanced) ").lower()
+            if audience in ["beginner", "intermediate", "advanced"]:
+                self.state.audience_level = audience
+                break
+            print("Please enter 'beginner', 'intermediate', or 'advanced'")
+
+        print(f"\nCreating a guide on {self.state.topic} for {self.state.audience_level} audience...\n")
+        return self.state
+
+    @listen(get_user_input)
+    def create_guide_outline(self, state):
+        """Create a structured outline for the guide using a direct LLM call"""
+        print("Creating guide outline...")
+
+        # Initialize the LLM
+        llm = LLM(model="openai/gpt-4o-mini", response_format=GuideOutline)
+
+        # Create the messages for the outline
+        messages = [
+            {"role": "system", "content": "You are a helpful assistant designed to output JSON."},
+            {"role": "user", "content": f"""
+            Create a detailed outline for a comprehensive guide on "{state.topic}" for {state.audience_level} level learners.
+
+            The outline should include:
+            1. A compelling title for the guide
+            2. An introduction to the topic
+            3. 4-6 main sections that cover the most important aspects of the topic
+            4. A conclusion or summary
+
+            For each section, provide a clear title and a brief description of what it should cover.
+            """}
+        ]
+
+        # Make the LLM call with JSON response format
+        response = llm.call(messages=messages)
+
+        # Parse the JSON response
+        outline_dict = json.loads(response)
+        self.state.guide_outline = GuideOutline(**outline_dict)
+
+        # Save the outline to a file
+        with open("output/guide_outline.json", "w") as f:
+            json.dump(outline_dict, f, indent=2)
+
+        print(f"Guide outline created with {len(self.state.guide_outline.sections)} sections")
+        return self.state.guide_outline
+
+    @listen(create_guide_outline)
+    def write_and_compile_guide(self, outline):
+        """Write all sections and compile the guide"""
+        print("Writing guide sections and compiling...")
+        completed_sections = []
+
+        # Process sections one by one to maintain context flow
+        for section in outline.sections:
+            print(f"Processing section: {section.title}")
+
+            # Build context from previous sections
+            previous_sections_text = ""
+            if completed_sections:
+                previous_sections_text = "# Previously Written Sections\n\n"
+                for title in completed_sections:
+                    previous_sections_text += f"## {title}\n\n"
+                    previous_sections_text += self.state.sections_content.get(title, "") + "\n\n"
+            else:
+                previous_sections_text = "No previous sections written yet."
+
+            # Run the content crew for this section
+            result = ContentCrew().crew().kickoff(inputs={
+                "section_title": section.title,
+                "section_description": section.description,
+                "audience_level": self.state.audience_level,
+                "previous_sections": previous_sections_text,
+                "draft_content": ""
+            })
+
+            # Store the content
+            self.state.sections_content[section.title] = result.raw
+            completed_sections.append(section.title)
+            print(f"Section completed: {section.title}")
+
+        # Compile the final guide
+        guide_content = f"# {outline.title}\n\n"
+        guide_content += f"## Introduction\n\n{outline.introduction}\n\n"
+
+        # Add each section in order
+        for section in outline.sections:
+            section_content = self.state.sections_content.get(section.title, "")
+            guide_content += f"\n\n{section_content}\n\n"
+
+        # Add conclusion
+        guide_content += f"## Conclusion\n\n{outline.conclusion}\n\n"
+
+        # Save the guide
+        with open("output/complete_guide.md", "w") as f:
+            f.write(guide_content)
+
+        print("\nComplete guide compiled and saved to output/complete_guide.md")
+        return "Guide creation completed successfully"
+
+def kickoff():
+    """Run the guide creator flow"""
+    GuideCreatorFlow().kickoff()
+    print("\n=== Flow Complete ===")
+    print("Your comprehensive guide is ready in the output directory.")
+    print("Open output/complete_guide.md to view it.")
+
+def plot():
+    """Generate a visualization of the flow"""
+    flow = GuideCreatorFlow()
+    flow.plot("guide_creator_flow")
+    print("Flow visualization saved to guide_creator_flow.html")
+
+if __name__ == "__main__":
+    kickoff()
+```
+
+## Step 6: Set Up Your Environment Variables
+
+Create a `.env` file in your project root with your API keys:
+
+```
+OPENAI_API_KEY=your_openai_api_key
+```
+
+## Step 7: Install Dependencies
+
+Install the required dependencies:
+
+```bash
+crewai install
+```
+
+## Step 8: Run Your Flow
+
+Now, run your flow using the CrewAI CLI:
+
+```bash
+crewai flow kickoff
+```
+
+Your flow will:
+
+1. Prompt you for a topic and target audience
+2. Make a direct LLM call to create a structured guide outline
+3. Process each section in parallel using the content writer crew
+4. Combine everything into a final comprehensive guide
+
+This demonstrates the power of flows to orchestrate different types of operations, including user input, direct LLM interactions, and crew-based processing.
+
+## Step 9: Visualize Your Flow
+
+You can also generate a visualization of your flow:
+
+```bash
+crewai flow plot
+```
+
+This will create an HTML file that shows the structure of your flow, which can be helpful for understanding and debugging.
+
+## Step 10: Review the Output
+
+Once the flow completes, you'll find two files in the `output` directory:
+
+1. `guide_outline.json`: Contains the structured outline of the guide
+2. `complete_guide.md`: The comprehensive guide with all sections
+
+## Key Features Demonstrated
+
+This guide creator flow demonstrates several powerful features of CrewAI:
+
+1. **User interaction**: The flow collects input directly from the user
+2. **Direct LLM calls**: Uses the LLM class for efficient, single-purpose AI interactions
+3. **Structured data with Pydantic**: Uses Pydantic models to ensure type safety
+4. **Sequential processing with context**: Writes sections in order, providing previous sections for context
+5. **Multi-agent crews**: Leverages specialized agents (writer and reviewer) for content creation
+6. **State management**: Maintains state across different steps of the process
+
+## Understanding the Flow Structure
+
+Let's break down the key components of this flow:
+
+### 1. Direct LLM Calls
+
+The flow uses CrewAI's `LLM` class to make direct calls to the language model:
+
+```python
+llm = LLM(model="openai/gpt-4o-mini")
+response = llm.call(prompt)
+```
+
+This is more efficient than using a crew when you need a simple, structured response.
+
+### 2. Asynchronous Processing
+
+The flow uses async/await to process multiple sections in parallel:
+
+```python
+@listen(create_guide_outline)
+async def write_sections(self, outline):
+    # ...
+    section_tasks = []
+    for section in outline.sections:
+        task = self.write_section(section, outline.target_audience)
+        section_tasks.append(task)
+
+    sections_content = await asyncio.gather(*section_tasks)
+    # ...
+```
+
+This significantly speeds up the guide creation process.
+
+### 3. Multi-Agent Crews
+
+The flow uses a crew with multiple specialized agents:
+
+```python
+# Content creation crew with writer and reviewer
+@agent
+def content_writer(self) -> Agent:
+    return Agent(
+        config=self.agents_config['content_writer'],
+        verbose=True
+    )
+
+@agent
+def content_reviewer(self) -> Agent:
+    return Agent(
+        config=self.agents_config['content_reviewer'],
+        verbose=True
+    )
+```
+
+This demonstrates how flows can orchestrate crews with multiple specialized agents that work together on complex tasks.
+
+### 4. Context-Aware Sequential Processing
+
+The flow processes sections in order, providing previous sections as context:
+
+```python
+# Getting previous sections for context
+previous_sections_text = ""
+if self.state.completed_sections:
+    previous_sections_text = "# Previously Written Sections\n\n"
+    for title in self.state.completed_sections:
+        previous_sections_text += f"## {title}\n\n"
+        previous_sections_text += self.state.sections_content.get(title, "") + "\n\n"
+```
+
+This ensures coherence and continuity throughout the guide.
+
+## Customizing Your Flow
+
+You can customize your flow in several ways:
+
+1. **Add more user inputs**: Collect additional information about the desired guide
+2. **Enhance the outline**: Modify the LLM prompt to create more detailed outlines
+3. **Add more crews**: Use different crews for different parts of the guide
+4. **Add review steps**: Include a review and refinement step for the final guide
+
+## Next Steps
+
+Now that you've built your first flow, you can:
+
+1. Experiment with more complex flow structures
+2. Try using `@router()` to create conditional branches
+3. Explore the `and_` and `or_` functions for more complex parallel execution
+4. Connect your flow to external APIs or services
+
+<Check>
+Congratulations! You've successfully built your first CrewAI Flow that combines regular code, direct LLM calls, and crew-based processing to create a comprehensive guide.
+</Check>

docs/introduction.mdx

@@ -6,20 +6,23 @@ icon: handshake
 
 # What is CrewAI?
 
-**CrewAI is a cutting-edge framework for orchestrating autonomous AI agents.**
+**CrewAI is a lean, lightning-fast Python framework built entirely from scratch—completely independent of LangChain or other agent frameworks.**
 
-CrewAI enables you to create AI teams where each agent has specific roles, tools, and goals, working together to accomplish complex tasks.
+CrewAI empowers developers with both high-level simplicity and precise low-level control, ideal for creating autonomous AI agents tailored to any scenario:
 
-Think of it as assembling your dream team - each member (agent) brings unique skills and expertise, collaborating seamlessly to achieve your objectives.
+- **CrewAI Crews**: Optimize for autonomy and collaborative intelligence, enabling you to create AI teams where each agent has specific roles, tools, and goals.
+- **CrewAI Flows**: Enable granular, event-driven control, single LLM calls for precise task orchestration and supports Crews natively.
 
-## How CrewAI Works
+With over 100,000 developers certified through our community courses, CrewAI is rapidly becoming the standard for enterprise-ready AI automation.
+
+## How Crews Work
 
 <Note>
   Just like a company has departments (Sales, Engineering, Marketing) working together under leadership to achieve business goals, CrewAI helps you create an organization of AI agents with specialized roles collaborating to accomplish complex tasks.
 </Note>
 
 <Frame caption="CrewAI Framework Overview">
-  <img src="asset.png" alt="CrewAI Framework Overview" />
+  <img src="crews.png" alt="CrewAI Framework Overview" />
 </Frame>
 
 | Component | Description | Key Features |
@@ -53,12 +56,87 @@ Think of it as assembling your dream team - each member (agent) brings unique sk
   </Card>
 </CardGroup>
 
+## How Flows Work
+
+<Note>
+  While Crews excel at autonomous collaboration, Flows provide structured automations, offering granular control over workflow execution. Flows ensure tasks are executed reliably, securely, and efficiently, handling conditional logic, loops, and dynamic state management with precision. Flows integrate seamlessly with Crews, enabling you to balance high autonomy with exacting control.
+</Note>
+
+<Frame caption="CrewAI Framework Overview">
+  <img src="flows.png" alt="CrewAI Framework Overview" />
+</Frame>
+
+| Component | Description | Key Features |
+|:----------|:-----------:|:------------|
+| **Flow** | Structured workflow orchestration | • Manages execution paths<br/>• Handles state transitions<br/>• Controls task sequencing<br/>• Ensures reliable execution |
+| **Events** | Triggers for workflow actions | • Initiate specific processes<br/>• Enable dynamic responses<br/>• Support conditional branching<br/>• Allow for real-time adaptation |
+| **States** | Workflow execution contexts | • Maintain execution data<br/>• Enable persistence<br/>• Support resumability<br/>• Ensure execution integrity |
+| **Crew Support** | Enhances workflow automation | • Injects pockets of agency when needed<br/>• Complements structured workflows<br/>• Balances automation with intelligence<br/>• Enables adaptive decision-making |
+
+### Key Capabilities
+
+<CardGroup cols={2}>
+  <Card title="Event-Driven Orchestration" icon="bolt">
+    Define precise execution paths responding dynamically to events
+  </Card>
+  <Card title="Fine-Grained Control" icon="sliders">
+    Manage workflow states and conditional execution securely and efficiently
+  </Card>
+  <Card title="Native Crew Integration" icon="puzzle-piece">
+    Effortlessly combine with Crews for enhanced autonomy and intelligence
+  </Card>
+  <Card title="Deterministic Execution" icon="route">
+    Ensure predictable outcomes with explicit control flow and error handling
+  </Card>
+</CardGroup>
+
+## When to Use Crews vs. Flows
+
+<Note>
+  Understanding when to use Crews versus Flows is key to maximizing the potential of CrewAI in your applications.
+</Note>
+
+| Use Case | Recommended Approach | Why? |
+|:---------|:---------------------|:-----|
+| **Open-ended research** | Crews | When tasks require creative thinking, exploration, and adaptation |
+| **Content generation** | Crews | For collaborative creation of articles, reports, or marketing materials |
+| **Decision workflows** | Flows | When you need predictable, auditable decision paths with precise control |
+| **API orchestration** | Flows | For reliable integration with multiple external services in a specific sequence |
+| **Hybrid applications** | Combined approach | Use Flows to orchestrate overall process with Crews handling complex subtasks |
+
+### Decision Framework
+
+- **Choose Crews when:** You need autonomous problem-solving, creative collaboration, or exploratory tasks
+- **Choose Flows when:** You require deterministic outcomes, auditability, or precise control over execution
+- **Combine both when:** Your application needs both structured processes and pockets of autonomous intelligence
+
 ## Why Choose CrewAI?
 
 - 🧠 **Autonomous Operation**: Agents make intelligent decisions based on their roles and available tools
 - 📝 **Natural Interaction**: Agents communicate and collaborate like human team members
 - 🛠️ **Extensible Design**: Easy to add new tools, roles, and capabilities
 - 🚀 **Production Ready**: Built for reliability and scalability in real-world applications
+- 🔒 **Security-Focused**: Designed with enterprise security requirements in mind
+- 💰 **Cost-Efficient**: Optimized to minimize token usage and API calls
+
+## Ready to Start Building?
+
+<CardGroup cols={2}>
+  <Card
+    title="Build Your First Crew"
+    icon="users-gear"
+    href="/guides/crews/first-crew"
+  >
+    Step-by-step tutorial to create a collaborative AI team that works together to solve complex problems.
+  </Card>
+  <Card
+    title="Build Your First Flow"
+    icon="diagram-project"
+    href="/guides/flows/first-flow"
+  >
+    Learn how to create structured, event-driven workflows with precise control over execution.
+  </Card>
+</CardGroup>
 
 <CardGroup cols={3}>
   <Card