> ## Documentation Index
> Fetch the complete documentation index at: https://docs.camel-ai.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Tasks

For more detailed usage information, please refer to our cookbook: [Task Generation Cookbook](../cookbooks/multi_agent_society/task_generation.ipynb)

<Card title="What is a Task in CAMEL?" icon="clipboard-list">
  A <b>task</b> in CAMEL is a structured assignment that can be given to one or more agents. Tasks are higher-level than prompts and managed by modules like the Planner and Workforce.
  <b>Key ideas:</b><br />

  * Tasks can be <b>collaborative</b>, requiring multiple agents.<br />
  * Tasks can be <b>decomposed</b> into subtasks or evolved over time.<br />
</Card>

## Task Attributes

| Attribute | Type           | Description                                                      |
| --------- | -------------- | ---------------------------------------------------------------- |
| content   | string         | A clear and concise description of the task at hand.             |
| id        | string         | A unique string identifier for the task.                         |
| state     | Enum           | The task states: "OPEN", "RUNNING", "DONE", "FAILED", "DELETED". |
| type      | string         | The type of a task. (TODO)                                       |
| parent    | Task           | The parent task.                                                 |
| subtasks  | A list of Task | Subtasks related to the original Task.                           |
| result    | string         | The Task result.                                                 |

## Task Methods

| Method             | Type        | Description                                             |
| ------------------ | ----------- | ------------------------------------------------------- |
| from\_message      | classmethod | Load Task from Message.                                 |
| to\_message        | classmethod | Convert Task to Message.                                |
| reset              | instance    | Reset Task to initial state.                            |
| update\_result     | instance    | Set task result and mark the task as DONE.              |
| set\_id            | instance    | Set task id.                                            |
| set\_state         | instance    | Recursively set the state of the task and its subtasks. |
| add\_subtask       | instance    | Add a child task.                                       |
| remove\_subtask    | instance    | Delete a subtask by id.                                 |
| get\_running\_task | instance    | Get a RUNNING task.                                     |
| to\_string         | instance    | Convert task to a string.                               |
| get\_result        | instance    | Get task result as a string.                            |
| decompose          | instance    | Decompose a task to a list of subtasks.                 |
| compose            | instance    | Compose task result by subtasks.                        |
| get\_depth         | instance    | Get task depth; root depth is 1.                        |

<Card title="Getting Started: Creating Tasks" icon="bolt">
  Defining a task is simple: specify its content and a unique ID.

  <CodeGroup>
    ```python task_example.py theme={"system"}
    from camel.tasks import Task

    task = Task(
        content="Weng earns $12 an hour for babysitting. Yesterday, she just did 51 minutes of babysitting. How much did she earn?",
        id="0",
    )
    ```
  </CodeGroup>
</Card>

<Card title="Hierarchical Tasks Example" icon="sitemap">
  You can build nested, hierarchical tasks using subtasks. Here’s an example:

  <CodeGroup>
    ```python tasks_hierarchical.py theme={"system"}
    # Creating the root task
    root_task = Task(content="Prepare a meal", id="0")

    # Creating subtasks for the root task
    sub_task_1 = Task(content="Shop for ingredients", id="1")
    sub_task_2 = Task(content="Cook the meal", id="2")
    sub_task_3 = Task(content="Set the table", id="3")

    # Creating subtasks under "Cook the meal"
    sub_task_2_1 = Task(content="Chop vegetables", id="2.1")
    sub_task_2_2 = Task(content="Cook rice", id="2.2")

    # Adding subtasks to their respective parent tasks
    root_task.add_subtask(sub_task_1)
    root_task.add_subtask(sub_task_2)
    root_task.add_subtask(sub_task_3)

    sub_task_2.add_subtask(sub_task_2_1)
    sub_task_2.add_subtask(sub_task_2_2)

    # Printing the hierarchical task structure
    print(root_task.to_string())
    ```

    ```markdown output theme={"system"}
    >>>
        Task 0: Prepare a meal
        Task 1: Shop for ingredients
        Task 2: Cook the meal
            Task 2.1: Chop vegetables
            Task 2.2: Cook rice
        Task 3: Set the table
    ```
  </CodeGroup>
