preapring to cut new version

* removed hyphen in co-workers

* Fix issue with AgentTool agent selection. The LLM included double quotes in the agent name which messed up the string comparison. Added additional types. Cleaned up error messaging.

* Remove duplicate import

* Improve explanation

* Revert poetry.lock changes

* Fix missing line in poetry.lock

---------

Co-authored-by: madmag77 <goncharov.artemv@gmail.com>

.github/workflows/tests.yml

@@ -19,7 +19,7 @@ jobs:
       - name: Setup Python
         uses: actions/setup-python@v4
         with:
-          python-version: "3.11"
+          python-version: "3.10"
 
       - name: Install Requirements
         run: |

README.md

@@ -70,6 +70,17 @@ os.environ["SERPER_API_KEY"] = "Your Key" # serper.dev API key
 # os.environ["OPENAI_MODEL_NAME"] ='openhermes'  # Adjust based on available model
 # os.environ["OPENAI_API_KEY"] ='sk-111111111111111111111111111111111111111111111111'
 
+# You can pass an optional llm attribute specifying what model you wanna use.
+# It can be a local model through Ollama / LM Studio or a remote
+# model like OpenAI, Mistral, Antrophic or others (https://docs.crewai.com/how-to/LLM-Connections/)
+#
+# import os
+# os.environ['OPENAI_MODEL_NAME'] = 'gpt-3.5-turbo'
+#
+# OR
+#
+# from langchain_openai import ChatOpenAI
+
 search_tool = SerperDevTool()
 
 # Define your agents with roles and goals
