IMPORTANT: How to use manager_agent and hierarchical mode correctly?

[ckgithub2019]

Are the conditions for using manager_agent and hierarchical mode correct? Couldn't find out the official detailed explanations.

1. MUST customize manager_agent and manager_task?
2. only manager_agent could be set as "allow_delegation = True" and the other agents are "allow_delegation = False"?
3. MUST define the attribute "context" of Task?
4. MUST call Crew like this?
   """
   crew = Crew(
   agents=[
   researcher_agent,
   ...
   ],
   tasks=[
   research_task,
   ...
   manager_task
   ],
   verbose=2,
   process=Process.hierarchical,
   manager_agent=manager_agent,
   }

[theCyberTech]

Hi @ckgithub2019

1. Manager Agent: Optional: You can create a custom manager agent with specific skills for task management and delegation. If you don't provide one, CrewAI will create a default manager.
   2)Tasks: Optional: Define your tasks as you would for a sequential process. The manager will handle the delegation and execution order.
   3)Agent Delegation: OptionalWhile it's common for the manager to handle most delegation, you can allow other agents to delegate if it fits your use case.

[ckgithub2019]

Hi @ckgithub2019

1. Manager Agent: Optional: You can create a custom manager agent with specific skills for task management and delegation. If you don't provide one, CrewAI will create a default manager.
   2)Tasks: Optional: Define your tasks as you would for a sequential process. The manager will handle the delegation and execution order.
   3)Agent Delegation: OptionalWhile it's common for the manager to handle most delegation, you can allow other agents to delegate if it fits your use case.

Thanks.

1. the default manager created by CrewAI is only based on OpenAI API model? I have to configure it in agent setup?
2. About "The manager will handle the delegation and execution order" you said, is it automatic internally like a black box? Could I control the execution order of manager delegation?
3. you mean "allow_delegation" is not relevant to manager agent and hierarchical mode? it's flexible and could be used anytime, no limitation or dependancy, right?

[maxim-saplin]

Same troubles, puzzled with planning, hierarchical process and manager agent/llm - did't see any comprehensive documentation or samples, my code is constantly throwing errors (401 when using manager_llm) or doesn't use any of the agents in execution besides the manager agent (when setting manager_agent)

[skim0011]

crew = Crew(
agents=[distributor_agent, q_agent, a_agent],
tasks=[overall_task, task_distributor, task_q, task_a],

manager_agent=manager_agent, 

process=Process.hierarchical,
verbose=True,
memory=False, 

)

My intention was like below to separate agent and task:
distributor_agent => task_distributor
q_agent => task_q
a_agent => task_a

I tried this code, manager agent ran all the tasks.

I can still get a right answer if I move each task to each agent's prompt. But I believe separating task & agent has a benefit(and I guess that's why how crew ai designed that way?)

Q1 - can I still have multiple tasks when I use manager agent?
Q2 - Is there any complicated use cases of manager agent?
Even the crewai's researcher & writer & manager sample code doesn't run properly when I ran it, the task was done by researcher & manager only.

[pashakbit]

Maybe should we create issue, cause manager_llm/manager_agent functionality is working unexpected?
Or maybe has someone solution to use one common crew with manager that can choose corresponding task/agent by input data and doesn't do every task if input data is not corresponding to that?

[pashakbit]

I found that we can use Flow functionality and create our own delegator, that can works properly.
Something like that:

from crewai import Crew
from crewai.flow.flow import Flow, listen, start

from agents import delegator, agent_1, agent_2, agent_3, agents_config
from tasks import choose_task_and_agents, task_1, task_2, task_3, task_4, tasks_config

agents_dict = {
  'agent_1': {"id": "agent_1", "configuration": agents_config["agent_1"], "agent": agent_1},
  'agent_2': {"id": "agent_2", "configuration": agents_config["agent_2"], "agent": agent_2},
  'agent_3': {"id": "agent_3", "configuration": agents_config["agent_3"], "agent": agent_3},
}
tasks_dict = {
  'task_1': {"id": "task_1", "configuration": tasks_config["task_1"], "task": task_1},
  'task_2': {"id": "task_2", "configuration": tasks_config["task_2"], "task": task_2},
  'task_3': {"id": "task_3", "configuration": tasks_config["task_3"], "task": task_3},
  'task_4': {"id": "task_4", "configuration": tasks_config["task_4"], "task": task_4},
}

class AskFlow(Flow):
  @start()
  def chooseAgentAndTaskToResolveUserQuestion(self):
    """
    This function is responsible for choosing the agents and tasks to resolve the user request.
    It returns a dictionary with the delegation configuration and the user request.
    The delegation configuration is a dictionary with the agents and tasks to be used in the delegation.
    The user request is the request that the user made to the system.
    """

    # Get the user request from the state | provided by inputs from flow.kickoff method
    request = self._state["request"]

    crew = Crew(agents=[delegator], tasks=[delegate])

    inputs = {
      "request": request,
      "agents": json.dumps({"Agents": [{"id": item["id"], "configuration": item["configuration"]} for item in agents_dict.values()]}),
      "tasks": json.dumps({"Tasks": [{"id": item["id"], "configuration": item["configuration"]} for item in tasks_dict.values()]}),
    }
    print(inputs)

    output = crew.kickoff(inputs=inputs)
    result = output.to_dict()

    return {"delegation_config": result, "user_request": request}

  @listen(chooseAgentAndTaskToResolveUserQuestion)
  def resolveUserQuestion(self, data):
    """
    This function is responsible for resolving the user request.
    It returns the final result of the user request.
    """

    choosen_agents_list = [agents_dict[id]["agent"] for id in data["delegation_config"]["agents"]]
    choosen_tasks_list = [tasks_dict[id]["task"] for id in data["delegation_config"]["tasks"]]

    crew = Crew(agents=choosen_agents_list, tasks=choosen_tasks_list)

    output = crew.kickoff(inputs = {"request": data["user_request"]})
    result = output.to_dict()

    return result


flow = AskFlow()
result = flow.kickoff(inputs={"request": "Send message to Maxim with note about our meeting"})

I hope it will help to someone.

[gaya3govindaraj]

can you please share the complete pkg

[pashakbit]

Sorry, but for now I'm not going to share my pet project with github. Maybe I will think about it in the future.

[otomay]

same here, manager is running all the tasks

[AroSwift]

Same here

[mouramax]

I invite you all to check out this CrewAI community thread, which dives into exactly this topic. There, I shared two working code examples: one using the classic approach with Process.hierarchical, and another simplified version leveraging Flows. Hope it helps!