feat: bump version to 1.0.0a2

Co-authored-by: Greyson Lalonde <greyson.r.lalonde@gmail.com>

.env.test

@@ -1,161 +0,0 @@
-# =============================================================================
-# Test Environment Variables
-# =============================================================================
-# This file contains all environment variables needed to run tests locally
-# in a way that mimics the GitHub Actions CI environment.
-
-# =============================================================================
-
-# -----------------------------------------------------------------------------
-# LLM Provider API Keys
-# -----------------------------------------------------------------------------
-OPENAI_API_KEY=fake-api-key
-ANTHROPIC_API_KEY=fake-anthropic-key
-GEMINI_API_KEY=fake-gemini-key
-AZURE_API_KEY=fake-azure-key
-OPENROUTER_API_KEY=fake-openrouter-key
-
-# -----------------------------------------------------------------------------
-# AWS Credentials
-# -----------------------------------------------------------------------------
-AWS_ACCESS_KEY_ID=fake-aws-access-key
-AWS_SECRET_ACCESS_KEY=fake-aws-secret-key
-AWS_DEFAULT_REGION=us-east-1
-AWS_REGION_NAME=us-east-1
-
-# -----------------------------------------------------------------------------
-# Azure OpenAI Configuration
-# -----------------------------------------------------------------------------
-AZURE_ENDPOINT=https://fake-azure-endpoint.openai.azure.com
-AZURE_OPENAI_ENDPOINT=https://fake-azure-endpoint.openai.azure.com
-AZURE_OPENAI_API_KEY=fake-azure-openai-key
-AZURE_API_VERSION=2024-02-15-preview
-OPENAI_API_VERSION=2024-02-15-preview
-
-# -----------------------------------------------------------------------------
-# Google Cloud Configuration
-# -----------------------------------------------------------------------------
-#GOOGLE_CLOUD_PROJECT=fake-gcp-project
-#GOOGLE_CLOUD_LOCATION=us-central1
-
-# -----------------------------------------------------------------------------
-# OpenAI Configuration
-# -----------------------------------------------------------------------------
-OPENAI_BASE_URL=https://api.openai.com/v1
-OPENAI_API_BASE=https://api.openai.com/v1
-
-# -----------------------------------------------------------------------------
-# Search & Scraping Tool API Keys
-# -----------------------------------------------------------------------------
-SERPER_API_KEY=fake-serper-key
-EXA_API_KEY=fake-exa-key
-BRAVE_API_KEY=fake-brave-key
-FIRECRAWL_API_KEY=fake-firecrawl-key
-TAVILY_API_KEY=fake-tavily-key
-SERPAPI_API_KEY=fake-serpapi-key
-SERPLY_API_KEY=fake-serply-key
-LINKUP_API_KEY=fake-linkup-key
-PARALLEL_API_KEY=fake-parallel-key
-
-# -----------------------------------------------------------------------------
-# Exa Configuration
-# -----------------------------------------------------------------------------
-EXA_BASE_URL=https://api.exa.ai
-
-# -----------------------------------------------------------------------------
-# Web Scraping & Automation
-# -----------------------------------------------------------------------------
-BRIGHT_DATA_API_KEY=fake-brightdata-key
-BRIGHT_DATA_ZONE=fake-zone
-BRIGHTDATA_API_URL=https://api.brightdata.com
-BRIGHTDATA_DEFAULT_TIMEOUT=600
-BRIGHTDATA_DEFAULT_POLLING_INTERVAL=1
-
-OXYLABS_USERNAME=fake-oxylabs-user
-OXYLABS_PASSWORD=fake-oxylabs-pass
-
-SCRAPFLY_API_KEY=fake-scrapfly-key
-SCRAPEGRAPH_API_KEY=fake-scrapegraph-key
-
-BROWSERBASE_API_KEY=fake-browserbase-key
-BROWSERBASE_PROJECT_ID=fake-browserbase-project
-
-HYPERBROWSER_API_KEY=fake-hyperbrowser-key
-MULTION_API_KEY=fake-multion-key
-APIFY_API_TOKEN=fake-apify-token
-
-# -----------------------------------------------------------------------------
-# Database & Vector Store Credentials
-# -----------------------------------------------------------------------------
-SINGLESTOREDB_URL=mysql://fake:fake@localhost:3306/fake
-SINGLESTOREDB_HOST=localhost
-SINGLESTOREDB_PORT=3306
-SINGLESTOREDB_USER=fake-user
-SINGLESTOREDB_PASSWORD=fake-password
-SINGLESTOREDB_DATABASE=fake-database
-SINGLESTOREDB_CONNECT_TIMEOUT=30
-
-SNOWFLAKE_USER=fake-snowflake-user
-SNOWFLAKE_PASSWORD=fake-snowflake-password
-SNOWFLAKE_ACCOUNT=fake-snowflake-account
-SNOWFLAKE_WAREHOUSE=fake-snowflake-warehouse
-SNOWFLAKE_DATABASE=fake-snowflake-database
-SNOWFLAKE_SCHEMA=fake-snowflake-schema
-
-WEAVIATE_URL=http://localhost:8080
-WEAVIATE_API_KEY=fake-weaviate-key
-
-EMBEDCHAIN_DB_URI=sqlite:///test.db
-
-# Databricks Credentials
-DATABRICKS_HOST=https://fake-databricks.cloud.databricks.com
-DATABRICKS_TOKEN=fake-databricks-token
-DATABRICKS_CONFIG_PROFILE=fake-profile
-
-# MongoDB Credentials
-MONGODB_URI=mongodb://fake:fake@localhost:27017/fake
-
-# -----------------------------------------------------------------------------
-# CrewAI Platform & Enterprise
-# -----------------------------------------------------------------------------
-# setting CREWAI_PLATFORM_INTEGRATION_TOKEN causes these test to fail:
-#=========================== short test summary info ============================
-#FAILED tests/test_context.py::TestPlatformIntegrationToken::test_platform_context_manager_basic_usage - AssertionError: assert 'fake-platform-token' is None
-# +  where 'fake-platform-token' = get_platform_integration_token()
-#FAILED tests/test_context.py::TestPlatformIntegrationToken::test_context_var_isolation_between_tests - AssertionError: assert 'fake-platform-token' is None
-# +  where 'fake-platform-token' = get_platform_integration_token()
-#FAILED tests/test_context.py::TestPlatformIntegrationToken::test_multiple_sequential_context_managers - AssertionError: assert 'fake-platform-token' is None
-# +  where 'fake-platform-token' = get_platform_integration_token()
-#CREWAI_PLATFORM_INTEGRATION_TOKEN=fake-platform-token
-CREWAI_PERSONAL_ACCESS_TOKEN=fake-personal-token
-CREWAI_PLUS_URL=https://fake.crewai.com
-
-# -----------------------------------------------------------------------------
-# Other Service API Keys
-# -----------------------------------------------------------------------------
-ZAPIER_API_KEY=fake-zapier-key
-PATRONUS_API_KEY=fake-patronus-key
-MINDS_API_KEY=fake-minds-key
-HF_TOKEN=fake-hf-token
-
-# -----------------------------------------------------------------------------
-# Feature Flags/Testing Modes
-# -----------------------------------------------------------------------------
-CREWAI_DISABLE_TELEMETRY=true
-OTEL_SDK_DISABLED=true
-CREWAI_TESTING=true
-CREWAI_TRACING_ENABLED=false
-
-# -----------------------------------------------------------------------------
-# Testing/CI Configuration
-# -----------------------------------------------------------------------------
-# VCR recording mode: "none" (default), "new_episodes", "all", "once"
-PYTEST_VCR_RECORD_MODE=none
-
-# Set to "true" by GitHub when running in GitHub Actions
-# GITHUB_ACTIONS=false
-
-# -----------------------------------------------------------------------------
-# Python Configuration
-# -----------------------------------------------------------------------------
-PYTHONUNBUFFERED=1

.github/codeql/codeql-config.yml

@@ -1,28 +0,0 @@
-name: "CodeQL Config"
-
-paths-ignore:
-  # Ignore template files - these are boilerplate code that shouldn't be analyzed
-  - "lib/crewai/src/crewai/cli/templates/**"
-  # Ignore test cassettes - these are test fixtures/recordings
-  - "lib/crewai/tests/cassettes/**"
-  - "lib/crewai-tools/tests/cassettes/**"
-  # Ignore cache and build artifacts
-  - ".cache/**"
-  # Ignore documentation build artifacts
-  - "docs/.cache/**"
-  # Ignore experimental code
-  - "lib/crewai/src/crewai/experimental/a2a/**"
-
-paths:
-  # Include all Python source code from workspace packages
-  - "lib/crewai/src/**"
-  - "lib/crewai-tools/src/**"
-  - "lib/devtools/src/**"
-  # Include tests (but exclude cassettes via paths-ignore)
-  - "lib/crewai/tests/**"
-  - "lib/crewai-tools/tests/**"
-  - "lib/devtools/tests/**"
-
-# Configure specific queries or packs if needed
-# queries:
-#   - uses: security-and-quality

.github/dependabot.yml

@@ -1,11 +0,0 @@
-# To get started with Dependabot version updates, you'll need to specify which 
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
-
-version: 2
-updates:
-  - package-ecosystem: uv # See documentation for possible values
-    directory: "/" # Location of package manifests
-    schedule:
-      interval: "weekly"

.github/security.md

@@ -1,50 +1,27 @@
-## CrewAI Security Policy
+## CrewAI Security Vulnerability Reporting Policy
 
-We are committed to protecting the confidentiality, integrity, and availability of the CrewAI ecosystem. This policy explains how to report potential vulnerabilities and what you can expect from us when you do.
+CrewAI prioritizes the security of our software products, services, and GitHub repositories. To promptly address vulnerabilities, follow these steps for reporting security issues:
 
-### Scope
+### Reporting Process
+Do **not** report vulnerabilities via public GitHub issues.
 
-We welcome reports for vulnerabilities that could impact:
+Email all vulnerability reports directly to:  
+**security@crewai.com**
 
-- CrewAI-maintained source code and repositories
-- CrewAI-operated infrastructure and services
-- Official CrewAI releases, packages, and distributions
+### Required Information
+To help us quickly validate and remediate the issue, your report must include:
 
-Issues affecting clearly unaffiliated third-party services or user-generated content are out of scope, unless you can demonstrate a direct impact on CrewAI systems or customers.
+- **Vulnerability Type:** Clearly state the vulnerability type (e.g., SQL injection, XSS, privilege escalation).
+- **Affected Source Code:** Provide full file paths and direct URLs (branch, tag, or commit).
+- **Reproduction Steps:** Include detailed, step-by-step instructions. Screenshots are recommended.
+- **Special Configuration:** Document any special settings or configurations required to reproduce.
+- **Proof-of-Concept (PoC):** Provide exploit or PoC code (if available).
+- **Impact Assessment:** Clearly explain the severity and potential exploitation scenarios.
 
-### How to Report
+### Our Response
+- We will acknowledge receipt of your report promptly via your provided email.
+- Confirmed vulnerabilities will receive priority remediation based on severity.
+- Patches will be released as swiftly as possible following verification.
 
-- **Please do not** disclose vulnerabilities via public GitHub issues, pull requests, or social media.
-- Email detailed reports to **security@crewai.com** with the subject line `Security Report`.
-- If you need to share large files or sensitive artifacts, mention it in your email and we will coordinate a secure transfer method.
-
-### What to Include
-
-Providing comprehensive information enables us to validate the issue quickly:
-
-- **Vulnerability overview** — a concise description and classification (e.g., RCE, privilege escalation)
-- **Affected components** — repository, branch, tag, or deployed service along with relevant file paths or endpoints
-- **Reproduction steps** — detailed, step-by-step instructions; include logs, screenshots, or screen recordings when helpful
-- **Proof-of-concept** — exploit details or code that demonstrates the impact (if available)
-- **Impact analysis** — severity assessment, potential exploitation scenarios, and any prerequisites or special configurations
-
-### Our Commitment
-
-- **Acknowledgement:** We aim to acknowledge your report within two business days.
-- **Communication:** We will keep you informed about triage results, remediation progress, and planned release timelines.
-- **Resolution:** Confirmed vulnerabilities will be prioritized based on severity and fixed as quickly as possible.
-- **Recognition:** We currently do not run a bug bounty program; any rewards or recognition are issued at CrewAI's discretion.
-
-### Coordinated Disclosure
-
-We ask that you allow us a reasonable window to investigate and remediate confirmed issues before any public disclosure. We will coordinate publication timelines with you whenever possible.
-
-### Safe Harbor
-
-We will not pursue or support legal action against individuals who, in good faith:
-
-- Follow this policy and refrain from violating any applicable laws
-- Avoid privacy violations, data destruction, or service disruption
-- Limit testing to systems in scope and respect rate limits and terms of service
-
-If you are unsure whether your testing is covered, please contact us at **security@crewai.com** before proceeding.
+### Reward Notice
+Currently, we do not offer a bug bounty program. Rewards, if issued, are discretionary.

.github/workflows/build-uv-cache.yml

@@ -7,8 +7,6 @@ on:
     paths:
       - "uv.lock"
       - "pyproject.toml"
-  schedule:
-    - cron: "0 0 */5 * *"  # Run every 5 days at midnight UTC to prevent cache expiration
   workflow_dispatch:
 
 permissions:

.github/workflows/codeql.yml

@@ -73,7 +73,6 @@ jobs:
       with:
         languages: ${{ matrix.language }}
         build-mode: ${{ matrix.build-mode }}
-        config-file: ./.github/codeql/codeql-config.yml
         # If you wish to specify custom queries, you can do so here or in a config file.
         # By default, queries listed here will override any specified in a config file.
         # Prefix the list here with "+" to use these queries and those in the config file.

.github/workflows/docs-broken-links.yml

@@ -1,35 +0,0 @@
-name: Check Documentation Broken Links
-
-on:
-  pull_request:
-    paths:
-      - "docs/**"
-      - "docs.json"
-  push:
-    branches:
-      - main
-    paths:
-      - "docs/**"
-      - "docs.json"
-  workflow_dispatch:
-
-jobs:
-  check-links:
-    name: Check broken links
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: "latest"
-
-      - name: Install Mintlify CLI
-        run: npm i -g mintlify
-
-      - name: Run broken link checker
-        run: |
-          # Auto-answer the prompt with yes command
-          yes "" | mintlify broken-links || test $? -eq 141
-        working-directory: ./docs

.github/workflows/linter.yml

@@ -55,7 +55,6 @@ jobs:
          echo "${{ steps.changed-files.outputs.files }}" \
            | tr ' ' '\n' \
            | grep -v 'src/crewai/cli/templates/' \
-           | grep -v '/tests/' \
            | xargs -I{} uv run ruff check "{}"
 
       - name: Save uv caches

.github/workflows/publish.yml

@@ -1,37 +1,19 @@
 name: Publish to PyPI
 
 on:
-  repository_dispatch:
-    types: [deployment-tests-passed]
+  release:
+    types: [ published ]
   workflow_dispatch:
-    inputs:
-      release_tag:
-        description: 'Release tag to publish'
-        required: false
-        type: string
 
 jobs:
   build:
+    if: github.event.release.prerelease == true
     name: Build packages
     runs-on: ubuntu-latest
     permissions:
         contents: read
     steps:
-      - name: Determine release tag
-        id: release
-        run: |
-          # Priority: workflow_dispatch input > repository_dispatch payload > default branch
-          if [ -n "${{ inputs.release_tag }}" ]; then
-            echo "tag=${{ inputs.release_tag }}" >> $GITHUB_OUTPUT
-          elif [ -n "${{ github.event.client_payload.release_tag }}" ]; then
-            echo "tag=${{ github.event.client_payload.release_tag }}" >> $GITHUB_OUTPUT
-          else
-            echo "tag=" >> $GITHUB_OUTPUT
-          fi
-
       - uses: actions/checkout@v4
-        with:
-          ref: ${{ steps.release.outputs.tag || github.ref }}
 
       - name: Set up Python
         uses: actions/setup-python@v5
@@ -53,6 +35,7 @@ jobs:
           path: dist/
 
   publish:
+    if: github.event.release.prerelease == true
     name: Publish to PyPI
     needs: build
     runs-on: ubuntu-latest
@@ -82,19 +65,7 @@ jobs:
         env:
           UV_PUBLISH_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
         run: |