</Card>

## Decomposing and Composing a Task

You can break down (decompose) a task into smaller subtasks, or compose the results from subtasks. Typically, you define an agent, prompt template, and response parser.

<CodeGroup>
  ```python task_decompose.py theme={"system"}
  from camel.agents import ChatAgent
  from camel.tasks import Task
  from camel.tasks.task_prompt import (
      TASK_COMPOSE_PROMPT,
      TASK_DECOMPOSE_PROMPT,
  )
  from camel.messages import BaseMessage

  sys_msg = BaseMessage.make_assistant_message(
      role_name="Assistant", content="You're a helpful assistant"
  )
  # Set up an agent
  agent = ChatAgent(system_message=sys_msg)

  task = Task(
      content="Weng earns $12 an hour for babysitting. Yesterday, she just did 51 minutes of babysitting. How much did she earn?",
      id="0",
  )

  new_tasks = task.decompose(agent=agent)
  for t in new_tasks:
      print(t.to_string())
  ```

  ```markdown output theme={"system"}
  >>>
  Task 0.0: Convert 51 minutes into hours.
  Task 0.1: Calculate Weng's earnings for the converted hours at the rate of $12 per hour.
  Task 0.2: Provide the final earnings amount based on the calculation.
  ```
</CodeGroup>

<CodeGroup>
  ```python task_compose.py theme={"system"}
  # Compose task result by the sub-tasks.
  task.compose(agent=agent, template=TASK_COMPOSE_PROMPT)
  print(task.result)
  ```
</CodeGroup>

## TaskManager

<Card title="TaskManager Overview" icon="list-check">
  The <b>TaskManager</b> class helps you manage, sort, and evolve tasks—handling dependencies and progression automatically.
</Card>

| Method                 | Type     | Description                                                              |
| ---------------------- | -------- | ------------------------------------------------------------------------ |
| topological\_sort      | instance | Sort a list of tasks topologically.                                      |
| set\_tasks\_dependence | instance | Set relationship between root task and other tasks (serial or parallel). |
| evolve                 | instance | Evolve a task to a new task; used for data generation.                   |

<CodeGroup>
  ```python task_manager_example.py theme={"system"}
  from camel.tasks import (
      Task,
      TaskManager,
  )
  from camel.agents import ChatAgent

  sys_msg = "You're a helpful assistant"
  agent = ChatAgent(system_message=sys_msg)

  task = Task(
      content="Weng earns $12 an hour for babysitting. Yesterday, she just did 51 minutes of babysitting. How much did she earn?",
      id="0",
  )
  print(task.to_string())
  ```

  ```markdown output theme={"system"}
  >>>Task 0: Weng earns $12 an hour for babysitting. Yesterday, she just did 51 minutes of babysitting. How much did she earn?
  ```
</CodeGroup>

<CodeGroup>
  ```python task_manager_evolve.py theme={"system"}
  task_manager = TaskManager(task)
  evolved_task = task_manager.evolve(task, agent=agent)
  print(evolved_task.to_string())
  ```

  ```markdown output theme={"system"}
  >>>Task 0.0: Weng earns $12 an hour for babysitting. Yesterday, she babysat for 1 hour and 45 minutes. If she also received a $5 bonus for exceptional service, how much did she earn in total for that day?
  ```
</CodeGroup>

<Card title="Conclusion" icon="trophy">
  CAMEL offers a powerful, structured approach to task management. With support for task decomposition, composition, and deep hierarchies, you can automate everything from simple workflows to complex, multi-agent projects. Efficient, collaborative, and easy to integrate—this is next-level task orchestration for AI.
</Card>