parallel muti agent workflow

[bashiryounis]

Hi everyone,

I'm currently experimenting with multi-agent workflows using LlamaIndex, and I'm looking for some guidance on running agents in parallel rather than sequentially via handoff.

My goal is to have multiple agents (e.g., 4) working simultaneously and independently, while updating a shared state concurrently — instead of relying on the current sequential handoff approach, which slows down the process.

description_agent = FunctionAgent(
    name="DescriptionAgent",
    description="Generates a detailed description of a file based on its code.",
    system_prompt=(
        "Please provide a clear, professional, and comprehensive description of the file's purpose and functionality based solely on the provided code. "
        "After generating the description, hand off control to SummaryAgent to generate a code summary."
    ),
    llm=llm,
    tools=[generate_file_description],
    can_handoff_to=["SummaryAgent"],
)

summary_agent = FunctionAgent(
    name="SummaryAgent",
    description="Generates a summary of the code including its functionality.",
    system_prompt=(
        "Provide an overview of what the code does. "
        "After generating the summary, hand off control to ComplexityAgent for a complexity analysis."
    ),
    llm=llm,
    tools=[generate_code_summary],
    can_handoff_to=["ComplexityAgent"],
)

complexity_agent = FunctionAgent(
    name="ComplexityAgent",
    description="Analyzes the complexity of the code.",
    system_prompt=(
        "Analyze the code's complexity and provide a comprehensive assessment. "
        "After completing the complexity analysis, hand off control to DependencyAgent."
    ),
    llm=llm,
    tools=[analyze_complexity],
    can_handoff_to=["DependencyAgent"],
)

dependency_agent = FunctionAgent(
    name="DependencyAgent",
    description="Extracts and analyzes internal code dependencies.",
    system_prompt=(
        "Extract detailed internal dependency information from the provided code."
    ),
    llm=llm,
    tools=[analyze_dependency],
)

# Initialize the workflow
agent_workflow = AgentWorkflow(
    agents=[
        description_agent,
        summary_agent,
        complexity_agent,
        dependency_agent,
    ],
    root_agent=description_agent.name,
    initial_state={
        "file_description": "",
        "code_summary": "",
        "complexity_analysis": "",
        "dependency_analysis": [],
    },
)

the current setup relies on agent handoffs, which makes the workflow sequential. Instead, I'd like to run all four agents in parallel, letting them process the input concurrently and update the shared state as their tasks complete.

Is there a recommended pattern or approach within LlamaIndex (or any best practice) to achieve this kind of parallel agent execution?

Thanks in advance for your help!

[dosubot[bot]]

Hey @bashiryounis! I'm here to help you with any bugs, questions, or contributions you have. Let's tackle this together!

LlamaIndex supports parallel execution of agents natively through its workflow functionality. You can achieve parallel processing by using the @step(num_workers=N) decorator, which allows you to control the number of steps executed simultaneously. This enables efficient parallel execution without requiring external libraries or frameworks ^[1].

For your specific use case, you can modify your workflow to utilize this parallel execution feature. Here's a general approach you can follow:

1. Define Parallel Steps: Use the @step decorator to define each agent's task as a step in the workflow. Set the num_workers parameter to the number of agents you want to run in parallel.

2. Manage Shared State: Ensure that your shared state is updated in a thread-safe manner. While LlamaIndex provides the mechanism for parallel execution, you may need to implement your own logic to handle concurrent updates to the shared state.

3. Synchronize Task Completion: Use the schedule method to run tasks in parallel while respecting dependencies. This method uses asyncio.gather to execute tasks concurrently and checks for task completion ^[2].

By following these steps, you can set up a parallel agent workflow in LlamaIndex that allows multiple agents to work simultaneously and independently, updating a shared state as their tasks complete.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}