@@ -81,18 +92,9 @@ researcher = Agent(
   You have a knack for dissecting complex data and presenting actionable insights.""",
   verbose=True,
   allow_delegation=False,
-  tools=[search_tool]
   # You can pass an optional llm attribute specifying what model you wanna use.
-  # It can be a local model through Ollama / LM Studio or a remote
-  # model like OpenAI, Mistral, Antrophic or others (https://docs.crewai.com/how-to/LLM-Connections/)
-  #
-  # import os
-  # os.environ['OPENAI_MODEL_NAME'] = 'gpt-3.5-turbo'
-  #
-  # OR
-  #
-  # from langchain_openai import ChatOpenAI
-  # llm=ChatOpenAI(model_name="gpt-3.5", temperature=0.7)
+  # llm=ChatOpenAI(model_name="gpt-3.5", temperature=0.7),
+  tools=[search_tool]
 )
 writer = Agent(
   role='Tech Content Strategist',

docs/core-concepts/Agents.md

@@ -24,14 +24,16 @@ description: What are crewAI Agents and how to use them.
 | **LLM** *(optional)*       | Represents the language model that will run the agent. It dynamically fetches the model name from the `OPENAI_MODEL_NAME` environment variable, defaulting to "gpt-4" if not specified.                                                         |
 | **Tools** *(optional)*     | Set of capabilities or functions that the agent can use to perform tasks. Expected to be instances of custom classes compatible with the agent's execution environment. Tools are initialized with a default value of an empty list.             |
 | **Function Calling LLM** *(optional)* | Specifies the language model that will handle the tool calling for this agent, overriding the crew function calling LLM if passed. Default is `None`.                                                                                          |
-| **Max Iter** *(optional)*  | The maximum number of iterations the agent can perform before being forced to give its best answer. Default is `25`.                                                                                                                           |
-| **Max RPM** *(optional)*   | The maximum number of requests per minute the agent can perform to avoid rate limits. It's optional and can be left unspecified, with a default value of `None`.                                                                               |
-| **max_execution_time** *(optional)*   | Maximum execution time for an agent to execute a task It's optional and can be left unspecified, with a default value of `None`, menaning no max execution time                                                                     |
+| **Max Iter** *(optional)*  | `max_iter` is the maximum number of iterations the agent can perform before being forced to give its best answer. Default is `25`.                                                                                                                           |
+| **Max RPM** *(optional)*   | `max_rpm` is Tte maximum number of requests per minute the agent can perform to avoid rate limits. It's optional and can be left unspecified, with a default value of `None`.                                                                               |
+| **Max Execution Time** *(optional)*   | `max_execution_time` is the Maximum execution time for an agent to execute a task. It's optional and can be left unspecified, with a default value of `None`, meaning no max execution time.                                                                     |
 | **Verbose** *(optional)*   | Setting this to `True` configures the internal logger to provide detailed execution logs, aiding in debugging and monitoring. Default is `False`.                                                                                              |
 | **Allow Delegation** *(optional)* | Agents can delegate tasks or questions to one another, ensuring that each task is handled by the most suitable agent. Default is `True`.                                                                                                       |
 | **Step Callback** *(optional)* | A function that is called after each step of the agent. This can be used to log the agent's actions or to perform other operations. It will overwrite the crew `step_callback`.                                                               |
 | **Cache** *(optional)*     | Indicates if the agent should use a cache for tool usage. Default is `True`.                                                                                                                                                                  |
-
+| **System Template** *(optional)*     | Specifies the system format for the agent. Default is `None`.                                                                                                                                                                  |
+| **Prompt Template** *(optional)*     | Specifies the prompt format for the agent. Default is `None`.                                                                                                                                                                  |
+| **Response Template** *(optional)*     | Specifies the response format for the agent. Default is `None`.                                                                                                                                                                  |
 ## Creating an Agent
 
 !!! note "Agent Interaction"
@@ -56,12 +58,43 @@ agent = Agent(
   function_calling_llm=my_llm,  # Optional
   max_iter=15,  # Optional
   max_rpm=None, # Optional
+  max_execution_time=None, # Optional
   verbose=True,  # Optional
   allow_delegation=True,  # Optional
   step_callback=my_intermediate_step_callback,  # Optional
-  cache=True  # Optional
+  cache=True,  # Optional
+  system_template=my_system_template,  # Optional
+  prompt_template=my_prompt_template,  # Optional
+  response_template=my_response_template,  # Optional
+  config=my_config,  # Optional
+  crew=my_crew,  # Optional
+  tools_handler=my_tools_handler,  # Optional
+  cache_handler=my_cache_handler,  # Optional
+  callbacks=[callback1, callback2],  # Optional
+  agent_executor=my_agent_executor  # Optional
 )
 ```
 
+## Setting prompt templates
+
+Prompt templates are used to format the prompt for the agent. You can use to update the system, regular and response templates for the agent. Here's an example of how to set prompt templates:
+
+```python
+agent = Agent(
+        role="{topic} specialist",
+        goal="Figure {goal} out",
+        backstory="I am the master of {role}",
+        system_template="""<|start_header_id|>system<|end_header_id|>
+
+{{ .System }}<|eot_id|>""",
+        prompt_template="""<|start_header_id|>user<|end_header_id|>
+
+{{ .Prompt }}<|eot_id|>""",
+        response_template="""<|start_header_id|>assistant<|end_header_id|>
+
+{{ .Response }}<|eot_id|>""",
+    )
+```
+
 ## Conclusion
 Agents are the building blocks of the CrewAI framework. By understanding how to define and interact with agents, you can create sophisticated AI systems that leverage the power of collaborative intelligence.

docs/core-concepts/Collaboration.md

@@ -15,16 +15,19 @@ description: Exploring the dynamics of agent collaboration within the CrewAI fra
 The `Crew` class has been enriched with several attributes to support advanced functionalities:
 
 - **Language Model Management (`manager_llm`, `function_calling_llm`)**: Manages language models for executing tasks and tools, facilitating sophisticated agent-tool interactions. Note that while `manager_llm` is mandatory for hierarchical processes to ensure proper execution flow, `function_calling_llm` is optional, with a default value provided for streamlined tool interaction.
+- **Custom Manager Agent (`manager_agent`)**: Allows specifying a custom agent as the manager instead of using the default manager provided by CrewAI.
 - **Process Flow (`process`)**: Defines the execution logic (e.g., sequential, hierarchical) to streamline task distribution and execution.
 - **Verbose Logging (`verbose`)**: Offers detailed logging capabilities for monitoring and debugging purposes. It supports both integer and boolean types to indicate the verbosity level. For example, setting `verbose` to 1 might enable basic logging, whereas setting it to True enables more detailed logs.
 - **Rate Limiting (`max_rpm`)**: Ensures efficient utilization of resources by limiting requests per minute. Guidelines for setting `max_rpm` should consider the complexity of tasks and the expected load on resources.
-- **Internationalization Support (`language`, `language_file`)**: Facilitates operation in multiple languages, enhancing global usability. Supported languages and the process for utilizing the `language_file` attribute for customization should be clearly documented.
+- **Internationalization / Customization Support (`language`, `prompt_file`)**: Facilitates full customization of the inner prompts, enhancing global usability. Supported languages and the process for utilizing the `prompt_file` attribute for customization should be clearly documented. [Example of file](https://github.com/joaomdmoura/crewAI/blob/main/src/crewai/translations/en.json)
 - **Execution and Output Handling (`full_output`)**: Distinguishes between full and final outputs for nuanced control over task results. Examples showcasing the difference in outputs can aid in understanding the practical implications of this attribute.
 - **Callback and Telemetry (`step_callback`, `task_callback`)**: Integrates callbacks for step-wise and task-level execution monitoring, alongside telemetry for performance analytics. The purpose and usage of `task_callback` alongside `step_callback` for granular monitoring should be clearly explained.
 - **Crew Sharing (`share_crew`)**: Enables sharing of crew information with CrewAI for continuous improvement and training models. The privacy implications and benefits of this feature, including how it contributes to model improvement, should be outlined.
 - **Usage Metrics (`usage_metrics`)**: Stores all metrics for the language model (LLM) usage during all tasks' execution, providing insights into operational efficiency and areas for improvement. Detailed information on accessing and interpreting these metrics for performance analysis should be provided.
 - **Memory Usage (`memory`)**: Indicates whether the crew should use memory to store memories of its execution, enhancing task execution and agent learning.
 - **Embedder Configuration (`embedder`)**: Specifies the configuration for the embedder to be used by the crew for understanding and generating language. This attribute supports customization of the language model provider.
+- **Cache Management (`cache`)**: Determines whether the crew should use a cache to store the results of tool executions, optimizing performance.
+- **Output Logging (`output_log_file`)**: Specifies the file path for logging the output of the crew execution.
 
 ## Delegation: Dividing to Conquer
 Delegation enhances functionality by allowing agents to intelligently assign tasks or seek help, thereby amplifying the crew's overall capability.
@@ -36,4 +39,4 @@ Setting up a crew involves defining the roles and capabilities of each agent. Cr
 Consider a crew with a researcher agent tasked with data gathering and a writer agent responsible for compiling reports. The integration of advanced language model management and process flow attributes allows for more sophisticated interactions, such as the writer delegating complex research tasks to the researcher or querying specific information, thereby facilitating a seamless workflow.
 
 ## Conclusion
-The integration of advanced attributes and functionalities into the CrewAI framework significantly enriches the agent collaboration ecosystem. These enhancements not only simplify interactions but also offer unprecedented flexibility and control, paving the way for sophisticated AI-driven solutions capable of tackling complex tasks through intelligent collaboration and delegation.
+The integration of advanced attributes and functionalities into the CrewAI framework significantly enriches the agent collaboration ecosystem. These enhancements not only simplify interactions but also offer unprecedented flexibility and control, paving the way for sophisticated AI-driven solutions capable of tackling complex tasks through intelligent collaboration and delegation.

docs/core-concepts/Crews.md

@@ -22,13 +22,15 @@ A crew in crewAI represents a collaborative group of agents working together to
 | **Language File** *(optional)* | Path to the language file to be used for the crew.          |
 | **Memory** *(optional)*     | Utilized for storing execution memories (short-term, long-term, entity memory). |
 | **Cache** *(optional)*      | Specifies whether to use a cache for storing the results of tools' execution. |
-| **Embedder** *(optional)*   | Configuration for the embedder to be used by the crew. mostly used by memory for now       |
+| **Embedder** *(optional)*   | Configuration for the embedder to be used by the crew. Mostly used by memory for now.       |
 | **Full Output** *(optional)*| Whether the crew should return the full output with all tasks outputs or just the final output. |
 | **Step Callback** *(optional)* | A function that is called after each step of every agent. This can be used to log the agent's actions or to perform other operations; it won't override the agent-specific `step_callback`. |
 | **Task Callback** *(optional)* | A function that is called after the completion of each task. Useful for monitoring or additional operations post-task execution. |
 | **Share Crew** *(optional)* | Whether you want to share the complete crew information and execution with the crewAI team to make the library better, and allow us to train models. |
-| **Output Log File** *(optional)* | Whether you want to have a file with the complete crew output and execution. You can set it using True and it will default to the folder you are currently and it will be called logs.txt or passing a string with the full path and name of the file. |
-
+| **Output Log File** *(optional)* | Whether you want to have a file with the complete crew output and execution. You can set it using True and it will default to the folder you are currently in and it will be called logs.txt or passing a string with the full path and name of the file. |
+| **Manager Agent** *(optional)* | `manager` sets a ustom agent that will be used as a manager. |
+| **Manager Callbacks** *(optional)* | `manager_callbacks` takes a list of callback handlers to be executed by the manager agent when a hierarchical process is used. |
+| **Prompt File** *(optional)* | Path to the prompt JSON file to be used for the crew. |
 
 !!! note "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.
@@ -47,23 +49,34 @@ from langchain_community.tools import DuckDuckGoSearchRun
 researcher = Agent(
     role='Senior Research Analyst',
     goal='Discover innovative AI technologies',
+    backstory="""You're a senior research analyst at a large company.
+        You're responsible for analyzing data and providing insights
+        to the business.
+        You're currently working on a project to analyze the
+        trends and innovations in the space of artificial intelligence.""",
     tools=[DuckDuckGoSearchRun()]
 )
 
 writer = Agent(
     role='Content Writer',
     goal='Write engaging articles on AI discoveries',
+    backstory="""You're a senior writer at a large company.
+        You're responsible for creating content to the business.
+        You're currently working on a project to write about trends
+        and innovations in the space of AI for your next meeting.""",
     verbose=True
 )
 
 # Create tasks for the agents
 research_task = Task(
     description='Identify breakthrough AI technologies',
-    agent=researcher
+    agent=researcher,
+    expected_output='A bullet list summary of the top 5 most important AI news'
 )
 write_article_task = Task(
     description='Draft an article on the latest AI technologies',
-    agent=writer
+    agent=writer,
+    expected_output='3 paragraph blog post on the latest AI technologies'
 )
 
 # Assemble the crew with a sequential process
@@ -98,7 +111,7 @@ print(crew.usage_metrics)
 ## Crew Execution Process
 
 - **Sequential Process**: Tasks are executed one after another, allowing for a linear flow of work.
-- **Hierarchical Process**: A manager agent coordinates the crew, delegating tasks and validating outcomes before proceeding. **Note**: A `manager_llm` is required for this process and it's essential for validating the process flow.
+- **Hierarchical Process**: A manager agent coordinates the crew, delegating tasks and validating outcomes before proceeding. **Note**: A `manager_llm` or `manager_agent` is required for this process and it's essential for validating the process flow.
 
 ### Kicking Off a Crew
 
@@ -109,3 +122,34 @@ Once your crew is assembled, initiate the workflow with the `kickoff()` method.
 result = my_crew.kickoff()
 print(result)
 ```
+
+### Kicking 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: `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 for each agent individually.
+`kickoff_async()`: Initiates the workflow asynchronously.
+`kickoff_for_each_async()`: Executes tasks for each agent individually in an asynchronous manner.
+
+```python
+# Start the crew's task execution
+result = my_crew.kickoff()
+print(result)
+
+# Example of using kickoff_for_each
+results = my_crew.kickoff_for_each()
+for result in results:
+    print(result)
+
+# Example of using kickoff_async
+async_result = my_crew.kickoff_async()
+print(async_result)
+
+# Example of using kickoff_for_each_async
+async_results = my_crew.kickoff_for_each_async()
+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

docs/core-concepts/Memory.md

@@ -5,16 +5,16 @@ description: Leveraging memory systems in the crewAI framework to enhance agent
 
 ## Introduction to Memory Systems in crewAI
 !!! note "Enhancing Agent Intelligence"
-    The crewAI framework introduces a sophisticated memory system designed to significantly enhance the capabilities of AI agents. This system comprises short-term memory, long-term memory, entity memory, and newly identified contextual memory, each serving a unique purpose in aiding agents to remember, reason, and learn from past interactions.
+    The crewAI framework introduces a sophisticated memory system designed to significantly enhance the capabilities of AI agents. This system comprises short-term memory, long-term memory, entity memory, and contextual memory, each serving a unique purpose in aiding agents to remember, reason, and learn from past interactions.
 
 ## Memory System Components
 
 | Component            | Description                                                  |
 | :------------------- | :----------------------------------------------------------- |
-| **Short-Term Memory**| Temporarily stores recent interactions and outcomes, enabling agents to recall and utilize information relevant to their current context. |
-| **Long-Term Memory** | Preserves valuable insights and learnings from past executions, allowing agents to build and refine their knowledge over time. |
+| **Short-Term Memory**| Temporarily stores recent interactions and outcomes, enabling agents to recall and utilize information relevant to their current context during the current executions. |
+| **Long-Term Memory** | Preserves valuable insights and learnings from past executions, allowing agents to build and refine their knowledge over time. So Agents can remeber what they did right and wrong across multiple executions |
 | **Entity Memory**    | Captures and organizes information about entities (people, places, concepts) encountered during tasks, facilitating deeper understanding and relationship mapping. |
-| **Contextual Memory**| Maintains the context of interactions, aiding in the coherence and relevance of agent responses over a sequence of tasks or a conversation. |
+| **Contextual Memory**| Maintains the context of interactions by combining `ShortTermMemory`, `LongTermMemory`, and `EntityMemory`, aiding in the coherence and relevance of agent responses over a sequence of tasks or a conversation. |
 
 ## How Memory Systems Empower Agents
 
@@ -27,8 +27,7 @@ description: Leveraging memory systems in the crewAI framework to enhance agent
 ## Implementing Memory in Your Crew
 
 When configuring a crew, you can enable and customize each memory component to suit the crew's objectives and the nature of tasks it will perform.
-By default, the memory system is disabled, and you can ensure it is active by setting `memory=True` in the crew configuration.
-The memory will use OpenAI Embeddings by default, but you can change it by setting `embedder` to a different model.
+By default, the memory system is disabled, and you can ensure it is active by setting `memory=True` in the crew configuration. The memory will use OpenAI Embeddings by default, but you can change it by setting `embedder` to a different model.
 
 ### Example: Configuring Memory for a Crew
 

docs/core-concepts/Processes.md

@@ -10,14 +10,14 @@ description: Detailed guide on workflow management through processes in CrewAI,
 ## Process Implementations
 
 - **Sequential**: Executes tasks sequentially, ensuring tasks are completed in an orderly progression.
-- **Hierarchical**: Organizes tasks in a managerial hierarchy, where tasks are delegated and executed based on a structured chain of command. A manager language model (`manager_llm`) must be specified in the crew to enable the hierarchical process, facilitating the creation and management of tasks by the manager.
+- **Hierarchical**: Organizes tasks in a managerial hierarchy, where tasks are delegated and executed based on a structured chain of command. A manager language model (`manager_llm`) or a custom manager agent (`manager_agent`) must be specified in the crew to enable the hierarchical process, facilitating the creation and management of tasks by the manager.
 - **Consensual Process (Planned)**: Aiming for collaborative decision-making among agents on task execution, this process type introduces a democratic approach to task management within CrewAI. It is planned for future development and is not currently implemented in the codebase.
 
 ## The Role of Processes in Teamwork
 Processes enable individual agents to operate as a cohesive unit, streamlining their efforts to achieve common objectives with efficiency and coherence.
 
 ## Assigning Processes to a Crew
-To assign a process to a crew, specify the process type upon crew creation to set the execution strategy. For a hierarchical process, ensure to define `manager_llm` for the manager agent.
+To assign a process to a crew, specify the process type upon crew creation to set the execution strategy. For a hierarchical process, ensure to define `manager_llm` or `manager_agent` for the manager agent.
 
 ```python
 from crewai import Crew
@@ -32,15 +32,17 @@ crew = Crew(
 )
 
 # Example: Creating a crew with a hierarchical process
-# Ensure to provide a manager_llm
+# Ensure to provide a manager_llm or manager_agent
 crew = Crew(
     agents=my_agents,
     tasks=my_tasks,
     process=Process.hierarchical,
     manager_llm=ChatOpenAI(model="gpt-4")
+    # or
+    # manager_agent=my_manager_agent
 )
 ```
-**Note:** Ensure `my_agents` and `my_tasks` are defined prior to creating a `Crew` object, and for the hierarchical process, `manager_llm` is also required.
+**Note:** Ensure `my_agents` and `my_tasks` are defined prior to creating a `Crew` object, and for the hierarchical process, either `manager_llm` or `manager_agent` is also required.
 
 ## Sequential Process
 This method mirrors dynamic team workflows, progressing through tasks in a thoughtful and systematic manner. Task execution follows the predefined order in the task list, with the output of one task serving as context for the next.
@@ -48,7 +50,7 @@ This method mirrors dynamic team workflows, progressing through tasks in a thoug
 To customize task context, utilize the `context` parameter in the `Task` class to specify outputs that should be used as context for subsequent tasks.
 
 ## Hierarchical Process
-Emulates a corporate hierarchy, CrewAI automatically creates a manager for you, requiring the specification of a manager language model (`manager_llm`) for the manager agent. This agent oversees task execution, including planning, delegation, and validation. Tasks are not pre-assigned; the manager allocates tasks to agents based on their capabilities, reviews outputs, and assesses task completion.
+Emulates a corporate hierarchy, CrewAI allows specifying a custom manager agent or automatically creates one, requiring the specification of a manager language model (`manager_llm`). This agent oversees task execution, including planning, delegation, and validation. Tasks are not pre-assigned; the manager allocates tasks to agents based on their capabilities, reviews outputs, and assesses task completion.
 
 ## Process Class: Detailed Overview
 The `Process` class is implemented as an enumeration (`Enum`), ensuring type safety and restricting process values to the defined types (`sequential`, `hierarchical`). The consensual process is planned for future inclusion, emphasizing our commitment to continuous development and innovation.

docs/core-concepts/Tasks.md

@@ -88,7 +88,7 @@ This demonstrates how tasks with specific tools can override an agent's default
 
 ## Referring to Other Tasks
 
-In crewAI, the output of one task is automatically relayed into the next one, but you can specifically define what tasks' output, including multiple should be used as context for another task.
+In crewAI, the output of one task is automatically relayed into the next one, but you can specifically define what tasks' output, including multiple, should be used as context for another task.
 
 This is useful when you have a task that depends on the output of another task that is not performed immediately after it. This is done through the `context` attribute of the task:
 
@@ -225,6 +225,25 @@ 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
+
+You can now specify if a task should create directories when saving its output to a file. This is particularly useful for organizing outputs and ensuring that file paths are correctly structured.
+
+```python
+# ...
+
+save_output_task = Task(
+    description='Save the summarized AI news to a file',
+    expected_output='File saved successfully',
+    agent=research_agent,
+    tools=[file_save_tool],
+    output_file='outputs/ai_news_summary.txt',
+    create_directory=True
+)
+
+#...
+```
+
 ## Conclusion
 
-Tasks are the driving force behind the actions of agents in crewAI. By properly defining tasks and their outcomes, you set the stage for your AI agents to work effectively, either independently or as a collaborative unit. Equipping tasks with appropriate tools, understanding the execution process, and following robust validation practices are crucial for maximizing CrewAI's potential, ensuring agents are effectively prepared for their assignments and that tasks are executed as intended.
+Tasks are the driving force behind the actions of agents in crewAI. By properly defining tasks and their outcomes, you set the stage for your AI agents to work effectively, either independently or as a collaborative unit. Equipping tasks with appropriate tools, understanding the execution process, and following robust validation practices are crucial for maximizing CrewAI's potential, ensuring agents are effectively prepared for their assignments and that tasks are executed as intended.

docs/core-concepts/Tools.md

@@ -94,7 +94,7 @@ crew.kickoff()
 ## Available crewAI Tools
 
 - **Error Handling**: All tools are built with error handling capabilities, allowing agents to gracefully manage exceptions and continue their tasks.
-- **Caching Mechanism**: All tools support caching, enabling agents to efficiently reuse previously obtained results, reducing the load on external resources and speeding up the execution time, you can also define finner control over the caching mechanism, using `cache_function` attribute on the tool.
+- **Caching Mechanism**: All tools support caching, enabling agents to efficiently reuse previously obtained results, reducing the load on external resources and speeding up the execution time. You can also define finer control over the caching mechanism using the `cache_function` attribute on the tool.
 
 Here is a list of the available tools and their descriptions:
 
@@ -107,7 +107,7 @@ Here is a list of the available tools and their descriptions:
 | **DirectoryReadTool**       | Facilitates reading and processing of directory structures and their contents.                |
 | **FileReadTool**            | Enables reading and extracting data from files, supporting various file formats.              |
 | **GithubSearchTool**        | A RAG tool for searching within GitHub repositories, useful for code and documentation search.|
-| **SerperDevTool**            | A specialized tool for development purposes, with specific functionalities under development. |
+| **SerperDevTool**           | A specialized tool for development purposes, with specific functionalities under development. |
 | **TXTSearchTool**           | A RAG tool focused on searching within text (.txt) files, suitable for unstructured data.     |
 | **JSONSearchTool**          | A RAG tool designed for searching within JSON files, catering to structured data handling.     |
 | **MDXSearchTool**           | A RAG tool tailored for searching within Markdown (MDX) files, useful for documentation.      |
@@ -120,13 +120,14 @@ Here is a list of the available tools and their descriptions:
 | **XMLSearchTool**           | A RAG tool designed for searching within XML files, suitable for structured data formats.      |
 | **YoutubeChannelSearchTool**| A RAG tool for searching within YouTube channels, useful for video content analysis.           |
 | **YoutubeVideoSearchTool**  | A RAG tool aimed at searching within YouTube videos, ideal for video data extraction.          |
+| **BrowserbaseTool**         | A tool for interacting with and extracting data from web browsers.                            |
+| **ExaSearchTool**           | A tool designed for performing exhaustive searches across various data sources.               |
 
 ## Creating your own Tools
 
 !!! example "Custom Tool Creation"
     Developers can craft custom tools tailored for their agent’s needs or utilize pre-built options:
 
-
 To create your own crewAI tools you will need to install our extra tools package:
 
 ```bash
@@ -141,7 +142,7 @@ from crewai_tools import BaseTool
 
 class MyCustomTool(BaseTool):
     name: str = "Name of my tool"
-    description: str = "Clear description for what this tool is useful for, you agent will need this information to use it."
+    description: str = "Clear description for what this tool is useful for, your agent will need this information to use it."
 
     def _run(self, argument: str) -> str:
         # Implementation goes here
@@ -154,7 +155,7 @@ class MyCustomTool(BaseTool):
 from crewai_tools import tool
 @tool("Name of my tool")
 def my_tool(question: str) -> str:
-    """Clear description for what this tool is useful for, you agent will need this information to use it."""
+    """Clear description for what this tool is useful for, your agent will need this information to use it."""
     # Function logic here
     return "Result from your custom tool"
 ```
@@ -180,45 +181,14 @@ multiplication_tool.cache_function = cache_func
 
 writer1 = Agent(
         role="Writer",
-        goal="You write lesssons of math for kids.",
-        backstory="You're an expert in writting and you love to teach kids but you know nothing of math.",
-        tools=[multiplcation_tool],
+        goal="You write lessons of math for kids.",
+        backstory="You're an expert in writing and you love to teach kids but you know nothing of math.",
+        tools=[multiplication_tool],
         allow_delegation=False,
     )
     #...
 ```
 
-## Using LangChain Tools
-!!! info "LangChain Integration"
-    CrewAI seamlessly integrates with LangChain’s comprehensive toolkit for search-based queries and more, here are the available built-in tools that are offered by Langchain [LangChain Toolkit](https://python.langchain.com/docs/integrations/tools/)
- :
-
-```python
-from crewai import Agent
-from langchain.agents import Tool
-from langchain.utilities import GoogleSerperAPIWrapper
-
-# Setup API keys
-os.environ["SERPER_API_KEY"] = "Your Key"
-
-search = GoogleSerperAPIWrapper()
-
-# Create and assign the search tool to an agent
-serper_tool = Tool(
-  name="Intermediate Answer",
-  func=search.run,
-  description="Useful for search-based queries",
-)
-
-agent = Agent(
-  role='Research Analyst',
-  goal='Provide up-to-date market analysis',
-  backstory='An expert analyst with a keen eye for market trends.',
-  tools=[serper_tool]
-)
-
-# rest of the code ...
-```
 
 ## Conclusion
-Tools are pivotal in extending the capabilities of CrewAI agents, enabling them to undertake a broad spectrum of tasks and collaborate effectively. When building solutions with CrewAI, leverage both custom and existing tools to empower your agents and enhance the AI ecosystem. Consider utilizing error handling, caching mechanisms, and the flexibility of tool arguments to optimize your agents' performance and capabilities.
+Tools are pivotal in extending the capabilities of CrewAI agents, enabling them to undertake a broad spectrum of tasks and collaborate effectively. When building solutions with CrewAI, leverage both custom and existing tools to empower your agents and enhance the AI ecosystem. Consider utilizing error handling, caching mechanisms, and the flexibility of tool arguments to optimize your agents' performance and capabilities.

docs/core-concepts/Using-LangChain-Tools.md

@@ -0,0 +1,38 @@
+---
+title: Using LangChain Tools
+description: Learn how to integrate LangChain tools with CrewAI agents to enhance search-based queries and more.
+---
+
+## Using LangChain Tools
+!!! info "LangChain Integration"
+    CrewAI seamlessly integrates with LangChain’s comprehensive toolkit for search-based queries and more, here are the available built-in tools that are offered by Langchain [LangChain Toolkit](https://python.langchain.com/docs/integrations/tools/)
+
+```python
+from crewai import Agent
+from langchain.agents import Tool
+from langchain.utilities import GoogleSerperAPIWrapper
+
+# Setup API keys
+os.environ["SERPER_API_KEY"] = "Your Key"
+
+search = GoogleSerperAPIWrapper()
+
+# Create and assign the search tool to an agent
+serper_tool = Tool(
+  name="Intermediate Answer",
+  func=search.run,
+  description="Useful for search-based queries",
+)
+
+agent = Agent(
+  role='Research Analyst',
+  goal='Provide up-to-date market analysis',
+  backstory='An expert analyst with a keen eye for market trends.',
+  tools=[serper_tool]
+)
+
+# rest of the code ...
+```
+
+## Conclusion
+Tools are pivotal in extending the capabilities of CrewAI agents, enabling them to undertake a broad spectrum of tasks and collaborate effectively. When building solutions with CrewAI, leverage both custom and existing tools to empower your agents and enhance the AI ecosystem. Consider utilizing error handling, caching mechanisms, and the flexibility of tool arguments to optimize your agents' performance and capabilities.

docs/core-concepts/Using-LlamaIndex-Tools.md

@@ -0,0 +1,57 @@
+---
+title: Using LlamaIndex Tools
+description: Learn how to integrate LlamaIndex tools with CrewAI agents to enhance search-based queries and more.
+---
+
+## Using LlamaIndex Tools
+
+!!! info "LlamaIndex Integration"
+    CrewAI seamlessly integrates with LlamaIndex’s comprehensive toolkit for RAG (Retrieval-Augmented Generation) and agentic pipelines, enabling advanced search-based queries and more. Here are the available built-in tools offered by LlamaIndex.
+
+```python
+from crewai import Agent
+from crewai_tools import LlamaIndexTool
+
+# Example 1: Initialize from FunctionTool
+from llama_index.core.tools import FunctionTool
+
+your_python_function = lambda ...: ...
+og_tool = FunctionTool.from_defaults(your_python_function, name="<name>", description='<description>')
+tool = LlamaIndexTool.from_tool(og_tool)
+
+# Example 2: Initialize from LlamaHub Tools
+from llama_index.tools.wolfram_alpha import WolframAlphaToolSpec
+wolfram_spec = WolframAlphaToolSpec(app_id="<app_id>")
+wolfram_tools = wolfram_spec.to_tool_list()
+tools = [LlamaIndexTool.from_tool(t) for t in wolfram_tools]
+
+# Example 3: Initialize Tool from a LlamaIndex Query Engine
+query_engine = index.as_query_engine()
+query_tool = LlamaIndexTool.from_query_engine(
+    query_engine,
+    name="Uber 2019 10K Query Tool",
+    description="Use this tool to lookup the 2019 Uber 10K Annual Report"
+)
+
+# Create and assign the tools to an agent
+agent = Agent(
+  role='Research Analyst',
+  goal='Provide up-to-date market analysis',
+  backstory='An expert analyst with a keen eye for market trends.',
+  tools=[tool, *tools, query_tool]
+)
+
+# rest of the code ...
+```
+
+## Steps to Get Started
+
+To effectively use the LlamaIndexTool, follow these steps:
+
+1. **Package Installation**: Confirm that the `crewai[tools]` package is installed in your Python environment.
+
+    ```shell
+    pip install 'crewai[tools]'
+    ```
+
+2. **Install and Use LlamaIndex**: Follow LlamaIndex documentation [LlamaIndex Documentation](https://docs.llamaindex.ai/) to set up a RAG/agent pipeline.

docs/how-to/AgentOps-Observability.md

@@ -4,8 +4,7 @@ description: Understanding and logging your agent performance with AgentOps.
 ---
 
 # Intro
-Observability is a key aspect of developing and deploying conversational AI agents. It allows developers to understand how their agents are performing, how their agents are interacting with users, and how their agents use external tools and APIs. AgentOps is a product independent of CrewAI that provides a comprehensive observability solution for agents. 
-
+Observability is a key aspect of developing and deploying conversational AI agents. It allows developers to understand how their agents are performing, how their agents are interacting with users, and how their agents use external tools and APIs. AgentOps is a product independent of CrewAI that provides a comprehensive observability solution for agents.
 
 ## AgentOps
 
@@ -23,54 +22,53 @@ Additionally, AgentOps provides session drilldowns for viewing Crew agent intera
 ![Viewing a step-by-step agent replay execution graph](..%2Fassets%2Fagentops-replay.png)
 
 ### Features
-- **LLM Cost Management and Tracking**: Track spend with foundation model providers
-- **Replay Analytics**: Watch step-by-step agent execution graphs
-- **Recursive Thought Detection**: Identify when agents fall into infinite loops
-- **Custom Reporting**: Create custom analytics on agent performance
-- **Analytics Dashboard**: Monitor high level statistics about agents in development and production
-- **Public Model Testing**: Test your agents against benchmarks and leaderboards
-- **Custom Tests**: Run your agents against domain specific tests
-- **Time Travel Debugging**: Restart your sessions from checkpoints
-- **Compliance and Security**: Create audit logs and detect potential threats such as profanity and PII leaks
-- **Prompt Injection Detection**: Identify potential code injection and secret leaks
+- **LLM Cost Management and Tracking**: Track spend with foundation model providers.
+- **Replay Analytics**: Watch step-by-step agent execution graphs.
+- **Recursive Thought Detection**: Identify when agents fall into infinite loops.
+- **Custom Reporting**: Create custom analytics on agent performance.
+- **Analytics Dashboard**: Monitor high-level statistics about agents in development and production.
+- **Public Model Testing**: Test your agents against benchmarks and leaderboards.
+- **Custom Tests**: Run your agents against domain-specific tests.
+- **Time Travel Debugging**: Restart your sessions from checkpoints.
+- **Compliance and Security**: Create audit logs and detect potential threats such as profanity and PII leaks.
+- **Prompt Injection Detection**: Identify potential code injection and secret leaks.
 
 ### Using AgentOps
 
 1. **Create an API Key:**
-Create a user API key here: [Create API Key](app.agentops.ai/account)
+   Create a user API key here: [Create API Key](app.agentops.ai/account)
 
 2. **Configure Your Environment:**
-Add your API key to your environment variables
+   Add your API key to your environment variables
 
-```
-AGENTOPS_API_KEY=<YOUR_AGENTOPS_API_KEY>
-```
+   ```bash
+   AGENTOPS_API_KEY=<YOUR_AGENTOPS_API_KEY>
+   ```
 
 3. **Install AgentOps:**
-Install AgentOps with:
-```
-pip install crewai[agentops]
-```
-or
-```
-pip install agentops
-```
+   Install AgentOps with:
+   ```bash
+   pip install crewai[agentops]
+   ```
+   or
+   ```bash
+   pip install agentops
+   ```
 
-Before using `Crew` in your script, include these lines:
+   Before using `Crew` in your script, include these lines:
 
-```python
-import agentops
-agentops.init()
-```
+   ```python
+   import agentops
+   agentops.init()
+   ```
 
-This will initiate an AgentOps session as well as automatically track Crew agents. For further info on how to outfit more complex agentic systems, check out the [AgentOps documentation](https://docs.agentops.ai) or join the [Discord](https://discord.gg/j4f3KbeH).
+   This will initiate an AgentOps session as well as automatically track Crew agents. For further info on how to outfit more complex agentic systems, check out the [AgentOps documentation](https://docs.agentops.ai) or join the [Discord](https://discord.gg/j4f3KbeH).
 
 ### Crew + AgentOps Examples
 - [Job Posting](https://github.com/joaomdmoura/crewAI-examples/tree/main/job-posting)
 - [Markdown Validator](https://github.com/joaomdmoura/crewAI-examples/tree/main/markdown_validator)
 - [Instagram Post](https://github.com/joaomdmoura/crewAI-examples/tree/main/instagram_post)
 
-
 ### Further Information
 
 To get started, create an [AgentOps account](https://agentops.ai/?=crew).

docs/how-to/Create-Custom-Tools.md

@@ -42,6 +42,7 @@ def my_simple_tool(question: str) -> str:
     # Tool logic here
     return "Tool output"
 ```
+
 ### Defining a Cache Function for the Tool
 
 To optimize tool performance with caching, define custom caching strategies using the `cache_function` attribute.

docs/how-to/Creating-a-Crew-and-kick-it-off.md

@@ -16,7 +16,7 @@ pip install 'crewai[tools]'
 ```
 
 ## Step 1: Assemble Your Agents
-Define your agents with distinct roles, backstories, and enhanced capabilities like verbose mode and memory usage. These elements add depth and guide their task execution and interaction within the crew.
+Define your agents with distinct roles, backstories, and enhanced capabilities like verbose mode, memory usage, and the ability to set specific agents as managers. These elements add depth and guide their task execution and interaction within the crew.
 
 ```python
 import os
@@ -24,8 +24,10 @@ os.environ["SERPER_API_KEY"] = "Your Key"  # serper.dev API key
 os.environ["OPENAI_API_KEY"] = "Your Key"
 
 from crewai import Agent
-from crewai_tools import SerperDevTool
+from crewai_tools import SerperDevTool, BrowserbaseTool, ExaSearchTool
 search_tool = SerperDevTool()
+browser_tool = BrowserbaseTool()
+exa_search_tool = ExaSearchTool()
 
 # Creating a senior researcher agent with memory and verbose mode
 researcher = Agent(
@@ -38,8 +40,7 @@ researcher = Agent(
     "innovation, eager to explore and share knowledge that could change"
     "the world."
   ),
-  tools=[search_tool],
-  allow_delegation=True
+  tools=[search_tool, browser_tool],
 )
 
 # Creating a writer agent with custom tools and delegation capability
@@ -53,9 +54,20 @@ writer = Agent(
     "engaging narratives that captivate and educate, bringing new"
     "discoveries to light in an accessible manner."
   ),
-  tools=[search_tool],
+  tools=[exa_search_tool],
   allow_delegation=False
 )
+
+# Setting a specific manager agent
+manager = Agent(
+  role='Manager',
+  goal='Ensure the smooth operation and coordination of the team',
+  verbose=True,
+  backstory=(
+    "As a seasoned project manager, you excel in organizing"
+    "tasks, managing timelines, and ensuring the team stays on track."
+  )
+)
 ```
 
 ## Step 2: Define the Tasks
@@ -75,6 +87,8 @@ research_task = Task(
   expected_output='A comprehensive 3 paragraphs long report on the latest AI trends.',
   tools=[search_tool],
   agent=researcher,
+  callback="research_callback",  # Example of task callback
+  human_input=True
 )
 
 # Writing task with language model configuration
@@ -85,15 +99,14 @@ write_task = Task(
     "This article should be easy to understand, engaging, and positive."
   ),
   expected_output='A 4 paragraph article on {topic} advancements formatted as markdown.',
-  tools=[search_tool],
+  tools=[exa_search_tool],
   agent=writer,
-  async_execution=False,
-  output_file='new-blog-post.md'  # Example of output customization
+  output_file='new-blog-post.md',  # Example of output customization
 )
 ```
 
 ## Step 3: Form the Crew
-Combine your agents into a crew, setting the workflow process they'll follow to accomplish the tasks. Now with options to configure language models for enhanced interaction and additional configurations for optimizing performance.
+Combine your agents into a crew, setting the workflow process they'll follow to accomplish the tasks. Now with options to configure language models for enhanced interaction and additional configurations for optimizing performance, such as creating directories when saving files.
 
 ```python
 from crewai import Crew, Process
@@ -106,7 +119,7 @@ crew = Crew(
   memory=True,
   cache=True,
   max_rpm=100,
-  share_crew=True
+  manager_agent=manager
 )
 ```
 

docs/how-to/Customize-Prompts.md

@@ -0,0 +1,94 @@
+---
+title: Initial Support to Bring Your Own Prompts in CrewAI
+description: Enhancing customization and internationalization by allowing users to bring their own prompts in CrewAI.
+
+---
+
+# Initial Support to Bring Your Own Prompts in CrewAI
+
+CrewAI now supports the ability to bring your own prompts, enabling extensive customization and internationalization. This feature allows users to tailor the inner workings of their agents to better suit specific needs, including support for multiple languages.
+
+## Internationalization and Customization Support
+
+### Custom Prompts with `prompt_file`
+
+The `prompt_file` attribute facilitates full customization of the agent prompts, enhancing the global usability of CrewAI. Users can specify their prompt templates, ensuring that the agents communicate in a manner that aligns with specific project requirements or language preferences.
+
+#### Example of a Custom Prompt File
+
+The custom prompts can be defined in a JSON file, similar to the example provided [here](https://github.com/joaomdmoura/crewAI/blob/main/src/crewai/translations/en.json).
+
+### Supported Languages
+
+CrewAI's custom prompt support includes internationalization, allowing prompts to be written in different languages. This is particularly useful for global teams or projects that require multilingual support.
+
+## How to Use the `prompt_file` Attribute
+
+To utilize the `prompt_file` attribute, include it in your crew definition. Below is an example demonstrating how to set up agents and tasks with custom prompts.
+
+### Example
+
+```python
+import os
+from crewai import Agent, Task, Crew
+
+# Define your agents
+researcher = Agent(
+    role="Researcher",
+    goal="Make the best research and analysis on content about AI and AI agents",
+    backstory="You're an expert researcher, specialized in technology, software engineering, AI and startups. You work as a freelancer and is now working on doing research and analysis for a new customer.",
+    allow_delegation=False,
+)
+
+writer = Agent(
+    role="Senior Writer",
+    goal="Write the best content about AI and AI agents.",
+    backstory="You're a senior writer, specialized in technology, software engineering, AI and startups. You work as a freelancer and are now working on writing content for a new customer.",
+    allow_delegation=False,
+)
+
+# Define your tasks
+tasks = [
+    Task(
+        description="Say Hi",
+        expected_output="The word: Hi",
+        agent=researcher,
+    )
+]
+
+# Instantiate your crew with custom prompts
+crew = Crew(
+    agents=[researcher],
+    tasks=tasks,
+    prompt_file="prompt.json",  # Path to your custom prompt file
+)
+
+# Get your crew to work!
+crew.kickoff()
+```
+
+## Advanced Customization Features
+
+### `language` Attribute
+
+In addition to `prompt_file`, the `language` attribute can be used to specify the language for the agent's prompts. This ensures that the prompts are generated in the desired language, further enhancing the internationalization capabilities of CrewAI.
+
+### Creating Custom Prompt Files
+
+Custom prompt files should be structured in JSON format and include all necessary prompt templates. Below is a simplified example of a prompt JSON file:
+
+```json
+{
+    "system": "You are a system template.",
+    "prompt": "Here is your prompt template.",
+    "response": "Here is your response template."
+}
+```
+
+### Benefits of Custom Prompts
+
+- **Enhanced Flexibility**: Tailor agent communication to specific project needs.
+- **Improved Usability**: Supports multiple languages, making it suitable for global projects.
+- **Consistency**: Ensures uniform prompt structures across different agents and tasks.
+
+By incorporating these updates, CrewAI provides users with the ability to fully customize and internationalize their agent prompts, making the platform more versatile and user-friendly.

docs/how-to/Customizing-Agents.md

@@ -10,7 +10,16 @@ Crafting an efficient CrewAI team hinges on the ability to dynamically tailor yo
 - **Role**: Specifies the agent's job within the crew, such as 'Analyst' or 'Customer Service Rep'.
 - **Goal**: Defines what the agent aims to achieve, in alignment with its role and the overarching objectives of the crew.
 - **Backstory**: Provides depth to the agent's persona, enriching its motivations and engagements within the crew.
-- **Tools**: Represents the capabilities or methods the agent uses to perform tasks, from simple functions to intricate integrations.
+- **Tools** *(Optional)*: Represents the capabilities or methods the agent uses to perform tasks, from simple functions to intricate integrations.
+- **Cache** *(Optional)*: Determines whether the agent should use a cache for tool usage.
+- **Max RPM**: Sets the maximum number of requests per minute (`max_rpm`). This attribute is optional and can be set to `None` for no limit, allowing for unlimited queries to external services if needed.
+- **Verbose** *(Optional)*: Enables detailed logging of an agent's actions, useful for debugging and optimization. Specifically, it provides insights into agent execution processes, aiding in the optimization of performance.
+- **Allow Delegation** *(Optional)*: `allow_delegation` controls whether the agent is allowed to delegate tasks to other agents.
+- **Max Iter** *(Optional)*: The `max_iter` attribute allows users to define the maximum number of iterations an agent can perform for a single task, preventing infinite loops or excessively long executions. The default value is set to 25, providing a balance between thoroughness and efficiency. Once the agent approaches this number, it will try its best to give a good answer.
+- **Max Execution Time** *(Optional)*: `max_execution_time` Sets the maximum execution time for an agent to complete a task.
+- **System Template** *(Optional)*: `system_template` defines the system format for the agent.
+- **Prompt Template** *(Optional)*: `prompt_template` defines the prompt format for the agent.
+- **Response Template** *(Optional)*: `response_template` defines the response format for the agent.
 
 ## Advanced Customization Options
 Beyond the basic attributes, CrewAI allows for deeper customization to enhance an agent's behavior and capabilities significantly.
@@ -26,7 +35,7 @@ Adjusting an agent's performance and monitoring its operations are crucial for e
 - **RPM Limit**: Sets the maximum number of requests per minute (`max_rpm`). This attribute is optional and can be set to `None` for no limit, allowing for unlimited queries to external services if needed.
 
 ### Maximum Iterations for Task Execution
-The `max_iter` attribute allows users to define the maximum number of iterations an agent can perform for a single task, preventing infinite loops or excessively long executions. The default value is set to 15, providing a balance between thoroughness and efficiency. Once the agent approaches this number, it will try its best to give a good answer.
+The `max_iter` attribute allows users to define the maximum number of iterations an agent can perform for a single task, preventing infinite loops or excessively long executions. The default value is set to 25, providing a balance between thoroughness and efficiency. Once the agent approaches this number, it will try its best to give a good answer.
 
 ## Customizing Agents and Tools
 Agents are customized by defining their attributes and tools during initialization. Tools are critical for an agent's functionality, enabling them to perform specialized tasks. The `tools` attribute should be an array of tools the agent can utilize, and it's initialized as an empty list by default. Tools can be added or modified post-agent initialization to adapt to new requirements.
@@ -57,7 +66,7 @@ agent = Agent(
   memory=True, # Enable memory
   verbose=True,
   max_rpm=None, # No limit on requests per minute
-  max_iter=15, # Default value for maximum iterations
+  max_iter=25, # Default value for maximum iterations
   allow_delegation=False
 )
 ```

docs/how-to/Hierarchical.md

@@ -10,7 +10,7 @@ The hierarchical process in CrewAI introduces a structured approach to task mana
     The hierarchical process is designed to leverage advanced models like GPT-4, optimizing token usage while handling complex tasks with greater efficiency.
 
 ## Hierarchical Process Overview
-By default, tasks in CrewAI are managed through a sequential process. However, adopting a hierarchical approach allows for a clear hierarchy in task management, where a 'manager' agent coordinates the workflow, delegates tasks, and validates outcomes for streamlined and effective execution. This manager agent is automatically created by crewAI so you don't need to worry about it.
+By default, tasks in CrewAI are managed through a sequential process. However, adopting a hierarchical approach allows for a clear hierarchy in task management, where a 'manager' agent coordinates the workflow, delegates tasks, and validates outcomes for streamlined and effective execution. This manager agent can now be either automatically created by CrewAI or explicitly set by the user.
 
 ### Key Features
 - **Task Delegation**: A manager agent allocates tasks among crew members based on their roles and capabilities.
@@ -52,9 +52,10 @@ writer = Agent(
 project_crew = Crew(
     tasks=[...],  # Tasks to be delegated and executed under the manager's supervision
     agents=[researcher, writer],
-    manager_llm=ChatOpenAI(temperature=0, model="gpt-4"),  # Mandatory for hierarchical process
+    manager_llm=ChatOpenAI(temperature=0, model="gpt-4"),  # Mandatory if manager_agent is not set
     process=Process.hierarchical,  # Specifies the hierarchical management approach
     memory=True,  # Enable memory usage for enhanced task execution
+    manager_agent=None,  # Optional: explicitly set a specific agent as manager instead of the manager_llm
 )
 ```
 
@@ -64,4 +65,4 @@ project_crew = Crew(
 3. **Sequential Task Progression**: Despite being a hierarchical process, tasks follow a logical order for smooth progression, facilitated by the manager's oversight.
 
 ## Conclusion
-Adopting the hierarchical process in crewAI, with the correct configurations and understanding of the system's capabilities, facilitates an organized and efficient approach to project management.
+Adopting the hierarchical process in CrewAI, with the correct configurations and understanding of the system's capabilities, facilitates an organized and efficient approach to project management. Utilize the advanced features and customizations to tailor the workflow to your specific needs, ensuring optimal task execution and project success.

docs/how-to/Human-Input-on-Execution.md

@@ -22,7 +22,7 @@ import os
 from crewai import Agent, Task, Crew
 from crewai_tools import SerperDevTool
 
-os.environ["SERPER_API_KEY"] = "Your Key" # serper.dev API key
+os.environ["SERPER_API_KEY"] = "Your Key"  # serper.dev API key
 os.environ["OPENAI_API_KEY"] = "Your Key"
 
 # Loading Tools
@@ -30,59 +30,59 @@ search_tool = SerperDevTool()
 
 # Define your agents with roles, goals, tools, and additional attributes
 researcher = Agent(
-  role='Senior Research Analyst',
-  goal='Uncover cutting-edge developments in AI and data science',
-  backstory=(
-    "You are a Senior Research Analyst at a leading tech think tank."
-    "Your expertise lies in identifying emerging trends and technologies in AI and data science."
-    "You have a knack for dissecting complex data and presenting actionable insights."
-  ),
-  verbose=True,
-  allow_delegation=False,
-  tools=[search_tool],
-  max_rpm=100
+    role='Senior Research Analyst',
+    goal='Uncover cutting-edge developments in AI and data science',
+    backstory=(
+        "You are a Senior Research Analyst at a leading tech think tank. "
+        "Your expertise lies in identifying emerging trends and technologies in AI and data science. "
+        "You have a knack for dissecting complex data and presenting actionable insights."
+    ),
+    verbose=True,
+    allow_delegation=False,
+    tools=[search_tool]
 )
 writer = Agent(
-  role='Tech Content Strategist',
-  goal='Craft compelling content on tech advancements',
-  backstory=(
-    "You are a renowned Tech Content Strategist, known for your insightful and engaging articles on technology and innovation."
-    "With a deep understanding of the tech industry, you transform complex concepts into compelling narratives."
-  ),
-  verbose=True,
-  allow_delegation=True,
-  tools=[search_tool],
-  cache=False, # Disable cache for this agent
+    role='Tech Content Strategist',
+    goal='Craft compelling content on tech advancements',
+    backstory=(
+        "You are a renowned Tech Content Strategist, known for your insightful and engaging articles on technology and innovation. "
+        "With a deep understanding of the tech industry, you transform complex concepts into compelling narratives."
+    ),
+    verbose=True,
+    allow_delegation=True,
+    tools=[search_tool],
+    cache=False,  # Disable cache for this agent
 )
 
 # Create tasks for your agents
 task1 = Task(
-  description=(
-    "Conduct a comprehensive analysis of the latest advancements in AI in 2024."
-    "Identify key trends, breakthrough technologies, and potential industry impacts."
-    "Compile your findings in a detailed report."
-    "Make sure to check with a human if the draft is good before finalizing your answer."
-  ),
-  expected_output='A comprehensive full report on the latest AI advancements in 2024, leave nothing out',
-  agent=researcher,
-  human_input=True,
+    description=(
+        "Conduct a comprehensive analysis of the latest advancements in AI in 2024. "
+        "Identify key trends, breakthrough technologies, and potential industry impacts. "
+        "Compile your findings in a detailed report. "
+        "Make sure to check with a human if the draft is good before finalizing your answer."
+    ),
+    expected_output='A comprehensive full report on the latest AI advancements in 2024, leave nothing out',
+    agent=researcher,
+    human_input=True
 )
 
 task2 = Task(
-  description=(
-    "Using the insights from the researcher's report, develop an engaging blog post that highlights the most significant AI advancements."
-    "Your post should be informative yet accessible, catering to a tech-savvy audience."
-    "Aim for a narrative that captures the essence of these breakthroughs and their implications for the future."
-  ),
-  expected_output='A compelling 3 paragraphs blog post formatted as markdown about the latest AI advancements in 2024',
-  agent=writer
+    description=(
+        "Using the insights from the researcher\'s report, develop an engaging blog post that highlights the most significant AI advancements. "
+        "Your post should be informative yet accessible, catering to a tech-savvy audience. "
+        "Aim for a narrative that captures the essence of these breakthroughs and their implications for the future."
+    ),
+    expected_output='A compelling 3 paragraphs blog post formatted as markdown about the latest AI advancements in 2024',
+    agent=writer
 )
 
 # Instantiate your crew with a sequential process
 crew = Crew(
-  agents=[researcher, writer],
-  tasks=[task1, task2],
-  verbose=2
+    agents=[researcher, writer],
+    tasks=[task1, task2],
+    verbose=2,
+    memory=True,
 )
 
 # Get your crew to work!

docs/how-to/Installing-CrewAI.md

@@ -12,7 +12,7 @@ Welcome to crewAI! This guide will walk you through the installation process for
 To install crewAI, you need to have Python >=3.10 and <=3.13 installed on your system:
 
 ```shell
-# Install the mains crewAI package
+# Install the main crewAI package
 pip install crewai
 
 # Install the main crewAI package and the tools package

docs/how-to/LLM-Connections.md

@@ -16,16 +16,20 @@ The `Agent` class is the cornerstone for implementing AI solutions in CrewAI. He
     - `role`: Defines the agent's role within the solution.
     - `goal`: Specifies the agent's objective.
     - `backstory`: Provides a background story to the agent.
-    - `llm`: Indicates the Large Language Model the agent uses. By default, it uses the GPT-4 model defined in the environment variable "OPENAI_MODEL_NAME".
-    - `function_calling_llm` *Optional*: Will turn the ReAct crewAI agent into a function calling agent.
-    - `max_iter`: Maximum number of iterations for an agent to execute a task, default is 15.
-    - `memory`: Enables the agent to retain information during and a across executions. Default is `False`.
-    - `max_rpm`: Maximum number of requests per minute the agent's execution should respect. Optional.
-    - `verbose`: Enables detailed logging of the agent's execution. Default is `False`.
-    - `allow_delegation`: Allows the agent to delegate tasks to other agents, default is `True`.
+    - `cache` *Optional*: Determines whether the agent should use a cache for tool usage. Default is `True`.
+    - `max_rpm` *Optional*: Maximum number of requests per minute the agent's execution should respect. Optional.
+    - `verbose` *Optional*: Enables detailed logging of the agent's execution. Default is `False`.
+    - `allow_delegation` *Optional*: Allows the agent to delegate tasks to other agents, default is `True`.
     - `tools`: Specifies the tools available to the agent for task execution. Optional.
-    - `step_callback`: Provides a callback function to be executed after each step. Optional.
-    - `cache`: Determines whether the agent should use a cache for tool usage. Default is `True`.
+    - `max_iter` *Optional*: Maximum number of iterations for an agent to execute a task, default is 25.
+    - `max_execution_time` *Optional*: Maximum execution time for an agent to execute a task. Optional.
+    - `step_callback` *Optional*: Provides a callback function to be executed after each step. Optional.
+    - `llm` *Optional*: Indicates the Large Language Model the agent uses. By default, it uses the GPT-4 model defined in the environment variable "OPENAI_MODEL_NAME".
+    - `function_calling_llm` *Optional* :  Will turn the ReAct CrewAI agent into a function-calling agent.
+    - `callbacks` *Optional*: A list of callback functions from the LangChain library that are triggered during the agent's execution process.
+    - `system_template` *Optional*: Optional string to define the system format for the agent.
+    - `prompt_template` *Optional*: Optional string to define the prompt format for the agent.
+    - `response_template` *Optional*: Optional string to define the response format for the agent.
 
 ```python
 # Required
@@ -36,13 +40,12 @@ example_agent = Agent(
   role='Local Expert',
   goal='Provide insights about the city',
   backstory="A knowledgeable local guide.",
-  verbose=True,
-  memory=True
+  verbose=True
 )
 ```
 
 ## Ollama Integration
-Ollama is preferred for local LLM integration, offering customization and privacy benefits. To integrate Ollama with CrewAI, set the appropriate environment variables as shown below. 
+Ollama is preferred for local LLM integration, offering customization and privacy benefits. To integrate Ollama with CrewAI, set the appropriate environment variables as shown below.
 
 ### Setting Up Ollama
 - **Environment Variables Configuration**: To integrate Ollama, set the following environment variables:
@@ -53,8 +56,8 @@ OPENAI_API_KEY=''
 ```
 
 ## Ollama Integration (ex. for using Llama 2 locally)
-1. [Download Ollama](https://ollama.com/download).   
-2. After setting up the Ollama, Pull the Llama2 by typing following lines into the terminal ```ollama pull llama2```.   
+1. [Download Ollama](https://ollama.com/download).
+2. After setting up the Ollama, Pull the Llama2 by typing following lines into the terminal ```ollama pull llama2```.
 3. Create a ModelFile similar the one below in your project directory.
 ```
 FROM llama2
@@ -70,7 +73,7 @@ PARAMETER stop Result
 
 SYSTEM """"""
 ```
-4. Create a script to get the base model, which in our case is llama2, and create a model on top of that with ModelFile above. PS: this will be ".sh" file.     
+4. Create a script to get the base model, which in our case is llama2, and create a model on top of that with ModelFile above. PS: this will be ".sh" file.
 ```
 #!/bin/zsh
 
@@ -84,9 +87,9 @@ ollama pull $model_name
 #create the model file
 ollama create $custom_model_name -f ./Llama2ModelFile
 ```
-5. Go into the directory where the script file and ModelFile is located and run the script.   
-6. Enjoy your free Llama2 model that powered up by excellent agents from crewai.   
-```
+5. Go into the directory where the script file and ModelFile is located and run the script.
+6. Enjoy your free Llama2 model that is powered up by excellent agents from CrewAI.
+```python
 from crewai import Agent, Task, Crew
 from langchain_openai import ChatOpenAI
 import os
@@ -102,7 +105,8 @@ general_agent = Agent(role = "Math Professor",
                       allow_delegation = False,
                       verbose = True,
                       llm = llm)
-task = Task (description="""what is 3 + 5""",
+
+task = Task(description="""what is 3 + 5""",
              agent = general_agent,
              expected_output="A numerical answer.")
 
@@ -162,7 +166,7 @@ OPENAI_API_KEY=NA
 ```
 
 #### LM Studio
-Launch [LM Studio](https://lmstudio.ai) and go to the Server tab. Then select a model from the dropdown menu then wait for it to load. Once it's loaded, click the green Start Server button and use the URL, port, and API key that's shown (you can modify them). Below is an example of the default settings as of LM Studio 0.2.19:
+Launch [LM Studio](https://lmstudio.ai) and go to the Server tab. Then select a model from the dropdown menu and wait for it to load. Once it's loaded, click the green Start Server button and use the URL, port, and API key that's shown (you can modify them). Below is an example of the default settings as of LM Studio 0.2.19:
 ```sh
 OPENAI_API_BASE="http://localhost:1234/v1"
 OPENAI_API_KEY="lm-studio"
@@ -176,15 +180,16 @@ OPENAI_MODEL_NAME="mistral-small"
 ```
 
 ### Solar
-```sh
+```python
 from langchain_community.chat_models.solar import SolarChat
 # Initialize language model
 os.environ["SOLAR_API_KEY"] = "your-solar-api-key"
 llm = SolarChat(max_tokens=1024)
 
-Free developer API key available here: https://console.upstage.ai/services/solar
-Langchain Example: https://github.com/langchain-ai/langchain/pull/18556
+# Free developer API key available here: https://console.upstage.ai/services/solar
+# Langchain Example: https://github.com/langchain-ai/langchain/pull/18556
 ```
+
 ### text-gen-web-ui
 ```sh
 OPENAI_API_BASE=http://localhost:5000/v1
@@ -193,17 +198,16 @@ OPENAI_API_KEY=NA
 ```
 
 ### Cohere
-```sh
-from langchain_community.chat_models import ChatCohere
+```python
+from langchain_cohere import ChatCohere
 # Initialize language model
 os.environ["COHERE_API_KEY"] = "your-cohere-api-key"
 llm = ChatCohere()
 
-Free developer API key available here: https://cohere.com/
-Langchain Documentation: https://python.langchain.com/docs/integrations/chat/cohere
+# Free developer API key available here: https://cohere.com/
+# Langchain Documentation: https://python.langchain.com/docs/integrations/chat/cohere
 ```
 
-
 ### Azure Open AI Configuration
 For Azure OpenAI API integration, set the following environment variables:
 ```sh
@@ -235,4 +239,4 @@ azure_agent = Agent(
 ```
 
 ## Conclusion
-Integrating CrewAI with different LLMs expands the framework's versatility, allowing for customized, efficient AI solutions across various domains and platforms.
+Integrating CrewAI with different LLMs expands the framework's versatility, allowing for customized, efficient AI solutions across various domains and platforms.

docs/how-to/Langtrace-Observability.md

@@ -0,0 +1,44 @@
+---
+title: CrewAI Agent Monitoring with Langtrace
+description: How to monitor cost, latency, and performance of CrewAI Agents using Langtrace.
+---
+
+# Langtrace Overview
+Langtrace is an open-source tool that helps you set up observability and evaluations for LLMs, LLM frameworks, and VectorDB. With Langtrace, you can get deep visibility into the cost, latency, and performance of your CrewAI Agents. Additionally, you can log the hyperparameters and monitor for any performance regressions and set up a process to continuously improve your Agents.
+
+## Setup Instructions
+
+1. Sign up for [Langtrace](https://langtrace.ai/) by going to [https://langtrace.ai/signup](https://langtrace.ai/signup).
+2. Create a project and generate an API key.
+3. Install Langtrace in your code using the following commands.
+**Note**: For detailed instructions on integrating Langtrace, you can check out the official docs from [here](https://docs.langtrace.ai/supported-integrations/llm-frameworks/crewai).
+
+```
+# Install the SDK
+pip install langtrace-python-sdk
+
+# Import it into your project
+from langtrace_python_sdk import langtrace # Must precede any llm module imports
+langtrace.init(api_key = '<LANGTRACE_API_KEY>')
+```
+
+### Features
+- **LLM Token and Cost tracking**
+- **Trace graph showing detailed execution steps with latency and logs**
+- **Dataset curation using manual annotation**
+- **Prompt versioning and management**
+- **Prompt Playground with comparison views between models**
+- **Testing and Evaluations**
+
+![Langtrace Cost and Usage Tracking](..%2Fassets%2Fcrewai-langtrace-stats.png)
+![Langtrace Span Graph and Logs Dashboard](..%2Fassets%2Fcrewai-langtrace-spans.png)
+
+#### Extra links
+
+<a href="https://x.com/langtrace_ai">🐦 Twitter</a>
+<span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+<a href="https://discord.com/invite/EaSATwtr4t">📢 Discord</a>
+<span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+<a href="https://langtrace.ai/">🖇 Website</a>
+<span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+<a href="https://docs.langtrace.ai/introduction">📙 Documentation</a>

docs/how-to/Sequential.md

@@ -13,6 +13,7 @@ The sequential process ensures tasks are executed one after the other, following
 - **Linear Task Flow**: Ensures orderly progression by handling tasks in a predetermined sequence.
 - **Simplicity**: Best suited for projects with clear, step-by-step tasks.
 - **Easy Monitoring**: Facilitates easy tracking of task completion and project progress.
+
 ## Implementing the Sequential Process
 Assemble your crew and define tasks in the order they need to be executed.
 

docs/how-to/Your-Own-Manager-Agent.md

@@ -0,0 +1,68 @@
+---
+title: Ability to Set a Specific Agent as Manager in CrewAI
+description: Introducing the ability to set a specific agent as a manager instead of having CrewAI create one automatically.
+
+---
+
+# Ability to Set a Specific Agent as Manager in CrewAI
+
+CrewAI now allows users to set a specific agent as the manager of the crew, providing more control over the management and coordination of tasks. This feature enables the customization of the managerial role to better fit the project's requirements.
+
+## Using the `manager_agent` Attribute
+
+### Custom Manager Agent
+
+The `manager_agent` attribute allows you to define a custom agent to manage the crew. This agent will oversee the entire process, ensuring that tasks are completed efficiently and to the highest standard.
+
+### Example
+
+```python
+import os
+from crewai import Agent, Task, Crew, Process
+
+# Define your agents
+researcher = Agent(
+    role="Researcher",
+    goal="Make the best research and analysis on content about AI and AI agents",
+    backstory="You're an expert researcher, specialized in technology, software engineering, AI and startups. You work as a freelancer and is now working on doing research and analysis for a new customer.",
+    allow_delegation=False,
+)
+
+writer = Agent(
+    role="Senior Writer",
+    goal="Write the best content about AI and AI agents.",
+    backstory="You're a senior writer, specialized in technology, software engineering, AI and startups. You work as a freelancer and are now working on writing content for a new customer.",
+    allow_delegation=False,
+)
+
+# Define your task
+task = Task(
+    description="Come up with a list of 5 interesting ideas to explore for an article, then write one amazing paragraph highlight for each idea that showcases how good an article about this topic could be. Return the list of ideas with their paragraph and your notes.",
+    expected_output="5 bullet points with a paragraph for each idea.",
+)
+
+# Define the manager agent
+manager = Agent(
+    role="Manager",
+    goal="Manage the crew and ensure the tasks are completed efficiently.",
+    backstory="You're an experienced manager, skilled in overseeing complex projects and guiding teams to success. Your role is to coordinate the efforts of the crew members, ensuring that each task is completed on time and to the highest standard.",
+    allow_delegation=False,
+)
+
+# Instantiate your crew with a custom manager
+crew = Crew(
+    agents=[researcher, writer],
+    process=Process.hierarchical,
+    manager_agent=manager,
+    tasks=[task],
+)
+
+# Get your crew to work!
+crew.kickoff()
+```
+
+## Benefits of a Custom Manager Agent
+
+- **Enhanced Control**: Allows for a more tailored management approach, fitting the specific needs of the project.
+- **Improved Coordination**: Ensures that the tasks are efficiently coordinated and managed by an experienced agent.
+- **Customizable Management**: Provides the flexibility to define managerial roles and responsibilities that align with the project's goals.

docs/telemetry/Telemetry.md

@@ -2,6 +2,7 @@
 title: Telemetry
 description: Understanding the telemetry data collected by CrewAI and how it contributes to the enhancement of the library.
 ---
+
 ## Telemetry
 
 CrewAI utilizes anonymous telemetry to gather usage statistics with the primary goal of enhancing the library. Our focus is on improving and developing the features, integrations, and tools most utilized by our users.

docs/tools/BrowserbaseLoadTool.md

@@ -2,11 +2,17 @@
 
 ## Description
 
-[Browserbase](https://browserbase.com) is a serverless platform for running headless browsers, it offers advanced debugging, session recordings, stealth mode, integrated proxies and captcha solving.
+[Browserbase](https://browserbase.com) is a developer platform to reliably run, manage, and monitor headless browsers.
+
+ Power your AI data retrievals with:
+ - [Serverless Infrastructure](https://docs.browserbase.com/under-the-hood) providing reliable browsers to extract data from complex UIs
+ - [Stealth Mode](https://docs.browserbase.com/features/stealth-mode) with included fingerprinting tactics and automatic captcha solving
+ - [Session Debugger](https://docs.browserbase.com/features/sessions) to inspect your Browser Session with networks timeline and logs
+ - [Live Debug](https://docs.browserbase.com/guides/session-debug-connection/browser-remote-control) to quickly debug your automation
 
 ## Installation
 
-- Get an API key from [browserbase.com](https://browserbase.com) and set it in environment variables (`BROWSERBASE_API_KEY`).
+- Get an API key and Project ID from [browserbase.com](https://browserbase.com) and set it in environment variables (`BROWSERBASE_API_KEY`, `BROWSERBASE_PROJECT_ID`).
 - Install the [Browserbase SDK](http://github.com/browserbase/python-sdk) along with `crewai[tools]` package:
 
 ```
@@ -25,5 +31,8 @@ tool = BrowserbaseLoadTool()
 
 ## Arguments
 
-- `api_key`: Optional. Specifies Browserbase API key. Defaults is the `BROWSERBASE_API_KEY` environment variable.
-- `text_content`: Optional. Load pages as readable text. Default is `False`.
+- `api_key` Optional. Browserbase API key. Default is `BROWSERBASE_API_KEY` env variable.
+- `project_id` Optional. Browserbase Project ID. Default is `BROWSERBASE_PROJECT_ID` env variable.
+- `text_content` Retrieve only text content. Default is `False`.
+- `session_id` Optional. Provide an existing Session ID.
+- `proxy` Optional. Enable/Disable Proxies."

docs/tools/EXASearchTool.md

@@ -0,0 +1,36 @@
+# EXASearchTool Documentation
+
+## Description
+
+The EXASearchTool is designed to perform a semantic search for a specified query from a text's content across the internet. It utilizes the [exa.ai](https://exa.ai/) API to fetch and display the most relevant search results based on the query provided by the user.
+
+## Installation
+
+To incorporate this tool into your project, follow the installation instructions below:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Example
+
+The following example demonstrates how to initialize the tool and execute a search with a given query:
+
+```python
+from crewai_tools import EXASearchTool
+
+# Initialize the tool for internet searching capabilities
+tool = EXASearchTool()
+```
+
+## Steps to Get Started
+
+To effectively use the EXASearchTool, follow these steps:
+
+1. **Package Installation**: Confirm that the `crewai[tools]` package is installed in your Python environment.
+2. **API Key Acquisition**: Acquire a [exa.ai](https://exa.ai/) API key by registering for a free account at [exa.ai](https://exa.ai/).
+3. **Environment Configuration**: Store your obtained API key in an environment variable named `EXA_API_KEY` to facilitate its use by the tool.
+
+## Conclusion
+
+By integrating the EXASearchTool into Python projects, users gain the ability to conduct real-time, relevant searches across the internet directly from their applications. By adhering to the setup and usage guidelines provided, incorporating this tool into projects is streamlined and straightforward.

mkdocs.yml

@@ -127,21 +127,26 @@ nav:
     - Crews: 'core-concepts/Crews.md'
     - Collaboration: 'core-concepts/Collaboration.md'
     - Memory: 'core-concepts/Memory.md'
+    - Using LangChain Tools: 'core-concepts/Using-LangChain-Tools.md'
+    - Using LlamaIndex Tools: 'core-concepts/Using-LlamaIndex-Tools.md'
   - How to Guides:
     - Installing CrewAI: 'how-to/Installing-CrewAI.md'
     - Getting Started: 'how-to/Creating-a-Crew-and-kick-it-off.md'
     - Create Custom Tools: 'how-to/Create-Custom-Tools.md'
     - Using Sequential Process: 'how-to/Sequential.md'
     - Using Hierarchical Process: 'how-to/Hierarchical.md'
+    - Create your own Manager Agent: 'how-to/Your-Own-Manager-Agent.md'
     - Connecting to any LLM: 'how-to/LLM-Connections.md'
     - Customizing Agents: 'how-to/Customizing-Agents.md'
     - Human Input on Execution: 'how-to/Human-Input-on-Execution.md'
     - Agent Monitoring with AgentOps: 'how-to/AgentOps-Observability.md'
+    - Agent Monitoring with LangTrace: 'how-to/Langtrace-Observability.md'
   - Tools Docs:
     - Google Serper Search: 'tools/SerperDevTool.md'
     - Browserbase Web Loader: 'tools/BrowserbaseLoadTool.md'
     - Scrape Website: 'tools/ScrapeWebsiteTool.md'
     - Directory Read: 'tools/DirectoryReadTool.md'
+    - Exa Serch Web Loader: 'tools/EXASearchTool.md'
     - File Read: 'tools/FileReadTool.md'
     - Selenium Scraper: 'tools/SeleniumScrapingTool.md'
     - Directory RAG Search: 'tools/DirectorySearchTool.md'
@@ -174,6 +179,7 @@ extra_css:
 
 plugins:
   - social
+  - search
 
 extra:
   analytics:

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "crewai"
-version = "0.30.11"
+version = "0.32.0"
 description = "Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks."
 authors = ["Joao Moura <joao@crewai.com>"]
 readme = "README.md"
@@ -19,13 +19,14 @@ openai = "^1.13.3"
 opentelemetry-api = "^1.22.0"
 opentelemetry-sdk = "^1.22.0"
 opentelemetry-exporter-otlp-proto-http = "^1.22.0"
-instructor = "^0.5.2"
+instructor = "1.3.3"
 regex = "^2023.12.25"
-crewai-tools = { version = "^0.2.6", optional = true }
+crewai-tools = { version = "^0.3.0", optional = true }
 click = "^8.1.7"
 python-dotenv = "^1.0.0"
-embedchain = "^0.1.98"
+embedchain = "0.1.109"
 appdirs = "^1.4.4"
+jsonref = "^1.1.0"
 
 [tool.poetry.extras]
 tools = ["crewai-tools"]
@@ -42,7 +43,7 @@ mkdocs-material = { extras = ["imaging"], version = "^9.5.7" }
 mkdocs-material-extensions = "^1.3.1"
 pillow = "^10.2.0"
 cairosvg = "^2.7.1"
-crewai-tools = "^0.2.6"
+crewai-tools = "^0.3.0"
 
 [tool.poetry.group.test.dependencies]
 pytest = "^8.0.0"

src/crewai/agent.py

@@ -1,3 +1,4 @@
+from copy import deepcopy
 import os
 import uuid
 from typing import Any, Dict, List, Optional, Tuple
@@ -39,7 +40,7 @@ class Agent(BaseModel):
             backstory: The backstory of the agent.
             config: Dict representation of agent configuration.
             llm: The language model that will run the agent.
-            function_calling_llm: The language model that will the tool calling for this agent, it overrides the crew function_calling_llm.
+            function_calling_llm: The language model that will handle the tool calling for this agent, it overrides the crew function_calling_llm.
             max_iter: Maximum number of iterations for an agent to execute a task.
             memory: Whether the agent should have memory or not.
             max_rpm: Maximum number of requests per minute for the agent execution to be respected.
@@ -97,7 +98,8 @@ class Agent(BaseModel):
     agent_executor: InstanceOf[CrewAgentExecutor] = Field(
         default=None, description="An instance of the CrewAgentExecutor class."
     )
-    crew: Any = Field(default=None, description="Crew to which the agent belongs.")
+    crew: Any = Field(
+        default=None, description="Crew to which the agent belongs.")
     tools_handler: InstanceOf[ToolsHandler] = Field(
         default=None, description="An instance of the ToolsHandler class."
     )
@@ -108,10 +110,11 @@ class Agent(BaseModel):
         default=None,
         description="Callback to be executed after each step of the agent execution.",
     )
-    i18n: I18N = Field(default=I18N(), description="Internationalization settings.")
+    i18n: I18N = Field(
+        default=I18N(), description="Internationalization settings.")
     llm: Any = Field(
         default_factory=lambda: ChatOpenAI(
-            model=os.environ.get("OPENAI_MODEL_NAME", "gpt-4")
+            model=os.environ.get("OPENAI_MODEL_NAME", "gpt-4o")
         ),
         description="Language model that will run the agent.",
     )
@@ -169,7 +172,8 @@ class Agent(BaseModel):
     def set_agent_executor(self) -> "Agent":
         """set agent executor is set."""
         if hasattr(self.llm, "model_name"):
-            token_handler = TokenCalcHandler(self.llm.model_name, self._token_process)
+            token_handler = TokenCalcHandler(
+                self.llm.model_name, self._token_process)
 
             # Ensure self.llm.callbacks is a list
             if not isinstance(self.llm.callbacks, list):
@@ -204,7 +208,8 @@ class Agent(BaseModel):
             Output of the agent
         """
         if self.tools_handler:
-            self.tools_handler.last_used_tool = {}  # type: ignore # Incompatible types in assignment (expression has type "dict[Never, Never]", variable has type "ToolCalling")
+            # type: ignore # Incompatible types in assignment (expression has type "dict[Never, Never]", variable has type "ToolCalling")
+            self.tools_handler.last_used_tool = {}
 
         task_prompt = task.prompt()
 
@@ -224,13 +229,15 @@ class Agent(BaseModel):
                 task_prompt += self.i18n.slice("memory").format(memory=memory)
 
         tools = tools or self.tools
-        parsed_tools = self._parse_tools(tools)  # type: ignore # Argument 1 to "_parse_tools" of "Agent" has incompatible type "list[Any] | None"; expected "list[Any]"
+        # type: ignore # Argument 1 to "_parse_tools" of "Agent" has incompatible type "list[Any] | None"; expected "list[Any]"
+        parsed_tools = self._parse_tools(tools)
 
         self.create_agent_executor(tools=tools)
         self.agent_executor.tools = parsed_tools
         self.agent_executor.task = task
 
-        self.agent_executor.tools_description = render_text_description(parsed_tools)
+        self.agent_executor.tools_description = render_text_description(
+            parsed_tools)
         self.agent_executor.tools_names = self.__tools_names(parsed_tools)
 
         result = self.agent_executor.invoke(
@@ -328,7 +335,8 @@ class Agent(BaseModel):
             )
 
         bind = self.llm.bind(stop=stop_words)
-        inner_agent = agent_args | execution_prompt | bind | CrewAgentParser(agent=self)
+        inner_agent = agent_args | execution_prompt | bind | CrewAgentParser(
+            agent=self)
         self.agent_executor = CrewAgentExecutor(
             agent=RunnableAgent(runnable=inner_agent), **executor_args
         )
@@ -363,8 +371,31 @@ class Agent(BaseModel):
             thoughts += action.log
             thoughts += f"\n{observation_prefix}{observation}\n{llm_prefix}"
         return thoughts
+    
+    def copy(self):
+        """Create a deep copy of the Agent."""
+        exclude = {
+            "id",
+            "_logger",
+            "_rpm_controller",
+            "_request_within_rpm_limit",
+            "_token_process",      
+            "agent_executor",  
+            "tools",
+            "tools_handler",
+            "cache_handler",
+        }
 
-    def _parse_tools(self, tools: List[Any]) -> List[LangChainTool]:  # type: ignore # Function "langchain_core.tools.tool" is not valid as a type
+        copied_data = self.model_dump(exclude=exclude)
+        copied_data = {k: v for k, v in copied_data.items() if v is not None}
+
+        copied_agent = Agent(**copied_data)
+        copied_agent.tools = deepcopy(self.tools)
+
+        return copied_agent
+
+    # type: ignore # Function "langchain_core.tools.tool" is not valid as a type
+    def _parse_tools(self, tools: List[Any]) -> List[LangChainTool]:
         """Parse tools to be used for the task."""
         # tentatively try to import from crewai_tools import BaseTool as CrewAITool
         tools_list = []

src/crewai/agents/executor.py

@@ -58,7 +58,7 @@ class CrewAgentExecutor(AgentExecutor):
         if (
             self.crew
             and self.crew.memory
-            and "Action: Delegate work to co-worker" not in output.log
+            and "Action: Delegate work to coworker" not in output.log
         ):
             memory = ShortTermMemoryItem(
                 data=output.log,

src/crewai/crew.py

@@ -1,3 +1,4 @@
+import asyncio
 import json
 import uuid
 from typing import Any, Dict, List, Optional, Union
@@ -47,10 +48,10 @@ class Crew(BaseModel):
         max_rpm: Maximum number of requests per minute for the crew execution to be respected.
         prompt_file: Path to the prompt json file to be used for the crew.
         id: A unique identifier for the crew instance.
-        full_output: Whether the crew should return the full output with all tasks outputs or just the final output.
+        full_output: Whether the crew should return the full output with all tasks outputs and token usage metrics or just the final output.
         task_callback: Callback to be executed after each task for every agents execution.
         step_callback: Callback to be executed after each step for every agents execution.
-        share_crew: Whether you want to share the complete crew infromation and execution with crewAI to make the library better, and allow us to train models.
+        share_crew: Whether you want to share the complete crew information and execution with crewAI to make the library better, and allow us to train models.
     """
 
     __hash__ = object.__hash__  # type: ignore
@@ -83,7 +84,7 @@ class Crew(BaseModel):
     )
     full_output: Optional[bool] = Field(
         default=False,
-        description="Whether the crew should return the full output with all tasks outputs or just the final output.",
+        description="Whether the crew should return the full output with all tasks outputs and token usage metrics or just the final output.",
     )
     manager_llm: Optional[Any] = Field(
         description="Language model that will run the agent.", default=None
@@ -241,10 +242,14 @@ class Crew(BaseModel):
         del task_config["agent"]
         return Task(**task_config, agent=task_agent)
 
-    def kickoff(self, inputs: Optional[Dict[str, Any]] = {}) -> str:
+    def kickoff(
+        self,
+        inputs: Optional[Dict[str, Any]] = {},
+    ) -> Union[str, Dict[str, Any]]:
         """Starts the crew to work on its assigned tasks."""
         self._execution_span = self._telemetry.crew_execution_span(self)
-        self._interpolate_inputs(inputs)  # type: ignore # Argument 1 to "_interpolate_inputs" of "Crew" has incompatible type "dict[str, Any] | None"; expected "dict[str, Any]"
+        # type: ignore # Argument 1 to "_interpolate_inputs" of "Crew" has incompatible type "dict[str, Any] | None"; expected "dict[str, Any]"
+        self._interpolate_inputs(inputs)
         self._set_tasks_callbacks()
 
         i18n = I18N(prompt_file=self.prompt_file)
@@ -265,9 +270,10 @@ class Crew(BaseModel):
         if self.process == Process.sequential:
             result = self._run_sequential_process()
         elif self.process == Process.hierarchical:
-            result, manager_metrics = self._run_hierarchical_process()  # type: ignore # Unpacking a string is disallowed
-            metrics.append(manager_metrics)  # type: ignore # Cannot determine type of "manager_metrics"
-
+            # type: ignore # Unpacking a string is disallowed
+            result, manager_metrics = self._run_hierarchical_process()
+            # type: ignore # Cannot determine type of "manager_metrics"
+            metrics.append(manager_metrics)
         else:
             raise NotImplementedError(
                 f"The process '{self.process}' is not implemented yet."
@@ -282,11 +288,51 @@ class Crew(BaseModel):
 
         return result
 
+    def kickoff_for_each(self, inputs: List[Dict[str, Any]]) -> List:
+        """Executes the Crew's workflow for each input in the list and aggregates results."""
+        results = []
+
+        for input_data in inputs:
+            crew = self.copy()
+
+            for task in crew.tasks:
+                task.interpolate_inputs(input_data)
+            for agent in crew.agents:
+                agent.interpolate_inputs(input_data)
+
+            output = crew.kickoff()
+            results.append(output)
+
+        return results
+
+    async def kickoff_async(
+        self, inputs: Optional[Dict[str, Any]] = {}
+    ) -> Union[str, Dict]:
+        """Asynchronous kickoff method to start the crew execution."""
+        return await asyncio.to_thread(self.kickoff, inputs)
+
+    async def kickoff_for_each_async(self, inputs: List[Dict]) -> List[Any]:
+        async def run_crew(input_data):
+            crew = self.copy()
+
+            for task in crew.tasks:
+                task.interpolate_inputs(input_data)
+            for agent in crew.agents:
+                agent.interpolate_inputs(input_data)
+
+            return await crew.kickoff_async()
+
+        tasks = [asyncio.create_task(run_crew(input_data)) for input_data in inputs]
+
+        results = await asyncio.gather(*tasks)
+
+        return results
+
     def train(self, n_iterations: int) -> None:
         # TODO: Implement training
         pass
 
-    def _run_sequential_process(self) -> str:
+    def _run_sequential_process(self) -> Union[str, Dict[str, Any]]:
         """Executes tasks sequentially and returns the final output."""
         task_output = ""
         for task in self.tasks:
@@ -309,6 +355,7 @@ class Crew(BaseModel):
                 )
 
             output = task.execute(context=task_output)
+
             if not task.async_execution:
                 task_output = output
 
@@ -319,9 +366,12 @@ class Crew(BaseModel):
                 self._file_handler.log(agent=role, task=task_output, status="completed")
 
         self._finish_execution(task_output)
-        return self._format_output(task_output)
+        # type: ignore # Item "None" of "Agent | None" has no attribute "_token_process"
+        token_usage = task.agent._token_process.get_summary()
+        # type: ignore # Incompatible return value type (got "tuple[str, Any]", expected "str")
+        return self._format_output(task_output, token_usage)
 
-    def _run_hierarchical_process(self) -> str:
+    def _run_hierarchical_process(self) -> Union[str, Dict[str, Any]]:
         """Creates and assigns a manager agent to make sure the crew completes the tasks."""
 
         i18n = I18N(prompt_file=self.prompt_file)
@@ -363,7 +413,41 @@ class Crew(BaseModel):
                 )
 
         self._finish_execution(task_output)