-          failed=0
           for package in dist/*; do
-            if [[ "$package" == *"crewai_devtools"* ]]; then
-              echo "Skipping private package: $package"
-              continue
-            fi
             echo "Publishing $package"
-            if ! uv publish "$package"; then
-              echo "Failed to publish $package"
-              failed=1
-            fi
+            uv publish "$package"
           done
-          if [ $failed -eq 1 ]; then
-            echo "Some packages failed to publish"
-            exit 1
-          fi

.github/workflows/tests.yml

@@ -5,6 +5,18 @@ on: [pull_request]
 permissions:
   contents: read
 
+env:
+  OPENAI_API_KEY: fake-api-key
+  PYTHONUNBUFFERED: 1
+  BRAVE_API_KEY: fake-brave-key
+  SNOWFLAKE_USER: fake-snowflake-user
+  SNOWFLAKE_PASSWORD: fake-snowflake-password
+  SNOWFLAKE_ACCOUNT: fake-snowflake-account
+  SNOWFLAKE_WAREHOUSE: fake-snowflake-warehouse
+  SNOWFLAKE_DATABASE: fake-snowflake-database
+  SNOWFLAKE_SCHEMA: fake-snowflake-schema
+  EMBEDCHAIN_DB_URI: sqlite:///test.db
+
 jobs:
   tests:
     name: tests (${{ matrix.python-version }})
@@ -72,20 +84,26 @@ jobs:
           # fi
 
           cd lib/crewai && uv run pytest \
+            --block-network \
+            --timeout=30 \
             -vv \
             --splits 8 \
             --group ${{ matrix.group }} \
             $DURATIONS_ARG \
             --durations=10 \
+            -n auto \
             --maxfail=3
 
       - name: Run tool tests (group ${{ matrix.group }} of 8)
         run: |
           cd lib/crewai-tools && uv run pytest \
+            --block-network \
+            --timeout=30 \
             -vv \
             --splits 8 \
             --group ${{ matrix.group }} \
             --durations=10 \
+            -n auto \
             --maxfail=3
 
 

.github/workflows/trigger-deployment-tests.yml

@@ -1,18 +0,0 @@
-name: Trigger Deployment Tests
-
-on:
-  release:
-    types: [published]
-
-jobs:
-  trigger:
-    name: Trigger deployment tests
-    runs-on: ubuntu-latest
-    steps:
-      - name: Trigger deployment tests
-        uses: peter-evans/repository-dispatch@v3
-        with:
-          token: ${{ secrets.CREWAI_DEPLOYMENTS_PAT }}
-          repository: ${{ secrets.CREWAI_DEPLOYMENTS_REPOSITORY }}
-          event-type: crewai-release
-          client-payload: '{"release_tag": "${{ github.event.release.tag_name }}", "release_name": "${{ github.event.release.name }}"}'

.pre-commit-config.yaml

@@ -3,31 +3,19 @@ repos:
     hooks:
       - id: ruff
         name: ruff
-        entry: bash -c 'source .venv/bin/activate && uv run ruff check --config pyproject.toml "$@"' --
+        entry: uv run ruff check
         language: system
-        pass_filenames: true
         types: [python]
+        exclude: ^lib/crewai/
       - id: ruff-format
         name: ruff-format
-        entry: bash -c 'source .venv/bin/activate && uv run ruff format --config pyproject.toml "$@"' --
+        entry: uv run ruff format
         language: system
-        pass_filenames: true
         types: [python]
+        exclude: ^lib/crewai/
       - id: mypy
         name: mypy
-        entry: bash -c 'source .venv/bin/activate && uv run mypy --config-file pyproject.toml "$@"' --
+        entry: uv run mypy
         language: system
-        pass_filenames: true
         types: [python]
-        exclude: ^(lib/crewai/src/crewai/cli/templates/|lib/crewai/tests/|lib/crewai-tools/tests/)
-  - repo: https://github.com/astral-sh/uv-pre-commit
-    rev: 0.9.3
-    hooks:
-      - id: uv-lock
-  - repo: https://github.com/commitizen-tools/commitizen
-    rev: v4.10.1
-    hooks:
-      - id: commitizen
-      - id: commitizen-branch
-        stages: [ pre-push ]
-
+        exclude: ^lib/crewai/

README.md

@@ -57,7 +57,7 @@
 > It empowers developers with both high-level simplicity and precise low-level control, ideal for creating autonomous AI agents tailored to any scenario.
 
 - **CrewAI Crews**: Optimize for autonomy and collaborative intelligence.
-- **CrewAI Flows**: The **enterprise and production architecture** for building and deploying multi-agent systems. Enable granular, event-driven control, single LLM calls for precise task orchestration and supports Crews natively
+- **CrewAI Flows**: Enable granular, event-driven control, single LLM calls for precise task orchestration and supports Crews natively
 
 With over 100,000 developers certified through our community courses at [learn.crewai.com](https://learn.crewai.com), CrewAI is rapidly becoming the
 standard for enterprise-ready AI automation.
@@ -124,8 +124,7 @@ Setup and run your first CrewAI agents by following this tutorial.
 [![CrewAI Getting Started Tutorial](https://img.youtube.com/vi/-kSOTtYzgEw/hqdefault.jpg)](https://www.youtube.com/watch?v=-kSOTtYzgEw "CrewAI Getting Started Tutorial")
 
 ###
-
-Learning Resources
+ Learning Resources
 
 Learn CrewAI through our comprehensive courses:
 
@@ -142,7 +141,6 @@ CrewAI offers two powerful, complementary approaches that work seamlessly togeth
    - Dynamic task delegation and collaboration
    - Specialized roles with defined goals and expertise
    - Flexible problem-solving approaches
-
 2. **Flows**: Production-ready, event-driven workflows that deliver precise control over complex automations. Flows provide:
 
    - Fine-grained control over execution paths for real-world scenarios
@@ -168,13 +166,13 @@ Ensure you have Python >=3.10 <3.14 installed on your system. CrewAI uses [UV](h
 First, install CrewAI:
 
 ```shell
-uv pip install crewai
+pip install crewai
 ```
 
 If you want to install the 'crewai' package along with its optional features that include additional tools for agents, you can do so by using the following command:
 
 ```shell
-uv pip install 'crewai[tools]'
+pip install 'crewai[tools]'
 ```
 
 The command above installs the basic package and also adds extra components which require more dependencies to function.
@@ -187,15 +185,14 @@ If you encounter issues during installation or usage, here are some common solut
 
 1. **ModuleNotFoundError: No module named 'tiktoken'**
 
-   - Install tiktoken explicitly: `uv pip install 'crewai[embeddings]'`
-   - If using embedchain or other tools: `uv pip install 'crewai[tools]'`
-
+   - Install tiktoken explicitly: `pip install 'crewai[embeddings]'`
+   - If using embedchain or other tools: `pip install 'crewai[tools]'`
 2. **Failed building wheel for tiktoken**
 
    - Ensure Rust compiler is installed (see installation steps above)
    - For Windows: Verify Visual C++ Build Tools are installed
-   - Try upgrading pip: `uv pip install --upgrade pip`
-   - If issues persist, use a pre-built wheel: `uv pip install tiktoken --prefer-binary`
+   - Try upgrading pip: `pip install --upgrade pip`
+   - If issues persist, use a pre-built wheel: `pip install tiktoken --prefer-binary`
 
 ### 2. Setting Up Your Crew with the YAML Configuration
 
@@ -273,7 +270,7 @@ reporting_analyst:
 
 **tasks.yaml**
 
-````yaml
+```yaml
 # src/my_project/config/tasks.yaml
 research_task:
   description: >
@@ -293,7 +290,7 @@ reporting_task:
     Formatted as markdown without '```'
   agent: reporting_analyst
   output_file: report.md
-````
+```
 
 **crew.py**
 
@@ -559,7 +556,7 @@ Please refer to the [Connect CrewAI to LLMs](https://docs.crewai.com/how-to/LLM-
 
 - **LangGraph**: While LangGraph provides a foundation for building agent workflows, its approach requires significant boilerplate code and complex state management patterns. The framework's tight coupling with LangChain can limit flexibility when implementing custom agent behaviors or integrating with external systems.
 
-_P.S. CrewAI demonstrates significant performance advantages over LangGraph, executing 5.76x faster in certain cases like this QA task example ([see comparison](https://github.com/crewAIInc/crewAI-examples/tree/main/Notebooks/CrewAI%20Flows%20%26%20Langgraph/QA%20Agent)) while achieving higher evaluation scores with faster completion times in certain coding tasks, like in this example ([detailed analysis](https://github.com/crewAIInc/crewAI-examples/blob/main/Notebooks/CrewAI%20Flows%20%26%20Langgraph/Coding%20Assistant/coding_assistant_eval.ipynb))._
+*P.S. CrewAI demonstrates significant performance advantages over LangGraph, executing 5.76x faster in certain cases like this QA task example ([see comparison](https://github.com/crewAIInc/crewAI-examples/tree/main/Notebooks/CrewAI%20Flows%20%26%20Langgraph/QA%20Agent)) while achieving higher evaluation scores with faster completion times in certain coding tasks, like in this example ([detailed analysis](https://github.com/crewAIInc/crewAI-examples/blob/main/Notebooks/CrewAI%20Flows%20%26%20Langgraph/Coding%20Assistant/coding_assistant_eval.ipynb)).*
 
 - **Autogen**: While Autogen excels at creating conversational agents capable of working together, it lacks an inherent concept of process. In Autogen, orchestrating agents' interactions requires additional programming, which can become complex and cumbersome as the scale of tasks grows.
 - **ChatDev**: ChatDev introduced the idea of processes into the realm of AI agents, but its implementation is quite rigid. Customizations in ChatDev are limited and not geared towards production environments, which can hinder scalability and flexibility in real-world applications.
@@ -614,7 +611,7 @@ uv build
 ### Installing Locally
 
 ```bash
-uv pip install dist/*.tar.gz
+pip install dist/*.tar.gz
 ```
 
 ## Telemetry
@@ -690,13 +687,13 @@ A: CrewAI is a standalone, lean, and fast Python framework built specifically fo
 A: Install CrewAI using pip:
 
 ```shell
-uv pip install crewai
+pip install crewai
 ```
 
 For additional tools, use:
 
 ```shell
-uv pip install 'crewai[tools]'
+pip install 'crewai[tools]'
 ```
 
 ### Q: Does CrewAI depend on LangChain?

conftest.py

@@ -1,199 +0,0 @@
-"""Pytest configuration for crewAI workspace."""
-
-from collections.abc import Generator
-import os
-from pathlib import Path
-import tempfile
-from typing import Any
-
-from dotenv import load_dotenv
-import pytest
-from vcr.request import Request  # type: ignore[import-untyped]
-
-
-env_test_path = Path(__file__).parent / ".env.test"
-load_dotenv(env_test_path, override=True)
-load_dotenv(override=True)
-
-
-@pytest.fixture(autouse=True, scope="function")
-def cleanup_event_handlers() -> Generator[None, Any, None]:
-    """Clean up event bus handlers after each test to prevent test pollution."""
-    yield
-
-    try:
-        from crewai.events.event_bus import crewai_event_bus
-
-        with crewai_event_bus._rwlock.w_locked():
-            crewai_event_bus._sync_handlers.clear()
-            crewai_event_bus._async_handlers.clear()
-    except Exception:  # noqa: S110
-        pass
-
-
-@pytest.fixture(autouse=True, scope="function")
-def setup_test_environment() -> Generator[None, Any, None]:
-    """Setup test environment for crewAI workspace."""
-    with tempfile.TemporaryDirectory() as temp_dir:
-        storage_dir = Path(temp_dir) / "crewai_test_storage"
-        storage_dir.mkdir(parents=True, exist_ok=True)
-
-        if not storage_dir.exists() or not storage_dir.is_dir():
-            raise RuntimeError(
-                f"Failed to create test storage directory: {storage_dir}"
-            )
-
-        try:
-            test_file = storage_dir / ".permissions_test"
-            test_file.touch()
-            test_file.unlink()
-        except (OSError, IOError) as e:
-            raise RuntimeError(
-                f"Test storage directory {storage_dir} is not writable: {e}"
-            ) from e
-
-        os.environ["CREWAI_STORAGE_DIR"] = str(storage_dir)
-        os.environ["CREWAI_TESTING"] = "true"
-
-        try:
-            yield
-        finally:
-            os.environ.pop("CREWAI_TESTING", "true")
-            os.environ.pop("CREWAI_STORAGE_DIR", None)
-            os.environ.pop("CREWAI_DISABLE_TELEMETRY", "true")
-            os.environ.pop("OTEL_SDK_DISABLED", "true")
-            os.environ.pop("OPENAI_BASE_URL", "https://api.openai.com/v1")
-            os.environ.pop("OPENAI_API_BASE", "https://api.openai.com/v1")
-
-
-HEADERS_TO_FILTER = {
-    "authorization": "AUTHORIZATION-XXX",
-    "content-security-policy": "CSP-FILTERED",
-    "cookie": "COOKIE-XXX",
-    "set-cookie": "SET-COOKIE-XXX",
-    "permissions-policy": "PERMISSIONS-POLICY-XXX",
-    "referrer-policy": "REFERRER-POLICY-XXX",
-    "strict-transport-security": "STS-XXX",
-    "x-content-type-options": "X-CONTENT-TYPE-XXX",
-    "x-frame-options": "X-FRAME-OPTIONS-XXX",
-    "x-permitted-cross-domain-policies": "X-PERMITTED-XXX",
-    "x-request-id": "X-REQUEST-ID-XXX",
-    "x-runtime": "X-RUNTIME-XXX",
-    "x-xss-protection": "X-XSS-PROTECTION-XXX",
-    "x-stainless-arch": "X-STAINLESS-ARCH-XXX",
-    "x-stainless-os": "X-STAINLESS-OS-XXX",
-    "x-stainless-read-timeout": "X-STAINLESS-READ-TIMEOUT-XXX",
-    "cf-ray": "CF-RAY-XXX",
-    "etag": "ETAG-XXX",
-    "Strict-Transport-Security": "STS-XXX",
-    "access-control-expose-headers": "ACCESS-CONTROL-XXX",
-    "openai-organization": "OPENAI-ORG-XXX",
-    "openai-project": "OPENAI-PROJECT-XXX",
-    "x-ratelimit-limit-requests": "X-RATELIMIT-LIMIT-REQUESTS-XXX",
-    "x-ratelimit-limit-tokens": "X-RATELIMIT-LIMIT-TOKENS-XXX",
-    "x-ratelimit-remaining-requests": "X-RATELIMIT-REMAINING-REQUESTS-XXX",
-    "x-ratelimit-remaining-tokens": "X-RATELIMIT-REMAINING-TOKENS-XXX",
-    "x-ratelimit-reset-requests": "X-RATELIMIT-RESET-REQUESTS-XXX",
-    "x-ratelimit-reset-tokens": "X-RATELIMIT-RESET-TOKENS-XXX",
-    "x-goog-api-key": "X-GOOG-API-KEY-XXX",
-    "api-key": "X-API-KEY-XXX",
-    "User-Agent": "X-USER-AGENT-XXX",
-    "apim-request-id:": "X-API-CLIENT-REQUEST-ID-XXX",
-    "azureml-model-session": "AZUREML-MODEL-SESSION-XXX",
-    "x-ms-client-request-id": "X-MS-CLIENT-REQUEST-ID-XXX",
-    "x-ms-region": "X-MS-REGION-XXX",
-    "apim-request-id": "APIM-REQUEST-ID-XXX",
-    "x-api-key": "X-API-KEY-XXX",
-    "anthropic-organization-id": "ANTHROPIC-ORGANIZATION-ID-XXX",
-    "request-id": "REQUEST-ID-XXX",
-    "anthropic-ratelimit-input-tokens-limit": "ANTHROPIC-RATELIMIT-INPUT-TOKENS-LIMIT-XXX",
-    "anthropic-ratelimit-input-tokens-remaining": "ANTHROPIC-RATELIMIT-INPUT-TOKENS-REMAINING-XXX",
-    "anthropic-ratelimit-input-tokens-reset": "ANTHROPIC-RATELIMIT-INPUT-TOKENS-RESET-XXX",
-    "anthropic-ratelimit-output-tokens-limit": "ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-LIMIT-XXX",
-    "anthropic-ratelimit-output-tokens-remaining": "ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-REMAINING-XXX",
-    "anthropic-ratelimit-output-tokens-reset": "ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-RESET-XXX",
-    "anthropic-ratelimit-tokens-limit": "ANTHROPIC-RATELIMIT-TOKENS-LIMIT-XXX",
-    "anthropic-ratelimit-tokens-remaining": "ANTHROPIC-RATELIMIT-TOKENS-REMAINING-XXX",
-    "anthropic-ratelimit-tokens-reset": "ANTHROPIC-RATELIMIT-TOKENS-RESET-XXX",
-    "x-amz-date": "X-AMZ-DATE-XXX",
-    "amz-sdk-invocation-id": "AMZ-SDK-INVOCATION-ID-XXX",
-    "accept-encoding": "ACCEPT-ENCODING-XXX",
-    "x-amzn-requestid": "X-AMZN-REQUESTID-XXX",
-    "x-amzn-RequestId": "X-AMZN-REQUESTID-XXX",
-    "x-a2a-notification-token": "X-A2A-NOTIFICATION-TOKEN-XXX",
-    "x-a2a-version": "X-A2A-VERSION-XXX",
-}
-
-
-def _filter_request_headers(request: Request) -> Request:  # type: ignore[no-any-unimported]
-    """Filter sensitive headers from request before recording."""
-    for header_name, replacement in HEADERS_TO_FILTER.items():
-        for variant in [header_name, header_name.upper(), header_name.title()]:
-            if variant in request.headers:
-                request.headers[variant] = [replacement]
-
-    request.method = request.method.upper()
-    return request
-
-
-def _filter_response_headers(response: dict[str, Any]) -> dict[str, Any]:
-    """Filter sensitive headers from response before recording."""
-    # Remove Content-Encoding to prevent decompression issues on replay
-    for encoding_header in ["Content-Encoding", "content-encoding"]:
-        response["headers"].pop(encoding_header, None)
-
-    for header_name, replacement in HEADERS_TO_FILTER.items():
-        for variant in [header_name, header_name.upper(), header_name.title()]:
-            if variant in response["headers"]:
-                response["headers"][variant] = [replacement]
-    return response
-
-
-@pytest.fixture(scope="module")
-def vcr_cassette_dir(request: Any) -> str:
-    """Generate cassette directory path based on test module location.
-
-    Organizes cassettes to mirror test directory structure within each package:
-    lib/crewai/tests/llms/google/test_google.py -> lib/crewai/tests/cassettes/llms/google/
-    lib/crewai-tools/tests/tools/test_search.py -> lib/crewai-tools/tests/cassettes/tools/
-    """
-    test_file = Path(request.fspath)
-
-    for parent in test_file.parents:
-        if parent.name in ("crewai", "crewai-tools") and parent.parent.name == "lib":
-            package_root = parent
-            break
-    else:
-        package_root = test_file.parent
-
-    tests_root = package_root / "tests"
-    test_dir = test_file.parent
-
-    if test_dir != tests_root:
-        relative_path = test_dir.relative_to(tests_root)
-        cassette_dir = tests_root / "cassettes" / relative_path
-    else:
-        cassette_dir = tests_root / "cassettes"
-
-    cassette_dir.mkdir(parents=True, exist_ok=True)
-
-    return str(cassette_dir)
-
-
-@pytest.fixture(scope="module")
-def vcr_config(vcr_cassette_dir: str) -> dict[str, Any]:
-    """Configure VCR with organized cassette storage."""
-    config = {
-        "cassette_library_dir": vcr_cassette_dir,
-        "record_mode": os.getenv("PYTEST_VCR_RECORD_MODE", "once"),
-        "filter_headers": [(k, v) for k, v in HEADERS_TO_FILTER.items()],
-        "before_record_request": _filter_request_headers,
-        "before_record_response": _filter_response_headers,
-        "filter_query_parameters": ["key"],
-        "match_on": ["method", "scheme", "host", "port", "path"],
-    }
-
-    if os.getenv("GITHUB_ACTIONS") == "true":
-        config["record_mode"] = "none"
-
-    return config

docs/docs.json

@@ -116,7 +116,6 @@
                   "en/concepts/tasks",
                   "en/concepts/crews",
                   "en/concepts/flows",
-                  "en/concepts/production-architecture",
                   "en/concepts/knowledge",
                   "en/concepts/llms",
                   "en/concepts/processes",
@@ -135,7 +134,6 @@
                 "group": "MCP Integration",
                 "pages": [
                   "en/mcp/overview",
-                  "en/mcp/dsl-integration",
                   "en/mcp/stdio",
                   "en/mcp/sse",
                   "en/mcp/streamable-http",
@@ -254,8 +252,7 @@
                     "pages": [
                       "en/tools/integration/overview",
                       "en/tools/integration/bedrockinvokeagenttool",
-                      "en/tools/integration/crewaiautomationtool",
-                      "en/tools/integration/mergeagenthandlertool"
+                      "en/tools/integration/crewaiautomationtool"
                     ]
                   },
                   {
@@ -278,7 +275,6 @@
                   "en/observability/overview",
                   "en/observability/arize-phoenix",
                   "en/observability/braintrust",
-                  "en/observability/datadog",
                   "en/observability/langdb",
                   "en/observability/langfuse",
                   "en/observability/langtrace",
@@ -309,17 +305,13 @@
                   "en/learn/hierarchical-process",
                   "en/learn/human-input-on-execution",
                   "en/learn/human-in-the-loop",
-                  "en/learn/human-feedback-in-flows",
                   "en/learn/kickoff-async",
                   "en/learn/kickoff-for-each",
                   "en/learn/llm-connections",
                   "en/learn/multimodal-agents",
                   "en/learn/replay-tasks-from-latest-crew-kickoff",
                   "en/learn/sequential-process",
-                  "en/learn/using-annotations",
-                  "en/learn/execution-hooks",
-                  "en/learn/llm-hooks",
-                  "en/learn/tool-hooks"
+                  "en/learn/using-annotations"
                 ]
               },
               {
@@ -369,20 +361,10 @@
                   "en/enterprise/integrations/github",
                   "en/enterprise/integrations/gmail",
                   "en/enterprise/integrations/google_calendar",
-                  "en/enterprise/integrations/google_contacts",
-                  "en/enterprise/integrations/google_docs",
-                  "en/enterprise/integrations/google_drive",
                   "en/enterprise/integrations/google_sheets",
-                  "en/enterprise/integrations/google_slides",
                   "en/enterprise/integrations/hubspot",
                   "en/enterprise/integrations/jira",
                   "en/enterprise/integrations/linear",
-                  "en/enterprise/integrations/microsoft_excel",
-                  "en/enterprise/integrations/microsoft_onedrive",
-                  "en/enterprise/integrations/microsoft_outlook",
-                  "en/enterprise/integrations/microsoft_sharepoint",
-                  "en/enterprise/integrations/microsoft_teams",
-                  "en/enterprise/integrations/microsoft_word",
                   "en/enterprise/integrations/notion",
                   "en/enterprise/integrations/salesforce",
                   "en/enterprise/integrations/shopify",
@@ -415,7 +397,6 @@
                   "en/enterprise/guides/kickoff-crew",
                   "en/enterprise/guides/update-crew",
                   "en/enterprise/guides/enable-crew-studio",
-                  "en/enterprise/guides/capture_telemetry_logs",
                   "en/enterprise/guides/azure-openai-setup",
                   "en/enterprise/guides/tool-repository",
                   "en/enterprise/guides/react-component-export",
@@ -440,7 +421,6 @@
                   "en/api-reference/introduction",
                   "en/api-reference/inputs",
                   "en/api-reference/kickoff",
-                  "en/api-reference/resume",
                   "en/api-reference/status"
                 ]
               }
@@ -560,7 +540,6 @@
                   "pt-BR/concepts/tasks",
                   "pt-BR/concepts/crews",
                   "pt-BR/concepts/flows",
-                  "pt-BR/concepts/production-architecture",
                   "pt-BR/concepts/knowledge",
                   "pt-BR/concepts/llms",
                   "pt-BR/concepts/processes",
@@ -579,7 +558,6 @@
                 "group": "Integração MCP",
                 "pages": [
                   "pt-BR/mcp/overview",
-                  "pt-BR/mcp/dsl-integration",
                   "pt-BR/mcp/stdio",
                   "pt-BR/mcp/sse",
                   "pt-BR/mcp/streamable-http",
@@ -705,11 +683,9 @@
               {
                 "group": "Observabilidade",
                 "pages": [
-                  "pt-BR/observability/tracing",
                   "pt-BR/observability/overview",
                   "pt-BR/observability/arize-phoenix",
                   "pt-BR/observability/braintrust",
-                  "pt-BR/observability/datadog",
                   "pt-BR/observability/langdb",
                   "pt-BR/observability/langfuse",
                   "pt-BR/observability/langtrace",
@@ -739,17 +715,13 @@
                   "pt-BR/learn/hierarchical-process",
                   "pt-BR/learn/human-input-on-execution",
                   "pt-BR/learn/human-in-the-loop",
-                  "pt-BR/learn/human-feedback-in-flows",
                   "pt-BR/learn/kickoff-async",
                   "pt-BR/learn/kickoff-for-each",
                   "pt-BR/learn/llm-connections",
                   "pt-BR/learn/multimodal-agents",
                   "pt-BR/learn/replay-tasks-from-latest-crew-kickoff",
                   "pt-BR/learn/sequential-process",
-                  "pt-BR/learn/using-annotations",
-                  "pt-BR/learn/execution-hooks",
-                  "pt-BR/learn/llm-hooks",
-                  "pt-BR/learn/tool-hooks"
+                  "pt-BR/learn/using-annotations"
                 ]
               },
               {
@@ -799,20 +771,10 @@
                   "pt-BR/enterprise/integrations/github",
                   "pt-BR/enterprise/integrations/gmail",
                   "pt-BR/enterprise/integrations/google_calendar",
-                  "pt-BR/enterprise/integrations/google_contacts",
-                  "pt-BR/enterprise/integrations/google_docs",
-                  "pt-BR/enterprise/integrations/google_drive",
                   "pt-BR/enterprise/integrations/google_sheets",
-                  "pt-BR/enterprise/integrations/google_slides",
                   "pt-BR/enterprise/integrations/hubspot",
                   "pt-BR/enterprise/integrations/jira",
                   "pt-BR/enterprise/integrations/linear",
-                  "pt-BR/enterprise/integrations/microsoft_excel",
-                  "pt-BR/enterprise/integrations/microsoft_onedrive",
-                  "pt-BR/enterprise/integrations/microsoft_outlook",
-                  "pt-BR/enterprise/integrations/microsoft_sharepoint",
-                  "pt-BR/enterprise/integrations/microsoft_teams",
-                  "pt-BR/enterprise/integrations/microsoft_word",
                   "pt-BR/enterprise/integrations/notion",
                   "pt-BR/enterprise/integrations/salesforce",
                   "pt-BR/enterprise/integrations/shopify",
@@ -841,12 +803,6 @@
                 "group": "Triggers",
                 "pages": [
                   "pt-BR/enterprise/guides/automation-triggers",
-                  "pt-BR/enterprise/guides/gmail-trigger",
-                  "pt-BR/enterprise/guides/google-calendar-trigger",
-                  "pt-BR/enterprise/guides/google-drive-trigger",
-                  "pt-BR/enterprise/guides/outlook-trigger",
-                  "pt-BR/enterprise/guides/onedrive-trigger",
-                  "pt-BR/enterprise/guides/microsoft-teams-trigger",
                   "pt-BR/enterprise/guides/slack-trigger",
                   "pt-BR/enterprise/guides/hubspot-trigger",
                   "pt-BR/enterprise/guides/salesforce-trigger",
@@ -871,7 +827,6 @@
                   "pt-BR/api-reference/introduction",
                   "pt-BR/api-reference/inputs",
                   "pt-BR/api-reference/kickoff",
-                  "pt-BR/api-reference/resume",
                   "pt-BR/api-reference/status"
                 ]
               }
@@ -987,7 +942,6 @@
                   "ko/concepts/tasks",
                   "ko/concepts/crews",
                   "ko/concepts/flows",
-                  "ko/concepts/production-architecture",
                   "ko/concepts/knowledge",
                   "ko/concepts/llms",
                   "ko/concepts/processes",
@@ -1006,7 +960,6 @@
                 "group": "MCP 통합",
                 "pages": [
                   "ko/mcp/overview",
-                  "ko/mcp/dsl-integration",
                   "ko/mcp/stdio",
                   "ko/mcp/sse",
                   "ko/mcp/streamable-http",
@@ -1144,11 +1097,9 @@
               {
                 "group": "Observability",
                 "pages": [
-                  "ko/observability/tracing",
                   "ko/observability/overview",
                   "ko/observability/arize-phoenix",
                   "ko/observability/braintrust",
-                  "ko/observability/datadog",
                   "ko/observability/langdb",
                   "ko/observability/langfuse",
                   "ko/observability/langtrace",
@@ -1178,17 +1129,13 @@
                   "ko/learn/hierarchical-process",
                   "ko/learn/human-input-on-execution",
                   "ko/learn/human-in-the-loop",
-                  "ko/learn/human-feedback-in-flows",
                   "ko/learn/kickoff-async",
                   "ko/learn/kickoff-for-each",
                   "ko/learn/llm-connections",
                   "ko/learn/multimodal-agents",
                   "ko/learn/replay-tasks-from-latest-crew-kickoff",
                   "ko/learn/sequential-process",
-                  "ko/learn/using-annotations",
-                  "ko/learn/execution-hooks",
-                  "ko/learn/llm-hooks",
-                  "ko/learn/tool-hooks"
+                  "ko/learn/using-annotations"
                 ]
               },
               {
@@ -1238,20 +1185,10 @@
                   "ko/enterprise/integrations/github",
                   "ko/enterprise/integrations/gmail",
                   "ko/enterprise/integrations/google_calendar",
-                  "ko/enterprise/integrations/google_contacts",
-                  "ko/enterprise/integrations/google_docs",
-                  "ko/enterprise/integrations/google_drive",
                   "ko/enterprise/integrations/google_sheets",
-                  "ko/enterprise/integrations/google_slides",
                   "ko/enterprise/integrations/hubspot",
                   "ko/enterprise/integrations/jira",
                   "ko/enterprise/integrations/linear",
-                  "ko/enterprise/integrations/microsoft_excel",
-                  "ko/enterprise/integrations/microsoft_onedrive",
-                  "ko/enterprise/integrations/microsoft_outlook",
-                  "ko/enterprise/integrations/microsoft_sharepoint",
-                  "ko/enterprise/integrations/microsoft_teams",
-                  "ko/enterprise/integrations/microsoft_word",
                   "ko/enterprise/integrations/notion",
                   "ko/enterprise/integrations/salesforce",
                   "ko/enterprise/integrations/shopify",
@@ -1280,12 +1217,6 @@
                 "group": "트리거",
                 "pages": [
                   "ko/enterprise/guides/automation-triggers",
-                  "ko/enterprise/guides/gmail-trigger",
-                  "ko/enterprise/guides/google-calendar-trigger",
-                  "ko/enterprise/guides/google-drive-trigger",
-                  "ko/enterprise/guides/outlook-trigger",
-                  "ko/enterprise/guides/onedrive-trigger",
-                  "ko/enterprise/guides/microsoft-teams-trigger",
                   "ko/enterprise/guides/slack-trigger",
                   "ko/enterprise/guides/hubspot-trigger",
                   "ko/enterprise/guides/salesforce-trigger",
@@ -1308,7 +1239,6 @@
                   "ko/api-reference/introduction",
                   "ko/api-reference/inputs",
                   "ko/api-reference/kickoff",
-                  "ko/api-reference/resume",
                   "ko/api-reference/status"
                 ]
               }

docs/en/api-reference/introduction.mdx

@@ -16,17 +16,16 @@ Welcome to the CrewAI AMP API reference. This API allows you to programmatically
     Navigate to your crew's detail page in the CrewAI AMP dashboard and copy your Bearer Token from the Status tab.
   </Step>
 
-<Step title="Discover Required Inputs">
+  <Step title="Discover Required Inputs">
     Use the `GET /inputs` endpoint to see what parameters your crew expects.
-</Step>
+  </Step>
 
-<Step title="Start a Crew Execution">
-  Call `POST /kickoff` with your inputs to start the crew execution and receive
-  a `kickoff_id`.
-</Step>
+  <Step title="Start a Crew Execution">
+    Call `POST /kickoff` with your inputs to start the crew execution and receive a `kickoff_id`.
+  </Step>
 
   <Step title="Monitor Progress">
-    Use `GET /{kickoff_id}/status` to check execution status and retrieve results.
+    Use `GET /status/{kickoff_id}` to check execution status and retrieve results.
   </Step>
 </Steps>
 
@@ -42,13 +41,12 @@ curl -H "Authorization: Bearer YOUR_CREW_TOKEN" \
 ### Token Types
 
 | Token Type | Scope | Use Case |
-| :-------------------- | :------------------------ | :----------------------------------------------------------- |
+|:-----------|:--------|:----------|
 | **Bearer Token** | Organization-level access | Full crew operations, ideal for server-to-server integration |
 | **User Bearer Token** | User-scoped access | Limited permissions, suitable for user-specific operations |
 
 <Tip>
-  You can find both token types in the Status tab of your crew's detail page in
-  the CrewAI AMP dashboard.
+You can find both token types in the Status tab of your crew's detail page in the CrewAI AMP dashboard.
 </Tip>
 
 ## Base URL
@@ -65,7 +63,7 @@ Replace `your-crew-name` with your actual crew's URL from the dashboard.
 
 1. **Discovery**: Call `GET /inputs` to understand what your crew needs
 2. **Execution**: Submit inputs via `POST /kickoff` to start processing
-3. **Monitoring**: Poll `GET /{kickoff_id}/status` until completion
+3. **Monitoring**: Poll `GET /status/{kickoff_id}` until completion
 4. **Results**: Extract the final output from the completed response
 
 ## Error Handling
@@ -73,7 +71,7 @@ Replace `your-crew-name` with your actual crew's URL from the dashboard.
 The API uses standard HTTP status codes:
 
 | Code | Meaning |
-| ----- | :----------------------------------------- |
+|------|:--------|
 | `200` | Success |
 | `400` | Bad Request - Invalid input format |
 | `401` | Unauthorized - Invalid bearer token |
@@ -84,14 +82,10 @@ The API uses standard HTTP status codes:
 ## Interactive Testing
 
 <Info>
-  **Why no "Send" button?** Since each CrewAI AMP user has their own unique crew
-  URL, we use **reference mode** instead of an interactive playground to avoid
-  confusion. This shows you exactly what the requests should look like without
-  non-functional send buttons.
+**Why no "Send" button?** Since each CrewAI AMP user has their own unique crew URL, we use **reference mode** instead of an interactive playground to avoid confusion. This shows you exactly what the requests should look like without non-functional send buttons.
 </Info>
 
 Each endpoint page shows you:
-
 - ✅ **Exact request format** with all parameters
 - ✅ **Response examples** for success and error cases
 - ✅ **Code samples** in multiple languages (cURL, Python, JavaScript, etc.)
@@ -109,7 +103,6 @@ Each endpoint page shows you:
 </CardGroup>
 
 **Example workflow:**
-
 1. **Copy this cURL example** from any endpoint page
 2. **Replace `your-actual-crew-name.crewai.com`** with your real crew URL
 3. **Replace the Bearer token** with your real token from the dashboard
@@ -118,18 +111,10 @@ Each endpoint page shows you:
 ## Need Help?
 
 <CardGroup cols={2}>
-  <Card
-    title="Enterprise Support"
-    icon="headset"
-    href="mailto:support@crewai.com"
-  >
+  <Card title="Enterprise Support" icon="headset" href="mailto:support@crewai.com">
     Get help with API integration and troubleshooting
   </Card>
-  <Card
-    title="Enterprise Dashboard"
-    icon="chart-line"
-    href="https://app.crewai.com"
-  >
+  <Card title="Enterprise Dashboard" icon="chart-line" href="https://app.crewai.com">
     Manage your crews and view execution logs
   </Card>
 </CardGroup>

docs/en/api-reference/resume.mdx

@@ -1,6 +0,0 @@
----
-title: "POST /resume"
-description: "Resume crew execution with human feedback"
-openapi: "/enterprise-api.en.yaml POST /resume"
-mode: "wide"
----

docs/en/api-reference/status.mdx

@@ -1,6 +1,8 @@
 ---
-title: "GET /{kickoff_id}/status"
+title: "GET /status/{kickoff_id}"
 description: "Get execution status"
-openapi: "/enterprise-api.en.yaml GET /{kickoff_id}/status"
+openapi: "/enterprise-api.en.yaml GET /status/{kickoff_id}"
 mode: "wide"
 ---
+
+

docs/en/concepts/agents.mdx

@@ -8,7 +8,6 @@ mode: "wide"
 ## Overview of an Agent
 
 In the CrewAI framework, an `Agent` is an autonomous unit that can:
-
 - Perform specific tasks
 - Make decisions based on its role and goal
 - Use tools to accomplish objectives
@@ -17,10 +16,7 @@ In the CrewAI framework, an `Agent` is an autonomous unit that can:
 - Delegate tasks when allowed
 
 <Tip>
-  Think of an agent as a specialized team member with specific skills,
-  expertise, and responsibilities. For example, a `Researcher` agent might excel
-  at gathering and analyzing information, while a `Writer` agent might be better
-  at creating content.
+Think of an agent as a specialized team member with specific skills, expertise, and responsibilities. For example, a `Researcher` agent might excel at gathering and analyzing information, while a `Writer` agent might be better at creating content.
 </Tip>
 
 <Note type="info" title="Enterprise Enhancement: Visual Agent Builder">
@@ -29,7 +25,6 @@ CrewAI AMP includes a Visual Agent Builder that simplifies agent creation and co
 ![Visual Agent Builder Screenshot](/images/enterprise/crew-studio-interface.png)
 
 The Visual Agent Builder enables:
-
 - Intuitive agent configuration with form-based interfaces
 - Real-time testing and validation
 - Template library with pre-configured agent types
@@ -39,7 +34,7 @@ The Visual Agent Builder enables:
 ## Agent Attributes
 
 | Attribute                               | Parameter                | Type                          | Description                                                                                                          |
-| :-------------------------------------- | :----------------------- | :------------------------------------ | :------------------------------------------------------------------------------------------------------- |
+| :-------------------------------------- | :----------------------- | :---------------------------- | :------------------------------------------------------------------------------------------------------------------- |
 | **Role**                                | `role`                   | `str`                         | Defines the agent's function and expertise within the crew.                                                           |
 | **Goal**                                | `goal`                   | `str`                         | The individual objective that guides the agent's decision-making.                                                     |
 | **Backstory**                           | `backstory`              | `str`                         | Provides context and personality to the agent, enriching interactions.                                                |
@@ -142,8 +137,7 @@ class LatestAiDevelopmentCrew():
 ```
 
 <Note>
-  The names you use in your YAML files (`agents.yaml`) should match the method
-  names in your Python code.
+The names you use in your YAML files (`agents.yaml`) should match the method names in your Python code.
 </Note>
 
 ### Direct Code Definition
@@ -190,7 +184,6 @@ agent = Agent(
 Let's break down some key parameter combinations for common use cases:
 
 #### Basic Research Agent
-
 ```python Code
 research_agent = Agent(
     role="Research Analyst",
@@ -202,7 +195,6 @@ research_agent = Agent(
 ```
 
 #### Code Development Agent
-
 ```python Code
 dev_agent = Agent(
     role="Senior Python Developer",
@@ -216,7 +208,6 @@ dev_agent = Agent(
 ```
 
 #### Long-Running Analysis Agent
-
 ```python Code
 analysis_agent = Agent(
     role="Data Analyst",
@@ -230,7 +221,6 @@ analysis_agent = Agent(
 ```
 
 #### Custom Template Agent
-
 ```python Code
 custom_agent = Agent(
     role="Customer Service Representative",
@@ -246,7 +236,6 @@ custom_agent = Agent(
 ```
 
 #### Date-Aware Agent with Reasoning
-
 ```python Code
 strategic_agent = Agent(
     role="Market Analyst",
@@ -261,7 +250,6 @@ strategic_agent = Agent(
 ```
 
 #### Reasoning Agent
-
 ```python Code
 reasoning_agent = Agent(
     role="Strategic Planner",
@@ -275,7 +263,6 @@ reasoning_agent = Agent(
 ```
 
 #### Multimodal Agent
-
 ```python Code
 multimodal_agent = Agent(
     role="Visual Content Analyst",
@@ -289,64 +276,52 @@ multimodal_agent = Agent(
 ### Parameter Details
 
 #### Critical Parameters
-
 - `role`, `goal`, and `backstory` are required and shape the agent's behavior
 - `llm` determines the language model used (default: OpenAI's GPT-4)
 
 #### Memory and Context
-
 - `memory`: Enable to maintain conversation history
 - `respect_context_window`: Prevents token limit issues
 - `knowledge_sources`: Add domain-specific knowledge bases
 
 #### Execution Control
-
 - `max_iter`: Maximum attempts before giving best answer
 - `max_execution_time`: Timeout in seconds
 - `max_rpm`: Rate limiting for API calls
 - `max_retry_limit`: Retries on error
 
 #### Code Execution
-
 - `allow_code_execution`: Must be True to run code
 - `code_execution_mode`:
   - `"safe"`: Uses Docker (recommended for production)
   - `"unsafe"`: Direct execution (use only in trusted environments)
 
 <Note>
-  This runs a default Docker image. If you want to configure the docker image,
-  the checkout the Code Interpreter Tool in the tools section. Add the code
-  interpreter tool as a tool in the agent as a tool parameter.
-</Note>
+  This runs a default Docker image. If you want to configure the docker image, the checkout the Code Interpreter Tool in the tools section.
+  Add the code interpreter tool as a tool in the agent as a tool parameter.
+  </Note>
 
 #### Advanced Features
-
 - `multimodal`: Enable multimodal capabilities for processing text and visual content
 - `reasoning`: Enable agent to reflect and create plans before executing tasks
 - `inject_date`: Automatically inject current date into task descriptions
 
 #### Templates
-
 - `system_template`: Defines agent's core behavior
 - `prompt_template`: Structures input format
 - `response_template`: Formats agent responses
 
 <Note>
-  When using custom templates, ensure that both `system_template` and
-  `prompt_template` are defined. The `response_template` is optional but
-  recommended for consistent output formatting.
+When using custom templates, ensure that both `system_template` and `prompt_template` are defined. The `response_template` is optional but recommended for consistent output formatting.
 </Note>
 
 <Note>
-  When using custom templates, you can use variables like `{role}`, `{goal}`,
-  and `{backstory}` in your templates. These will be automatically populated
-  during execution.
+When using custom templates, you can use variables like `{role}`, `{goal}`, and `{backstory}` in your templates. These will be automatically populated during execution.
 </Note>
 
 ## Agent Tools
 
 Agents can be equipped with various tools to enhance their capabilities. CrewAI supports tools from:
-
 - [CrewAI Toolkit](https://github.com/joaomdmoura/crewai-tools)
 - [LangChain Tools](https://python.langchain.com/docs/integrations/tools)
 
@@ -385,8 +360,7 @@ analyst = Agent(
 ```
 
 <Note>
-  When `memory` is enabled, the agent will maintain context across multiple
-  interactions, improving its ability to handle complex, multi-step tasks.
+When `memory` is enabled, the agent will maintain context across multiple interactions, improving its ability to handle complex, multi-step tasks.
 </Note>
 
 ## Context Window Management
@@ -416,7 +390,6 @@ smart_agent = Agent(
 ```
 
 **What happens when context limits are exceeded:**
-
 - ⚠️ **Warning message**: `"Context length exceeded. Summarizing content to fit the model context window."`
 - 🔄 **Automatic summarization**: CrewAI intelligently summarizes the conversation history
 - ✅ **Continued execution**: Task execution continues seamlessly with the summarized context
@@ -438,7 +411,6 @@ strict_agent = Agent(
 ```
 
 **What happens when context limits are exceeded:**
-
 - ❌ **Error message**: `"Context length exceeded. Consider using smaller text or RAG tools from crewai_tools."`
 - 🛑 **Execution stops**: Task execution halts immediately
 - 🔧 **Manual intervention required**: You need to modify your approach
@@ -446,7 +418,6 @@ strict_agent = Agent(
 ### Choosing the Right Setting
 
 #### Use `respect_context_window=True` (Default) when:
-
 - **Processing large documents** that might exceed context limits
 - **Long-running conversations** where some summarization is acceptable
 - **Research tasks** where general context is more important than exact details
@@ -465,7 +436,6 @@ document_processor = Agent(
 ```
 
 #### Use `respect_context_window=False` when:
-
 - **Precision is critical** and information loss is unacceptable
 - **Legal or medical tasks** requiring complete context
 - **Code review** where missing details could introduce bugs
@@ -488,7 +458,6 @@ precision_agent = Agent(
 When dealing with very large datasets, consider these strategies:
 
 #### 1. Use RAG Tools
-
 ```python Code
 from crewai_tools import RagTool
 
@@ -506,7 +475,6 @@ rag_agent = Agent(
 ```
 
 #### 2. Use Knowledge Sources
-
 ```python Code
 # Use knowledge sources instead of large prompts
 knowledge_agent = Agent(
@@ -530,7 +498,6 @@ knowledge_agent = Agent(
 ### Troubleshooting Context Issues
 
 **If you're getting context limit errors:**
-
 ```python Code
 # Quick fix: Enable automatic handling
 agent.respect_context_window = True
@@ -544,7 +511,6 @@ agent.tools = [RagTool()]
 ```
 
 **If automatic summarization loses important information:**
-
 ```python Code
 # Disable auto-summarization and use RAG instead
 agent = Agent(
@@ -558,10 +524,7 @@ agent = Agent(
 ```
 
 <Note>
-  The context window management feature works automatically in the background.
-  You don't need to call any special functions - just set
-  `respect_context_window` to your preferred behavior and CrewAI handles the
-  rest!
+The context window management feature works automatically in the background. You don't need to call any special functions - just set `respect_context_window` to your preferred behavior and CrewAI handles the rest!
 </Note>
 
 ## Direct Agent Interaction with `kickoff()`
@@ -594,7 +557,7 @@ print(result.raw)
 ### Parameters and Return Values
 
 | Parameter         | Type                                | Description                                                               |
-| :---------------- | :--------------------------------- | :------------------------------------------------------------------------ |
+| :---------------- | :---------------------------------- | :------------------------------------------------------------------------ |
 | `messages`        | `Union[str, List[Dict[str, str]]]`  | Either a string query or a list of message dictionaries with role/content |
 | `response_format` | `Optional[Type[Any]]`               | Optional Pydantic model for structured output                             |
 
@@ -658,34 +621,28 @@ asyncio.run(main())
 ```
 
 <Note>
-  The `kickoff()` method uses a `LiteAgent` internally, which provides a simpler
-  execution flow while preserving all of the agent's configuration (role, goal,
-  backstory, tools, etc.).
+The `kickoff()` method uses a `LiteAgent` internally, which provides a simpler execution flow while preserving all of the agent's configuration (role, goal, backstory, tools, etc.).
 </Note>
 
 ## Important Considerations and Best Practices
 
 ### Security and Code Execution
-
 - When using `allow_code_execution`, be cautious with user input and always validate it
 - Use `code_execution_mode: "safe"` (Docker) in production environments
 - Consider setting appropriate `max_execution_time` limits to prevent infinite loops
 
 ### Performance Optimization
-
 - Use `respect_context_window: true` to prevent token limit issues
 - Set appropriate `max_rpm` to avoid rate limiting
 - Enable `cache: true` to improve performance for repetitive tasks
 - Adjust `max_iter` and `max_retry_limit` based on task complexity
 
 ### Memory and Context Management
-
 - Leverage `knowledge_sources` for domain-specific information
 - Configure `embedder` when using custom embedding models
 - Use custom templates (`system_template`, `prompt_template`, `response_template`) for fine-grained control over agent behavior
 
 ### Advanced Features
-
 - Enable `reasoning: true` for agents that need to plan and reflect before executing complex tasks
 - Set appropriate `max_reasoning_attempts` to control planning iterations (None for unlimited attempts)
 - Use `inject_date: true` to provide agents with current date awareness for time-sensitive tasks
@@ -693,7 +650,6 @@ asyncio.run(main())
 - Enable `multimodal: true` for agents that need to process both text and visual content
 
 ### Agent Collaboration
-
 - Enable `allow_delegation: true` when agents need to work together
 - Use `step_callback` to monitor and log agent interactions
 - Consider using different LLMs for different purposes:
@@ -701,7 +657,6 @@ asyncio.run(main())
   - `function_calling_llm` for efficient tool usage
 
 ### Date Awareness and Reasoning
-
 - Use `inject_date: true` to provide agents with current date awareness for time-sensitive tasks
 - Customize the date format with `date_format` using standard Python datetime format codes
 - Valid format codes include: %Y (year), %m (month), %d (day), %B (full month name), etc.
@@ -709,26 +664,22 @@ asyncio.run(main())
 - Enable `reasoning: true` for complex tasks that benefit from upfront planning and reflection
 
 ### Model Compatibility
-
 - Set `use_system_prompt: false` for older models that don't support system messages
 - Ensure your chosen `llm` supports the features you need (like function calling)
 
 ## Troubleshooting Common Issues
 
 1. **Rate Limiting**: If you're hitting API rate limits:
-
    - Implement appropriate `max_rpm`
    - Use caching for repetitive operations
    - Consider batching requests
 
 2. **Context Window Errors**: If you're exceeding context limits:
-
    - Enable `respect_context_window`
    - Use more efficient prompts
    - Clear agent memory periodically
 
 3. **Code Execution Issues**: If code execution fails:
-
    - Verify Docker is installed for safe mode
    - Check execution permissions
    - Review code sandbox settings

docs/en/concepts/cli.mdx

@@ -5,12 +5,7 @@ icon: terminal
 mode: "wide"
 ---
 
-<Warning>
-  Since release 0.140.0, CrewAI AMP started a process of migrating their login
-  provider. As such, the authentication flow via CLI was updated. Users that use
-  Google to login, or that created their account after July 3rd, 2025 will be
-  unable to log in with older versions of the `crewai` library.
-</Warning>
+<Warning>Since release 0.140.0, CrewAI AMP started a process of migrating their login provider. As such, the authentication flow via CLI was updated. Users that use Google to login, or that created their account after July 3rd, 2025 will be unable to log in with older versions of the `crewai` library.</Warning>
 
 ## Overview
 
@@ -46,7 +41,6 @@ crewai create [OPTIONS] TYPE NAME
 - `NAME`: Name of the crew or flow
 
 Example:
-
 ```shell Terminal
 crewai create crew my_new_crew
 crewai create flow my_new_flow
@@ -63,7 +57,6 @@ crewai version [OPTIONS]
 - `--tools`: (Optional) Show the installed version of CrewAI tools
 
 Example:
-
 ```shell Terminal
 crewai version
 crewai version --tools
@@ -81,7 +74,6 @@ crewai train [OPTIONS]
 - `-f, --filename TEXT`: Path to a custom file for training (default: "trained_agents_data.pkl")
 
 Example:
-
 ```shell Terminal
 crewai train -n 10 -f my_training_data.pkl
 ```
@@ -97,7 +89,6 @@ crewai replay [OPTIONS]
 - `-t, --task_id TEXT`: Replay the crew from this task ID, including all subsequent tasks
 
 Example:
-
 ```shell Terminal
 crewai replay -t task_123456
 ```
@@ -127,7 +118,6 @@ crewai reset-memories [OPTIONS]
 - `-a, --all`: Reset ALL memories
 
 Example:
-
 ```shell Terminal
 crewai reset-memories --long --short
 crewai reset-memories --all
@@ -145,7 +135,6 @@ crewai test [OPTIONS]
 - `-m, --model TEXT`: LLM Model to run the tests on the Crew (default: "gpt-4o-mini")
 
 Example:
-
 ```shell Terminal
 crewai test -n 5 -m gpt-3.5-turbo
 ```
@@ -159,16 +148,12 @@ crewai run
 ```
 
 <Note>
-  Starting from version 0.103.0, the `crewai run` command can be used to run
-  both standard crews and flows. For flows, it automatically detects the type
-  from pyproject.toml and runs the appropriate command. This is now the
-  recommended way to run both crews and flows.
+Starting from version 0.103.0, the `crewai run` command can be used to run both standard crews and flows. For flows, it automatically detects the type from pyproject.toml and runs the appropriate command. This is now the recommended way to run both crews and flows.
 </Note>
 
 <Note>
-  Make sure to run these commands from the directory where your CrewAI project
-  is set up. Some commands may require additional configuration or setup within
-  your project structure.
+Make sure to run these commands from the directory where your CrewAI project is set up.
+Some commands may require additional configuration or setup within your project structure.
 </Note>
 
 ### 9. Chat
@@ -180,7 +165,6 @@ After receiving the results, you can continue interacting with the assistant for
 ```shell Terminal
 crewai chat
 ```
-
 <Note>
 Ensure you execute these commands from your CrewAI project's root directory.
 </Note>
@@ -198,7 +182,6 @@ def crew(self) -> Crew:
         chat_llm="gpt-4o",  # LLM for chat orchestration
     )
 ```
-
 </Note>
 
 ### 10. Deploy
@@ -207,7 +190,6 @@ Deploy the crew or flow to [CrewAI AMP](https://app.crewai.com).
 
 - **Authentication**: You need to be authenticated to deploy to CrewAI AMP.
     You can login or create an account with:
-
     ```shell Terminal
     crewai login
     ```
@@ -230,71 +212,56 @@ crewai org [COMMAND] [OPTIONS]
 #### Commands:
 
 - `list`: List all organizations you belong to
-
 ```shell Terminal
 crewai org list
 ```
 
 - `current`: Display your currently active organization
-
 ```shell Terminal
 crewai org current
 ```
 
 - `switch`: Switch to a specific organization
-
 ```shell Terminal
 crewai org switch <organization_id>
 ```
 
 <Note>
-  You must be authenticated to CrewAI AMP to use these organization management
-  commands.
+You must be authenticated to CrewAI AMP to use these organization management commands.
 </Note>
 
 - **Create a deployment** (continued):
-
     - Links the deployment to the corresponding remote GitHub repository (it usually detects this automatically).
 
 - **Deploy the Crew**: Once you are authenticated, you can deploy your crew or flow to CrewAI AMP.
-
     ```shell Terminal
     crewai deploy push
     ```
-
     - Initiates the deployment process on the CrewAI AMP platform.
     - Upon successful initiation, it will output the Deployment created successfully! message along with the Deployment Name and a unique Deployment ID (UUID).
 
 - **Deployment Status**: You can check the status of your deployment with:
-
     ```shell Terminal
     crewai deploy status
     ```
-
     This fetches the latest deployment status of your most recent deployment attempt (e.g., `Building Images for Crew`, `Deploy Enqueued`, `Online`).
 
 - **Deployment Logs**: You can check the logs of your deployment with:
-
     ```shell Terminal
     crewai deploy logs
     ```
-
     This streams the deployment logs to your terminal.
 
 - **List deployments**: You can list all your deployments with:
-
     ```shell Terminal
     crewai deploy list
     ```
-
     This lists all your deployments.
 
 - **Delete a deployment**: You can delete a deployment with:
-
     ```shell Terminal
     crewai deploy remove
     ```
-
     This deletes the deployment from the CrewAI AMP platform.
 
 - **Help Command**: You can get help with the CLI with:
@@ -323,20 +290,18 @@ crewai login
 ```
 
 What happens:
-
 - A verification URL and short code are displayed in your terminal
 - Your browser opens to the verification URL
 - Enter/confirm the code to complete authentication
 
 Notes:
-
 - The OAuth2 provider and domain are configured via `crewai config` (defaults use `login.crewai.com`)
 - After successful login, the CLI also attempts to authenticate to the Tool Repository automatically
 - If you reset your configuration, run `crewai login` again to re-authenticate
 
 ### 12. API Keys
 
-When running `crewai create crew` command, the CLI will show you a list of available LLM providers to choose from, followed by model selection for your chosen provider.
+When running ```crewai create crew``` command, the CLI will show you a list of available LLM providers to choose from, followed by model selection for your chosen provider.
 
 Once you've selected an LLM provider and model, you will be prompted for API keys.
 
@@ -344,11 +309,11 @@ Once you've selected an LLM provider and model, you will be prompted for API key
 
 Here's a list of the most popular LLM providers suggested by the CLI:
 
-- OpenAI
-- Groq
-- Anthropic
-- Google Gemini
-- SambaNova
+* OpenAI
+* Groq
+* Anthropic
+* Google Gemini
+* SambaNova
 
 When you select a provider, the CLI will then show you available models for that provider and prompt you to enter your API key.
 
@@ -360,7 +325,7 @@ When you select a provider, the CLI will prompt you to enter the Key name and th
 
 See the following link for each provider's key name:
 
-- [LiteLLM Providers](https://docs.litellm.ai/docs/providers)
+* [LiteLLM Providers](https://docs.litellm.ai/docs/providers)
 
 ### 13. Configuration Management
 
@@ -373,19 +338,16 @@ crewai config [COMMAND] [OPTIONS]
 #### Commands:
 
 - `list`: Display all CLI configuration parameters
-
 ```shell Terminal
 crewai config list
 ```
 
 - `set`: Set a CLI configuration parameter
-
 ```shell Terminal
 crewai config set <key> <value>
 ```
 
 - `reset`: Reset all CLI configuration parameters to default values
-
 ```shell Terminal
 crewai config reset
 ```
@@ -401,7 +363,6 @@ crewai config reset
 #### Examples
 
 Display current configuration:
-
 ```shell Terminal
 crewai config list
 ```
@@ -418,124 +379,33 @@ Example output:
 | oauth2_domain       | login.crewai.com         | Provider domain (e.g., your-org.auth0.com)                  |
 
 Set the enterprise base URL:
-
 ```shell Terminal
 crewai config set enterprise_base_url https://my-enterprise.crewai.com
 ```
 
 Set OAuth2 provider:
-
 ```shell Terminal
 crewai config set oauth2_provider auth0
 ```
 
 Set OAuth2 domain:
-
 ```shell Terminal
 crewai config set oauth2_domain my-company.auth0.com
 ```
 
 Reset all configuration to defaults:
-
 ```shell Terminal
 crewai config reset
 ```
 
 <Tip>
-  After resetting configuration, re-run `crewai login` to authenticate again.
-</Tip>
-
-### 14. Trace Management
-
-Manage trace collection preferences for your Crew and Flow executions.
-
-```shell Terminal
-crewai traces [COMMAND]
-```
-
-#### Commands:
-
-- `enable`: Enable trace collection for crew/flow executions
-
-```shell Terminal
-crewai traces enable
-```
-
-- `disable`: Disable trace collection for crew/flow executions
-
-```shell Terminal
-crewai traces disable
-```
-
-- `status`: Show current trace collection status
-
-```shell Terminal
-crewai traces status
-```
-
-#### How Tracing Works
-
-Trace collection is controlled by checking three settings in priority order:
-
-1. **Explicit flag in code** (highest priority - can enable OR disable):
-
-   ```python
-   crew = Crew(agents=[...], tasks=[...], tracing=True)   # Always enable
-   crew = Crew(agents=[...], tasks=[...], tracing=False)  # Always disable
-   crew = Crew(agents=[...], tasks=[...])                 # Check lower priorities (default)
-   ```
-
-   - `tracing=True` will **always enable** tracing (overrides everything)
-   - `tracing=False` will **always disable** tracing (overrides everything)
-   - `tracing=None` or omitted will check lower priority settings
-
-2. **Environment variable** (second priority):
-
-   ```env
-   CREWAI_TRACING_ENABLED=true
-   ```
-
-   - Checked only if `tracing` is not explicitly set to `True` or `False` in code
-   - Set to `true` or `1` to enable tracing
-
-3. **User preference** (lowest priority):
-   ```shell Terminal
-   crewai traces enable
-   ```
-   - Checked only if `tracing` is not set in code and `CREWAI_TRACING_ENABLED` is not set to `true`
-   - Running `crewai traces enable` is sufficient to enable tracing by itself
-
-<Note>
-**To enable tracing**, use any one of these methods:
-- Set `tracing=True` in your Crew/Flow code, OR
-- Add `CREWAI_TRACING_ENABLED=true` to your `.env` file, OR
-- Run `crewai traces enable`
-
-**To disable tracing**, use any ONE of these methods:
-
-- Set `tracing=False` in your Crew/Flow code (overrides everything), OR
-- Remove or set to `false` the `CREWAI_TRACING_ENABLED` env var, OR
-- Run `crewai traces disable`
-
-Higher priority settings override lower ones.
-
-</Note>
-
-<Tip>
-  For more information about tracing, see the [Tracing
-  documentation](/observability/tracing).
+After resetting configuration, re-run `crewai login` to authenticate again.
 </Tip>
 
 <Tip>
-  CrewAI CLI handles authentication to the Tool Repository automatically when
-  adding packages to your project. Just append `crewai` before any `uv` command
-  to use it. E.g. `crewai uv add requests`. For more information, see [Tool
-  Repository](https://docs.crewai.com/enterprise/features/tool-repository) docs.
+CrewAI CLI handles authentication to the Tool Repository automatically when adding packages to your project. Just append `crewai` before any `uv` command to use it. E.g. `crewai uv add requests`. For more information, see [Tool Repository](https://docs.crewai.com/enterprise/features/tool-repository) docs.
 </Tip>
 
 <Note>
-  Configuration settings are stored in `~/.config/crewai/settings.json`. Some
-  settings like organization name and UUID are read-only and managed through
-  authentication and organization commands. Tool repository related settings are
-  hidden and cannot be set directly by users.
+Configuration settings are stored in `~/.config/crewai/settings.json`. Some settings like organization name and UUID are read-only and managed through authentication and organization commands. Tool repository related settings are hidden and cannot be set directly by users.
 </Note>

docs/en/concepts/crews.mdx

@@ -33,7 +33,6 @@ A crew in crewAI represents a collaborative group of agents working together to
 | **Planning** *(optional)*             | `planning`             | Adds planning ability to the Crew. When activated before each Crew iteration, all Crew data is sent to an AgentPlanner that will plan the tasks and this plan will be added to each task description.                                                     |
 | **Planning LLM** *(optional)*         | `planning_llm`         | The language model used by the AgentPlanner in a planning process.                                                                                                                                                                                        |
 | **Knowledge Sources** _(optional)_    | `knowledge_sources`    | Knowledge sources available at the crew level, accessible to all the agents.                                                                                                                                                                                    |
-| **Stream** _(optional)_               | `stream`               | Enable streaming output to receive real-time updates during crew execution. Returns a `CrewStreamingOutput` object that can be iterated for chunks. Defaults to `False`.                                                                                    |
 
 <Tip>
 **Crew Max RPM**: The `max_rpm` attribute sets the maximum number of requests per minute the crew can perform to avoid rate limits and will override individual agents' `max_rpm` settings if you set it.
@@ -307,27 +306,12 @@ print(result)
 
 ### Different Ways to Kick Off a Crew
 
-Once your crew is assembled, initiate the workflow with the appropriate kickoff method. CrewAI provides several methods for better control over the kickoff process.
-
-#### Synchronous Methods
+Once your crew is assembled, initiate the workflow with the appropriate kickoff method. CrewAI provides several methods for better control over the kickoff process: `kickoff()`, `kickoff_for_each()`, `kickoff_async()`, and `kickoff_for_each_async()`.
 
 - `kickoff()`: Starts the execution process according to the defined process flow.
 - `kickoff_for_each()`: Executes tasks sequentially for each provided input event or item in the collection.
-
-#### Asynchronous Methods
-
-CrewAI offers two approaches for async execution:
-
-| Method | Type | Description |
-|--------|------|-------------|
-| `akickoff()` | Native async | True async/await throughout the entire execution chain |
-| `akickoff_for_each()` | Native async | Native async execution for each input in a list |
-| `kickoff_async()` | Thread-based | Wraps synchronous execution in `asyncio.to_thread` |
-| `kickoff_for_each_async()` | Thread-based | Thread-based async for each input in a list |
-
-<Note>
-For high-concurrency workloads, `akickoff()` and `akickoff_for_each()` are recommended as they use native async for task execution, memory operations, and knowledge retrieval.
-</Note>
+- `kickoff_async()`: Initiates the workflow asynchronously.
+- `kickoff_for_each_async()`: Executes tasks concurrently for each provided input event or item, leveraging asynchronous processing.
 
 ```python Code
 # Start the crew's task execution
@@ -340,53 +324,19 @@ results = my_crew.kickoff_for_each(inputs=inputs_array)
 for result in results:
     print(result)
 
-# Example of using native async with akickoff
-inputs = {'topic': 'AI in healthcare'}
-async_result = await my_crew.akickoff(inputs=inputs)
-print(async_result)
-
-# Example of using native async with akickoff_for_each
-inputs_array = [{'topic': 'AI in healthcare'}, {'topic': 'AI in finance'}]
-async_results = await my_crew.akickoff_for_each(inputs=inputs_array)
-for async_result in async_results:
-    print(async_result)
-
-# Example of using thread-based kickoff_async
+# Example of using kickoff_async
 inputs = {'topic': 'AI in healthcare'}
 async_result = await my_crew.kickoff_async(inputs=inputs)
 print(async_result)
 
-# Example of using thread-based kickoff_for_each_async
+# Example of using kickoff_for_each_async
 inputs_array = [{'topic': 'AI in healthcare'}, {'topic': 'AI in finance'}]
 async_results = await my_crew.kickoff_for_each_async(inputs=inputs_array)
 for async_result in async_results:
     print(async_result)
 ```
 
-These methods provide flexibility in how you manage and execute tasks within your crew, allowing for both synchronous and asynchronous workflows tailored to your needs. For detailed async examples, see the [Kickoff Crew Asynchronously](/en/learn/kickoff-async) guide.
-
-### Streaming Crew Execution
-
-For real-time visibility into crew execution, you can enable streaming to receive output as it's generated:
-
-```python Code
-# Enable streaming
-crew = Crew(
-    agents=[researcher],
-    tasks=[task],
-    stream=True
-)
-
-# Iterate over streaming output
-streaming = crew.kickoff(inputs={"topic": "AI"})
-for chunk in streaming:
-    print(chunk.content, end="", flush=True)
-
-# Access final result
-result = streaming.result
-```
-
-Learn more about streaming in the [Streaming Crew Execution](/en/learn/streaming-crew-execution) guide.
+These methods provide flexibility in how you manage and execute tasks within your crew, allowing for both synchronous and asynchronous workflows tailored to your needs.
 
 ### Replaying from a Specific Task
 

docs/en/concepts/event-listener.mdx

@@ -1,6 +1,6 @@
 ---
-title: "Event Listeners"
-description: "Tap into CrewAI events to build custom integrations and monitoring"
+title: 'Event Listeners'
+description: 'Tap into CrewAI events to build custom integrations and monitoring'
 icon: spinner
 mode: "wide"
 ---
@@ -25,7 +25,6 @@ CrewAI AMP provides a built-in Prompt Tracing feature that leverages the event s
 ![Prompt Tracing Dashboard](/images/enterprise/traces-overview.png)
 
 With Prompt Tracing you can:
-
 - View the complete history of all prompts sent to your LLM
 - Track token usage and costs
 - Debug agent reasoning failures
@@ -275,6 +274,7 @@ The structure of the event object depends on the event type, but all events inhe
 
 Additional fields vary by event type. For example, `CrewKickoffCompletedEvent` includes `crew_name` and `output` fields.
 
+
 ## Advanced Usage: Scoped Handlers
 
 For temporary event handling (useful for testing or specific operations), you can use the `scoped_handlers` context manager:

docs/en/concepts/flows.mdx

@@ -572,55 +572,6 @@ The `third_method` and `fourth_method` listen to the output of the `second_metho
 
 When you run this Flow, the output will change based on the random boolean value generated by the `start_method`.
 
-### Human in the Loop (human feedback)
-
-The `@human_feedback` decorator enables human-in-the-loop workflows by pausing flow execution to collect feedback from a human. This is useful for approval gates, quality review, and decision points that require human judgment.
-
-```python Code
-from crewai.flow.flow import Flow, start, listen
-from crewai.flow.human_feedback import human_feedback, HumanFeedbackResult
-
-class ReviewFlow(Flow):
-    @start()
-    @human_feedback(
-        message="Do you approve this content?",
-        emit=["approved", "rejected", "needs_revision"],
-        llm="gpt-4o-mini",
-        default_outcome="needs_revision",
-    )
-    def generate_content(self):
-        return "Content to be reviewed..."
-
-    @listen("approved")
-    def on_approval(self, result: HumanFeedbackResult):
-        print(f"Approved! Feedback: {result.feedback}")
-
-    @listen("rejected")
-    def on_rejection(self, result: HumanFeedbackResult):
-        print(f"Rejected. Reason: {result.feedback}")
-```
-
-When `emit` is specified, the human's free-form feedback is interpreted by an LLM and collapsed into one of the specified outcomes, which then triggers the corresponding `@listen` decorator.
-
-You can also use `@human_feedback` without routing to simply collect feedback:
-
-```python Code
-@start()
-@human_feedback(message="Any comments on this output?")
-def my_method(self):
-    return "Output for review"
-
-@listen(my_method)
-def next_step(self, result: HumanFeedbackResult):
-    # Access feedback via result.feedback
-    # Access original output via result.output
-    pass
-```
-
-Access all feedback collected during a flow via `self.last_human_feedback` (most recent) or `self.human_feedback_history` (all feedback as a list).
-
-For a complete guide on human feedback in flows, including **async/non-blocking feedback** with custom providers (Slack, webhooks, etc.), see [Human Feedback in Flows](/en/learn/human-feedback-in-flows).
-
 ## Adding Agents to Flows
 
 Agents can be seamlessly integrated into your flows, providing a lightweight alternative to full Crews when you need simpler, focused task execution. Here's an example of how to use an Agent within a flow to perform market research:
@@ -946,31 +897,6 @@ flow = ExampleFlow()
 result = flow.kickoff()
 ```
 
-### Streaming Flow Execution
-
-For real-time visibility into flow execution, you can enable streaming to receive output as it's generated:
-
-```python
-class StreamingFlow(Flow):
-    stream = True  # Enable streaming
-
-    @start()
-    def research(self):
-        # Your flow implementation
-        pass
-
-# Iterate over streaming output
-flow = StreamingFlow()
-streaming = flow.kickoff()
-for chunk in streaming:
-    print(chunk.content, end="", flush=True)
-
-# Access final result
-result = streaming.result
-```
-
-Learn more about streaming in the [Streaming Flow Execution](/en/learn/streaming-flow-execution) guide.
-
 ### Using the CLI
 
 Starting from version 0.103.0, you can run flows using the `crewai run` command:

docs/en/concepts/knowledge.mdx

@@ -388,8 +388,8 @@ crew = Crew(
     agents=[sales_agent, tech_agent, support_agent],
     tasks=[...],
     embedder={  # Fallback embedder for agents without their own
-        "provider": "google-generativeai",
-        "config": {"model_name": "gemini-embedding-001"}
+        "provider": "google",
+        "config": {"model": "text-embedding-004"}
     }
 )
 
@@ -629,9 +629,9 @@ agent = Agent(
     backstory="Expert researcher",
     knowledge_sources=[knowledge_source],
     embedder={
-        "provider": "google-generativeai",
+        "provider": "google",
         "config": {
-            "model_name": "gemini-embedding-001",
+            "model": "models/text-embedding-004",
             "api_key": "your-google-key"
         }
     }
@@ -739,7 +739,7 @@ class KnowledgeMonitorListener(BaseEventListener):
 knowledge_monitor = KnowledgeMonitorListener()
 ```
 
-For more information on using events, see the [Event Listeners](/en/concepts/event-listener) documentation.
+For more information on using events, see the [Event Listeners](https://docs.crewai.com/concepts/event-listener) documentation.
 
 ### Custom Knowledge Sources
 

docs/en/concepts/llms.mdx

@@ -7,7 +7,7 @@ mode: "wide"
 
 ## Overview
 
-CrewAI integrates with multiple LLM providers through providers native sdks, giving you the flexibility to choose the right model for your specific use case. This guide will help you understand how to configure and use different LLM providers in your CrewAI projects.
+CrewAI integrates with multiple LLM providers through LiteLLM, giving you the flexibility to choose the right model for your specific use case. This guide will help you understand how to configure and use different LLM providers in your CrewAI projects.
 
 
 ## What are LLMs?
@@ -113,104 +113,44 @@ In this section, you'll find detailed examples that help you select, configure,
 
 <AccordionGroup>
   <Accordion title="OpenAI">
-    CrewAI provides native integration with OpenAI through the OpenAI Python SDK.
+    Set the following environment variables in your `.env` file:
 
     ```toml Code
     # Required
     OPENAI_API_KEY=sk-...
 
     # Optional
-    OPENAI_BASE_URL=<custom-base-url>
+    OPENAI_API_BASE=<custom-base-url>
+    OPENAI_ORGANIZATION=<your-org-id>
     ```
 
-    **Basic Usage:**
+    Example usage in your CrewAI project:
     ```python Code
     from crewai import LLM
 
     llm = LLM(
-        model="openai/gpt-4o",
-        api_key="your-api-key",  # Or set OPENAI_API_KEY
-        temperature=0.7,
-        max_tokens=4000
-    )
-    ```
-
-    **Advanced Configuration:**
-    ```python Code
-    from crewai import LLM
-
-    llm = LLM(
-        model="openai/gpt-4o",
-        api_key="your-api-key",
-        base_url="https://api.openai.com/v1",  # Optional custom endpoint
-        organization="org-...",  # Optional organization ID
-        project="proj_...",  # Optional project ID
-        temperature=0.7,
-        max_tokens=4000,
-        max_completion_tokens=4000,  # For newer models
+        model="openai/gpt-4", # call model by provider/model_name
+        temperature=0.8,
+        max_tokens=150,
         top_p=0.9,
         frequency_penalty=0.1,
         presence_penalty=0.1,
         stop=["END"],
-        seed=42,  # For reproducible outputs
-        stream=True,  # Enable streaming
-        timeout=60.0,  # Request timeout in seconds
-        max_retries=3,  # Maximum retry attempts
-        logprobs=True,  # Return log probabilities
-        top_logprobs=5,  # Number of most likely tokens
-        reasoning_effort="medium"  # For o1 models: low, medium, high
+        seed=42
     )
     ```
 
-    **Structured Outputs:**
-    ```python Code
-    from pydantic import BaseModel
-    from crewai import LLM
-
-    class ResponseFormat(BaseModel):
-        name: str
-        age: int
-        summary: str
-
-    llm = LLM(
-        model="openai/gpt-4o",
-    )
-    ```
-
-    **Supported Environment Variables:**
-    - `OPENAI_API_KEY`: Your OpenAI API key (required)
-    - `OPENAI_BASE_URL`: Custom base URL for OpenAI API (optional)
-
-    **Features:**
-    - Native function calling support (except o1 models)
-    - Structured outputs with JSON schema
-    - Streaming support for real-time responses
-    - Token usage tracking
-    - Stop sequences support (except o1 models)
-    - Log probabilities for token-level insights
-    - Reasoning effort control for o1 models
-
-    **Supported Models:**
+    OpenAI is one of the leading providers of LLMs with a wide range of models and features.
 
     | Model               | Context Window   | Best For                                      |
     |---------------------|------------------|-----------------------------------------------|
-    | gpt-4.1             | 1M tokens        | Latest model with enhanced capabilities       |
-    | gpt-4.1-mini        | 1M tokens        | Efficient version with large context          |
-    | gpt-4.1-nano        | 1M tokens        | Ultra-efficient variant                       |
-    | gpt-4o              | 128,000 tokens   | Optimized for speed and intelligence          |
-    | gpt-4o-mini         | 200,000 tokens   | Cost-effective with large context             |
-    | gpt-4-turbo         | 128,000 tokens   | Long-form content, document analysis          |
-    | gpt-4               | 8,192 tokens     | High-accuracy tasks, complex reasoning        |
-    | o1                  | 200,000 tokens   | Advanced reasoning, complex problem-solving   |
-    | o1-preview          | 128,000 tokens   | Preview of reasoning capabilities             |
-    | o1-mini             | 128,000 tokens   | Efficient reasoning model                     |
-    | o3-mini             | 200,000 tokens   | Lightweight reasoning model                   |
-    | o4-mini             | 200,000 tokens   | Next-gen efficient reasoning                  |
-
-    **Note:** To use OpenAI, install the required dependencies:
-    ```bash
-    uv add "crewai[openai]"
-    ```
+    | GPT-4               | 8,192 tokens     | High-accuracy tasks, complex reasoning        |
+    | GPT-4 Turbo         | 128,000 tokens   | Long-form content, document analysis          |
+    | GPT-4o & GPT-4o-mini  | 128,000 tokens  | Cost-effective large context processing       |
+    | o3-mini             | 200,000 tokens   | Fast reasoning, complex reasoning             |
+    | o1-mini             | 128,000 tokens   | Fast reasoning, complex reasoning             |
+    | o1-preview          | 128,000 tokens   | Fast reasoning, complex reasoning             |
+    | o1                  | 200,000 tokens   | Fast reasoning, complex reasoning             |
   </Accordion>
 
   <Accordion title="Meta-Llama">
@@ -247,230 +187,69 @@ In this section, you'll find detailed examples that help you select, configure,
   </Accordion>
 
   <Accordion title="Anthropic">
-    CrewAI provides native integration with Anthropic through the Anthropic Python SDK.
-
     ```toml Code
     # Required
     ANTHROPIC_API_KEY=sk-ant-...
+
+    # Optional
+    ANTHROPIC_API_BASE=<custom-base-url>
     ```
 
-    **Basic Usage:**
+    Example usage in your CrewAI project:
     ```python Code
-    from crewai import LLM
-
     llm = LLM(
-        model="anthropic/claude-3-5-sonnet-20241022",
-        api_key="your-api-key",  # Or set ANTHROPIC_API_KEY
-        max_tokens=4096  # Required for Anthropic
+        model="anthropic/claude-3-sonnet-20240229-v1:0",
+        temperature=0.7
     )
     ```
-
-    **Advanced Configuration:**
-    ```python Code
-    from crewai import LLM
-
-    llm = LLM(
-        model="anthropic/claude-3-5-sonnet-20241022",
-        api_key="your-api-key",
-        base_url="https://api.anthropic.com",  # Optional custom endpoint
-        temperature=0.7,
-        max_tokens=4096,  # Required parameter
-        top_p=0.9,
-        stop_sequences=["END", "STOP"],  # Anthropic uses stop_sequences
-        stream=True,  # Enable streaming
-        timeout=60.0,  # Request timeout in seconds
-        max_retries=3  # Maximum retry attempts
-    )
-    ```
-
-    **Extended Thinking (Claude Sonnet 4 and Beyond):**
-
-    CrewAI supports Anthropic's Extended Thinking feature, which allows Claude to think through problems in a more human-like way before responding. This is particularly useful for complex reasoning, analysis, and problem-solving tasks.
-
-    ```python Code
-    from crewai import LLM
-
-    # Enable extended thinking with default settings
-    llm = LLM(
-        model="anthropic/claude-sonnet-4",
-        thinking={"type": "enabled"},
-        max_tokens=10000
-    )
-
-    # Configure thinking with budget control
-    llm = LLM(
-        model="anthropic/claude-sonnet-4",
-        thinking={
-            "type": "enabled",
-            "budget_tokens": 5000  # Limit thinking tokens
-        },
-        max_tokens=10000
-    )
-    ```
-
-    **Thinking Configuration Options:**
-    - `type`: Set to `"enabled"` to activate extended thinking mode
-    - `budget_tokens` (optional): Maximum tokens to use for thinking (helps control costs)
-
-    **Models Supporting Extended Thinking:**
-    - `claude-sonnet-4` and newer models
-    - `claude-3-7-sonnet` (with extended thinking capabilities)
-
-    **When to Use Extended Thinking:**
-    - Complex reasoning and multi-step problem solving
-    - Mathematical calculations and proofs
-    - Code analysis and debugging
-    - Strategic planning and decision making
-    - Research and analytical tasks
-
-    **Note:** Extended thinking consumes additional tokens but can significantly improve response quality for complex tasks.
-
-    **Supported Environment Variables:**
-    - `ANTHROPIC_API_KEY`: Your Anthropic API key (required)
-
-    **Features:**
-    - Native tool use support for Claude 3+ models
-    - Extended Thinking support for Claude Sonnet 4+
-    - Streaming support for real-time responses
-    - Automatic system message handling
-    - Stop sequences for controlled output
-    - Token usage tracking
-    - Multi-turn tool use conversations
-
-    **Important Notes:**
-    - `max_tokens` is a **required** parameter for all Anthropic models
-    - Claude uses `stop_sequences` instead of `stop`
-    - System messages are handled separately from conversation messages
-    - First message must be from the user (automatically handled)
-    - Messages must alternate between user and assistant
-
-    **Supported Models:**
-
-    | Model                        | Context Window | Best For                                      |
-    |------------------------------|----------------|-----------------------------------------------|
-    | claude-sonnet-4              | 200,000 tokens | Latest with extended thinking capabilities    |
-    | claude-3-7-sonnet            | 200,000 tokens | Advanced reasoning and agentic tasks          |
-    | claude-3-5-sonnet-20241022   | 200,000 tokens | Latest Sonnet with best performance           |
-    | claude-3-5-haiku             | 200,000 tokens | Fast, compact model for quick responses       |
-    | claude-3-opus                | 200,000 tokens | Most capable for complex tasks                |
-    | claude-3-sonnet              | 200,000 tokens | Balanced intelligence and speed               |
-    | claude-3-haiku               | 200,000 tokens | Fastest for simple tasks                      |
-    | claude-2.1                   | 200,000 tokens | Extended context, reduced hallucinations      |
-    | claude-2                     | 100,000 tokens | Versatile model for various tasks             |
-    | claude-instant               | 100,000 tokens | Fast, cost-effective for everyday tasks       |
-
-    **Note:** To use Anthropic, install the required dependencies:
-    ```bash
-    uv add "crewai[anthropic]"
-    ```
   </Accordion>
 
   <Accordion title="Google (Gemini API)">
-    CrewAI provides native integration with Google Gemini through the Google Gen AI Python SDK.
-
-    Set your API key in your `.env` file. If you need a key, check [AI Studio](https://aistudio.google.com/apikey).
+    Set your API key in your `.env` file. If you need a key, or need to find an
+    existing key, check [AI Studio](https://aistudio.google.com/apikey).
 
     ```toml .env
-    # Required (one of the following)
-    GOOGLE_API_KEY=<your-api-key>
+    # https://ai.google.dev/gemini-api/docs/api-key
     GEMINI_API_KEY=<your-api-key>
-
-    # Optional - for Vertex AI
-    GOOGLE_CLOUD_PROJECT=<your-project-id>
-    GOOGLE_CLOUD_LOCATION=<location>  # Defaults to us-central1
-    GOOGLE_GENAI_USE_VERTEXAI=true  # Set to use Vertex AI
     ```
 
-    **Basic Usage:**
+    Example usage in your CrewAI project:
     ```python Code
     from crewai import LLM
 
     llm = LLM(
         model="gemini/gemini-2.0-flash",
-        api_key="your-api-key",  # Or set GOOGLE_API_KEY/GEMINI_API_KEY
-        temperature=0.7
-    )
-    ```
-
-    **Advanced Configuration:**
-    ```python Code
-    from crewai import LLM
-
-    llm = LLM(
-        model="gemini/gemini-2.5-flash",
-        api_key="your-api-key",
         temperature=0.7,
-        top_p=0.9,
-        top_k=40,  # Top-k sampling parameter
-        max_output_tokens=8192,
-        stop_sequences=["END", "STOP"],
-        stream=True,  # Enable streaming
-        safety_settings={
-            "HARM_CATEGORY_HARASSMENT": "BLOCK_NONE",
-            "HARM_CATEGORY_HATE_SPEECH": "BLOCK_NONE"
-        }
     )
     ```
 
-    **Vertex AI Configuration:**
-    ```python Code
-    from crewai import LLM
-
-    llm = LLM(
-        model="gemini/gemini-1.5-pro",
-        project="your-gcp-project-id",
-        location="us-central1"  # GCP region
-    )
-    ```
-
-    **Supported Environment Variables:**
-    - `GOOGLE_API_KEY` or `GEMINI_API_KEY`: Your Google API key (required for Gemini API)
-    - `GOOGLE_CLOUD_PROJECT`: Google Cloud project ID (for Vertex AI)
-    - `GOOGLE_CLOUD_LOCATION`: GCP location (defaults to `us-central1`)
-    - `GOOGLE_GENAI_USE_VERTEXAI`: Set to `true` to use Vertex AI
-
-    **Features:**
-    - Native function calling support for Gemini 1.5+ and 2.x models
-    - Streaming support for real-time responses
-    - Multimodal capabilities (text, images, video)
-    - Safety settings configuration
-    - Support for both Gemini API and Vertex AI
-    - Automatic system instruction handling
-    - Token usage tracking
-
-    **Gemini Models:**
+    ### Gemini models
 
     Google offers a range of powerful models optimized for different use cases.
 
     | Model                          | Context Window | Best For                                                          |
     |--------------------------------|----------------|-------------------------------------------------------------------|
-    | gemini-2.5-flash               | 1M tokens      | Adaptive thinking, cost efficiency                                |
-    | gemini-2.5-pro                 | 1M tokens      | Enhanced thinking and reasoning, multimodal understanding         |
-    | gemini-2.0-flash               | 1M tokens      | Next generation features, speed, thinking                         |
-    | gemini-2.0-flash-thinking      | 32,768 tokens  | Advanced reasoning with thinking process                          |
+    | gemini-2.5-flash-preview-04-17 | 1M tokens      | Adaptive thinking, cost efficiency                                |
+    | gemini-2.5-pro-preview-05-06   | 1M tokens      | Enhanced thinking and reasoning, multimodal understanding, advanced coding, and more |
+    | gemini-2.0-flash               | 1M tokens      | Next generation features, speed, thinking, and realtime streaming |
     | gemini-2.0-flash-lite          | 1M tokens      | Cost efficiency and low latency                                   |
-    | gemini-1.5-pro                 | 2M tokens      | Best performing, logical reasoning, coding                        |
     | gemini-1.5-flash               | 1M tokens      | Balanced multimodal model, good for most tasks                    |
-    | gemini-1.5-flash-8b            | 1M tokens      | Fastest, most cost-efficient                                      |
-    | gemini-1.0-pro                 | 32,768 tokens  | Earlier generation model                                          |
-
-    **Gemma Models:**
-
-    The Gemini API also supports [Gemma models](https://ai.google.dev/gemma/docs) hosted on Google infrastructure.
-
-    | Model          | Context Window | Best For                           |
-    |----------------|----------------|------------------------------------|
-    | gemma-3-1b     | 32,000 tokens  | Ultra-lightweight tasks            |
-    | gemma-3-4b     | 128,000 tokens | Efficient general-purpose tasks    |
-    | gemma-3-12b    | 128,000 tokens | Balanced performance and efficiency|
-    | gemma-3-27b    | 128,000 tokens | High-performance tasks             |
-
-    **Note:** To use Google Gemini, install the required dependencies:
-    ```bash
-    uv add "crewai[google-genai]"
-    ```
+    | gemini-1.5-flash-8B            | 1M tokens      | Fastest, most cost-efficient, good for high-frequency tasks       |
+    | gemini-1.5-pro                 | 2M tokens      | Best performing, wide variety of reasoning tasks including logical reasoning, coding, and creative collaboration |
 
     The full list of models is available in the [Gemini model docs](https://ai.google.dev/gemini-api/docs/models).
+
+    ### Gemma
+
+    The Gemini API also allows you to use your API key to access [Gemma models](https://ai.google.dev/gemma/docs) hosted on Google infrastructure.
+
+    | Model          | Context Window |
+    |----------------|----------------|
+    | gemma-3-1b-it  | 32k tokens     |
+    | gemma-3-4b-it  | 32k tokens     |
+    | gemma-3-12b-it | 32k tokens     |
+    | gemma-3-27b-it | 128k tokens    |
+
   </Accordion>
   <Accordion title="Google (Vertex AI)">
     Get credentials from your Google Cloud Console and save it to a JSON file, then load it with the following code:
@@ -512,146 +291,43 @@ In this section, you'll find detailed examples that help you select, configure,
   </Accordion>
 
   <Accordion title="Azure">
-    CrewAI provides native integration with Azure AI Inference and Azure OpenAI through the Azure AI Inference Python SDK.
-
     ```toml Code
     # Required
     AZURE_API_KEY=<your-api-key>
-    AZURE_ENDPOINT=<your-endpoint-url>
+    AZURE_API_BASE=<your-resource-url>
+    AZURE_API_VERSION=<api-version>
 
     # Optional
-    AZURE_API_VERSION=<api-version>  # Defaults to 2024-06-01
+    AZURE_AD_TOKEN=<your-azure-ad-token>
+    AZURE_API_TYPE=<your-azure-api-type>
     ```
 
-    **Endpoint URL Formats:**
-
-    For Azure OpenAI deployments:
-    ```
-    https://<resource-name>.openai.azure.com/openai/deployments/<deployment-name>
-    ```
-
-    For Azure AI Inference endpoints:
-    ```
-    https://<resource-name>.inference.azure.com
-    ```
-
-    **Basic Usage:**
+    Example usage in your CrewAI project:
     ```python Code
     llm = LLM(
         model="azure/gpt-4",
-        api_key="<your-api-key>",  # Or set AZURE_API_KEY
-        endpoint="<your-endpoint-url>",
-        api_version="2024-06-01"
+        api_version="2023-05-15"
     )
     ```
-
-    **Advanced Configuration:**
-    ```python Code
-    llm = LLM(
-        model="azure/gpt-4o",
-        temperature=0.7,
-        max_tokens=4000,
-        top_p=0.9,
-        frequency_penalty=0.0,
-        presence_penalty=0.0,
-        stop=["END"],
-        stream=True,
-        timeout=60.0,
-        max_retries=3
-    )
-    ```
-
-    **Supported Environment Variables:**
-    - `AZURE_API_KEY`: Your Azure API key (required)
-    - `AZURE_ENDPOINT`: Your Azure endpoint URL (required, also checks `AZURE_OPENAI_ENDPOINT` and `AZURE_API_BASE`)
-    - `AZURE_API_VERSION`: API version (optional, defaults to `2024-06-01`)
-
-    **Features:**
-    - Native function calling support for Azure OpenAI models (gpt-4, gpt-4o, gpt-3.5-turbo, etc.)
-    - Streaming support for real-time responses
-    - Automatic endpoint URL validation and correction
-    - Comprehensive error handling with retry logic
-    - Token usage tracking
-
-    **Note:** To use Azure AI Inference, install the required dependencies:
-    ```bash
-    uv add "crewai[azure-ai-inference]"
-    ```
   </Accordion>
 
   <Accordion title="AWS Bedrock">
-    CrewAI provides native integration with AWS Bedrock through the boto3 SDK using the Converse API.
-
     ```toml Code
-    # Required
     AWS_ACCESS_KEY_ID=<your-access-key>
     AWS_SECRET_ACCESS_KEY=<your-secret-key>
-
-    # Optional
-    AWS_SESSION_TOKEN=<your-session-token>  # For temporary credentials
-    AWS_DEFAULT_REGION=<your-region>  # Defaults to us-east-1
+    AWS_DEFAULT_REGION=<your-region>
     ```
 
-    **Basic Usage:**
+    Example usage in your CrewAI project:
     ```python Code
-    from crewai import LLM
-
     llm = LLM(
-        model="bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0",
-        region_name="us-east-1"
+        model="bedrock/anthropic.claude-3-sonnet-20240229-v1:0"
     )
     ```
 
-    **Advanced Configuration:**
-    ```python Code
-    from crewai import LLM
+    Before using Amazon Bedrock, make sure you have boto3 installed in your environment
 
-    llm = LLM(
-        model="bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0",
-        aws_access_key_id="your-access-key",  # Or set AWS_ACCESS_KEY_ID
-        aws_secret_access_key="your-secret-key",  # Or set AWS_SECRET_ACCESS_KEY
-        aws_session_token="your-session-token",  # For temporary credentials
-        region_name="us-east-1",
-        temperature=0.7,
-        max_tokens=4096,
-        top_p=0.9,
-        top_k=250,  # For Claude models
-        stop_sequences=["END", "STOP"],
-        stream=True,  # Enable streaming
-        guardrail_config={  # Optional content filtering
-            "guardrailIdentifier": "your-guardrail-id",
-            "guardrailVersion": "1"
-        },
-        additional_model_request_fields={  # Model-specific parameters
-            "top_k": 250
-        }
-    )
-    ```
-
-    **Supported Environment Variables:**
-    - `AWS_ACCESS_KEY_ID`: AWS access key (required)
-    - `AWS_SECRET_ACCESS_KEY`: AWS secret key (required)
-    - `AWS_SESSION_TOKEN`: AWS session token for temporary credentials (optional)
-    - `AWS_DEFAULT_REGION`: AWS region (defaults to `us-east-1`)
-
-    **Features:**
-    - Native tool calling support via Converse API
-    - Streaming and non-streaming responses
-    - Comprehensive error handling with retry logic
-    - Guardrail configuration for content filtering
-    - Model-specific parameters via `additional_model_request_fields`
-    - Token usage tracking and stop reason logging
-    - Support for all Bedrock foundation models
-    - Automatic conversation format handling
-
-    **Important Notes:**
-    - Uses the modern Converse API for unified model access
-    - Automatic handling of model-specific conversation requirements
-    - System messages are handled separately from conversation
-    - First message must be from user (automatically handled)
-    - Some models (like Cohere) require conversation to end with user message
-
-    [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) is a managed service that provides access to multiple foundation models from top AI companies through a unified API.
+    [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) is a managed service that provides access to multiple foundation models from top AI companies through a unified API, enabling secure and responsible AI application development.
 
     | Model                   | Context Window       | Best For                                                          |
     |-------------------------|----------------------|-------------------------------------------------------------------|
@@ -681,12 +357,7 @@ In this section, you'll find detailed examples that help you select, configure,
     | Jamba-Instruct          | Up to 256k tokens    | Model with extended context window optimized for cost-effective text generation, summarization, and Q&A. |
     | Mistral 7B Instruct     | Up to 32k tokens     | This LLM follows instructions, completes requests, and generates creative text. |
     | Mistral 8x7B Instruct   | Up to 32k tokens     | An MOE LLM that follows instructions, completes requests, and generates creative text. |
-    | DeepSeek R1             | 32,768 tokens        | Advanced reasoning model                                                       |
 
-    **Note:** To use AWS Bedrock, install the required dependencies:
-    ```bash
-    uv add "crewai[bedrock]"
-    ```
   </Accordion>
 
   <Accordion title="Amazon SageMaker">
@@ -1079,7 +750,7 @@ CrewAI supports streaming responses from LLMs, allowing your application to rece
     ```
 
     <Tip>
-      [Click here](/en/concepts/event-listener#event-listeners) for more details
+      [Click here](https://docs.crewai.com/concepts/event-listener#event-listeners) for more details
     </Tip>
   </Tab>
 
@@ -1133,50 +804,6 @@ CrewAI supports streaming responses from LLMs, allowing your application to rece
   </Tab>
 </Tabs>
 
-## Async LLM Calls
-
-CrewAI supports asynchronous LLM calls for improved performance and concurrency in your AI workflows. Async calls allow you to run multiple LLM requests concurrently without blocking, making them ideal for high-throughput applications and parallel agent operations.
-
-<Tabs>
-  <Tab title="Basic Usage">
-    Use the `acall` method for asynchronous LLM requests:
-
-    ```python
-    import asyncio
-    from crewai import LLM
-
-    async def main():
-        llm = LLM(model="openai/gpt-4o")
-
-        # Single async call
-        response = await llm.acall("What is the capital of France?")
-        print(response)
-
-    asyncio.run(main())
-    ```
-
-    The `acall` method supports all the same parameters as the synchronous `call` method, including messages, tools, and callbacks.
-  </Tab>
-
-  <Tab title="With Streaming">
-    Combine async calls with streaming for real-time concurrent responses:
-
-    ```python
-    import asyncio
-    from crewai import LLM
-
-    async def stream_async():
-        llm = LLM(model="openai/gpt-4o", stream=True)
-
-        response = await llm.acall("Write a short story about AI")
-
-        print(response)
-
-    asyncio.run(stream_async())
-    ```
-  </Tab>
-</Tabs>
-
 ## Structured LLM Calls
 
 CrewAI supports structured responses from LLM calls by allowing you to define a `response_format` using a Pydantic model. This enables the framework to automatically parse and validate the output, making it easier to integrate the response into your application without manual post-processing.
@@ -1272,7 +899,7 @@ Learn how to get the most out of your LLM configuration:
   </Accordion>
 
   <Accordion title="Drop Additional Parameters">
-    CrewAI internally uses native sdks for LLM calls, which allows you to drop additional parameters that are not needed for your specific use case. This can help simplify your code and reduce the complexity of your LLM configuration.
+    CrewAI internally uses Litellm for LLM calls, which allows you to drop additional parameters that are not needed for your specific use case. This can help simplify your code and reduce the complexity of your LLM configuration.
     For example, if you don't need to send the <code>stop</code> parameter, you can simply omit it from your LLM call:
 
     ```python
@@ -1288,52 +915,6 @@ Learn how to get the most out of your LLM configuration:
     )
     ```
   </Accordion>
-
-  <Accordion title="Transport Interceptors">
-    CrewAI provides message interceptors for several providers, allowing you to hook into request/response cycles at the transport layer.
-
-    **Supported Providers:**
-    - ✅ OpenAI
-    - ✅ Anthropic
-
-    **Basic Usage:**
-    ```python
-import httpx
-from crewai import LLM
-from crewai.llms.hooks import BaseInterceptor
-
-class CustomInterceptor(BaseInterceptor[httpx.Request, httpx.Response]):
-    """Custom interceptor to modify requests and responses."""
-
-    def on_outbound(self, request: httpx.Request) -> httpx.Request:
-        """Print request before sending to the LLM provider."""
-        print(request)
-        return request
-
-    def on_inbound(self, response: httpx.Response) -> httpx.Response:
-        """Process response after receiving from the LLM provider."""
-        print(f"Status: {response.status_code}")
-        print(f"Response time: {response.elapsed}")
-        return response
-
-# Use the interceptor with an LLM
-llm = LLM(
-    model="openai/gpt-4o",
-    interceptor=CustomInterceptor()
-)
-    ```
-
-    **Important Notes:**
-    - Both methods must return the received object or type of object.
-    - Modifying received objects may result in unexpected behavior or application crashes.
-    - Not all providers support interceptors - check the supported providers list above
-
-    <Info>
-      Interceptors operate at the transport layer. This is particularly useful for:
-      - Message transformation and filtering
-      - Debugging API interactions
-    </Info>
-  </Accordion>
 </AccordionGroup>
 
 ## Common Issues and Solutions

docs/en/concepts/memory.mdx

@@ -341,7 +341,7 @@ crew = Crew(
     embedder={
         "provider": "openai",
         "config": {
-            "model_name": "text-embedding-3-small"  # or "text-embedding-3-large"
+            "model": "text-embedding-3-small"  # or "text-embedding-3-large"
         }
     }
 )
@@ -353,7 +353,7 @@ crew = Crew(
         "provider": "openai",
         "config": {
             "api_key": "your-openai-api-key",  # Optional: override env var
-            "model_name": "text-embedding-3-large",
+            "model": "text-embedding-3-large",
             "dimensions": 1536,  # Optional: reduce dimensions for smaller storage
             "organization_id": "your-org-id"  # Optional: for organization accounts
         }
@@ -375,7 +375,7 @@ crew = Crew(
             "api_base": "https://your-resource.openai.azure.com/",
             "api_type": "azure",
             "api_version": "2023-05-15",
-            "model_name": "text-embedding-3-small",
+            "model": "text-embedding-3-small",
             "deployment_id": "your-deployment-name"  # Azure deployment name
         }
     }
@@ -390,10 +390,10 @@ Use Google's text embedding models for integration with Google Cloud services.
 crew = Crew(
     memory=True,
     embedder={
-        "provider": "google-generativeai",
+        "provider": "google",
         "config": {
             "api_key": "your-google-api-key",
-            "model_name": "gemini-embedding-001"  # or "text-embedding-005", "text-multilingual-embedding-002"
+            "model": "text-embedding-004"  # or "text-embedding-preview-0409"
         }
     }
 )
@@ -461,7 +461,7 @@ crew = Crew(
         "provider": "cohere",
         "config": {
             "api_key": "your-cohere-api-key",
-            "model_name": "embed-english-v3.0"  # or "embed-multilingual-v3.0"
+            "model": "embed-english-v3.0"  # or "embed-multilingual-v3.0"
         }
     }
 )
@@ -478,7 +478,7 @@ crew = Crew(
         "provider": "voyageai",
         "config": {
             "api_key": "your-voyage-api-key",
-            "model": "voyage-3",  # or "voyage-3-lite", "voyage-code-3"
+            "model": "voyage-large-2",  # or "voyage-code-2" for code
             "input_type": "document"  # or "query"
         }
     }
@@ -515,7 +515,8 @@ crew = Crew(
         "provider": "huggingface",
         "config": {
             "api_key": "your-hf-token",  # Optional for public models
-            "model": "sentence-transformers/all-MiniLM-L6-v2"
+            "model": "sentence-transformers/all-MiniLM-L6-v2",
+            "api_url": "https://api-inference.huggingface.co"  # or your custom endpoint
         }
     }
 )
@@ -911,10 +912,10 @@ crew = Crew(
 crew = Crew(
     memory=True,
     embedder={
-        "provider": "google-generativeai",
+        "provider": "google",
         "config": {
             "api_key": "your-api-key",
-            "model_name": "gemini-embedding-001"
+            "model": "text-embedding-004"
         }
     }
 )

docs/en/concepts/production-architecture.mdx

@@ -1,154 +0,0 @@
----
-title: Production Architecture
-description: Best practices for building production-ready AI applications with CrewAI
-icon: server
-mode: "wide"
----
-
-# The Flow-First Mindset
-
-When building production AI applications with CrewAI, **we recommend starting with a Flow**.
-
-While it's possible to run individual Crews or Agents, wrapping them in a Flow provides the necessary structure for a robust, scalable application.
-
-## Why Flows?
-
-1.  **State Management**: Flows provide a built-in way to manage state across different steps of your application. This is crucial for passing data between Crews, maintaining context, and handling user inputs.
-2.  **Control**: Flows allow you to define precise execution paths, including loops, conditionals, and branching logic. This is essential for handling edge cases and ensuring your application behaves predictably.
-3.  **Observability**: Flows provide a clear structure that makes it easier to trace execution, debug issues, and monitor performance. We recommend using [CrewAI Tracing](/en/observability/tracing) for detailed insights. Simply run `crewai login` to enable free observability features.
-
-## The Architecture
-
-A typical production CrewAI application looks like this:
-
-```mermaid
-graph TD
-    Start((Start)) --> Flow[Flow Orchestrator]
-    Flow --> State{State Management}
-    State --> Step1[Step 1: Data Gathering]
-    Step1 --> Crew1[Research Crew]
-    Crew1 --> State
-    State --> Step2{Condition Check}
-    Step2 -- "Valid" --> Step3[Step 3: Execution]
-    Step3 --> Crew2[Action Crew]
-    Step2 -- "Invalid" --> End((End))
-    Crew2 --> End
-```
-
-### 1. The Flow Class
-Your `Flow` class is the entry point. It defines the state schema and the methods that execute your logic.
-
-```python
-from crewai.flow.flow import Flow, listen, start
-from pydantic import BaseModel
-
-class AppState(BaseModel):
-    user_input: str = ""
-    research_results: str = ""
-    final_report: str = ""
-
-class ProductionFlow(Flow[AppState]):
-    @start()
-    def gather_input(self):
-        # ... logic to get input ...
-        pass
-
-    @listen(gather_input)
-    def run_research_crew(self):
-        # ... trigger a Crew ...
-        pass
-```
-
-### 2. State Management
-Use Pydantic models to define your state. This ensures type safety and makes it clear what data is available at each step.
-
-- **Keep it minimal**: Store only what you need to persist between steps.
-- **Use structured data**: Avoid unstructured dictionaries when possible.
-
-### 3. Crews as Units of Work
-Delegate complex tasks to Crews. A Crew should be focused on a specific goal (e.g., "Research a topic", "Write a blog post").
-
-- **Don't over-engineer Crews**: Keep them focused.
-- **Pass state explicitly**: Pass the necessary data from the Flow state to the Crew inputs.
-
-```python
-    @listen(gather_input)
-    def run_research_crew(self):
-        crew = ResearchCrew()
-        result = crew.kickoff(inputs={"topic": self.state.user_input})
-        self.state.research_results = result.raw
-```
-
-## Control Primitives
-
-Leverage CrewAI's control primitives to add robustness and control to your Crews.
-
-### 1. Task Guardrails
-Use [Task Guardrails](/en/concepts/tasks#task-guardrails) to validate task outputs before they are accepted. This ensures that your agents produce high-quality results.
-
-```python
-def validate_content(result: TaskOutput) -> Tuple[bool, Any]:
-    if len(result.raw) < 100:
-        return (False, "Content is too short. Please expand.")
-    return (True, result.raw)
-
-task = Task(
-    ...,
-    guardrail=validate_content
-)
-```
-
-### 2. Structured Outputs
-Always use structured outputs (`output_pydantic` or `output_json`) when passing data between tasks or to your application. This prevents parsing errors and ensures type safety.
-
-```python
-class ResearchResult(BaseModel):
-    summary: str
-    sources: List[str]
-
-task = Task(
-    ...,
-    output_pydantic=ResearchResult
-)
-```
-
-### 3. LLM Hooks
-Use [LLM Hooks](/en/learn/llm-hooks) to inspect or modify messages before they are sent to the LLM, or to sanitize responses.
-
-```python
-@before_llm_call
-def log_request(context):
-    print(f"Agent {context.agent.role} is calling the LLM...")
-```
-
-## Deployment Patterns
-
-When deploying your Flow, consider the following:
-
-### CrewAI Enterprise
-The easiest way to deploy your Flow is using CrewAI Enterprise. It handles the infrastructure, authentication, and monitoring for you.
-
-Check out the [Deployment Guide](/en/enterprise/guides/deploy-crew) to get started.
-
-```bash
-crewai deploy create
-```
-
-### Async Execution
-For long-running tasks, use `kickoff_async` to avoid blocking your API.
-
-### Persistence
-Use the `@persist` decorator to save the state of your Flow to a database. This allows you to resume execution if the process crashes or if you need to wait for human input.
-
-```python
-@persist
-class ProductionFlow(Flow[AppState]):
-    # ...
-```
-
-## Summary
-
-- **Start with a Flow.**
-- **Define a clear State.**
-- **Use Crews for complex tasks.**
-- **Deploy with an API and persistence.**

docs/en/concepts/tasks.mdx

@@ -19,7 +19,6 @@ CrewAI AMP includes a Visual Task Builder in Crew Studio that simplifies complex
 ![Task Builder Screenshot](/images/enterprise/crew-studio-interface.png)
 
 The Visual Task Builder enables:
-
 - Drag-and-drop task creation
 - Visual task dependencies and flow
 - Real-time testing and validation
@@ -29,12 +28,10 @@ The Visual Task Builder enables:
 ### Task Execution Flow
 
 Tasks can be executed in two ways:
-
 - **Sequential**: Tasks are executed in the order they are defined
 - **Hierarchical**: Tasks are assigned to agents based on their roles and expertise
 
 The execution flow is defined when creating the crew:
-
 ```python Code
 crew = Crew(
     agents=[agent1, agent2],
@@ -46,7 +43,7 @@ crew = Crew(
 ## Task Attributes
 
 | Attribute                        | Parameters        | Type                          | Description                                                                                                          |
-| :------------------------------------- | :---------------------- | :-------------------------- | :-------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- |
+| :------------------------------- | :---------------- | :---------------------------- | :------------------------------------------------------------------------------------------------------------------- |
 | **Description**                  | `description`     | `str`                         | A clear, concise statement of what the task entails.                                                                 |
 | **Expected Output**              | `expected_output` | `str`                         | A detailed description of what the task's completion looks like.                                                     |
 | **Name** _(optional)_            | `name`            | `Optional[str]`               | A name identifier for the task.                                                                                      |
@@ -63,13 +60,11 @@ crew = Crew(
 | **Output Pydantic** _(optional)_ | `output_pydantic` | `Optional[Type[BaseModel]]`   | A Pydantic model for task output.                                                                                    |
 | **Callback** _(optional)_        | `callback`        | `Optional[Any]`               | Function/object to be executed after task completion.                                                                |
 | **Guardrail** _(optional)_       | `guardrail`       | `Optional[Callable]`             | Function to validate task output before proceeding to next task.                                                  |
-| **Guardrails** _(optional)_            | `guardrails`            | `Optional[List[Callable]    | List[str]]`                                                                                                     | List of guardrails to validate task output before proceeding to next task. |
 | **Guardrail Max Retries** _(optional)_ | `guardrail_max_retries` | `Optional[int]`     | Maximum number of retries when guardrail validation fails. Defaults to 3.                                         |
 
 <Note type="warning" title="Deprecated: max_retries">
   The task attribute `max_retries` is deprecated and will be removed in v1.0.0.
-  Use `guardrail_max_retries` instead to control retry attempts when a guardrail
-  fails.
+  Use `guardrail_max_retries` instead to control retry attempts when a guardrail fails.
 </Note>
 
 ## Creating Tasks
@@ -91,7 +86,7 @@ crew.kickoff(inputs={'topic': 'AI Agents'})
 
 Here's an example of how to configure tasks using YAML:
 
-````yaml tasks.yaml
+```yaml tasks.yaml
 research_task:
   description: >
     Conduct a thorough research about {topic}
@@ -111,7 +106,7 @@ reporting_task:
   agent: reporting_analyst
   markdown: true
   output_file: report.md
-````
+```
 
 To use this YAML configuration in your code, create a crew class that inherits from `CrewBase`:
 
@@ -169,8 +164,7 @@ class LatestAiDevelopmentCrew():
 ```
 
 <Note>
-  The names you use in your YAML files (`agents.yaml` and `tasks.yaml`) should
-  match the method names in your Python code.
+The names you use in your YAML files (`agents.yaml` and `tasks.yaml`) should match the method names in your Python code.
 </Note>
 
 ### Direct Code Definition (Alternative)
@@ -207,8 +201,7 @@ reporting_task = Task(
 ```
 
 <Tip>
-  Directly specify an `agent` for assignment or let the `hierarchical` CrewAI's
-  process decide based on roles, availability, etc.
+  Directly specify an `agent` for assignment or let the `hierarchical` CrewAI's process decide based on roles, availability, etc.
 </Tip>
 
 ## Task Output
@@ -230,7 +223,6 @@ By default, the `TaskOutput` will only include the `raw` output. A `TaskOutput`
 | **JSON Dict**     | `json_dict`     | `Optional[Dict[str, Any]]` | A dictionary representing the JSON output of the task.                                             |
 | **Agent**         | `agent`         | `str`                      | The agent that executed the task.                                                                  |
 | **Output Format** | `output_format` | `OutputFormat`             | The format of the task output, with options including RAW, JSON, and Pydantic. The default is RAW. |
-| **Messages**      | `messages`      | `list[LLMMessage]`         | The messages from the last task execution.                                                         |
 
 ### Task Methods and Properties
 
@@ -293,13 +285,12 @@ formatted_task = Task(
 ```
 
 When `markdown=True`, the agent will receive additional instructions to format the output using:
-
 - `#` for headers
 - `**text**` for bold text
 - `*text*` for italic text
 - `-` or `*` for bullet points
 - `` `code` `` for inline code
-- ` `language ``` for code blocks
+- ``` ```language ``` for code blocks
 
 ### YAML Configuration with Markdown
 
@@ -322,9 +313,7 @@ analysis_task:
 - **Cross-Platform Compatibility**: Markdown is universally supported
 
 <Note>
-  The markdown formatting instructions are automatically added to the task
-  prompt when `markdown=True`, so you don't need to specify formatting
-  requirements in your task description.
+The markdown formatting instructions are automatically added to the task prompt when `markdown=True`, so you don't need to specify formatting requirements in your task description.
 </Note>
 
 ## Task Dependencies and Context
@@ -352,11 +341,7 @@ Task guardrails provide a way to validate and transform task outputs before they
 are passed to the next task. This feature helps ensure data quality and provides
 feedback to agents when their output doesn't meet specific criteria.
 
-CrewAI supports two types of guardrails:
-
-1. **Function-based guardrails**: Python functions with custom validation logic, giving you complete control over the validation process and ensuring reliable, deterministic results.
-
-2. **LLM-based guardrails**: String descriptions that use the agent's LLM to validate outputs based on natural language criteria. These are ideal for complex or subjective validation requirements.
+Guardrails are implemented as Python functions that contain custom validation logic, giving you complete control over the validation process and ensuring reliable, deterministic results.
 
 ### Function-Based Guardrails
 
@@ -370,12 +355,12 @@ def validate_blog_content(result: TaskOutput) -> Tuple[bool, Any]:
     """Validate blog content meets requirements."""
     try:
         # Check word count
-        word_count = len(result.raw.split())
+        word_count = len(result.split())
         if word_count > 200:
             return (False, "Blog content exceeds 200 words")
 
         # Additional validation logic here
-        return (True, result.raw.strip())
+        return (True, result.strip())
     except Exception as e:
         return (False, "Unexpected error during validation")
 
@@ -387,156 +372,9 @@ blog_task = Task(
 )
 ```
 
-### LLM-Based Guardrails (String Descriptions)
-
-Instead of writing custom validation functions, you can use string descriptions that leverage LLM-based validation. When you provide a string to the `guardrail` or `guardrails` parameter, CrewAI automatically creates an `LLMGuardrail` that uses the agent's LLM to validate the output based on your description.
-
-**Requirements**:
-
-- The task must have an `agent` assigned (the guardrail uses the agent's LLM)
-- Provide a clear, descriptive string explaining the validation criteria
-
-```python Code
-from crewai import Task
-
-# Single LLM-based guardrail
-blog_task = Task(
-    description="Write a blog post about AI",
-    expected_output="A blog post under 200 words",
-    agent=blog_agent,
-    guardrail="The blog post must be under 200 words and contain no technical jargon"
-)
-```
-
-LLM-based guardrails are particularly useful for:
-
-- **Complex validation logic** that's difficult to express programmatically
-- **Subjective criteria** like tone, style, or quality assessments
-- **Natural language requirements** that are easier to describe than code
-
-The LLM guardrail will:
-
-1. Analyze the task output against your description
-2. Return `(True, output)` if the output complies with the criteria
-3. Return `(False, feedback)` with specific feedback if validation fails
-
-**Example with detailed validation criteria**:
-
-```python Code
-research_task = Task(
-    description="Research the latest developments in quantum computing",
-    expected_output="A comprehensive research report",
-    agent=researcher_agent,
-    guardrail="""
-    The research report must:
-    - Be at least 1000 words long
-    - Include at least 5 credible sources
-    - Cover both technical and practical applications
-    - Be written in a professional, academic tone
-    - Avoid speculation or unverified claims
-    """
-)
-```
-
-### Multiple Guardrails
-
-You can apply multiple guardrails to a task using the `guardrails` parameter. Multiple guardrails are executed sequentially, with each guardrail receiving the output from the previous one. This allows you to chain validation and transformation steps.
-
-The `guardrails` parameter accepts:
-
-- A list of guardrail functions or string descriptions
-- A single guardrail function or string (same as `guardrail`)
-
-**Note**: If `guardrails` is provided, it takes precedence over `guardrail`. The `guardrail` parameter will be ignored when `guardrails` is set.
-
-```python Code
-from typing import Tuple, Any
-from crewai import TaskOutput, Task
-
-def validate_word_count(result: TaskOutput) -> Tuple[bool, Any]:
-    """Validate word count is within limits."""
-    word_count = len(result.raw.split())
-    if word_count < 100:
-        return (False, f"Content too short: {word_count} words. Need at least 100 words.")
-    if word_count > 500:
-        return (False, f"Content too long: {word_count} words. Maximum is 500 words.")
-    return (True, result.raw)
-
-def validate_no_profanity(result: TaskOutput) -> Tuple[bool, Any]:
-    """Check for inappropriate language."""
-    profanity_words = ["badword1", "badword2"]  # Example list
-    content_lower = result.raw.lower()
-    for word in profanity_words:
-        if word in content_lower:
-            return (False, f"Inappropriate language detected: {word}")
-    return (True, result.raw)
-
-def format_output(result: TaskOutput) -> Tuple[bool, Any]:
-    """Format and clean the output."""
-    formatted = result.raw.strip()
-    # Capitalize first letter
-    formatted = formatted[0].upper() + formatted[1:] if formatted else formatted
-    return (True, formatted)
-
-# Apply multiple guardrails sequentially
-blog_task = Task(
-    description="Write a blog post about AI",
-    expected_output="A well-formatted blog post between 100-500 words",
-    agent=blog_agent,
-    guardrails=[
-        validate_word_count,      # First: validate length
-        validate_no_profanity,    # Second: check content
-        format_output             # Third: format the result
-    ],
-    guardrail_max_retries=3
-)
-```
-
-In this example, the guardrails execute in order:
-
-1. `validate_word_count` checks the word count
-2. `validate_no_profanity` checks for inappropriate language (using the output from step 1)
-3. `format_output` formats the final result (using the output from step 2)
-
-If any guardrail fails, the error is sent back to the agent, and the task is retried up to `guardrail_max_retries` times.
-
-**Mixing function-based and LLM-based guardrails**:
-
-You can combine both function-based and string-based guardrails in the same list:
-
-```python Code
-from typing import Tuple, Any
-from crewai import TaskOutput, Task
-
-def validate_word_count(result: TaskOutput) -> Tuple[bool, Any]:
-    """Validate word count is within limits."""
-    word_count = len(result.raw.split())
-    if word_count < 100:
-        return (False, f"Content too short: {word_count} words. Need at least 100 words.")
-    if word_count > 500:
-        return (False, f"Content too long: {word_count} words. Maximum is 500 words.")
-    return (True, result.raw)
-
-# Mix function-based and LLM-based guardrails
-blog_task = Task(
-    description="Write a blog post about AI",
-    expected_output="A well-formatted blog post between 100-500 words",
-    agent=blog_agent,
-    guardrails=[
-        validate_word_count,  # Function-based: precise word count check
-        "The content must be engaging and suitable for a general audience",  # LLM-based: subjective quality check
-        "The writing style should be clear, concise, and free of technical jargon"  # LLM-based: style validation
-    ],
-    guardrail_max_retries=3
-)
-```
-
-This approach combines the precision of programmatic validation with the flexibility of LLM-based assessment for subjective criteria.
-
 ### Guardrail Function Requirements
 
 1. **Function Signature**:
-
    - Must accept exactly one parameter (the task output)
    - Should return a tuple of `(bool, Any)`
    - Type hints are recommended but optional
@@ -545,10 +383,11 @@ This approach combines the precision of programmatic validation with the flexibi
    - On success: it returns a tuple of `(bool, Any)`. For example: `(True, validated_result)`
    - On Failure: it returns a tuple of `(bool, str)`. For example: `(False, "Error message explain the failure")`
 
+
+
 ### Error Handling Best Practices
 
 1. **Structured Error Responses**:
-
 ```python Code
 from crewai import TaskOutput, LLMGuardrail
 
@@ -564,13 +403,11 @@ def validate_with_context(result: TaskOutput) -> Tuple[bool, Any]:
 ```
 
 2. **Error Categories**:
-
    - Use specific error codes
    - Include relevant context
    - Provide actionable feedback
 
 3. **Validation Chain**:
-
 ```python Code
 from typing import Any, Dict, List, Tuple, Union
 from crewai import TaskOutput
@@ -597,7 +434,6 @@ def complex_validation(result: TaskOutput) -> Tuple[bool, Any]:
 ### Handling Guardrail Results
 
 When a guardrail returns `(False, error)`:
-
 1. The error is sent back to the agent
 2. The agent attempts to fix the issue
 3. The process repeats until:
@@ -605,7 +441,6 @@ When a guardrail returns `(False, error)`:
    - Maximum retries are reached (`guardrail_max_retries`)
 
 Example with retry handling:
-
 ```python Code
 from typing import Optional, Tuple, Union
 from crewai import TaskOutput, Task
@@ -631,12 +466,10 @@ task = Task(
 ## Getting Structured Consistent Outputs from Tasks
 
 <Note>
-  It's also important to note that the output of the final task of a crew
-  becomes the final output of the actual crew itself.
+It's also important to note that the output of the final task of a crew becomes the final output of the actual crew itself.
 </Note>
 
 ### Using `output_pydantic`
-
 The `output_pydantic` property allows you to define a Pydantic model that the task output should conform to. This ensures that the output is not only structured but also validated according to the Pydantic model.
 
 Here's an example demonstrating how to use output_pydantic:
@@ -706,22 +539,18 @@ print("Accessing Properties - Option 5")
 print("Blog:", result)
 
 ```
-
 In this example:
-
-- A Pydantic model Blog is defined with title and content fields.
-- The task task1 uses the output_pydantic property to specify that its output should conform to the Blog model.
-- After executing the crew, you can access the structured output in multiple ways as shown.
+* A Pydantic model Blog is defined with title and content fields.
+* The task task1 uses the output_pydantic property to specify that its output should conform to the Blog model.
+* After executing the crew, you can access the structured output in multiple ways as shown.
 
 #### Explanation of Accessing the Output
-
-1. Dictionary-Style Indexing: You can directly access the fields using result["field_name"]. This works because the CrewOutput class implements the **getitem** method.
+1. Dictionary-Style Indexing: You can directly access the fields using result["field_name"]. This works because the CrewOutput class implements the __getitem__ method.
 2. Directly from Pydantic Model: Access the attributes directly from the result.pydantic object.
 3. Using to_dict() Method: Convert the output to a dictionary and access the fields.
 4. Printing the Entire Object: Simply print the result object to see the structured output.
 
 ### Using `output_json`
-
 The `output_json` property allows you to define the expected output in JSON format. This ensures that the task's output is a valid JSON structure that can be easily parsed and used in your application.
 
 Here's an example demonstrating how to use `output_json`:
@@ -781,15 +610,14 @@ print("Blog:", result)
 ```
 
 In this example:
-
-- A Pydantic model Blog is defined with title and content fields, which is used to specify the structure of the JSON output.
-- The task task1 uses the output_json property to indicate that it expects a JSON output conforming to the Blog model.
-- After executing the crew, you can access the structured JSON output in two ways as shown.
+* A Pydantic model Blog is defined with title and content fields, which is used to specify the structure of the JSON output.
+* The task task1 uses the output_json property to indicate that it expects a JSON output conforming to the Blog model.
+* After executing the crew, you can access the structured JSON output in two ways as shown.
 
 #### Explanation of Accessing the Output
 
-1. Accessing Properties Using Dictionary-Style Indexing: You can access the fields directly using result["field_name"]. This is possible because the CrewOutput class implements the **getitem** method, allowing you to treat the output like a dictionary. In this option, we're retrieving the title and content from the result.
-2. Printing the Entire Blog Object: By printing result, you get the string representation of the CrewOutput object. Since the **str** method is implemented to return the JSON output, this will display the entire output as a formatted string representing the Blog object.
+1. Accessing Properties Using Dictionary-Style Indexing: You can access the fields directly using result["field_name"]. This is possible because the CrewOutput class implements the __getitem__ method, allowing you to treat the output like a dictionary. In this option, we're retrieving the title and content from the result.
+2. Printing the Entire Blog Object: By printing result, you get the string representation of the CrewOutput object. Since the __str__ method is implemented to return the JSON output, this will display the entire output as a formatted string representing the Blog object.
 
 ---
 
@@ -979,6 +807,8 @@ While creating and executing tasks, certain validation mechanisms are in place t
 
 These validations help in maintaining the consistency and reliability of task executions within the crewAI framework.
 
+
+
 ## Creating Directories when Saving Files
 
 The `create_directory` parameter controls whether CrewAI should automatically create directories when saving task outputs to files. This feature is particularly useful for organizing outputs and ensuring that file paths are correctly structured, especially when working with complex project hierarchies.
@@ -1040,14 +870,12 @@ audit_task:
 ### Use Cases
 
 **Automatic Directory Creation (`create_directory=True`):**
-
 - Development and prototyping environments
 - Dynamic report generation with date-based folders
 - Automated workflows where directory structure may vary
 - Multi-tenant applications with user-specific folders
 
 **Manual Directory Management (`create_directory=False`):**
-
 - Production environments with strict file system controls
 - Security-sensitive applications where directories must be pre-configured
 - Systems with specific permission requirements

docs/en/concepts/tools.mdx

@@ -20,7 +20,6 @@ enabling everything from simple searches to complex interactions and effective t
 CrewAI AMP provides a comprehensive Tools Repository with pre-built integrations for common business systems and APIs. Deploy agents with enterprise tools in minutes instead of days.
 
 The Enterprise Tools Repository includes:
-
 - Pre-built connectors for popular enterprise systems
 - Custom tool creation interface
 - Version control and sharing capabilities

docs/en/enterprise/features/marketplace.mdx

@@ -37,7 +37,7 @@ you can use them locally or refine them to your needs.
   <Card title="Tools & Integrations" href="/en/enterprise/features/tools-and-integrations" icon="wrench">
     Connect external apps and manage internal tools your agents can use.
   </Card>
-  <Card title="Tool Repository" href="/en/enterprise/guides/tool-repository#tool-repository" icon="toolbox">
+  <Card title="Tool Repository" href="/en/enterprise/features/tool-repository" icon="toolbox">
     Publish and install tools to enhance your crews' capabilities.
   </Card>
   <Card title="Agents Repository" href="/en/enterprise/features/agent-repositories" icon="people-group">

docs/en/enterprise/features/rbac.mdx

@@ -31,8 +31,7 @@ You can configure users and roles in Settings → Roles.
     Go to <b>Settings → Roles</b> in CrewAI AMP.
   </Step>
   <Step title="Choose a role type">
-    Use a predefined role (<b>Owner</b>, <b>Member</b>) or click{" "}
-    <b>Create role</b> to define a custom one.
+    Use a predefined role (<b>Owner</b>, <b>Member</b>) or click <b>Create role</b> to define a custom one.
   </Step>
   <Step title="Assign to members">
     Select users and assign the role. You can change this anytime.
@@ -42,7 +41,7 @@ You can configure users and roles in Settings → Roles.
 ### Configuration summary
 
 | Area | Where to configure | Options |
-| :-------------------- | :--------------------------------- | :-------------------------------------- |
+|:---|:---|:---|
 | Users & Roles | Settings → Roles | Predefined: Owner, Member; Custom roles |
 | Automation visibility | Automation → Settings → Visibility | Private; Whitelist users/roles |
 
@@ -71,30 +70,26 @@ You can configure automation‑level access control in Automation → Settings
     Navigate to <b>Automation → Settings → Visibility</b>.
   </Step>
   <Step title="Set visibility">
-    Choose <b>Private</b> to restrict access. The organization owner always
-    retains access.
+    Choose <b>Private</b> to restrict access. The organization owner always retains access.
   </Step>
   <Step title="Whitelist access">
-    Add specific users and roles allowed to view, run, and access
-    logs/metrics/settings.
+    Add specific users and roles allowed to view, run, and access logs/metrics/settings.
   </Step>
   <Step title="Save and verify">
-    Save changes, then confirm that non‑whitelisted users cannot view or run the
-    automation.
+    Save changes, then confirm that non‑whitelisted users cannot view or run the automation.
   </Step>
 </Steps>
 
 ### Private visibility: access outcomes
 
 | Action | Owner | Whitelisted user/role | Not whitelisted |
-| :--------------------------- | :---- | :-------------------- | :-------------- |
+|:---|:---|:---|:---|
 | View automation | ✓ | ✓ | ✗ |
 | Run automation/API | ✓ | ✓ | ✗ |
 | Access logs/metrics/settings | ✓ | ✓ | ✗ |
 
 <Tip>
-  The organization owner always has access. In private mode, only whitelisted
-  users and roles can view, run, and access logs/metrics/settings.
+The organization owner always has access. In private mode, only whitelisted users and roles can view, run, and access logs/metrics/settings.
 </Tip>
 
 <Frame>

docs/en/enterprise/features/tools-and-integrations.mdx

@@ -18,12 +18,11 @@ Tools & Integrations is the central hub for connecting third‑party apps and ma
 <Tabs>
   <Tab title="Integrations" icon="plug">
 
-## Agent Apps (Integrations)
+  ## Agent Apps (Integrations)
 
-Connect enterprise‑grade applications (e.g., Gmail, Google Drive, HubSpot, Slack) via OAuth to enable agent actions.
+  Connect enterprise‑grade applications (e.g., Gmail, Google Drive, HubSpot, Slack) via OAuth to enable agent actions.
 
-{" "}
-<Steps>
+  <Steps>
     <Step title="Connect">
       Click <b>Connect</b> on an app and complete OAuth.
     </Step>
@@ -33,211 +32,207 @@ Connect enterprise‑grade applications (e.g., Gmail, Google Drive, HubSpot, Sla
     <Step title="Use in Agents">
       Connected services become available as tools for your agents.
     </Step>
-</Steps>
+  </Steps>
 
-{" "}
-<Frame>![Integrations Grid](/images/enterprise/agent-apps.png)</Frame>
+  <Frame>
+    ![Integrations Grid](/images/enterprise/agent-apps.png)
+  </Frame>
 
-### Connect your Account
+  ### Connect your Account
 
-1. Go to <Link href="https://app.crewai.com/crewai_plus/connectors">Integrations</Link>
-2. Click <b>Connect</b> on the desired service
-3. Complete the OAuth flow and grant scopes
-4. Copy your Enterprise Token from <Link href="https://app.crewai.com/crewai_plus/settings/integrations">Integration Settings</Link>
+  1. Go to <Link href="https://app.crewai.com/crewai_plus/connectors">Integrations</Link>
+  2. Click <b>Connect</b> on the desired service
+  3. Complete the OAuth flow and grant scopes
+  4. Copy your Enterprise Token from the <b>Integration</b> tab
 
-{" "}
-<Frame>
+  <Frame>
     ![Enterprise Token](/images/enterprise/enterprise_action_auth_token.png)
-</Frame>
+  </Frame>
 
-### Install Integration Tools
+  ### Install Integration Tools
 
-To use the integrations locally, you need to install the latest `crewai-tools` package.
+  To use the integrations locally, you need to install the latest `crewai-tools` package.
 
-```bash
-uv add crewai-tools
-```
+  ```bash
+  uv add crewai-tools
+  ```
 
-### Environment Variable Setup
+  ### Usage Example
 
-{" "}
-<Note>
-  To use integrations with `Agent(apps=[])`, you must set the
-  `CREWAI_PLATFORM_INTEGRATION_TOKEN` environment variable with your Enterprise
-  Token.
-</Note>
+  <Tip>
+    All services you have authenticated will be available as tools. Add `CrewaiEnterpriseTools` to your agent and you’re set.
+  </Tip>
 
-```bash
-export CREWAI_PLATFORM_INTEGRATION_TOKEN="your_enterprise_token"
-```
+  ```python
+  from crewai import Agent, Task, Crew
+  from crewai_tools import CrewaiEnterpriseTools
 
-Or add it to your `.env` file:
+  # Get enterprise tools (Gmail tool will be included)
+  enterprise_tools = CrewaiEnterpriseTools(
+      enterprise_token="your_enterprise_token"
+  )
+  # print the tools
+  print(enterprise_tools)
 
-```
-CREWAI_PLATFORM_INTEGRATION_TOKEN=your_enterprise_token
-```
-
-### Usage Example
-
-{" "}
-<Tip>
-  Use the new streamlined approach to integrate enterprise apps. Simply specify
-  the app and its actions directly in the Agent configuration.
-</Tip>
-
-```python
-from crewai import Agent, Task, Crew
-
-# Create an agent with Gmail capabilities
-email_agent = Agent(
+  # Create an agent with Gmail capabilities
+  email_agent = Agent(
       role="Email Manager",
       goal="Manage and organize email communications",
       backstory="An AI assistant specialized in email management and communication.",
-    apps=['gmail', 'gmail/send_email']  # Using canonical name 'gmail'
-)
+      tools=enterprise_tools
+  )
 
-# Task to send an email
-email_task = Task(
+  # Task to send an email
+  email_task = Task(
       description="Draft and send a follow-up email to john@example.com about the project update",
       agent=email_agent,
       expected_output="Confirmation that email was sent successfully"
-)
+  )
 
-# Run the task
-crew = Crew(
+  # Run the task
+  crew = Crew(
       agents=[email_agent],
       tasks=[email_task]
-)
+  )
 
-# Run the crew
-crew.kickoff()
-```
+  # Run the crew
+  crew.kickoff()
+  ```
 
-### Filtering Tools
+  ### Filtering Tools
 
-```python
-from crewai import Agent, Task, Crew
+  ```python
+  from crewai_tools import CrewaiEnterpriseTools
 
-# Create agent with specific Gmail actions only
-gmail_agent = Agent(
+  enterprise_tools = CrewaiEnterpriseTools(
+      actions_list=["gmail_find_email"]  # only gmail_find_email tool will be available
+  )
+
+
+  gmail_tool = enterprise_tools["gmail_find_email"]
+
+
+  gmail_agent = Agent(
       role="Gmail Manager",
       goal="Manage gmail communications and notifications",
       backstory="An AI assistant that helps coordinate gmail communications.",
-    apps=['gmail/fetch_emails']  # Using canonical name with specific action
-)
+      tools=[gmail_tool]
+  )
 
-notification_task = Task(
+  notification_task = Task(
       description="Find the email from john@example.com",
       agent=gmail_agent,
       expected_output="Email found from john@example.com"
-)
+  )
 
-crew = Crew(
+  crew = Crew(
       agents=[gmail_agent],
       tasks=[notification_task]
-)
-```
+  )
+  ```
 
-On a deployed crew, you can specify which actions are available for each integration from the service settings page.
+  On a deployed crew, you can specify which actions are available for each integration from the service settings page.
 
-{" "}
-<Frame>
+  <Frame>
     ![Filter Actions](/images/enterprise/filtering_enterprise_action_tools.png)
-</Frame>
+  </Frame>
 
-### Scoped Deployments (multi‑user orgs)
+  ### Scoped Deployments (multi‑user orgs)
 
-You can scope each integration to a specific user. For example, a crew that connects to Google can use a specific user’s Gmail account.
+  You can scope each integration to a specific user. For example, a crew that connects to Google can use a specific user’s Gmail account.
 
-{" "}
-<Tip>Useful when different teams/users must keep data access separated.</Tip>
+  <Tip>
+    Useful when different teams/users must keep data access separated.
+  </Tip>
 
-Use the `user_bearer_token` to scope authentication to the requesting user. If the user isn’t logged in, the crew won’t use connected integrations. Otherwise it falls back to the default bearer token configured for the deployment.
+  Use the `user_bearer_token` to scope authentication to the requesting user. If the user isn’t logged in, the crew won’t use connected integrations. Otherwise it falls back to the default bearer token configured for the deployment.
 
-{" "}
-<Frame>![User Bearer Token](/images/enterprise/user_bearer_token.png)</Frame>
+  <Frame>
+    ![User Bearer Token](/images/enterprise/user_bearer_token.png)
+  </Frame>
 
-{" "}
-<div id="catalog"></div>
-### Catalog
+  <div id="catalog"></div>
+  ### Catalog
 
-#### Communication & Collaboration
+  #### Communication & Collaboration
+  - Gmail — Manage emails and drafts
+  - Slack — Workspace notifications and alerts
+  - Microsoft — Office 365 and Teams integration
 
-- Gmail — Manage emails and drafts
-- Slack — Workspace notifications and alerts
-- Microsoft — Office 365 and Teams integration
+  #### Project Management
+  - Jira — Issue tracking and project management
+  - ClickUp — Task and productivity management
+  - Asana — Team task and project coordination
+  - Notion — Page and database management
+  - Linear — Software project and bug tracking
+  - GitHub — Repository and issue management
 
-#### Project Management
+  #### Customer Relationship Management
+  - Salesforce — CRM account and opportunity management
+  - HubSpot — Sales pipeline and contact management
+  - Zendesk — Customer support ticket management
 
-- Jira — Issue tracking and project management
-- ClickUp — Task and productivity management
-- Asana — Team task and project coordination
-- Notion — Page and database management
-- Linear — Software project and bug tracking
-- GitHub — Repository and issue management
+  #### Business & Finance
+  - Stripe — Payment processing and customer management
+  - Shopify — E‑commerce store and product management
 
-#### Customer Relationship Management
+  #### Productivity & Storage
+  - Google Sheets — Spreadsheet data synchronization
+  - Google Calendar — Event and schedule management
+  - Box — File storage and document management
 
-- Salesforce — CRM account and opportunity management
-- HubSpot — Sales pipeline and contact management
-- Zendesk — Customer support ticket management
-
-#### Business & Finance
-
-- Stripe — Payment processing and customer management
-- Shopify — E‑commerce store and product management
-
-#### Productivity & Storage
-
-- Google Sheets — Spreadsheet data synchronization
-- Google Calendar — Event and schedule management
-- Box — File storage and document management
-
-…and more to come!
+  …and more to come!
 
   </Tab>
   <Tab title="Internal Tools" icon="toolbox">
 
-## Internal Tools
+  ## Internal Tools
 
-Create custom tools locally, publish them on CrewAI AMP Tool Repository and use them in your agents.
+  Create custom tools locally, publish them on CrewAI AMP Tool Repository and use them in your agents.
 
-{" "}
-<Tip>
-  Before running the commands below, make sure you log in to your CrewAI AMP
-  account by running this command: ```bash crewai login ```
-</Tip>
+  <Tip>
+  Before running the commands below, make sure you log in to your CrewAI AMP account by running this command:
+    ```bash
+    crewai login
+    ```
+  </Tip>
 
-{" "}
-<Frame>
+  <Frame>
     ![Internal Tool Detail](/images/enterprise/tools-integrations-internal.png)
-</Frame>
+  </Frame>
 
-{" "}
-<Steps>
+  <Steps>
     <Step title="Create">
-    Create a new tool locally. ```bash crewai tool create your-tool ```
+      Create a new tool locally.
+      ```bash
+      crewai tool create your-tool
+      ```
     </Step>
     <Step title="Publish">
-    Publish the tool to the CrewAI AMP Tool Repository. ```bash crewai tool
-    publish ```
+      Publish the tool to the CrewAI AMP Tool Repository.
+      ```bash
+      crewai tool publish
+      ```
     </Step>
     <Step title="Install">
-    Install the tool from the CrewAI AMP Tool Repository. ```bash crewai tool
-    install your-tool ```
+      Install the tool from the CrewAI AMP Tool Repository.
+      ```bash
+      crewai tool install your-tool
+      ```
     </Step>
-</Steps>
+  </Steps>
 
-Manage:
+  Manage:
 
-- Name and description
-- Visibility (Private / Public)
-- Required environment variables
-- Version history and downloads
-- Team and role access
+  - Name and description
+  - Visibility (Private / Public)
+  - Required environment variables
+  - Version history and downloads
+  - Team and role access
 
-{" "}
-<Frame>![Internal Tool Detail](/images/enterprise/tool-configs.png)</Frame>
+  <Frame>
+    ![Internal Tool Detail](/images/enterprise/tool-configs.png)
+  </Frame>
 
   </Tab>
 </Tabs>
@@ -245,18 +240,10 @@ Manage:
 ## Related
 
 <CardGroup cols={2}>
-  <Card
-    title="Tool Repository"
-    href="/en/enterprise/guides/tool-repository#tool-repository"
-    icon="toolbox"
-  >
+  <Card title="Tool Repository" href="/en/enterprise/features/tool-repository" icon="toolbox">
     Create, publish, and version custom tools for your organization.
   </Card>
-  <Card
-    title="Webhook Automation"
-    href="/en/enterprise/guides/webhook-automation"
-    icon="bolt"
-  >
+  <Card title="Webhook Automation" href="/en/enterprise/guides/webhook-automation" icon="bolt">
     Automate workflows and integrate with external platforms and services.
   </Card>
 </CardGroup>

docs/en/enterprise/features/traces.mdx

@@ -20,7 +20,9 @@ Traces in CrewAI AMP are detailed execution records that capture every aspect of
 - Execution times
 - Cost estimates
 
-<Frame>![Traces Overview](/images/enterprise/traces-overview.png)</Frame>
+<Frame>
+  ![Traces Overview](/images/enterprise/traces-overview.png)
+</Frame>
 
 ## Accessing Traces
 
@@ -49,7 +51,9 @@ The top section displays high-level metrics about the execution:
 - **Execution Time**: Total duration of the crew run
 - **Estimated Cost**: Approximate cost based on token usage
 
-<Frame>![Execution Summary](/images/enterprise/trace-summary.png)</Frame>
+<Frame>
+  ![Execution Summary](/images/enterprise/trace-summary.png)
+</Frame>
 
 ### 2. Tasks & Agents
 
@@ -60,25 +64,33 @@ This section shows all tasks and agents that were part of the crew execution:
 - Status (completed/failed)
 - Individual execution time of the task
 
-<Frame>![Task List](/images/enterprise/trace-tasks.png)</Frame>
+<Frame>
+  ![Task List](/images/enterprise/trace-tasks.png)
+</Frame>
 
 ### 3. Final Output
 
 Displays the final result produced by the crew after all tasks are completed.
 
-<Frame>![Final Output](/images/enterprise/final-output.png)</Frame>
+<Frame>
+  ![Final Output](/images/enterprise/final-output.png)
+</Frame>
 
 ### 4. Execution Timeline
 
 A visual representation of when each task started and ended, helping you identify bottlenecks or parallel execution patterns.
 
-<Frame>![Execution Timeline](/images/enterprise/trace-timeline.png)</Frame>
+<Frame>
+  ![Execution Timeline](/images/enterprise/trace-timeline.png)
+</Frame>
 
 ### 5. Detailed Task View
 
 When you click on a specific task in the timeline or task list, you'll see:
 
-<Frame>![Detailed Task View](/images/enterprise/trace-detailed-task.png)</Frame>
+<Frame>
+  ![Detailed Task View](/images/enterprise/trace-detailed-task.png)
+</Frame>
 
 - **Task Key**: Unique identifier for the task
 - **Task ID**: Technical identifier in the system
@@ -92,6 +104,7 @@ When you click on a specific task in the timeline or task list, you'll see:
 - **Input**: Any input provided to this task from previous tasks
 - **Output**: The actual result produced by the agent
 
+
 ## Using Traces for Debugging
 
 Traces are invaluable for troubleshooting issues with your crews:
@@ -108,7 +121,6 @@ Traces are invaluable for troubleshooting issues with your crews:
     <Frame>
       ![Failure Points](/images/enterprise/failure.png)
     </Frame>
-
   </Step>
 
   <Step title="Optimize Performance">
@@ -118,7 +130,6 @@ Traces are invaluable for troubleshooting issues with your crews:
     - Excessive token usage
     - Redundant tool operations
     - Unnecessary API calls
-
   </Step>
 
   <Step title="Improve Cost Efficiency">
@@ -128,7 +139,6 @@ Traces are invaluable for troubleshooting issues with your crews:
     - Refine prompts to be more concise
     - Cache frequently accessed information
     - Structure tasks to minimize redundant operations
-
   </Step>
 </Steps>
 
@@ -143,6 +153,5 @@ CrewAI batches trace uploads to reduce overhead on high-volume runs:
 This yields more stable tracing under load while preserving detailed task/agent telemetry.
 
 <Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
-  Contact our support team for assistance with trace analysis or any other
-  CrewAI AMP features.
+  Contact our support team for assistance with trace analysis or any other CrewAI AMP features.
 </Card>

docs/en/enterprise/features/webhook-streaming.mdx

@@ -16,7 +16,7 @@ When using the Kickoff API, include a `webhooks` object to your request, for exa
 
 ```json
 {
-  "inputs": { "foo": "bar" },
+  "inputs": {"foo": "bar"},
   "webhooks": {
     "events": ["crew_kickoff_started", "llm_call_started"],
     "url": "https://your.endpoint/webhook",
@@ -46,8 +46,8 @@ Each webhook sends a list of events:
       "data": {
         "model": "gpt-4",
         "messages": [
-          { "role": "system", "content": "You are an assistant." },
-          { "role": "user", "content": "Summarize this article." }
+          {"role": "system", "content": "You are an assistant."},
+          {"role": "user", "content": "Summarize this article."}
         ]
       }
     }
@@ -55,7 +55,7 @@ Each webhook sends a list of events:
 }
 ```
 
-The `data` object structure varies by event type. Refer to the [event list](https://github.com/crewAIInc/crewAI/tree/main/lib/crewai/src/crewai/events/types) on GitHub.
+The `data` object structure varies by event type. Refer to the [event list](https://github.com/crewAIInc/crewAI/tree/main/src/crewai/utilities/events) on GitHub.
 
 As requests are sent over HTTP, the order of events can't be guaranteed. If you need ordering, use the `timestamp` field.
 
@@ -65,109 +65,104 @@ CrewAI supports both system events and custom events in Enterprise Event Streami
 
 ### Flow Events:
 
-- `flow_created`
-- `flow_started`
-- `flow_finished`
-- `flow_plot`
-- `method_execution_started`
-- `method_execution_finished`
-- `method_execution_failed`
+  - `flow_created`
+  - `flow_started`
+  - `flow_finished`
+  - `flow_plot`
+  - `method_execution_started`
+  - `method_execution_finished`
+  - `method_execution_failed`
 
 ### Agent Events:
 
-- `agent_execution_started`
-- `agent_execution_completed`
-- `agent_execution_error`
-- `lite_agent_execution_started`
-- `lite_agent_execution_completed`
-- `lite_agent_execution_error`
-- `agent_logs_started`
-- `agent_logs_execution`
-- `agent_evaluation_started`
-- `agent_evaluation_completed`
-- `agent_evaluation_failed`
+  - `agent_execution_started`
+  - `agent_execution_completed`
+  - `agent_execution_error`
+  - `lite_agent_execution_started`
+  - `lite_agent_execution_completed`
+  - `lite_agent_execution_error`
+  - `agent_logs_started`
+  - `agent_logs_execution`
+  - `agent_evaluation_started`
+  - `agent_evaluation_completed`
+  - `agent_evaluation_failed`
 
 ### Crew Events:
 
-- `crew_kickoff_started`
-- `crew_kickoff_completed`
-- `crew_kickoff_failed`
-- `crew_train_started`
-- `crew_train_completed`
-- `crew_train_failed`
-- `crew_test_started`
-- `crew_test_completed`
-- `crew_test_failed`
-- `crew_test_result`
+  - `crew_kickoff_started`
+  - `crew_kickoff_completed`
+  - `crew_kickoff_failed`
+  - `crew_train_started`
+  - `crew_train_completed`
+  - `crew_train_failed`
+  - `crew_test_started`
+  - `crew_test_completed`
+  - `crew_test_failed`
+  - `crew_test_result`
 
 ### Task Events:
 
-- `task_started`
-- `task_completed`
-- `task_failed`
-- `task_evaluation`
+  - `task_started`
+  - `task_completed`
+  - `task_failed`
+  - `task_evaluation`
 
 ### Tool Usage Events:
 
-- `tool_usage_started`
-- `tool_usage_finished`
-- `tool_usage_error`
-- `tool_validate_input_error`
-- `tool_selection_error`
-- `tool_execution_error`
+  - `tool_usage_started`
+  - `tool_usage_finished`
+  - `tool_usage_error`
+  - `tool_validate_input_error`
+  - `tool_selection_error`
+  - `tool_execution_error`
 
 ### LLM Events:
 
-- `llm_call_started`
-- `llm_call_completed`
-- `llm_call_failed`
-- `llm_stream_chunk`
+  - `llm_call_started`
+  - `llm_call_completed`
+  - `llm_call_failed`
+  - `llm_stream_chunk`
 
 ### LLM Guardrail Events:
 
-- `llm_guardrail_started`
-- `llm_guardrail_completed`
+  - `llm_guardrail_started`
+  - `llm_guardrail_completed`
 
 ### Memory Events:
 
-- `memory_query_started`
-- `memory_query_completed`
-- `memory_query_failed`
-- `memory_save_started`
-- `memory_save_completed`
-- `memory_save_failed`
-- `memory_retrieval_started`
-- `memory_retrieval_completed`
+  - `memory_query_started`
+  - `memory_query_completed`
+  - `memory_query_failed`
+  - `memory_save_started`
+  - `memory_save_completed`
+  - `memory_save_failed`
+  - `memory_retrieval_started`
+  - `memory_retrieval_completed`
 
 ### Knowledge Events:
 
-- `knowledge_search_query_started`
-- `knowledge_search_query_completed`
-- `knowledge_search_query_failed`
-- `knowledge_query_started`
-- `knowledge_query_completed`
-- `knowledge_query_failed`
+  - `knowledge_search_query_started`
+  - `knowledge_search_query_completed`
+  - `knowledge_search_query_failed`
+  - `knowledge_query_started`
+  - `knowledge_query_completed`
+  - `knowledge_query_failed`
 
 ### Reasoning Events:
 
-- `agent_reasoning_started`
-- `agent_reasoning_completed`
-- `agent_reasoning_failed`
+  - `agent_reasoning_started`
+  - `agent_reasoning_completed`
+  - `agent_reasoning_failed`
 
 Event names match the internal event bus. See GitHub for the full list of events.
 
 You can emit your own custom events, and they will be delivered through the webhook stream alongside system events.
 
 <CardGroup>
-  <Card
-    title="GitHub"
-    icon="github"
-    href="https://github.com/crewAIInc/crewAI/tree/main/src/crewai/utilities/events"
-  >
+ <Card title="GitHub" icon="github" href="https://github.com/crewAIInc/crewAI/tree/main/src/crewai/utilities/events">
   Full list of events
  </Card>
-  <Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
-    Contact our support team for assistance with webhook integration or
-    troubleshooting.
-  </Card>
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with webhook integration or troubleshooting.
+</Card>
 </CardGroup>

docs/en/enterprise/guides/automation-triggers.mdx

@@ -20,61 +20,37 @@ Deep-dive guides walk through setup and sample workflows for each integration:
     <a href="/en/enterprise/guides/gmail-trigger">Enable crews when emails arrive or threads update.</a>
   </Card>
 
-{" "}
-<Card title="Google Calendar Trigger" icon="calendar-days">
-  <a href="/en/enterprise/guides/google-calendar-trigger">
-    React to calendar events as they are created, updated, or cancelled.
-  </a>
-</Card>
+  <Card title="Google Calendar Trigger" icon="calendar-days">
+    <a href="/en/enterprise/guides/google-calendar-trigger">React to calendar events as they are created, updated, or cancelled.</a>
+  </Card>
 
-{" "}
-<Card title="Google Drive Trigger" icon="folder-open">
-  <a href="/en/enterprise/guides/google-drive-trigger">
-    Handle Drive file uploads, edits, and deletions.
-  </a>
-</Card>
+  <Card title="Google Drive Trigger" icon="folder-open">
+    <a href="/en/enterprise/guides/google-drive-trigger">Handle Drive file uploads, edits, and deletions.</a>
+  </Card>
 
-{" "}
-<Card title="Outlook Trigger" icon="envelope-open">
-  <a href="/en/enterprise/guides/outlook-trigger">
-    Automate responses to new Outlook messages and calendar updates.
-  </a>
-</Card>
+  <Card title="Outlook Trigger" icon="envelope-open">
+    <a href="/en/enterprise/guides/outlook-trigger">Automate responses to new Outlook messages and calendar updates.</a>
+  </Card>
 
-{" "}
-<Card title="OneDrive Trigger" icon="cloud">
-  <a href="/en/enterprise/guides/onedrive-trigger">
-    Audit file activity and sharing changes in OneDrive.
-  </a>
-</Card>
+  <Card title="OneDrive Trigger" icon="cloud">
+    <a href="/en/enterprise/guides/onedrive-trigger">Audit file activity and sharing changes in OneDrive.</a>
+  </Card>
 
-{" "}
-<Card title="Microsoft Teams Trigger" icon="comments">
-  <a href="/en/enterprise/guides/microsoft-teams-trigger">
-    Kick off workflows when new Teams chats start.
-  </a>
-</Card>
+  <Card title="Microsoft Teams Trigger" icon="comments">
+    <a href="/en/enterprise/guides/microsoft-teams-trigger">Kick off workflows when new Teams chats start.</a>
+  </Card>
 
-{" "}
-<Card title="HubSpot Trigger" icon="hubspot">
-  <a href="/en/enterprise/guides/hubspot-trigger">
-    Launch automations from HubSpot workflows and lifecycle events.
-  </a>
-</Card>
+  <Card title="HubSpot Trigger" icon="hubspot">
+    <a href="/en/enterprise/guides/hubspot-trigger">Launch automations from HubSpot workflows and lifecycle events.</a>
+  </Card>
 
-{" "}
-<Card title="Salesforce Trigger" icon="salesforce">
-  <a href="/en/enterprise/guides/salesforce-trigger">
-    Connect Salesforce processes to CrewAI for CRM automation.
-  </a>
-</Card>
+  <Card title="Salesforce Trigger" icon="salesforce">
+    <a href="/en/enterprise/guides/salesforce-trigger">Connect Salesforce processes to CrewAI for CRM automation.</a>
+  </Card>
 
-{" "}
-<Card title="Slack Trigger" icon="slack">
-  <a href="/en/enterprise/guides/slack-trigger">
-    Start crews directly from Slack slash commands.
-  </a>
-</Card>
+  <Card title="Slack Trigger" icon="slack">
+    <a href="/en/enterprise/guides/slack-trigger">Start crews directly from Slack slash commands.</a>
+  </Card>
 
   <Card title="Zapier Trigger" icon="bolt">
     <a href="/en/enterprise/guides/zapier-trigger">Bridge CrewAI with thousands of Zapier-supported apps.</a>
@@ -100,10 +76,7 @@ To access and manage your automation triggers:
 2. Click on the **Triggers** tab to view all available trigger integrations
 
 <Frame caption="Example of available automation triggers for a Gmail deployment">
-  <img
-    src="/images/enterprise/list-available-triggers.png"
-    alt="List of available automation triggers"
-  />
+  <img src="/images/enterprise/list-available-triggers.png" alt="List of available automation triggers" />
 </Frame>
 
 This view shows all the trigger integrations available for your deployment, along with their current connection status.
@@ -113,10 +86,7 @@ This view shows all the trigger integrations available for your deployment, alon
 Each trigger can be easily enabled or disabled using the toggle switch:
 
 <Frame caption="Enable or disable triggers with toggle">
-  <img
-    src="/images/enterprise/trigger-selected.png"
-    alt="Enable or disable triggers with toggle"
-  />
+  <img src="/images/enterprise/trigger-selected.png" alt="Enable or disable triggers with toggle" />
 </Frame>
 
 - **Enabled (blue toggle)**: The trigger is active and will automatically execute your deployment when the specified events occur
@@ -129,10 +99,7 @@ Simply click the toggle to change the trigger state. Changes take effect immedia
 Track the performance and history of your triggered executions:
 
 <Frame caption="List of executions triggered by automation">
-  <img
-    src="/images/enterprise/list-executions.png"
-    alt="List of executions triggered by automation"
-  />
+  <img src="/images/enterprise/list-executions.png" alt="List of executions triggered by automation" />
 </Frame>
 
 ## Building Trigger-Driven Automations
@@ -150,51 +117,27 @@ Before wiring a trigger into production, make sure you:
 - Decide whether to pass trigger context automatically using `allow_crewai_trigger_context`
 - Set up monitoring—webhook logs, CrewAI execution history, and optional external alerting
 
-### Testing Triggers Locally with CLI
+### Payload & Crew Examples Repository
 
-The CrewAI CLI provides powerful commands to help you develop and test trigger-driven automations without deploying to production.
+We maintain a comprehensive repository with end-to-end trigger examples to help you build and test your automations:
 
-#### List Available Triggers
+This repository contains:
 
-View all available triggers for your connected integrations:
+- **Realistic payload samples** for every supported trigger integration
+- **Ready-to-run crew implementations** that parse each payload and turn it into a business workflow
+- **Multiple scenarios per integration** (e.g., new events, updates, deletions) so you can match the shape of your data
 
-```bash
-crewai triggers list
-```
+| Integration | When it fires | Payload Samples | Crew Examples |
+| :-- | :-- | :-- | :-- |
+| Gmail | New messages, thread updates | [New alerts, thread updates](https://github.com/crewAIInc/crewai-enterprise-trigger-examples/tree/main/gmail) | [`new-email-crew.py`, `gmail-alert-crew.py`](https://github.com/crewAIInc/crewai-enterprise-trigger-examples/tree/main/gmail) |
+| Google Calendar | Event created / updated / started / ended / cancelled | [Event lifecycle payloads](https://github.com/crewAIInc/crewai-enterprise-trigger-examples/tree/main/google_calendar) | [`calendar-event-crew.py`, `calendar-meeting-crew.py`, `calendar-working-location-crew.py`](https://github.com/crewAIInc/crewai-enterprise-trigger-examples/tree/main/google_calendar) |
+| Google Drive | File created / updated / deleted | [File lifecycle payloads](https://github.com/crewAIInc/crewai-enterprise-trigger-examples/tree/main/google_drive) | [`drive-file-crew.py`, `drive-file-deletion-crew.py`](https://github.com/crewAIInc/crewai-enterprise-trigger-examples/tree/main/google_drive) |
+| Outlook | New email, calendar event removed | [Outlook payloads](https://github.com/crewAIInc/crewai-enterprise-trigger-examples/tree/main/outlook) | [`outlook-message-crew.py`, `outlook-event-removal-crew.py`](https://github.com/crewAIInc/crewai-enterprise-trigger-examples/tree/main/outlook) |
+| OneDrive | File operations (create, update, share, delete) | [OneDrive payloads](https://github.com/crewAIInc/crewai-enterprise-trigger-examples/tree/main/onedrive) | [`onedrive-file-crew.py`](https://github.com/crewAIInc/crewai-enterprise-trigger-examples/tree/main/onedrive) |
+| HubSpot | Record created / updated (contacts, companies, deals) | [HubSpot payloads](https://github.com/crewAIInc/crewai-enterprise-trigger-examples/tree/main/hubspot) | [`hubspot-company-crew.py`, `hubspot-contact-crew.py`, `hubspot-record-crew.py`](https://github.com/crewAIInc/crewai-enterprise-trigger-examples/tree/main/hubspot) |
+| Microsoft Teams | Chat thread created | [Teams chat payload](https://github.com/crewAIInc/crewai-enterprise-trigger-examples/tree/main/microsoft-teams) | [`teams-chat-created-crew.py`](https://github.com/crewAIInc/crewai-enterprise-trigger-examples/tree/main/microsoft-teams) |
 
-This command displays all triggers available based on your connected integrations, showing:
-
-- Integration name and connection status
-- Available trigger types
-- Trigger names and descriptions
-
-#### Simulate Trigger Execution
-
-Test your crew with realistic trigger payloads before deployment:
-
-```bash
-crewai triggers run <trigger_name>
-```
-
-For example:
-
-```bash
-crewai triggers run microsoft_onedrive/file_changed
-```
-
-This command:
-
-- Executes your crew locally
-- Passes a complete, realistic trigger payload
-- Simulates exactly how your crew will be called in production
-
-<Warning>
-  **Important Development Notes:**
-  - Use `crewai triggers run <trigger>` to simulate trigger execution during development
-  - Using `crewai run` will NOT simulate trigger calls and won't pass the trigger payload
-  - After deployment, your crew will be executed with the actual trigger payload
-  - If your crew expects parameters that aren't in the trigger payload, execution may fail
-</Warning>
+Use these samples to understand payload shape, copy the matching crew, and then replace the test payload with your live trigger data.
 
 ### Triggers with Crew
 
@@ -227,12 +170,10 @@ class MyAutomatedCrew:
 The crew will automatically receive and can access the trigger payload through the standard CrewAI context mechanisms.
 
 <Note>
-  Crew and Flow inputs can include `crewai_trigger_payload`. CrewAI
-  automatically injects this payload: - Tasks: appended to the first task's
-  description by default ("Trigger Payload: {crewai_trigger_payload}") - Control
-  via `allow_crewai_trigger_context`: set `True` to always inject, `False` to
-  never inject - Flows: any `@start()` method that accepts a
-  `crewai_trigger_payload` parameter will receive it
+  Crew and Flow inputs can include `crewai_trigger_payload`. CrewAI automatically injects this payload:
+  - Tasks: appended to the first task's description by default ("Trigger Payload: {crewai_trigger_payload}")
+  - Control via `allow_crewai_trigger_context`: set `True` to always inject, `False` to never inject
+  - Flows: any `@start()` method that accepts a `crewai_trigger_payload` parameter will receive it
 </Note>
 
 ### Integration with Flows
@@ -300,23 +241,15 @@ def delegate_to_crew(self, crewai_trigger_payload: dict = None):
 ## Troubleshooting
 
 **Trigger not firing:**
-
-- Verify the trigger is enabled in your deployment's Triggers tab
-- Check integration connection status under Tools & Integrations
-- Ensure all required environment variables are properly configured
+- Verify the trigger is enabled
+- Check integration connection status
 
 **Execution failures:**
-
 - Check the execution logs for error details
-- Use `crewai triggers run <trigger_name>` to test locally and see the exact payload structure
-- Verify your crew can handle the `crewai_trigger_payload` parameter
-- Ensure your crew doesn't expect parameters that aren't included in the trigger payload
-
-**Development issues:**
-
-- Always test with `crewai triggers run <trigger>` before deploying to see the complete payload
-- Remember that `crewai run` does NOT simulate trigger calls—use `crewai triggers run` instead
-- Use `crewai triggers list` to verify which triggers are available for your connected integrations
-- After deployment, your crew will receive the actual trigger payload, so test thoroughly locally first
+- If you are developing, make sure the inputs include the `crewai_trigger_payload` parameter with the correct payload
 
 Automation triggers transform your CrewAI deployments into responsive, event-driven systems that can seamlessly integrate with your existing business processes and tools.
+
+<Card title="CrewAI AMP Trigger Examples" href="https://github.com/crewAIInc/crewai-enterprise-trigger-examples" icon="github">
+    Check them out on GitHub!
+</Card>

docs/en/enterprise/guides/azure-openai-setup.mdx

@@ -37,7 +37,6 @@ This guide walks you through connecting Azure OpenAI with Crew Studio for seamle
             - Navigate to `Resource Management > Networking`.
             - Ensure that `Allow access from all networks` is enabled. If this setting is restricted, CrewAI may be blocked from accessing your Azure OpenAI endpoint.
     </Step>
-
 </Steps>
 
 ## Verification
@@ -47,7 +46,6 @@ You're all set! Crew Studio will now use your Azure OpenAI connection. Test the
 ## Troubleshooting
 
 If you encounter issues:
-
 - Verify the Target URI format matches the expected pattern
 - Check that the API key is correct and has proper permissions
 - Ensure network access is configured to allow CrewAI connections

docs/en/enterprise/guides/build-crew.mdx

@@ -22,27 +22,21 @@ mode: "wide"
 
 ### Installation and Setup
 
-<Card
-  title="Follow Standard Installation"
-  icon="wrench"
-  href="/en/installation"
->
-  Follow our standard installation guide to set up CrewAI CLI and create your
-  first project.
+<Card title="Follow Standard Installation" icon="wrench" href="/en/installation">
+  Follow our standard installation guide to set up CrewAI CLI and create your first project.
 </Card>
 
 ### Building Your Crew
 
 <Card title="Quickstart Tutorial" icon="rocket" href="/en/quickstart">
-  Follow our quickstart guide to create your first agent crew using YAML
-  configuration.
+  Follow our quickstart guide to create your first agent crew using YAML configuration.
 </Card>
 
 ## Support and Resources
 
 For Enterprise-specific support or questions, contact our dedicated support team at [support@crewai.com](mailto:support@crewai.com).
 
+
 <Card title="Schedule a Demo" icon="calendar" href="mailto:support@crewai.com">
-  Book time with our team to learn more about Enterprise features and how they
-  can benefit your organization.
+  Book time with our team to learn more about Enterprise features and how they can benefit your organization.
 </Card>