-        return self._format_output(task_output), manager._token_process.get_summary()  # type: ignore # Incompatible return value type (got "tuple[str, Any]", expected "str")
+        # type: ignore # Incompatible return value type (got "tuple[str, Any]", expected "str")
+        manager_token_usage = manager._token_process.get_summary()
+        return self._format_output(
+            task_output, manager_token_usage
+        ), manager_token_usage
+
+    def copy(self):
+        """Create a deep copy of the Crew."""
+
+        exclude = {
+            "id",
+            "_rpm_controller",
+            "_logger",
+            "_execution_span",
+            "_file_handler",
+            "_cache_handler",
+            "_short_term_memory",
+            "_long_term_memory",
+            "_entity_memory",
+            "agents",
+            "tasks",
+        }
+
+        cloned_agents = [agent.copy() for agent in self.agents]
+        cloned_tasks = [task.copy() for task in self.tasks]
+
+        copied_data = self.model_dump(exclude=exclude)
+        copied_data = {k: v for k, v in copied_data.items() if v is not None}
+
+        copied_data.pop("agents", None)
+        copied_data.pop("tasks", None)
+
+        copied_crew = Crew(**copied_data, agents=cloned_agents, tasks=cloned_tasks)
+
+        return copied_crew
 
     def _set_tasks_callbacks(self) -> None:
         """Sets callback for every task suing task_callback"""
@@ -373,15 +457,28 @@ class Crew(BaseModel):
 
     def _interpolate_inputs(self, inputs: Dict[str, Any]) -> None:
         """Interpolates the inputs in the tasks and agents."""
-        [task.interpolate_inputs(inputs) for task in self.tasks]  # type: ignore # "interpolate_inputs" of "Task" does not return a value (it only ever returns None)
-        [agent.interpolate_inputs(inputs) for agent in self.agents]  # type: ignore # "interpolate_inputs" of "Agent" does not return a value (it only ever returns None)
+        [
+            task.interpolate_inputs(
+                # type: ignore # "interpolate_inputs" of "Task" does not return a value (it only ever returns None)
+                inputs
+            )
+            for task in self.tasks
+        ]
+        # type: ignore # "interpolate_inputs" of "Agent" does not return a value (it only ever returns None)
+        [agent.interpolate_inputs(inputs) for agent in self.agents]
 
-    def _format_output(self, output: str) -> str:
-        """Formats the output of the crew execution."""
+    def _format_output(
+        self, output: str, token_usage: Optional[Dict[str, Any]]
+    ) -> Union[str, Dict[str, Any]]:
+        """
+        Formats the output of the crew execution.
+        If full_output is True, then returned data type will be a dictionary else returned outputs are string
+        """
         if self.full_output:
             return {  # type: ignore # Incompatible return value type (got "dict[str, Sequence[str | TaskOutput | None]]", expected "str")
                 "final_output": output,
                 "tasks_outputs": [task.output for task in self.tasks if task],
+                "usage_metrics": token_usage,
             }
         else:
             return output

src/crewai/project/annotations.py

@@ -1,6 +1,3 @@
-tasks_order = []
-
-
 def memoize(func):
     cache = {}
 
@@ -10,14 +7,21 @@ def memoize(func):
             cache[key] = func(*args, **kwargs)
         return cache[key]
 
+    memoized_func.__dict__.update(func.__dict__)
     return memoized_func
 
 
 def task(func):
+    if not hasattr(task, "registration_order"):
+        task.registration_order = []
+
     func.is_task = True
-    tasks_order.append(func.__name__)
-    func = memoize(func)
-    return func
+    wrapped_func = memoize(func)
+
+    # Append the function name to the registration order list
+    task.registration_order.append(func.__name__)
+
+    return wrapped_func
 
 
 def agent(func):
@@ -32,26 +36,43 @@ def crew(func):
         instantiated_agents = []
 
         agent_roles = set()
-        # Iterate over tasks_order to maintain the defined order
-        for task_name in tasks_order:
-            possible_task = getattr(self, task_name)
-            if callable(possible_task):
-                task_instance = possible_task()
-                instantiated_tasks.append(task_instance)
-                if hasattr(task_instance, "agent"):
-                    agent_instance = task_instance.agent
-                    if agent_instance.role not in agent_roles:
-                        instantiated_agents.append(agent_instance)
-                        agent_roles.add(agent_instance.role)
+        all_functions = {
+            name: getattr(self, name)
+            for name in dir(self)
+            if callable(getattr(self, name))
+        }
+        tasks = {
+            name: func
+            for name, func in all_functions.items()
+            if hasattr(func, "is_task")
+        }
+        agents = {
+            name: func
+            for name, func in all_functions.items()
+            if hasattr(func, "is_agent")
+        }
+
+        # Sort tasks by their registration order
+        sorted_task_names = sorted(
+            tasks, key=lambda name: task.registration_order.index(name)
+        )
+
+        # Instantiate tasks in the order they were defined
+        for task_name in sorted_task_names:
+            task_instance = tasks[task_name]()
+            instantiated_tasks.append(task_instance)
+            if hasattr(task_instance, "agent"):
+                agent_instance = task_instance.agent
+                if agent_instance.role not in agent_roles:
+                    instantiated_agents.append(agent_instance)
+                    agent_roles.add(agent_instance.role)
 
         # Instantiate any additional agents not already included by tasks
-        for attr_name in dir(self):
-            possible_agent = getattr(self, attr_name)
-            if callable(possible_agent) and hasattr(possible_agent, "is_agent"):
-                temp_agent_instance = possible_agent()
-                if temp_agent_instance.role not in agent_roles:
-                    instantiated_agents.append(temp_agent_instance)
-                    agent_roles.add(temp_agent_instance.role)
+        for agent_name in agents:
+            temp_agent_instance = agents[agent_name]()
+            if temp_agent_instance.role not in agent_roles:
+                instantiated_agents.append(temp_agent_instance)
+                agent_roles.add(temp_agent_instance.role)
 
         self.agents = instantiated_agents
         self.tasks = instantiated_tasks

src/crewai/task.py

@@ -1,3 +1,4 @@
+from copy import deepcopy
 import os
 import re
 import threading
@@ -163,13 +164,16 @@ class Task(BaseModel):
             )
 
         if self.context:
-            context = []  # type: ignore # Incompatible types in assignment (expression has type "list[Never]", variable has type "str | None")
+            # type: ignore # Incompatible types in assignment (expression has type "list[Never]", variable has type "str | None")
+            context = []
             for task in self.context:
                 if task.async_execution:
                     task.thread.join()  # type: ignore # Item "None" of "Thread | None" has no attribute "join"
                 if task and task.output:
-                    context.append(task.output.raw_output)  # type: ignore # Item "str" of "str | None" has no attribute "append"
-            context = "\n".join(context)  # type: ignore # Argument 1 to "join" of "str" has incompatible type "str | None"; expected "Iterable[str]"
+                    # type: ignore # Item "str" of "str | None" has no attribute "append"
+                    context.append(task.output.raw_output)
+            # type: ignore # Argument 1 to "join" of "str" has incompatible type "str | None"; expected "Iterable[str]"
+            context = "\n".join(context)
 
         self.prompt_context = context
         tools = tools or self.tools
@@ -201,6 +205,7 @@ class Task(BaseModel):
             description=self.description,
             exported_output=exported_output,
             raw_output=result,
+            agent=agent.role,
         )
 
         if self.callback:
@@ -241,6 +246,32 @@ class Task(BaseModel):
         """Increment the delegations counter."""
         self.delegations += 1
 
+    def copy(self):
+        """Create a deep copy of the Task."""
+        exclude = {
+            "id",
+            "agent",
+            "context",
+            "tools",
+        }
+
+        copied_data = self.model_dump(exclude=exclude)
+        copied_data = {k: v for k, v in copied_data.items() if v is not None}
+
+        cloned_context = (
+            [task.copy() for task in self.context] if self.context else None
+        )
+        cloned_agent = self.agent.copy() if self.agent else None
+        cloned_tools = deepcopy(self.tools) if self.tools else None
+
+        copied_task = Task(
+            **copied_data,
+            context=cloned_context,
+            agent=cloned_agent,
+            tools=cloned_tools,
+        )
+        return copied_task
+
     def _export_output(self, result: str) -> Any:
         exported_result = result
         instructions = "I'm gonna convert this raw text into valid JSON."
@@ -250,26 +281,32 @@ class Task(BaseModel):
 
             # try to convert task_output directly to pydantic/json
             try:
-                exported_result = model.model_validate_json(result)  # type: ignore # Item "None" of "type[BaseModel] | None" has no attribute "model_validate_json"
+                # type: ignore # Item "None" of "type[BaseModel] | None" has no attribute "model_validate_json"
+                exported_result = model.model_validate_json(result)
                 if self.output_json:
-                    return exported_result.model_dump()  # type: ignore # "str" has no attribute "model_dump"
+                    # type: ignore # "str" has no attribute "model_dump"
+                    return exported_result.model_dump()
                 return exported_result
             except Exception:
                 # sometimes the response contains valid JSON in the middle of text
                 match = re.search(r"({.*})", result, re.DOTALL)
                 if match:
                     try:
-                        exported_result = model.model_validate_json(match.group(0))  # type: ignore # Item "None" of "type[BaseModel] | None" has no attribute "model_validate_json"
+                        # type: ignore # Item "None" of "type[BaseModel] | None" has no attribute "model_validate_json"
+                        exported_result = model.model_validate_json(match.group(0))
                         if self.output_json:
-                            return exported_result.model_dump()  # type: ignore # "str" has no attribute "model_dump"
+                            # type: ignore # "str" has no attribute "model_dump"
+                            return exported_result.model_dump()
                         return exported_result
                     except Exception:
                         pass
 
-            llm = self.agent.function_calling_llm or self.agent.llm  # type: ignore # Item "None" of "Agent | None" has no attribute "function_calling_llm"
+            # type: ignore # Item "None" of "Agent | None" has no attribute "function_calling_llm"
+            llm = self.agent.function_calling_llm or self.agent.llm
 
             if not self._is_gpt(llm):
-                model_schema = PydanticSchemaParser(model=model).get_schema()  # type: ignore # Argument "model" to "PydanticSchemaParser" has incompatible type "type[BaseModel] | None"; expected "type[BaseModel]"
+                # type: ignore # Argument "model" to "PydanticSchemaParser" has incompatible type "type[BaseModel] | None"; expected "type[BaseModel]"
+                model_schema = PydanticSchemaParser(model=model).get_schema()
                 instructions = f"{instructions}\n\nThe json should have the following structure, with the following keys:\n{model_schema}"
 
             converter = Converter(
@@ -290,7 +327,8 @@ class Task(BaseModel):
 
         if self.output_file:
             content = (
-                exported_result if not self.output_pydantic else exported_result.json()  # type: ignore # "str" has no attribute "json"
+                # type: ignore # "str" has no attribute "json"
+                exported_result if not self.output_pydantic else exported_result.json()
             )
             self._save_file(content)
 
@@ -300,12 +338,14 @@ class Task(BaseModel):
         return isinstance(llm, ChatOpenAI) and llm.openai_api_base is None
 
     def _save_file(self, result: Any) -> None:
-        directory = os.path.dirname(self.output_file)  # type: ignore # Value of type variable "AnyOrLiteralStr" of "dirname" cannot be "str | None"
+        # type: ignore # Value of type variable "AnyOrLiteralStr" of "dirname" cannot be "str | None"
+        directory = os.path.dirname(self.output_file)
 
         if directory and not os.path.exists(directory):
             os.makedirs(directory)
 
-        with open(self.output_file, "w", encoding="utf-8") as file:  # type: ignore # Argument 1 to "open" has incompatible type "str | None"; expected "int | str | bytes | PathLike[str] | PathLike[bytes]"
+        # type: ignore # Argument 1 to "open" has incompatible type "str | None"; expected "int | str | bytes | PathLike[str] | PathLike[bytes]"
+        with open(self.output_file, "w", encoding="utf-8") as file:
             file.write(result)
         return None
 

src/crewai/tasks/task_output.py

@@ -11,6 +11,7 @@ class TaskOutput(BaseModel):
     exported_output: Union[str, BaseModel] = Field(
         description="Output of the task", default=None
     )
+    agent: str = Field(description="Agent that executed the task")
     raw_output: str = Field(description="Result of the task")
 
     @model_validator(mode="after")

src/crewai/tools/agent_tools.py

@@ -18,14 +18,14 @@ class AgentTools(BaseModel):
         tools = [
             StructuredTool.from_function(
                 func=self.delegate_work,
-                name="Delegate work to co-worker",
+                name="Delegate work to coworker",
                 description=self.i18n.tools("delegate_work").format(
                     coworkers=f"[{', '.join([f'{agent.role}' for agent in self.agents])}]"
                 ),
             ),
             StructuredTool.from_function(
                 func=self.ask_question,
-                name="Ask question to co-worker",
+                name="Ask question to coworker",
                 description=self.i18n.tools("ask_question").format(
                     coworkers=f"[{', '.join([f'{agent.role}' for agent in self.agents])}]"
                 ),
@@ -34,34 +34,54 @@ class AgentTools(BaseModel):
         return tools
 
     def delegate_work(
-        self, task: str, context: str, coworker: Union[str, None] = None, **kwargs
+        self,
+        task: str,
+        context: Union[str, None] = None,
+        coworker: Union[str, None] = None,
+        **kwargs,
     ):
-        """Useful to delegate a specific task to a co-worker passing all necessary context and names."""
-        coworker = coworker or kwargs.get("co_worker") or kwargs.get("co-worker")
-        if coworker is not None:
+        """Useful to delegate a specific task to a coworker passing all necessary context and names."""
+        coworker = coworker or kwargs.get("co_worker") or kwargs.get("coworker")
+        if coworker:
             is_list = coworker.startswith("[") and coworker.endswith("]")
             if is_list:
                 coworker = coworker[1:-1].split(",")[0]
         return self._execute(coworker, task, context)
 
     def ask_question(
-        self, question: str, context: str, coworker: Union[str, None] = None, **kwargs
+        self,
+        question: str,
+        context: Union[str, None] = None,
+        coworker: Union[str, None] = None,
+        **kwargs,
     ):
-        """Useful to ask a question, opinion or take from a co-worker passing all necessary context and names."""
-        coworker = coworker or kwargs.get("co_worker") or kwargs.get("co-worker")
-        if coworker is not None:
+        """Useful to ask a question, opinion or take from a coworker passing all necessary context and names."""
+        coworker = coworker or kwargs.get("co_worker") or kwargs.get("coworker")
+        if coworker:
             is_list = coworker.startswith("[") and coworker.endswith("]")
             if is_list:
                 coworker = coworker[1:-1].split(",")[0]
         return self._execute(coworker, question, context)
 
-    def _execute(self, agent, task, context):
+    def _execute(self, agent: Union[str, None], task: str, context: Union[str, None]):
         """Execute the command."""
         try:
+            if agent is None:
+                agent = ""
+
+            # It is important to remove the quotes from the agent name.
+            # The reason we have to do this is because less-powerful LLM's
+            # have difficulty producing valid JSON.
+            # As a result, we end up with invalid JSON that is truncated like this:
+            # {"task": "....", "coworker": "....
+            # when it should look like this:
+            # {"task": "....", "coworker": "...."}
+            agent_name = agent.casefold().replace('"', "")
+
             agent = [
                 available_agent
                 for available_agent in self.agents
-                if available_agent.role.casefold().strip() == agent.casefold().strip()
+                if available_agent.role.casefold() == agent_name
             ]
         except Exception as _:
             return self.i18n.errors("agent_tool_unexsiting_coworker").format(
@@ -81,6 +101,6 @@ class AgentTools(BaseModel):
         task = Task(
             description=task,
             agent=agent,
-            expected_output="Your best answer to your co-worker asking you this, accounting for the context shared.",
+            expected_output="Your best answer to your coworker asking you this, accounting for the context shared.",
         )
         return agent.execute_task(task, context)

src/crewai/tools/tool_usage.py

@@ -126,8 +126,8 @@ class ToolUsage:
         if not result:
             try:
                 if calling.tool_name in [
-                    "Delegate work to co-worker",
-                    "Ask question to co-worker",
+                    "Delegate work to coworker",
+                    "Ask question to coworker",
                 ]:
                     self.task.increment_delegations()
 

src/crewai/translations/en.json

@@ -9,7 +9,7 @@
     "task": "\nCurrent Task: {input}\n\nBegin! This is VERY important to you, use the tools available and give your best Final Answer, your job depends on it!\n\nThought:",
     "memory": "\n\n# Useful context: \n{memory}",
     "role_playing": "You are {role}. {backstory}\nYour personal goal is: {goal}",
-    "tools": "\nYou ONLY have access to the following tools, and should NEVER make up tools that are not listed here:\n\n{tools}\n\nUse the following format:\n\nThought: you should always think about what to do\nAction: the action to take, only one name of [{tool_names}], just the name, exactly as it's written.\nAction Input: the input to the action, just a simple a python dictionary, enclosed in curly braces, using \" to wrap keys and values.\nObservation: the result of the action\n\nOnce all necessary information is gathered:\n\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question\n",
+    "tools": "\nYou ONLY have access to the following tools, and should NEVER make up tools that are not listed here:\n\n{tools}\n\nUse the following format:\n\nThought: you should always think about what to do\nAction: the action to take, only one name of [{tool_names}], just the name, exactly as it's written.\nAction Input: the input to the action, just a simple python dictionary, enclosed in curly braces, using \" to wrap keys and values.\nObservation: the result of the action\n\nOnce all necessary information is gathered:\n\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question\n",
     "no_tools": "To give my best complete final answer to the task use the exact following format:\n\nThought: I now can give a great answer\nFinal Answer: my best complete final answer to the task.\nYour final answer must be the great and the most complete as possible, it must be outcome described.\n\nI MUST use these formats, my job depends on it!",
     "format": "I MUST either use a tool (use one at time) OR give my best final answer. To Use the following format:\n\nThought: you should always think about what to do\nAction: the action to take, should be one of [{tool_names}]\nAction Input: the input to the action, dictionary enclosed in curly braces\nObservation: the result of the action\n... (this Thought/Action/Action Input/Observation can repeat N times)\nThought: I now can give a great answer\nFinal Answer: my best complete final answer to the task.\nYour final answer must be the great and the most complete as possible, it must be outcome described\n\n ",
     "final_answer_format": "If you don't need to use any more tools, you must give your best complete final answer, make sure it satisfy the expect criteria, use the EXACT format below:\n\nThought: I now can give a great answer\nFinal Answer: my best complete final answer to the task.\n\n",
@@ -21,7 +21,7 @@
   },
   "errors": {
     "force_final_answer": "Tool won't be use because it's time to give your final answer. Don't use tools and just your absolute BEST Final answer.",
-    "agent_tool_unexsiting_coworker": "\nError executing tool. Co-worker mentioned not found, it must to be one of the following options:\n{coworkers}\n",
+    "agent_tool_unexsiting_coworker": "\nError executing tool. coworker mentioned not found, it must be one of the following options:\n{coworkers}\n",
     "task_repeated_usage": "I tried reusing the same input, I must stop using this action input. I'll try something else instead.\n\n",
     "tool_usage_error": "I encountered an error: {error}",
     "tool_arguments_error": "Error: the Action Input is not a valid key, value dictionary.",
@@ -29,7 +29,7 @@
     "tool_usage_exception": "I encountered an error while trying to use the tool. This was the error: {error}.\n Tool {tool} accepts these inputs: {tool_inputs}"
   },
   "tools": {
-    "delegate_work": "Delegate a specific task to one of the following co-workers: {coworkers}\nThe input to this tool should be the co-worker, the task you want them to do, and ALL necessary context to execute the task, they know nothing about the task, so share absolute everything you know, don't reference things but instead explain them.",
-    "ask_question": "Ask a specific question to one of the following co-workers: {coworkers}\nThe input to this tool should be the co-worker, the question you have for them, and ALL necessary context to ask the question properly, they know nothing about the question, so share absolute everything you know, don't reference things but instead explain them."
+    "delegate_work": "Delegate a specific task to one of the following coworkers: {coworkers}\nThe input to this tool should be the coworker, the task you want them to do, and ALL necessary context to execute the task, they know nothing about the task, so share absolute everything you know, don't reference things but instead explain them.",
+    "ask_question": "Ask a specific question to one of the following coworkers: {coworkers}\nThe input to this tool should be the coworker, the question you have for them, and ALL necessary context to ask the question properly, they know nothing about the question, so share absolute everything you know, don't reference things but instead explain them."
   }
 }

src/crewai/utilities/fileHandler.py

@@ -16,5 +16,5 @@ class FileHandler:
     def log(self, **kwargs):
         now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         message = f"{now}: ".join([f"{key}={value}" for key, value in kwargs.items()])
-        with open(self._path, "a") as file:
+        with open(self._path, "a", encoding = 'utf-8') as file:
             file.write(message + "\n")

src/crewai/utilities/logger.py

@@ -1,3 +1,5 @@
+from datetime import datetime
+
 from crewai.utilities.printer import Printer
 
 
@@ -13,4 +15,7 @@ class Logger:
     def log(self, level, message, color="bold_green"):
         level_map = {"debug": 1, "info": 2}
         if self.verbose_level and level_map.get(level, 0) <= self.verbose_level:
-            self._printer.print(f"[{level.upper()}]: {message}", color=color)
+            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            self._printer.print(
+                f"[{timestamp}][{level.upper()}]: {message}", color=color
+            )

tests/agent_test.py

@@ -29,7 +29,7 @@ def test_agent_default_values():
     agent = Agent(role="test role", goal="test goal", backstory="test backstory")
 
     assert isinstance(agent.llm, ChatOpenAI)
-    assert agent.llm.model_name == "gpt-4"
+    assert agent.llm.model_name == "gpt-4o"
     assert agent.llm.temperature == 0.7
     assert agent.llm.verbose is False
     assert agent.allow_delegation is True
@@ -732,7 +732,7 @@ def test_agent_llm_uses_token_calc_handler_with_llm_has_model_name():
 
     assert len(agent1.llm.callbacks) == 1
     assert agent1.llm.callbacks[0].__class__.__name__ == "TokenCalcHandler"
-    assert agent1.llm.callbacks[0].model == "gpt-4"
+    assert agent1.llm.callbacks[0].model == "gpt-4o"
     assert (
         agent1.llm.callbacks[0].token_cost_process.__class__.__name__ == "TokenProcess"
     )

tests/agent_tools/agent_tools_test.py

@@ -55,6 +55,7 @@ def test_ask_question():
         == "As an AI researcher, I don't have personal feelings or emotions like love or hate. However, I recognize the importance of AI Agents in today's technological landscape. They have the potential to greatly enhance our lives and make tasks more efficient. At the same time, it is crucial to consider the ethical implications and societal impacts that come with their use. My role is to provide objective research and analysis on these topics."
     )
 
+
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_ask_question_with_wrong_co_worker_variable():
     result = tools.ask_question(
@@ -68,6 +69,7 @@ def test_ask_question_with_wrong_co_worker_variable():
         == "No, I don't hate AI agents. In fact, I find them quite fascinating. They are powerful tools that can greatly assist in various tasks, including my research. As a technology researcher, AI and AI agents are subjects of interest to me due to their potential in advancing our understanding and capabilities in various fields. My supposed love for them stems from this professional interest and the potential they hold."
     )
 
+
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_delegate_work_withwith_coworker_as_array():
     result = tools.delegate_work(
@@ -105,7 +107,7 @@ def test_delegate_work_to_wrong_agent():
 
     assert (
         result
-        == "\nError executing tool. Co-worker mentioned not found, it must to be one of the following options:\n- researcher\n"
+        == "\nError executing tool. coworker mentioned not found, it must be one of the following options:\n- researcher\n"
     )
 
 
@@ -118,5 +120,5 @@ def test_ask_question_to_wrong_agent():
 
     assert (
         result
-        == "\nError executing tool. Co-worker mentioned not found, it must to be one of the following options:\n- researcher\n"
+        == "\nError executing tool. coworker mentioned not found, it must be one of the following options:\n- researcher\n"
     )

tests/agent_tools/cassettes/test_ask_question_with_coworker_as_array.yaml

@@ -8,7 +8,7 @@ interactions:
       the task.\nYour final answer must be the great and the most complete as possible,
       it must be outcome described.\n\nI MUST use these formats, my job depends on
       it!\nCurrent Task: do you hate AI Agents?\n\nThis is the expect criteria for
-      your final answer: Your best answer to your co-worker asking you this, accounting
+      your final answer: Your best answer to your coworker asking you this, accounting
       for the context shared. \n you MUST return the actual complete content as the
       final answer, not a summary.\n\nThis is the context you''re working with:\nI
       heard you LOVE them\n\nBegin! This is VERY important to you, use the tools available

tests/agent_tools/cassettes/test_ask_question_with_wrong_co_worker_variable.yaml

@@ -200797,7 +200797,7 @@ interactions:
       the task.\nYour final answer must be the great and the most complete as possible,
       it must be outcome described.\n\nI MUST use these formats, my job depends on
       it!\nCurrent Task: do you hate AI Agents?\n\nThis is the expect criteria for
-      your final answer: Your best answer to your co-worker asking you this, accounting
+      your final answer: Your best answer to your coworker asking you this, accounting
       for the context shared. \n you MUST return the actual complete content as the
       final answer, not a summary.\n\nThis is the context you''re working with:\nI
       heard you LOVE them\n\nBegin! This is VERY important to you, use the tools available

tests/agent_tools/cassettes/test_delegate_work_with_wrong_co_worker_variable.yaml

@@ -95,7 +95,7 @@ interactions:
       the task.\nYour final answer must be the great and the most complete as possible,
       it must be outcome described.\n\nI MUST use these formats, my job depends on
       it!\nCurrent Task: share your take on AI Agents\n\nThis is the expect criteria
-      for your final answer: Your best answer to your co-worker asking you this, accounting
+      for your final answer: Your best answer to your coworker asking you this, accounting
       for the context shared. \n you MUST return the actual complete content as the
       final answer, not a summary.\n\nThis is the context you''re working with:\nI
       heard you hate them\n\nBegin! This is VERY important to you, use the tools available

tests/agent_tools/cassettes/test_delegate_work_withwith_coworker_as_array.yaml

@@ -95,7 +95,7 @@ interactions:
       the task.\nYour final answer must be the great and the most complete as possible,
       it must be outcome described.\n\nI MUST use these formats, my job depends on
       it!\nCurrent Task: share your take on AI Agents\n\nThis is the expect criteria
-      for your final answer: Your best answer to your co-worker asking you this, accounting
+      for your final answer: Your best answer to your coworker asking you this, accounting
       for the context shared. \n you MUST return the actual complete content as the
       final answer, not a summary.\n\nThis is the context you''re working with:\nI
       heard you hate them\n\nBegin! This is VERY important to you, use the tools available

tests/cassettes/test_agent_usage_metrics_are_captured_for_hierarchical_process.yaml

@@ -8,20 +8,20 @@ interactions:
       allows you to properly evaluate the work of your team members.\nYour personal
       goal is: Manage the team to complete the task in the best way possible.\nYou
       ONLY have access to the following tools, and should NEVER make up tools that
-      are not listed here:\n\nDelegate work to co-worker: Delegate work to co-worker(coworker:
+      are not listed here:\n\nDelegate work to coworker: Delegate work to coworker(coworker:
       str, task: str, context: str) - Delegate a specific task to one of the following
-      co-workers: [Researcher]\nThe input to this tool should be the coworker, the
+      coworkers: [Researcher]\nThe input to this tool should be the coworker, the
       task you want them to do, and ALL necessary context to execute the task, they
       know nothing about the task, so share absolute everything you know, don''t reference
-      things but instead explain them.\nAsk question to co-worker: Ask question to
-      co-worker(coworker: str, question: str, context: str) - Ask a specific question
-      to one of the following co-workers: [Researcher]\nThe input to this tool should
+      things but instead explain them.\nAsk question to coworker: Ask question to
+      coworker(coworker: str, question: str, context: str) - Ask a specific question
+      to one of the following coworkers: [Researcher]\nThe input to this tool should
       be the coworker, the question you have for them, and ALL necessary context to
       ask the question properly, they know nothing about the question, so share absolute
       everything you know, don''t reference things but instead explain them.\n\nUse
       the following format:\n\nThought: you should always think about what to do\nAction:
-      the action to take, only one name of [Delegate work to co-worker, Ask question
-      to co-worker], just the name, exactly as it''s written.\nAction Input: the input
+      the action to take, only one name of [Delegate work to coworker, Ask question
+      to coworker], just the name, exactly as it''s written.\nAction Input: the input
       to the action, just a simple a python dictionary using \" to wrap keys and values.\nObservation:
       the result of the action\n\nOnce all necessary information is gathered:\n\nThought:
       I now know the final answer\nFinal Answer: the final answer to the original
@@ -1027,20 +1027,20 @@ interactions:
       allows you to properly evaluate the work of your team members.\nYour personal
       goal is: Manage the team to complete the task in the best way possible.\nYou
       ONLY have access to the following tools, and should NEVER make up tools that
-      are not listed here:\n\nDelegate work to co-worker: Delegate work to co-worker(coworker:
+      are not listed here:\n\nDelegate work to coworker: Delegate work to coworker(coworker:
       str, task: str, context: str) - Delegate a specific task to one of the following
-      co-workers: [Researcher]\nThe input to this tool should be the coworker, the
+      coworkers: [Researcher]\nThe input to this tool should be the coworker, the
       task you want them to do, and ALL necessary context to execute the task, they
       know nothing about the task, so share absolute everything you know, don''t reference
-      things but instead explain them.\nAsk question to co-worker: Ask question to
-      co-worker(coworker: str, question: str, context: str) - Ask a specific question
-      to one of the following co-workers: [Researcher]\nThe input to this tool should
+      things but instead explain them.\nAsk question to coworker: Ask question to
+      coworker(coworker: str, question: str, context: str) - Ask a specific question
+      to one of the following coworkers: [Researcher]\nThe input to this tool should
       be the coworker, the question you have for them, and ALL necessary context to
       ask the question properly, they know nothing about the question, so share absolute
       everything you know, don''t reference things but instead explain them.\n\nUse
       the following format:\n\nThought: you should always think about what to do\nAction:
-      the action to take, only one name of [Delegate work to co-worker, Ask question
-      to co-worker], just the name, exactly as it''s written.\nAction Input: the input
+      the action to take, only one name of [Delegate work to coworker, Ask question
+      to coworker], just the name, exactly as it''s written.\nAction Input: the input
       to the action, just a simple a python dictionary using \" to wrap keys and values.\nObservation:
       the result of the action\n\nOnce all necessary information is gathered:\n\nThought:
       I now know the final answer\nFinal Answer: the final answer to the original
@@ -1051,7 +1051,7 @@ interactions:
       job depends on it!\n\nThought: \nI need to delegate the task of saying \"hi\"
       to the researcher. I will provide them with the context that this is a simple
       greeting task and they should respond with \"Howdy!\".\n\nAction: \nDelegate
-      work to co-worker\n\nAction Input: \n{\n  \"coworker\": \"Researcher\",\n  \"task\":
+      work to coworker\n\nAction Input: \n{\n  \"coworker\": \"Researcher\",\n  \"task\":
       \"Say hi\",\n  \"context\": \"This is a simple task where you need to greet
       by saying ''Howdy!''. This is a common greeting in certain parts of the world,
       particularly in the southern United States. It''s a friendly, informal way to

tests/cassettes/test_agent_use_specific_tasks_output_as_context.yaml

@@ -3,19 +3,19 @@ interactions:
     body: '{"messages": [{"role": "user", "content": "You are test role. test backstory\nYour
       personal goal is: test goal\n\nYou ONLY have access to the following tools,
       and should NEVER make up tools that are not listed here:\n\nDelegate work to
-      co-worker: Delegate work to co-worker(coworker: str, task: str, context: str)
-      - Delegate a specific task to one of the following co-workers: [''test role2'']\nThe
+      coworker: Delegate work to coworker(coworker: str, task: str, context: str)
+      - Delegate a specific task to one of the following coworkers: [''test role2'']\nThe
       input to this tool should be the coworker, the task you want them to do, and
       ALL necessary context to execute the task, they know nothing about the task,
       so share absolute everything you know, don''t reference things but instead explain
-      them.\nAsk question to co-worker: Ask question to co-worker(coworker: str, question:
-      str, context: str) - Ask a specific question to one of the following co-workers:
+      them.\nAsk question to coworker: Ask question to coworker(coworker: str, question:
+      str, context: str) - Ask a specific question to one of the following coworkers:
       [''test role2'']\nThe input to this tool should be the coworker, the question
       you have for them, and ALL necessary context to ask the question properly, they
       know nothing about the question, so share absolute everything you know, don''t
       reference things but instead explain them.\n\nUse the following format:\n\nThought:
       you should always think about what to do\nAction: the action to take, only one
-      name of [Delegate work to co-worker, Ask question to co-worker], just the name,
+      name of [Delegate work to coworker, Ask question to coworker], just the name,
       exactly as it''s written.\nAction Input: the input to the action, just a simple
       a python dictionary using \" to wrap keys and values.\nObservation: the result
       of the action\n\nOnce all necessary information is gathered:\n\nThought: I now
@@ -323,19 +323,19 @@ interactions:
     body: '{"messages": [{"role": "user", "content": "You are test role. test backstory\nYour
       personal goal is: test goal\n\nYou ONLY have access to the following tools,
       and should NEVER make up tools that are not listed here:\n\nDelegate work to
-      co-worker: Delegate work to co-worker(coworker: str, task: str, context: str)
-      - Delegate a specific task to one of the following co-workers: [''test role2'']\nThe
+      coworker: Delegate work to coworker(coworker: str, task: str, context: str)
+      - Delegate a specific task to one of the following coworkers: [''test role2'']\nThe
       input to this tool should be the coworker, the task you want them to do, and
       ALL necessary context to execute the task, they know nothing about the task,
       so share absolute everything you know, don''t reference things but instead explain
-      them.\nAsk question to co-worker: Ask question to co-worker(coworker: str, question:
-      str, context: str) - Ask a specific question to one of the following co-workers:
+      them.\nAsk question to coworker: Ask question to coworker(coworker: str, question:
+      str, context: str) - Ask a specific question to one of the following coworkers:
       [''test role2'']\nThe input to this tool should be the coworker, the question
       you have for them, and ALL necessary context to ask the question properly, they
       know nothing about the question, so share absolute everything you know, don''t
       reference things but instead explain them.\n\nUse the following format:\n\nThought:
       you should always think about what to do\nAction: the action to take, only one
-      name of [Delegate work to co-worker, Ask question to co-worker], just the name,
+      name of [Delegate work to coworker, Ask question to coworker], just the name,
       exactly as it''s written.\nAction Input: the input to the action, just a simple
       a python dictionary using \" to wrap keys and values.\nObservation: the result
       of the action\n\nOnce all necessary information is gathered:\n\nThought: I now
@@ -345,23 +345,23 @@ interactions:
       as the final answer, not a summary.\n\nBegin! This is VERY important to you,
       use the tools available and give your best Final Answer, your job depends on
       it!\n\nThought: \nAs this task is very straightforward and doesn''t require
-      any input or help from my co-worker, I should go ahead and complete it myself.\n\nAction:
+      any input or help from my coworker, I should go ahead and complete it myself.\n\nAction:
       None\n\nAction Input: None\n\nObservation: I encountered an error: Action ''None''
-      don''t exist, these are the only available Actions: Delegate work to co-worker:
-      Delegate work to co-worker(coworker: str, task: str, context: str) - Delegate
-      a specific task to one of the following co-workers: [''test role2'']\nThe input
+      don''t exist, these are the only available Actions: Delegate work to coworker:
+      Delegate work to coworker(coworker: str, task: str, context: str) - Delegate
+      a specific task to one of the following coworkers: [''test role2'']\nThe input
       to this tool should be the coworker, the task you want them to do, and ALL necessary
       context to execute the task, they know nothing about the task, so share absolute
       everything you know, don''t reference things but instead explain them.\nAsk
-      question to co-worker: Ask question to co-worker(coworker: str, question: str,
-      context: str) - Ask a specific question to one of the following co-workers:
+      question to coworker: Ask question to coworker(coworker: str, question: str,
+      context: str) - Ask a specific question to one of the following coworkers:
       [''test role2'']\nThe input to this tool should be the coworker, the question
       you have for them, and ALL necessary context to ask the question properly, they
       know nothing about the question, so share absolute everything you know, don''t
       reference things but instead explain them.\nMoving on then. I MUST either use
       a tool (use one at time) OR give my best final answer. To Use the following
       format:\n\nThought: you should always think about what to do\nAction: the action
-      to take, should be one of [Delegate work to co-worker, Ask question to co-worker]\nAction
+      to take, should be one of [Delegate work to coworker, Ask question to coworker]\nAction
       Input: the input to the action, dictionary\nObservation: the result of the action\n...
       (this Thought/Action/Action Input/Observation can repeat N times)\nThought:
       I now can give a great answer\nFinal Answer: my best complete final answer to
@@ -1024,19 +1024,19 @@ interactions:
     body: '{"messages": [{"role": "user", "content": "You are test role. test backstory\nYour
       personal goal is: test goal\n\nYou ONLY have access to the following tools,
       and should NEVER make up tools that are not listed here:\n\nDelegate work to
-      co-worker: Delegate work to co-worker(coworker: str, task: str, context: str)
-      - Delegate a specific task to one of the following co-workers: [''test role2'']\nThe
+      coworker: Delegate work to coworker(coworker: str, task: str, context: str)
+      - Delegate a specific task to one of the following coworkers: [''test role2'']\nThe
       input to this tool should be the coworker, the task you want them to do, and
       ALL necessary context to execute the task, they know nothing about the task,
       so share absolute everything you know, don''t reference things but instead explain
-      them.\nAsk question to co-worker: Ask question to co-worker(coworker: str, question:
-      str, context: str) - Ask a specific question to one of the following co-workers:
+      them.\nAsk question to coworker: Ask question to coworker(coworker: str, question:
+      str, context: str) - Ask a specific question to one of the following coworkers:
       [''test role2'']\nThe input to this tool should be the coworker, the question
       you have for them, and ALL necessary context to ask the question properly, they
       know nothing about the question, so share absolute everything you know, don''t
       reference things but instead explain them.\n\nUse the following format:\n\nThought:
       you should always think about what to do\nAction: the action to take, only one
-      name of [Delegate work to co-worker, Ask question to co-worker], just the name,
+      name of [Delegate work to coworker, Ask question to coworker], just the name,
       exactly as it''s written.\nAction Input: the input to the action, just a simple
       a python dictionary using \" to wrap keys and values.\nObservation: the result
       of the action\n\nOnce all necessary information is gathered:\n\nThought: I now
@@ -1046,31 +1046,31 @@ interactions:
       as the final answer, not a summary.\n\nBegin! This is VERY important to you,
       use the tools available and give your best Final Answer, your job depends on
       it!\n\nThought: \nAs this task is very straightforward and doesn''t require
-      any input or help from my co-worker, I should go ahead and complete it myself.\n\nAction:
+      any input or help from my coworker, I should go ahead and complete it myself.\n\nAction:
       None\n\nAction Input: None\n\nObservation: I encountered an error: Action ''None''
-      don''t exist, these are the only available Actions: Delegate work to co-worker:
-      Delegate work to co-worker(coworker: str, task: str, context: str) - Delegate
-      a specific task to one of the following co-workers: [''test role2'']\nThe input
+      don''t exist, these are the only available Actions: Delegate work to coworker:
+      Delegate work to coworker(coworker: str, task: str, context: str) - Delegate
+      a specific task to one of the following coworkers: [''test role2'']\nThe input
       to this tool should be the coworker, the task you want them to do, and ALL necessary
       context to execute the task, they know nothing about the task, so share absolute
       everything you know, don''t reference things but instead explain them.\nAsk
-      question to co-worker: Ask question to co-worker(coworker: str, question: str,
-      context: str) - Ask a specific question to one of the following co-workers:
+      question to coworker: Ask question to coworker(coworker: str, question: str,
+      context: str) - Ask a specific question to one of the following coworkers:
       [''test role2'']\nThe input to this tool should be the coworker, the question
       you have for them, and ALL necessary context to ask the question properly, they
       know nothing about the question, so share absolute everything you know, don''t
       reference things but instead explain them.\nMoving on then. I MUST either use
       a tool (use one at time) OR give my best final answer. To Use the following
       format:\n\nThought: you should always think about what to do\nAction: the action
-      to take, should be one of [Delegate work to co-worker, Ask question to co-worker]\nAction
+      to take, should be one of [Delegate work to coworker, Ask question to coworker]\nAction
       Input: the input to the action, dictionary\nObservation: the result of the action\n...
       (this Thought/Action/Action Input/Observation can repeat N times)\nThought:
       I now can give a great answer\nFinal Answer: my best complete final answer to
       the task.\nYour final answer must be the great and the most complete as possible,
       it must be outcome described\n\n \nThought: \nAlthough I initially thought that
       I could just say hi myself, this system seems to require me to use one of the
-      tools available. Therefore, I''ll delegate this task to my co-worker.\n\nAction:
-      Delegate work to co-worker\n\nAction Input: {\"coworker\": \"test role2\", \"task\":
+      tools available. Therefore, I''ll delegate this task to my coworker.\n\nAction:
+      Delegate work to coworker\n\nAction Input: {\"coworker\": \"test role2\", \"task\":
       \"Just say hi\", \"context\": \"We need to greet someone. Just say ''hi'' to
       them.\"}\n\nObservation: Hi there!\n"}], "model": "gpt-4", "n": 1, "stop": ["\nObservation"],
       "stream": true, "temperature": 0.7}'
@@ -1233,19 +1233,19 @@ interactions:
     body: '{"messages": [{"role": "user", "content": "You are test role. test backstory\nYour
       personal goal is: test goal\n\nYou ONLY have access to the following tools,
       and should NEVER make up tools that are not listed here:\n\nDelegate work to
-      co-worker: Delegate work to co-worker(coworker: str, task: str, context: str)
-      - Delegate a specific task to one of the following co-workers: [''test role2'']\nThe
+      coworker: Delegate work to coworker(coworker: str, task: str, context: str)
+      - Delegate a specific task to one of the following coworkers: [''test role2'']\nThe
       input to this tool should be the coworker, the task you want them to do, and
       ALL necessary context to execute the task, they know nothing about the task,
       so share absolute everything you know, don''t reference things but instead explain
-      them.\nAsk question to co-worker: Ask question to co-worker(coworker: str, question:
-      str, context: str) - Ask a specific question to one of the following co-workers:
+      them.\nAsk question to coworker: Ask question to coworker(coworker: str, question:
+      str, context: str) - Ask a specific question to one of the following coworkers:
       [''test role2'']\nThe input to this tool should be the coworker, the question
       you have for them, and ALL necessary context to ask the question properly, they
       know nothing about the question, so share absolute everything you know, don''t
       reference things but instead explain them.\n\nUse the following format:\n\nThought:
       you should always think about what to do\nAction: the action to take, only one
-      name of [Delegate work to co-worker, Ask question to co-worker], just the name,
+      name of [Delegate work to coworker, Ask question to coworker], just the name,
       exactly as it''s written.\nAction Input: the input to the action, just a simple
       a python dictionary using \" to wrap keys and values.\nObservation: the result
       of the action\n\nOnce all necessary information is gathered:\n\nThought: I now
@@ -1482,19 +1482,19 @@ interactions:
     body: '{"messages": [{"role": "user", "content": "You are test role2. test backstory2\nYour
       personal goal is: test goal2\n\nYou ONLY have access to the following tools,
       and should NEVER make up tools that are not listed here:\n\nDelegate work to
-      co-worker: Delegate work to co-worker(coworker: str, task: str, context: str)
-      - Delegate a specific task to one of the following co-workers: [''test role'']\nThe
+      coworker: Delegate work to coworker(coworker: str, task: str, context: str)
+      - Delegate a specific task to one of the following coworkers: [''test role'']\nThe
       input to this tool should be the coworker, the task you want them to do, and
       ALL necessary context to execute the task, they know nothing about the task,
       so share absolute everything you know, don''t reference things but instead explain
-      them.\nAsk question to co-worker: Ask question to co-worker(coworker: str, question:
-      str, context: str) - Ask a specific question to one of the following co-workers:
+      them.\nAsk question to coworker: Ask question to coworker(coworker: str, question:
+      str, context: str) - Ask a specific question to one of the following coworkers:
       [''test role'']\nThe input to this tool should be the coworker, the question
       you have for them, and ALL necessary context to ask the question properly, they
       know nothing about the question, so share absolute everything you know, don''t
       reference things but instead explain them.\n\nUse the following format:\n\nThought:
       you should always think about what to do\nAction: the action to take, only one
-      name of [Delegate work to co-worker, Ask question to co-worker], just the name,
+      name of [Delegate work to coworker, Ask question to coworker], just the name,
       exactly as it''s written.\nAction Input: the input to the action, just a simple
       a python dictionary using \" to wrap keys and values.\nObservation: the result
       of the action\n\nOnce all necessary information is gathered:\n\nThought: I now
@@ -2487,19 +2487,19 @@ interactions:
     body: '{"messages": [{"role": "user", "content": "You are test role2. test backstory2\nYour
       personal goal is: test goal2\n\nYou ONLY have access to the following tools,
       and should NEVER make up tools that are not listed here:\n\nDelegate work to
-      co-worker: Delegate work to co-worker(coworker: str, task: str, context: str)
-      - Delegate a specific task to one of the following co-workers: [''test role'']\nThe
+      coworker: Delegate work to coworker(coworker: str, task: str, context: str)
+      - Delegate a specific task to one of the following coworkers: [''test role'']\nThe
       input to this tool should be the coworker, the task you want them to do, and
       ALL necessary context to execute the task, they know nothing about the task,
       so share absolute everything you know, don''t reference things but instead explain
-      them.\nAsk question to co-worker: Ask question to co-worker(coworker: str, question:
-      str, context: str) - Ask a specific question to one of the following co-workers:
+      them.\nAsk question to coworker: Ask question to coworker(coworker: str, question:
+      str, context: str) - Ask a specific question to one of the following coworkers:
       [''test role'']\nThe input to this tool should be the coworker, the question
       you have for them, and ALL necessary context to ask the question properly, they
       know nothing about the question, so share absolute everything you know, don''t
       reference things but instead explain them.\n\nUse the following format:\n\nThought:
       you should always think about what to do\nAction: the action to take, only one
-      name of [Delegate work to co-worker, Ask question to co-worker], just the name,
+      name of [Delegate work to coworker, Ask question to coworker], just the name,
       exactly as it''s written.\nAction Input: the input to the action, just a simple
       a python dictionary using \" to wrap keys and values.\nObservation: the result
       of the action\n\nOnce all necessary information is gathered:\n\nThought: I now
@@ -2511,8 +2511,8 @@ interactions:
       you, use the tools available and give your best Final Answer, your job depends
       on it!\n\nThought: \nI need to understand the context better before I can provide
       a final answer. It seems I''m missing crucial information to proceed. I will
-      ask a question to my co-worker, ''test role'', to gather more details about
-      the situation.\n\nAction: \nAsk question to co-worker\n\nAction Input: \n{\"coworker\":
+      ask a question to my coworker, ''test role'', to gather more details about
+      the situation.\n\nAction: \nAsk question to coworker\n\nAction Input: \n{\"coworker\":
       \"test role\", \"question\": \"Could you please provide more details about the
       situation?\", \"context\": \"Hi there!\"}\n\nObservation: Could you please provide
       more details about the situation?\n"}], "model": "gpt-4", "n": 1, "stop": ["\nObservation"],

tests/cassettes/test_cache_hitting_between_agents.yaml

@@ -64,19 +64,19 @@ interactions:
       ONLY have access to the following tools, and should NEVER make up tools that
       are not listed here:\n\nmultiplier: multiplier(first_number: int, second_number:
       int) -> float - Useful for when you need to multiply two numbers together.\nDelegate
-      work to co-worker: Delegate work to co-worker(coworker: str, task: str, context:
-      str) - Delegate a specific task to one of the following co-workers: [''Researcher'']\nThe
+      work to coworker: Delegate work to coworker(coworker: str, task: str, context:
+      str) - Delegate a specific task to one of the following coworkers: [''Researcher'']\nThe
       input to this tool should be the coworker, the task you want them to do, and
       ALL necessary context to execute the task, they know nothing about the task,
       so share absolute everything you know, don''t reference things but instead explain
-      them.\nAsk question to co-worker: Ask question to co-worker(coworker: str, question:
-      str, context: str) - Ask a specific question to one of the following co-workers:
+      them.\nAsk question to coworker: Ask question to coworker(coworker: str, question:
+      str, context: str) - Ask a specific question to one of the following coworkers:
       [''Researcher'']\nThe input to this tool should be the coworker, the question
       you have for them, and ALL necessary context to ask the question properly, they
       know nothing about the question, so share absolute everything you know, don''t
       reference things but instead explain them.\n\nUse the following format:\n\nThought:
       you should always think about what to do\nAction: the action to take, only one
-      name of [multiplier, Delegate work to co-worker, Ask question to co-worker],
+      name of [multiplier, Delegate work to coworker, Ask question to coworker],
       just the name, exactly as it''s written.\nAction Input: the input to the action,
       just a simple a python dictionary using \" to wrap keys and values.\nObservation:
       the result of the action\n\nOnce all necessary information is gathered:\n\nThought:
@@ -439,19 +439,19 @@ interactions:
       ONLY have access to the following tools, and should NEVER make up tools that
       are not listed here:\n\nmultiplier: multiplier(first_number: int, second_number:
       int) -> float - Useful for when you need to multiply two numbers together.\nDelegate
-      work to co-worker: Delegate work to co-worker(coworker: str, task: str, context:
-      str) - Delegate a specific task to one of the following co-workers: [''Researcher'']\nThe
+      work to coworker: Delegate work to coworker(coworker: str, task: str, context:
+      str) - Delegate a specific task to one of the following coworkers: [''Researcher'']\nThe
       input to this tool should be the coworker, the task you want them to do, and
       ALL necessary context to execute the task, they know nothing about the task,
       so share absolute everything you know, don''t reference things but instead explain
-      them.\nAsk question to co-worker: Ask question to co-worker(coworker: str, question:
-      str, context: str) - Ask a specific question to one of the following co-workers:
+      them.\nAsk question to coworker: Ask question to coworker(coworker: str, question:
+      str, context: str) - Ask a specific question to one of the following coworkers:
       [''Researcher'']\nThe input to this tool should be the coworker, the question
       you have for them, and ALL necessary context to ask the question properly, they
       know nothing about the question, so share absolute everything you know, don''t
       reference things but instead explain them.\n\nUse the following format:\n\nThought:
       you should always think about what to do\nAction: the action to take, only one
-      name of [multiplier, Delegate work to co-worker, Ask question to co-worker],
+      name of [multiplier, Delegate work to coworker, Ask question to coworker],
       just the name, exactly as it''s written.\nAction Input: the input to the action,
       just a simple a python dictionary using \" to wrap keys and values.\nObservation:
       the result of the action\n\nOnce all necessary information is gathered:\n\nThought:
@@ -463,7 +463,7 @@ interactions:
       Answer, your job depends on it!\n\nThought: \nThe task at hand is to find the
       product of 2 and 6. Since I have the tool ''multiplier'' which multiplies two
       numbers, I can directly use it without needing to delegate or ask questions
-      to a co-worker.\n\nAction: multiplier\nAction Input: {\"first_number\": 2, \"second_number\":
+      to a coworker.\n\nAction: multiplier\nAction Input: {\"first_number\": 2, \"second_number\":
       6}\n\nObservation: 12\n"}], "model": "gpt-4", "n": 1, "stop": ["\nObservation"],
       "stream": true, "temperature": 0.7}'
     headers:

tests/cassettes/test_crew_with_delegating_agents.yaml

@@ -83,20 +83,20 @@ interactions:
       now working on a new project and want to make sure the content produced is amazing.\nYour
       personal goal is: Make sure the writers in your company produce amazing content.\n\nYou
       ONLY have access to the following tools, and should NEVER make up tools that
-      are not listed here:\n\nDelegate work to co-worker: Delegate work to co-worker(coworker:
+      are not listed here:\n\nDelegate work to coworker: Delegate work to coworker(coworker:
       str, task: str, context: str) - Delegate a specific task to one of the following
-      co-workers: [''Senior Writer'']\nThe input to this tool should be the coworker,
+      coworkers: [''Senior Writer'']\nThe input to this tool should be the coworker,
       the task you want them to do, and ALL necessary context to execute the task,
       they know nothing about the task, so share absolute everything you know, don''t
-      reference things but instead explain them.\nAsk question to co-worker: Ask question
-      to co-worker(coworker: str, question: str, context: str) - Ask a specific question
-      to one of the following co-workers: [''Senior Writer'']\nThe input to this tool
+      reference things but instead explain them.\nAsk question to coworker: Ask question
+      to coworker(coworker: str, question: str, context: str) - Ask a specific question
+      to one of the following coworkers: [''Senior Writer'']\nThe input to this tool
       should be the coworker, the question you have for them, and ALL necessary context
       to ask the question properly, they know nothing about the question, so share
       absolute everything you know, don''t reference things but instead explain them.\n\nUse
       the following format:\n\nThought: you should always think about what to do\nAction:
-      the action to take, only one name of [Delegate work to co-worker, Ask question
-      to co-worker], just the name, exactly as it''s written.\nAction Input: the input
+      the action to take, only one name of [Delegate work to coworker, Ask question
+      to coworker], just the name, exactly as it''s written.\nAction Input: the input
       to the action, just a simple a python dictionary using \" to wrap keys and values.\nObservation:
       the result of the action\n\nOnce all necessary information is gathered:\n\nThought:
       I now know the final answer\nFinal Answer: the final answer to the original
@@ -1713,20 +1713,20 @@ interactions:
       now working on a new project and want to make sure the content produced is amazing.\nYour
       personal goal is: Make sure the writers in your company produce amazing content.\n\nYou
       ONLY have access to the following tools, and should NEVER make up tools that
-      are not listed here:\n\nDelegate work to co-worker: Delegate work to co-worker(coworker:
+      are not listed here:\n\nDelegate work to coworker: Delegate work to coworker(coworker:
       str, task: str, context: str) - Delegate a specific task to one of the following
-      co-workers: [''Senior Writer'']\nThe input to this tool should be the coworker,
+      coworkers: [''Senior Writer'']\nThe input to this tool should be the coworker,
       the task you want them to do, and ALL necessary context to execute the task,
       they know nothing about the task, so share absolute everything you know, don''t
-      reference things but instead explain them.\nAsk question to co-worker: Ask question
-      to co-worker(coworker: str, question: str, context: str) - Ask a specific question
-      to one of the following co-workers: [''Senior Writer'']\nThe input to this tool
+      reference things but instead explain them.\nAsk question to coworker: Ask question
+      to coworker(coworker: str, question: str, context: str) - Ask a specific question
+      to one of the following coworkers: [''Senior Writer'']\nThe input to this tool
       should be the coworker, the question you have for them, and ALL necessary context
       to ask the question properly, they know nothing about the question, so share
       absolute everything you know, don''t reference things but instead explain them.\n\nUse
       the following format:\n\nThought: you should always think about what to do\nAction:
-      the action to take, only one name of [Delegate work to co-worker, Ask question
-      to co-worker], just the name, exactly as it''s written.\nAction Input: the input
+      the action to take, only one name of [Delegate work to coworker, Ask question
+      to coworker], just the name, exactly as it''s written.\nAction Input: the input
       to the action, just a simple a python dictionary using \" to wrap keys and values.\nObservation:
       the result of the action\n\nOnce all necessary information is gathered:\n\nThought:
       I now know the final answer\nFinal Answer: the final answer to the original
@@ -1738,7 +1738,7 @@ interactions:
       it!\n\nThought: \nI want to ensure that the Senior Writer understands the topic
       and the standard of quality that we aim to achieve. I''ll provide them with
       all the information they need to produce an amazing 1 paragraph draft about
-      AI Agents. \n\nAction: Delegate work to co-worker\nAction Input: {\"coworker\":
+      AI Agents. \n\nAction: Delegate work to coworker\nAction Input: {\"coworker\":
       \"Senior Writer\", \"task\": \"Produce a 1 paragraph draft of an article about
       AI Agents.\", \"context\": \"We are working on a new project that requires high-quality
       content about AI Agents. We want to make sure that the content is engaging,

tests/cassettes/test_hierarchical_process.yaml

@@ -63,20 +63,20 @@ interactions:
       allows you to properly evaluate the work of your team members.\nYour personal
       goal is: Manage the team to complete the task in the best way possible.\n\nYou
       ONLY have access to the following tools, and should NEVER make up tools that
-      are not listed here:\n\nDelegate work to co-worker: Delegate work to co-worker(coworker:
+      are not listed here:\n\nDelegate work to coworker: Delegate work to coworker(coworker:
       str, task: str, context: str) - Delegate a specific task to one of the following
-      co-workers: [''Researcher'', ''Senior Writer'']\nThe input to this tool should
+      coworkers: [''Researcher'', ''Senior Writer'']\nThe input to this tool should
       be the coworker, the task you want them to do, and ALL necessary context to
       execute the task, they know nothing about the task, so share absolute everything
       you know, don''t reference things but instead explain them.\nAsk question to
-      co-worker: Ask question to co-worker(coworker: str, question: str, context:
-      str) - Ask a specific question to one of the following co-workers: [''Researcher'',
+      coworker: Ask question to coworker(coworker: str, question: str, context:
+      str) - Ask a specific question to one of the following coworkers: [''Researcher'',
       ''Senior Writer'']\nThe input to this tool should be the coworker, the question
       you have for them, and ALL necessary context to ask the question properly, they
       know nothing about the question, so share absolute everything you know, don''t
       reference things but instead explain them.\n\nUse the following format:\n\nThought:
       you should always think about what to do\nAction: the action to take, only one
-      name of [Delegate work to co-worker, Ask question to co-worker], just the name,
+      name of [Delegate work to coworker, Ask question to coworker], just the name,
       exactly as it''s written.\nAction Input: the input to the action, just a simple
       a python dictionary using \" to wrap keys and values.\nObservation: the result
       of the action\n\nOnce all necessary information is gathered:\n\nThought: I now
@@ -2444,20 +2444,20 @@ interactions:
       allows you to properly evaluate the work of your team members.\nYour personal
       goal is: Manage the team to complete the task in the best way possible.\n\nYou
       ONLY have access to the following tools, and should NEVER make up tools that
-      are not listed here:\n\nDelegate work to co-worker: Delegate work to co-worker(coworker:
+      are not listed here:\n\nDelegate work to coworker: Delegate work to coworker(coworker:
       str, task: str, context: str) - Delegate a specific task to one of the following
-      co-workers: [''Researcher'', ''Senior Writer'']\nThe input to this tool should
+      coworkers: [''Researcher'', ''Senior Writer'']\nThe input to this tool should
       be the coworker, the task you want them to do, and ALL necessary context to
       execute the task, they know nothing about the task, so share absolute everything
       you know, don''t reference things but instead explain them.\nAsk question to
-      co-worker: Ask question to co-worker(coworker: str, question: str, context:
-      str) - Ask a specific question to one of the following co-workers: [''Researcher'',
+      coworker: Ask question to coworker(coworker: str, question: str, context:
+      str) - Ask a specific question to one of the following coworkers: [''Researcher'',
       ''Senior Writer'']\nThe input to this tool should be the coworker, the question
       you have for them, and ALL necessary context to ask the question properly, they
       know nothing about the question, so share absolute everything you know, don''t
       reference things but instead explain them.\n\nUse the following format:\n\nThought:
       you should always think about what to do\nAction: the action to take, only one
-      name of [Delegate work to co-worker, Ask question to co-worker], just the name,
+      name of [Delegate work to coworker, Ask question to coworker], just the name,
       exactly as it''s written.\nAction Input: the input to the action, just a simple
       a python dictionary using \" to wrap keys and values.\nObservation: the result
       of the action\n\nOnce all necessary information is gathered:\n\nThought: I now
@@ -2474,7 +2474,7 @@ interactions:
       a paragraph for each idea that showcases how good an article about this topic
       could be. I will delegate the task of coming up with the ideas to the Researcher
       and the task of writing the paragraphs to the Senior Writer.\n\nAction: \nDelegate
-      work to co-worker\n\nAction Input: \n{\n  \"coworker\": \"Researcher\",\n  \"task\":
+      work to coworker\n\nAction Input: \n{\n  \"coworker\": \"Researcher\",\n  \"task\":
       \"Come up with 5 interesting ideas for an article\",\n  \"context\": \"We need
       to create a list of 5 interesting ideas for an article. These ideas should be
       unique, engaging, and have the potential to be developed into a full-length
@@ -5363,20 +5363,20 @@ interactions:
       allows you to properly evaluate the work of your team members.\nYour personal
       goal is: Manage the team to complete the task in the best way possible.\n\nYou
       ONLY have access to the following tools, and should NEVER make up tools that
-      are not listed here:\n\nDelegate work to co-worker: Delegate work to co-worker(coworker:
+      are not listed here:\n\nDelegate work to coworker: Delegate work to coworker(coworker:
       str, task: str, context: str) - Delegate a specific task to one of the following
-      co-workers: [''Researcher'', ''Senior Writer'']\nThe input to this tool should
+      coworkers: [''Researcher'', ''Senior Writer'']\nThe input to this tool should
       be the coworker, the task you want them to do, and ALL necessary context to
       execute the task, they know nothing about the task, so share absolute everything
       you know, don''t reference things but instead explain them.\nAsk question to
-      co-worker: Ask question to co-worker(coworker: str, question: str, context:
-      str) - Ask a specific question to one of the following co-workers: [''Researcher'',
+      coworker: Ask question to coworker(coworker: str, question: str, context:
+      str) - Ask a specific question to one of the following coworkers: [''Researcher'',
       ''Senior Writer'']\nThe input to this tool should be the coworker, the question
       you have for them, and ALL necessary context to ask the question properly, they
       know nothing about the question, so share absolute everything you know, don''t
       reference things but instead explain them.\n\nUse the following format:\n\nThought:
       you should always think about what to do\nAction: the action to take, only one
-      name of [Delegate work to co-worker, Ask question to co-worker], just the name,
+      name of [Delegate work to coworker, Ask question to coworker], just the name,
       exactly as it''s written.\nAction Input: the input to the action, just a simple
       a python dictionary using \" to wrap keys and values.\nObservation: the result
       of the action\n\nOnce all necessary information is gathered:\n\nThought: I now
@@ -5393,7 +5393,7 @@ interactions:
       a paragraph for each idea that showcases how good an article about this topic
       could be. I will delegate the task of coming up with the ideas to the Researcher
       and the task of writing the paragraphs to the Senior Writer.\n\nAction: \nDelegate
-      work to co-worker\n\nAction Input: \n{\n  \"coworker\": \"Researcher\",\n  \"task\":
+      work to coworker\n\nAction Input: \n{\n  \"coworker\": \"Researcher\",\n  \"task\":
       \"Come up with 5 interesting ideas for an article\",\n  \"context\": \"We need
       to create a list of 5 interesting ideas for an article. These ideas should be
       unique, engaging, and have the potential to be developed into a full-length
@@ -5406,7 +5406,7 @@ interactions:
       for the article. Now, I need to delegate the task of writing a paragraph for
       each idea to the Senior Writer. I will provide the Senior Writer with the ideas
       and ask them to write a paragraph that showcases how good an article about each
-      topic could be.\n\nAction: \nDelegate work to co-worker\n\nAction Input: \n{\n  \"coworker\":
+      topic could be.\n\nAction: \nDelegate work to coworker\n\nAction Input: \n{\n  \"coworker\":
       \"Senior Writer\",\n  \"task\": \"Write one amazing paragraph highlight for
       each idea\",\n  \"context\": \"We have 5 interesting ideas for an article. They
       are: 1. ''Demystifying AI: An in-depth exploration of Artificial Intelligence

tests/cassettes/test_increment_delegations_for_hierarchical_process.yaml

@@ -144,20 +144,20 @@ interactions:
       allows you to properly evaluate the work of your team members.\nYour personal
       goal is: Manage the team to complete the task in the best way possible.\nYou
       ONLY have access to the following tools, and should NEVER make up tools that
-      are not listed here:\n\nDelegate work to co-worker: Delegate work to co-worker(task:
+      are not listed here:\n\nDelegate work to coworker: Delegate work to coworker(task:
       str, context: str, coworker: Optional[str] = None, **kwargs) - Delegate a specific
-      task to one of the following co-workers: [Scorer]\nThe input to this tool should
-      be the co-worker, the task you want them to do, and ALL necessary context to
+      task to one of the following coworkers: [Scorer]\nThe input to this tool should
+      be the coworker, the task you want them to do, and ALL necessary context to
       execute the task, they know nothing about the task, so share absolute everything
       you know, don''t reference things but instead explain them.\nAsk question to
-      co-worker: Ask question to co-worker(question: str, context: str, coworker:
+      coworker: Ask question to coworker(question: str, context: str, coworker:
       Optional[str] = None, **kwargs) - Ask a specific question to one of the following
-      co-workers: [Scorer]\nThe input to this tool should be the co-worker, the question
+      coworkers: [Scorer]\nThe input to this tool should be the coworker, the question
       you have for them, and ALL necessary context to ask the question properly, they
       know nothing about the question, so share absolute everything you know, don''t
       reference things but instead explain them.\n\nUse the following format:\n\nThought:
       you should always think about what to do\nAction: the action to take, only one
-      name of [Delegate work to co-worker, Ask question to co-worker], just the name,
+      name of [Delegate work to coworker, Ask question to coworker], just the name,
       exactly as it''s written.\nAction Input: the input to the action, just a simple
       a python dictionary, enclosed in curly braces, using \" to wrap keys and values.\nObservation:
       the result of the action\n\nOnce all necessary information is gathered:\n\nThought:
@@ -1391,7 +1391,7 @@ interactions:
       it must be outcome described.\n\nI MUST use these formats, my job depends on
       it!\nCurrent Task: What criteria do you use to score a title and how are these
       criteria weighted?\n\nThis is the expect criteria for your final answer: Your
-      best answer to your co-worker asking you this, accounting for the context shared.
+      best answer to your coworker asking you this, accounting for the context shared.
       \n you MUST return the actual complete content as the final answer, not a summary.\n\nThis
       is the context you''re working with:\nI need to assign a score between 1-5 to
       the title ''The impact of AI in the future of work.'' To ensure I understand
@@ -3120,20 +3120,20 @@ interactions:
       allows you to properly evaluate the work of your team members.\nYour personal
       goal is: Manage the team to complete the task in the best way possible.\nYou
       ONLY have access to the following tools, and should NEVER make up tools that
-      are not listed here:\n\nDelegate work to co-worker: Delegate work to co-worker(task:
+      are not listed here:\n\nDelegate work to coworker: Delegate work to coworker(task:
       str, context: str, coworker: Optional[str] = None, **kwargs) - Delegate a specific
-      task to one of the following co-workers: [Scorer]\nThe input to this tool should
-      be the co-worker, the task you want them to do, and ALL necessary context to
+      task to one of the following coworkers: [Scorer]\nThe input to this tool should
+      be the coworker, the task you want them to do, and ALL necessary context to
       execute the task, they know nothing about the task, so share absolute everything
       you know, don''t reference things but instead explain them.\nAsk question to
-      co-worker: Ask question to co-worker(question: str, context: str, coworker:
+      coworker: Ask question to coworker(question: str, context: str, coworker:
       Optional[str] = None, **kwargs) - Ask a specific question to one of the following
-      co-workers: [Scorer]\nThe input to this tool should be the co-worker, the question
+      coworkers: [Scorer]\nThe input to this tool should be the coworker, the question
       you have for them, and ALL necessary context to ask the question properly, they
       know nothing about the question, so share absolute everything you know, don''t
       reference things but instead explain them.\n\nUse the following format:\n\nThought:
       you should always think about what to do\nAction: the action to take, only one
-      name of [Delegate work to co-worker, Ask question to co-worker], just the name,
+      name of [Delegate work to coworker, Ask question to coworker], just the name,
       exactly as it''s written.\nAction Input: the input to the action, just a simple
       a python dictionary, enclosed in curly braces, using \" to wrap keys and values.\nObservation:
       the result of the action\n\nOnce all necessary information is gathered:\n\nThought:
@@ -3149,7 +3149,7 @@ interactions:
       contribute to a title''s score and how these factors are weighted. Given I can''t
       make assumptions and have to provide all necessary context, I need to first
       gather this information to ensure the task is completed accurately.\n\nAction:
-      Ask question to co-worker\n\nAction Input: {\"question\": \"What criteria do
+      Ask question to coworker\n\nAction Input: {\"question\": \"What criteria do
       you use to score a title and how are these criteria weighted?\", \"context\":
       \"I need to assign a score between 1-5 to the title ''The impact of AI in the
       future of work.'' To ensure I understand how to evaluate this title accurately,
@@ -4438,7 +4438,7 @@ interactions:
       the task.\nYour final answer must be the great and the most complete as possible,
       it must be outcome described.\n\nI MUST use these formats, my job depends on
       it!\nCurrent Task: Score the title using the provided criteria\n\nThis is the
-      expect criteria for your final answer: Your best answer to your co-worker asking
+      expect criteria for your final answer: Your best answer to your coworker asking
       you this, accounting for the context shared. \n you MUST return the actual complete
       content as the final answer, not a summary.\n\nThis is the context you''re working
       with:\nThe title to be scored is ''The impact of AI in the future of work.''
@@ -4936,20 +4936,20 @@ interactions:
       allows you to properly evaluate the work of your team members.\nYour personal
       goal is: Manage the team to complete the task in the best way possible.\nYou
       ONLY have access to the following tools, and should NEVER make up tools that
-      are not listed here:\n\nDelegate work to co-worker: Delegate work to co-worker(task:
+      are not listed here:\n\nDelegate work to coworker: Delegate work to coworker(task:
       str, context: str, coworker: Optional[str] = None, **kwargs) - Delegate a specific
-      task to one of the following co-workers: [Scorer]\nThe input to this tool should
-      be the co-worker, the task you want them to do, and ALL necessary context to
+      task to one of the following coworkers: [Scorer]\nThe input to this tool should
+      be the coworker, the task you want them to do, and ALL necessary context to
       execute the task, they know nothing about the task, so share absolute everything
       you know, don''t reference things but instead explain them.\nAsk question to
-      co-worker: Ask question to co-worker(question: str, context: str, coworker:
+      coworker: Ask question to coworker(question: str, context: str, coworker:
       Optional[str] = None, **kwargs) - Ask a specific question to one of the following
-      co-workers: [Scorer]\nThe input to this tool should be the co-worker, the question
+      coworkers: [Scorer]\nThe input to this tool should be the coworker, the question
       you have for them, and ALL necessary context to ask the question properly, they
       know nothing about the question, so share absolute everything you know, don''t
       reference things but instead explain them.\n\nUse the following format:\n\nThought:
       you should always think about what to do\nAction: the action to take, only one
-      name of [Delegate work to co-worker, Ask question to co-worker], just the name,
+      name of [Delegate work to coworker, Ask question to coworker], just the name,
       exactly as it''s written.\nAction Input: the input to the action, just a simple
       a python dictionary, enclosed in curly braces, using \" to wrap keys and values.\nObservation:
       the result of the action\n\nOnce all necessary information is gathered:\n\nThought:
@@ -4965,7 +4965,7 @@ interactions:
       contribute to a title''s score and how these factors are weighted. Given I can''t
       make assumptions and have to provide all necessary context, I need to first
       gather this information to ensure the task is completed accurately.\n\nAction:
-      Ask question to co-worker\n\nAction Input: {\"question\": \"What criteria do
+      Ask question to coworker\n\nAction Input: {\"question\": \"What criteria do
       you use to score a title and how are these criteria weighted?\", \"context\":
       \"I need to assign a score between 1-5 to the title ''The impact of AI in the
       future of work.'' To ensure I understand how to evaluate this title accurately,
@@ -4997,7 +4997,7 @@ interactions:
       impact of AI in the future of work\" based on Relevance, Clarity, Originality,
       Engagement, and Length. Given my understanding of the title''s subject and the
       criteria provided, I can now delegate the task of scoring the title using these
-      specific guidelines.\n\nAction: Delegate work to co-worker\n\nAction Input:
+      specific guidelines.\n\nAction: Delegate work to coworker\n\nAction Input:
       {\"task\": \"Score the title using the provided criteria\", \"context\": \"The
       title to be scored is ''The impact of AI in the future of work.'' Based on our
       scoring system, please evaluate the title against the following five criteria,

tests/cassettes/test_increment_tool_errors.yaml

@@ -57,20 +57,20 @@ interactions:
       allows you to properly evaluate the work of your team members.\nYour personal
       goal is: Manage the team to complete the task in the best way possible.\n\nYou
       ONLY have access to the following tools, and should NEVER make up tools that
-      are not listed here:\n\nDelegate work to co-worker: Delegate work to co-worker(coworker:
+      are not listed here:\n\nDelegate work to coworker: Delegate work to coworker(coworker:
       str, task: str, context: str) - Delegate a specific task to one of the following
-      co-workers: [''Scorer'']\nThe input to this tool should be the coworker, the
+      coworkers: [''Scorer'']\nThe input to this tool should be the coworker, the
       task you want them to do, and ALL necessary context to execute the task, they
       know nothing about the task, so share absolute everything you know, don''t reference
-      things but instead explain them.\nAsk question to co-worker: Ask question to
-      co-worker(coworker: str, question: str, context: str) - Ask a specific question
-      to one of the following co-workers: [''Scorer'']\nThe input to this tool should
+      things but instead explain them.\nAsk question to coworker: Ask question to
+      coworker(coworker: str, question: str, context: str) - Ask a specific question
+      to one of the following coworkers: [''Scorer'']\nThe input to this tool should
       be the coworker, the question you have for them, and ALL necessary context to
       ask the question properly, they know nothing about the question, so share absolute
       everything you know, don''t reference things but instead explain them.\n\nUse
       the following format:\n\nThought: you should always think about what to do\nAction:
-      the action to take, only one name of [Delegate work to co-worker, Ask question
-      to co-worker], just the name, exactly as it''s written.\nAction Input: the input
+      the action to take, only one name of [Delegate work to coworker, Ask question
+      to coworker], just the name, exactly as it''s written.\nAction Input: the input
       to the action, just a simple a python dictionary using \" to wrap keys and values.\nObservation:
       the result of the action\n\nOnce all necessary information is gathered:\n\nThought:
       I now know the final answer\nFinal Answer: the final answer to the original
@@ -3197,20 +3197,20 @@ interactions:
       allows you to properly evaluate the work of your team members.\nYour personal
       goal is: Manage the team to complete the task in the best way possible.\n\nYou
       ONLY have access to the following tools, and should NEVER make up tools that
-      are not listed here:\n\nDelegate work to co-worker: Delegate work to co-worker(coworker:
+      are not listed here:\n\nDelegate work to coworker: Delegate work to coworker(coworker:
       str, task: str, context: str) - Delegate a specific task to one of the following
-      co-workers: [''Scorer'']\nThe input to this tool should be the coworker, the
+      coworkers: [''Scorer'']\nThe input to this tool should be the coworker, the
       task you want them to do, and ALL necessary context to execute the task, they
       know nothing about the task, so share absolute everything you know, don''t reference
-      things but instead explain them.\nAsk question to co-worker: Ask question to
-      co-worker(coworker: str, question: str, context: str) - Ask a specific question
-      to one of the following co-workers: [''Scorer'']\nThe input to this tool should
+      things but instead explain them.\nAsk question to coworker: Ask question to
+      coworker(coworker: str, question: str, context: str) - Ask a specific question
+      to one of the following coworkers: [''Scorer'']\nThe input to this tool should
       be the coworker, the question you have for them, and ALL necessary context to
       ask the question properly, they know nothing about the question, so share absolute
       everything you know, don''t reference things but instead explain them.\n\nUse
       the following format:\n\nThought: you should always think about what to do\nAction:
-      the action to take, only one name of [Delegate work to co-worker, Ask question
-      to co-worker], just the name, exactly as it''s written.\nAction Input: the input
+      the action to take, only one name of [Delegate work to coworker, Ask question
+      to coworker], just the name, exactly as it''s written.\nAction Input: the input
       to the action, just a simple a python dictionary using \" to wrap keys and values.\nObservation:
       the result of the action\n\nOnce all necessary information is gathered:\n\nThought:
       I now know the final answer\nFinal Answer: the final answer to the original
@@ -3225,8 +3225,8 @@ interactions:
       it. Since scoring can be subjective, it''s essential to establish clear criteria
       based on relevance, insightfulness, current interest in the topic, and perhaps
       its specificity or ability to provoke thought. As I don''t have direct guidelines,
-      I will need to consult with my co-worker, Scorer, who might have a set of criteria
-      or insights on how to approach this task.\n\nAction: Ask question to co-worker\nAction
+      I will need to consult with my coworker, Scorer, who might have a set of criteria
+      or insights on how to approach this task.\n\nAction: Ask question to coworker\nAction
       Input: {\"coworker\": \"Scorer\", \"question\": \"What criteria should we use
       to evaluate and score the title ''The impact of AI in the future of work''?\",
       \"context\": \"We need to assign a score between 1-5 for the title ''The impact

tests/crew_test.py

@@ -384,6 +384,12 @@ def test_crew_full_ouput():
     assert result == {
         "final_output": "Hello! It is a delight to receive your message. I trust this response finds you in good spirits. It's indeed a pleasure to connect with you too.",
         "tasks_outputs": [task1.output, task2.output],
+        "usage_metrics": {
+            "completion_tokens": 109,
+            "prompt_tokens": 330,
+            "successful_requests": 2,
+            "total_tokens": 439,
+        },
     }
 
 
@@ -437,7 +443,6 @@ def test_async_task_execution():
         process=Process.sequential,
         tasks=[list_ideas, list_important_history, write_article],
     )
-    output = TaskOutput(description="A 4 paragraph article about AI.", raw_output="ok")
 
     with patch.object(Agent, "execute_task") as execute:
         execute.return_value = "ok"
@@ -445,11 +450,17 @@ def test_async_task_execution():
             thread = threading.Thread(target=lambda: None, args=()).start()
             start.return_value = thread
             with patch.object(threading.Thread, "join", wraps=thread.join()) as join:
-                list_ideas.output = output
-                list_important_history.output = output
-
+                list_ideas.output = TaskOutput(
+                    description="A 4 paragraph article about AI.",
+                    raw_output="ok",
+                    agent="writer",
+                )
+                list_important_history.output = TaskOutput(
+                    description="A 4 paragraph article about AI.",
+                    raw_output="ok",
+                    agent="writer",
+                )
                 crew.kickoff()
-
                 start.assert_called()
                 join.assert_called()
 
@@ -648,9 +659,9 @@ def test_agent_usage_metrics_are_captured_for_sequential_process():
     assert result == "Howdy!"
     assert crew.usage_metrics == {
         "completion_tokens": 17,
-        "prompt_tokens": 160,
+        "prompt_tokens": 158,
         "successful_requests": 1,
-        "total_tokens": 177,
+        "total_tokens": 175,
     }
 
 
@@ -676,9 +687,10 @@ def test_agent_usage_metrics_are_captured_for_hierarchical_process():
 
     result = crew.kickoff()
     assert result == '"Howdy!"'
+    print(crew.usage_metrics)
     assert crew.usage_metrics == {
-        "total_tokens": 1666,
-        "prompt_tokens": 1383,
+        "total_tokens": 1659,
+        "prompt_tokens": 1376,
         "completion_tokens": 283,
         "successful_requests": 3,
     }

tests/task_test.py

@@ -1,5 +1,7 @@
 """Test Agent creation and execution basic functionality."""
 
+import json
+
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -7,6 +9,7 @@ from pydantic import BaseModel
 from pydantic_core import ValidationError
 
 from crewai import Agent, Crew, Process, Task
+from crewai.tasks.task_output import TaskOutput
 
 
 def test_task_tool_reflect_agent_tools():
@@ -105,6 +108,46 @@ def test_task_callback():
         task_completed.assert_called_once_with(task.output)
 
 
+def test_task_callback_returns_task_ouput():
+    researcher = Agent(
+        role="Researcher",
+        goal="Make the best research and analysis on content about AI and AI agents",
+        backstory="You're an expert researcher, specialized in technology, software engineering, AI and startups. You work as a freelancer and is now working on doing research and analysis for a new customer.",
+        allow_delegation=False,
+    )
+
+    task_completed = MagicMock(return_value="done")
+
+    task = Task(
+        description="Give me a list of 5 interesting ideas to explore for an article, what makes them unique and interesting.",
+        expected_output="Bullet point list of 5 interesting ideas.",
+        agent=researcher,
+        callback=task_completed,
+    )
+
+    with patch.object(Agent, "execute_task") as execute:
+        execute.return_value = "exported_ok"
+        task.execute()
+        # Ensure the callback is called with a TaskOutput object serialized to JSON
+        task_completed.assert_called_once()
+        callback_data = task_completed.call_args[0][0]
+
+        # Check if callback_data is TaskOutput object or JSON string
+        if isinstance(callback_data, TaskOutput):
+            callback_data = json.dumps(callback_data.model_dump())
+
+        assert isinstance(callback_data, str)
+        output_dict = json.loads(callback_data)
+        expected_output = {
+            "description": task.description,
+            "exported_output": "exported_ok",
+            "raw_output": "exported_ok",
+            "agent": researcher.role,
+            "summary": "Give me a list of 5 interesting ideas to explore...",
+        }
+        assert output_dict == expected_output
+
+
 def test_execute_with_agent():
     researcher = Agent(
         role="Researcher",