What You Will Learn

• Understand LlamaIndex core components (LLMs, tools, workflows, context)
• Design and orchestrate multi-agent research workflows and handoffs
• Integrate and define tooling with type annotations and docstrings
• Implement streaming output, context management, and human-in-the-loop events

Study Guide

Introduction: Why Build Deep Research AI Multi-Agent Systems with LlamaIndex?

If you want to harness the real power of AI, you have to go deeper than just chatbots or simple automation. This course is your guide to building advanced, multi-agent AI systems specifically designed for deep research tasks, using the LlamaIndex framework.
LlamaIndex is more than just another AI toolkit. It’s a framework that enables you to build, orchestrate, and control AI agents,and, more importantly, multi-agent systems,that can handle complex research, reason through tasks, use external tools, and even work with humans in the loop. If you need an AI that can do more than answer trivia and actually create structured, actionable knowledge, you’re in the right place.

We’ll walk step-by-step from the basics of what an AI agent is, through integrating tools and managing context, all the way to constructing custom, parallelized workflows and orchestrating teams of specialized agents. By the end, you’ll have the mental models and practical skills to build your own deep research multi-agent systems,systems that can search, analyze, synthesize, and report on complex topics, all with real-time feedback and human guidance when needed.

This is not just a coding tutorial. It’s a blueprint for building the kind of AI that actually moves the needle, whether you’re building for yourself, your team, or your business.

The Two Core AI Trends Enabling Advanced Agents

There are two forces driving the explosion of useful AI agents: improved reasoning and improved tool use.
Let’s break both down:

1. AI is Getting Better at Reasoning
   AI models, especially Large Language Models (LLMs), have become much more capable of logical reasoning, deduction, and multi-step thinking. This matters because deep research isn’t just about collecting facts,it’s about connecting dots, forming hypotheses, and structuring knowledge. For example:
   • Example 1: An LLM can be prompted to break a complex question into sub-questions, research each individually, and then synthesize a comprehensive answer.
   • Example 2: An agent can reflect on its previous answers, critique them, and decide to revise or redo research steps if the initial results seem insufficient.
2. AI is Getting Better at Using Tools
   Modern LLMs can call external tools,APIs, web search, databases, code execution,transforming them from text predictors into autonomous agents. This means your AI can:
   • Example 1: Use a web search API like Tavily to find up-to-date information and then analyze it for relevance.
   • Example 2: Call a custom Python function to perform calculations, query internal databases, or automate complex tasks outside the LLM’s core capabilities.

These two trends,reasoning and tool use,are the foundation of building deep research agents. LlamaIndex is the framework that brings them together in a unified, developer-friendly way.

LlamaIndex: The AI Agent Development Framework

LlamaIndex is your toolkit for building AI agents and multi-agent systems.
It provides both high-level abstractions for rapid prototyping and lower-level classes for granular control.

• High-Level System (Agent Workflow): This lets you quickly create and run an agent by wiring together tools, an LLM, and a system prompt. Perfect when you want to get started fast or your agent’s workflow is straightforward.
  • Example 1: Build a single-agent research assistant that can answer questions by searching the web and summarizing results.
  • Example 2: Create a simple multi-agent workflow where a “Research Agent” gathers facts and a “Summary Agent” compiles them.
• Low-Level System (Workflow Classes): Use these when you need custom workflows: parallel execution, loops, custom event handling, and fine-grained state management.
  • Example 1: Build a workflow where multiple agents research different sub-questions in parallel, then aggregate their answers.
  • Example 2: Create a workflow that pauses for human review mid-process, or loops back to retry a step if certain criteria aren’t met.

With LlamaIndex, you’re not locked into a one-size-fits-all approach. Start simple, go deep as needed.

The Core Components of LlamaIndex Agents

To build agents that can tackle deep research, you need to understand and leverage several foundational components.

1. Large Language Models (LLMs)
   The LLM is your agent’s “brain.” LlamaIndex supports multiple LLMs; in the course, OpenAI’s 4.1 Mini is used for demonstration.
   • Example 1: Use OpenAI’s GPT to interpret user queries, decide which tools to use, and synthesize answers.
   • Example 2: Swap in a local LLM for privacy-sensitive applications or to reduce costs.
2. Tools
   Tools are Python functions (or APIs) that your agent can call to perform specific tasks. LlamaIndex recognizes tools by their metadata:
   • Name: Tells the agent what the tool is called.
   • Type Annotations: Specify input and output types, helping the LLM understand how to use the tool.
   • Docstrings: Explain what the tool does.
   • Example 1: Tavily Search Tool
     A function wrapping Tavily’s web search API with a clear name, input (search query), output (results), and a descriptive docstring. This enables the agent to fetch up-to-date information.
   • Example 2: Custom Database Query Tool
     A Python function that takes a query string and returns results from a company’s internal knowledge base, allowing the agent to pull proprietary data.

   Pro Tip: Always provide clear type annotations and docstrings. LlamaIndex uses this metadata so the LLM can “see” and use your tool correctly.
   

3. Agent Workflow (agent workflow class)
   This is a high-level abstraction for quickly wiring together your LLM, tools, and a system prompt into a functioning agent. You can run it with a user message as input.
   • Stateless by Default: Each run starts fresh, but you can pass a context object to preserve state across runs.
   • Example 1: Run agentworkflow.run(“What’s the latest research on quantum computing?”) to kick off a research process that uses your tools and LLM.
   • Example 2: Pass a context object to agentworkflow.run to remember previous answers, enabling the agent to build on past knowledge in a conversational session.
4. Context Management
   Agents can remember facts, previous interactions, or custom state by using a context object. You can access and modify context from within tools, allowing for persistent, stateful workflows.
   • Example 1: Store a user’s research preferences (e.g., preferred sources) in context, so the agent tailors future searches accordingly.
   • Example 2: Tools can log intermediate results or flags in context, enabling later steps or agents to pick up where another left off.

   Tip: For quick prototyping, agent workflows “remember” everything by default if you keep context. For granular control, manage state manually in custom workflows.
   

Integrating and Defining Tools in LlamaIndex

Let’s get practical: How do you actually add a tool your agent can use?
Define a standard Python function with:

• A descriptive name (e.g., search_with_tavily)
• Type annotations for all input and output parameters
• A clear docstring explaining the tool’s purpose and usage

LlamaIndex parses this metadata so the LLM knows exactly what the tool does and how to use it.

• Example 1:
  def search_with_tavily(query: str) -> str: """ Search the web with Tavily and return the top result. """ # Call Tavily API and return the result
• Example 2:
  def query_internal_db(query: str, context: Context) -> List[Dict]: """ Query the internal database for relevant documents using the provided query. """ # Database logic here

Best Practice: Keep your tool functions minimal and precise. The LLM will use the function name, type hints, and docstring to reason about when and how to invoke the tool.

Agent Workflow: Rapid Agent Prototyping

The agent workflow is LlamaIndex’s high-level system for building and running agents quickly.

• Key Properties:
  • Runs with a user message as input (“agent workflows always start with a user message”)
  • Stateless by default, but context can be passed to maintain state
  • Supports single agents or simple multi-agent systems
• Example 1:
  Run an agent with a prompt like “Summarize the latest trends in artificial intelligence,” and have it use your defined search tool to find and synthesize information.
• Example 2:
  Use agentworkflow.run with a context object, so the agent can refer back to information gathered in previous steps, such as “Now, analyze the sources we found earlier.”

Tip: Use the agent workflow to get started, but move to custom workflows as your application logic gets more complex.

Context and State Management: Making Agents Remember

Context is what makes an agent stateful. It’s an object you pass and update throughout your workflow, giving your agent memory.

• Use Cases:
  • Tracking facts, questions, or intermediate results
  • Storing user preferences or session info
  • Communicating between tools and steps
• Example 1:
  Store a cumulative list of research findings in context, so later steps can reference or summarize them.
• Example 2:
  Tools can update context with flags (e.g., “need human review”) to influence future workflow steps.

Best Practice: If you need fine-grained control over what gets remembered, use custom workflow classes and manage context variables yourself.

Streaming Output: Real-Time User Feedback

AI agents, especially those performing deep research, can take time to run. Streaming output is essential for a great user experience, letting users know what’s happening in real time.

• How It Works in LlamaIndex:
  • Run your workflow to get a handler object
  • Iterate through handler.stream_events() to process events as they’re generated
  • Event types include agent input, agent output, tool calls, and results
• Example 1:
  As your research agent calls the Tavily search tool, stream updates to the user: “Searching for recent publications...found N relevant articles.”
• Example 2:
  When compiling a report, stream each section as it’s written, letting the user see progress and intermediate results.

Tip: For custom workflows, remember to manually write events to the stream using context.write_event_to_stream.

Human-in-the-Loop: Integrating Human Judgment

Sometimes, even the best AI needs a human check,whether for confirmation, providing missing information, or making high-stakes decisions. Human-in-the-loop functionality is built in.

• Key Events:
  • InputRequiredEvent: Emitted by the workflow or a tool when human input is needed.
  • HumanResponseEvent: Sent by the handler/human back into the workflow with the required input.
• Example 1:
  The agent needs clarification (“Which market segment should we focus on?”), so it emits an InputRequiredEvent, and the workflow pauses until a human provides an answer.
• Example 2:
  Before publishing a report, the agent requests human approval, pausing execution until a HumanResponseEvent signals confirmation.

Best Practice: Subclass input/response events to handle complex data structures as needed. This allows for rich, structured human interactions.

Multi-Agent Systems: Dividing and Conquering Complex Tasks

When your task is too complex for a single agent, you need a multi-agent system. This means dividing responsibilities among specialized agents and orchestrating their interactions.

• Why Multi-Agent?
  • Different agents excel at different tasks (e.g., question generation, web research, synthesis)
  • Specialization leads to better logic, clearer code, and more maintainable systems
• Example 1:
  A “Question Agent” generates research questions, “Answer Agents” find answers using web search, and a “Report Agent” compiles everything into a final document.
• Example 2:
  An “Extract Agent” pulls structured data from unstructured documents, then hands off to a “Validate Agent” for quality checks.

Division of Labor Tip: Assign separate agents when you have specialized, complex tasks that shouldn’t be repeated or mixed with others. Think of your agents like team members,clear roles lead to better performance and less confusion.

How Multi-Agent Systems Pass Control

Agents in a multi-agent system often need to “handoff” control to each other. In LlamaIndex:

• System Prompts: You can instruct agents in their system prompt to handoff under certain conditions.
• Handoff Tool: Use a built-in tool or explicit function to transfer workflow control from one agent to another.
• Example 1:
  Once the “Question Agent” finishes generating questions, it explicitly hands off to multiple “Answer Agents” to tackle the questions in parallel.
• Example 2:
  After gathering all answers, the system automatically transitions to the “Report Agent” to synthesize and format the results.

Function Agent vs. React Agent: Choosing the Right Agent Type

LlamaIndex supports two main agent types for multi-agent workflows:

• Function Agent: Uses native tool calling capabilities of supported LLMs (like OpenAI). This is preferred,more reliable, and the LLM knows exactly how to call tools.
• React Agent: Uses a fallback pattern (Reasoning and Acting) for LLMs without native tool calling. It’s more general, but less reliable, because the LLM only indicates its intent to use a tool.
• Example 1:
  Use a Function Agent when your LLM supports structured tool calling,like GPT models with function calling APIs.
• Example 2:
  Use a React Agent for LLMs that don’t support native tool calling, or when prototyping with different models.

Best Practice: Always prefer Function Agents when available. Only drop to React Agents for broader model compatibility.

Custom Workflows: Building from Scratch for Total Control

If you need more than what agent workflow offers,loops, branches, parallel steps, or fine-tuned state,build a custom workflow class.

• Basic Structure:
  • Subclass LlamaIndex’s workflow base class
  • Define steps with the @step decorator
  • Connect steps using type annotations that specify which event types each accepts/emits
• Example 1:
  Define a workflow where you first generate questions, then have multiple answer steps run in parallel, then aggregate answers, and finally synthesize a report.
• Example 2:
  Build a workflow with a loop, where the agent can re-ask a research question if the initial answer doesn’t meet certain criteria, until a satisfactory answer is produced.

Advantages: Custom workflows give you full control over execution flow, state, error handling, and user feedback.

Workflow Components: Steps, Events, Loops, Branches, and Parallelism

Custom workflows in LlamaIndex are built from these primitives:

• Steps: Python functions decorated with @step; each represents a logical unit (e.g., “generate research questions”).
• Events: Data objects that trigger steps and carry information between them.
• Start Event: Triggers the first step in your workflow.
• Stop Event: Signals workflow completion.
• Custom Event Classes: Pass custom data between steps (e.g., question lists, answer objects).

Advanced Patterns:

• Loops: Steps can loop back to previous steps by emitting events those steps accept. Use this for “reflection” or retries.
  • Example 1:
    After generating an answer, the agent reflects on its quality and, if unsatisfactory, re-enters the answering step with feedback.
  • Example 2:
    Implement a “clarification loop” where the agent asks the user for more information if it can’t proceed.
• Branches: Workflows can emit different event types to follow different execution paths, enabling dynamic decision-making.
  • Example 1:
    If a research topic is too broad, the workflow can branch into a sub-question generation path.
  • Example 2:
    Based on the user’s input, the workflow can branch into either “Technical Research” or “Market Research” paths.
• Concurrent Execution (Parallelism): Steps can send multiple events, triggering parallel execution. Manage concurrency limits as needed.
  • Example 1:
    Generate five research questions, then spawn five parallel answer agents to tackle each one simultaneously.
  • Example 2:
    Run data extraction and validation in parallel on multiple documents, then aggregate results.
• Event Collection: Use context.collect_events to wait for all parallel events to complete before proceeding.
  • Example 1:
    Wait for all answer agents to finish before passing answers to the report agent.
  • Example 2:
    Collect results from multiple data sources before aggregating insights.

  Tip: The order of collected events isn’t guaranteed,include identifiers in your events if result order matters.

Streaming in Custom Workflows

When you build custom workflows, you’re responsible for streaming events to the user interface. Use context.write_event_to_stream to send updates.

• Example 1:
  Stream progress updates as agents answer questions in parallel: “Answering question 1 of 5...”
• Example 2:
  Stream each section of a research report as it’s compiled, so the user sees live results.

Tip: Streaming is crucial for long-running processes. It provides transparency, builds trust, and helps with debugging.

Deep Research Multi-Agent System: A Complete Example

Let’s put it all together. Here’s how you’d architect a deep research multi-agent system using LlamaIndex’s custom workflow:

• Agents Involved:
  • Question Agent: Generates a set of research questions on a given topic.
  • Answer Agent: Answers each question using search tools (e.g., Tavily), with each agent running in parallel.
  • Report Agent: Compiles all answers into a structured research report.
• Workflow Steps:
  1. Start event triggers the Question Agent.
  2. Generated questions are passed as events to spawn multiple Answer Agents in parallel.
  3. Each Answer Agent uses the search tool, updates context, and streams progress.
  4. context.collect_events waits for all answers before proceeding.
  5. All answers are handed to the Report Agent, which synthesizes and streams the final report.
• Streaming and Feedback: Progress is streamed to the user at each step, so they see questions being generated, answers being found, and the report being built.
• Example 2:
  You could extend this system with a “Reviewer Agent” that checks the report for accuracy and requests human input if uncertainty is detected.

Takeaway: Multi-agent systems enable you to divide complex research into manageable, parallelizable tasks, while streaming keeps the user engaged and informed.

Human Intervention: Adding Flexibility and Trust

Human-in-the-loop isn’t just for error correction,it’s a powerful pattern for adding flexibility, oversight, and trust in your agent systems.

• Flexibility: Humans can inject new information, clarify ambiguities, or make judgment calls that the AI can’t handle.
• Trust: By requiring human approval before critical actions (e.g., publishing a final report), you reduce risk.
• Example 1:
  The agent pauses and asks the user, “Is this the direction you want to pursue?” before launching a long, resource-intensive research phase.
• Example 2:
  An agent requests human input to resolve conflicting data sources, letting the user pick the most credible one.

Tip: Subclass input/response events to pass rich data,like annotated documents or structured choices,between agent and user.

Parallelization and Event Collection: Doing More, Faster

Parallel execution is essential for scaling research. LlamaIndex lets you emit multiple events from a step, triggering concurrent processing.

• Key Considerations:
  • Framework handles most pitfalls, but order of results isn’t guaranteed
  • Include identifiers (e.g., question ID) in your events for easy reordering
• Example 1:
  Dispatch five Answer Agents in parallel, each tagged with their question ID. Collect and reorder results before synthesizing.
• Example 2:
  For document extraction, process ten documents in parallel, then aggregate results by document ID.

Tip: Use context.collect_events to wait for all parallel tasks to finish before moving to the next stage.

Best Practices: Task Division and State Management

• Divide tasks between agents when:
  • The logic is specialized and complex enough to be encapsulated
  • Different agents need to use different tools or strategies
  • You want clean separation of concerns, like real-world teams
• Example 1:
  Assign question generation, answering, and reporting to separate agents instead of one monolithic agent.
• Example 2:
  Create a validation agent whose sole job is to check the work done by other agents.

For state management:

• Agent workflow remembers everything by default,great for prototyping and conversational memory.
• For granular control, build a custom workflow and explicitly manage what gets stored in context.

Visualization and Streaming: Why Real-Time Matters

Visualizing progress and streaming outputs aren’t just UX perks,they are crucial for debugging, monitoring, and user trust.

• Debugging: See where your workflow gets stuck, which events are emitted, and what data is passed at each step.
• Monitoring: Track progress on long-running research tasks, catch failures or delays early, and ensure workflows complete as expected.
• User Experience: Users are less likely to abandon or mistrust an agent if they see real-time updates and intermediate results.
• Example 1:
  Display a progress bar or timeline in your UI, updated via streamed events from your workflow.
• Example 2:
  Show users partial answers as soon as each Answer Agent completes, instead of waiting for the entire process to finish.

Tip: Stream everything that could help users (or developers) understand what’s happening under the hood.

Key Takeaways and Next Steps

Building a deep research AI multi-agent system with LlamaIndex is about more than wiring up an LLM to answer questions. It’s about orchestrating specialized agents, integrating external tools, managing state, handling parallel execution, and streaming progress to users,all while empowering humans to intervene where needed.

• Leverage both high-level agent workflow and low-level custom workflows: Start simple, but be ready to build custom logic as your needs grow.
• Design your system like a real team: Assign clear responsibilities, specialize agents, and handle handoffs cleanly.
• Stream progress and invite human intervention: This improves trust, usability, and operational safety.
• Master parallelism and event collection: It’s the key to scalable, efficient research workflows.

Now, put these skills to work. Build agents that don’t just answer questions,they research, reason, reflect, collaborate, and report. That’s the future of AI-powered research, and with LlamaIndex, you’re holding the blueprint.

Explore the LlamaIndex documentation for deeper dives, experiment with workflow primitives, and start architecting your own multi-agent systems for your most challenging research tasks.

Frequently Asked Questions

This FAQ brings clarity to everything you need to know about building deep research AI multi-agent systems using LlamaIndex,whether you’re just starting out or looking to fine-tune complex implementations. Here you'll find detailed answers on concepts, workflow structures, practical applications, and best practices. The goal: equip you to build, customize, and deploy effective multi-agent AI research systems for real-world business needs.

What are the two main AI trends discussed in the source?

AI is now better at reasoning and using tools autonomously.
The source highlights two significant trends: first, AI's improved reasoning abilities, making it suitable for complex research; second, AI's enhanced capacity to use tools, enabling it to work autonomously as an agent. This means agents can not only analyze but also act,retrieving data, summarizing, or even making decisions, all while leveraging external resources.

What is LlamaIndex and how does it help build AI agents?

LlamaIndex is an AI development framework for building agents and workflows.
It simplifies the process of creating AI-powered applications, including single and multi-agent systems. LlamaIndex offers high-level abstractions for quick prototyping and lower-level workflow classes for custom builds, allowing you to integrate tools, maintain state, and orchestrate complex agent behaviors with minimal overhead.

What is an "agent workflow" in LlamaIndex and how is it used to create a single agent?

Agent workflow is a high-level abstraction for quick agent creation.
Using AgentWorkflow.from_tools_or_functions(), you supply an array of tools or functions, an LLM (Large Language Model), and a system prompt. This setup lets you rapidly deploy a single agent that can perform complex tasks by reasoning and autonomously using the configured tools, often with just a few lines of code.

How can an agent maintain context or memory across different runs?

Agent workflows are stateless by default.
To give your agent memory, you must create a context object and pass it to workflow.run() on each call. This context object can store facts, previous responses, or any state information the agent needs for continuity. Tools and steps can also be designed to read from and update this context, enabling multi-turn conversations and persistent knowledge.

How does LlamaIndex facilitate human intervention in an agent's workflow?

Human-in-the-loop functionality is built-in using events.
Agents can emit an InputRequiredEvent to signal that human input is needed. A handler prompts the user, collects input, and returns it as a HumanResponseEvent so the workflow can continue. This approach seamlessly integrates human expertise where AI decisions need oversight or clarification, bridging the gap between automation and control.

How are multi-agent systems built using LlamaIndex's agent workflow?

Multi-agent systems are created by composing multiple agents with dedicated roles.
Using the AgentWorkflow class, you instantiate several specialized agents (e.g., one for research, another for writing, and a third for reviewing). These agents can pass tasks and data using a built-in handoff tool, allowing for collaborative problem-solving and delegation. The root agent initiates the process, and control flows naturally among agents as the task progresses.

What are the advantages of building a custom workflow from scratch using LlamaIndex's workflow classes compared to using agent workflow?

Custom workflows offer granular control and flexibility.
While agent workflow accelerates development, building from scratch allows you to define precise steps, handle structured inputs/outputs, implement advanced logic like query planning or reflection (self-evaluation), and set up concurrent tasks. For example, you might customize how agents prioritize tasks, implement error handling, or accommodate non-standard data types,capabilities essential in complex or regulated business environments.

How does LlamaIndex support concurrent execution and collecting results from parallel tasks within a workflow?

Concurrency is managed with events and context.
Within a workflow step, you can call send_event multiple times to trigger parallel branches. To gather their results, use collect_events on the context, specifying how many or what type of events to wait for. This makes it possible to run multiple research queries or analyses simultaneously, then aggregate the findings for further processing or reporting.

How does LlamaIndex enable integration with external tools like Tavily, and what metadata is important for tool usage?

External tools are integrated as Python functions with clear documentation.
LlamaIndex wraps third-party APIs by defining Python functions that include descriptive names, precise type annotations (for parameters and outputs), and informative docstrings. This metadata helps the LLM understand when and how to use each tool, making tool invocation reliable and context-aware. For example, the Tavily search tool can be seamlessly triggered by an agent to perform web lookups as part of a research workflow.

How can a tool function access the workflow's context in LlamaIndex?

Tools can access context by accepting it as the first parameter.
When a tool function is defined with context as its first argument, LlamaIndex automatically passes the current context object during execution. This allows the tool to read shared data, update state, or synchronize information across steps and agents. For instance, a research tool could store findings in context for later summarization by a report-writing agent.

Why is streaming output important for user experience, and how does LlamaIndex implement it?

Streaming output keeps users informed in real time.
Instead of waiting for the entire workflow to finish, streaming delivers updates or partial results as soon as they're available. In LlamaIndex, this is handled by obtaining a handler from workflow.run and iterating through handler.stream_events(). This approach improves transparency, reduces perceived latency, and helps users stay engaged,crucial in research scenarios with long-running tasks.

What is the difference between a Function Agent and a React Agent in LlamaIndex?

Function Agents use native tool-calling, while React Agents use a fallback pattern.
A Function Agent leverages LLMs that can natively call tools by generating structured tool-use outputs, resulting in higher reliability. A React Agent (Reasoning and Acting) works with any LLM, but the agent must infer tool usage from the model's output, which is less dependable. Use a Function Agent when your LLM supports this feature (like OpenAI); use a React Agent for broader compatibility.

What is event collection in LlamaIndex workflows, and why is it useful?

Event collection synchronizes parallel tasks.
When running multiple branches concurrently, you often need to wait for all results before proceeding. context.collect_events enables a step to pause execution until a specific number or type of events have been received. For example, if an agent launches three research queries in parallel, event collection ensures all three responses are in before moving to the synthesis step.

How do custom tools and workflow context contribute to building more capable agents?

Custom tools extend agent capabilities, while context ensures memory and state.
By defining tools tailored to your domain (e.g., accessing proprietary databases), you make agents more useful. Context enables these tools and steps to store and share intermediate results. For example, a data-enrichment tool can write new facts to context, which a later summarization step uses to generate a comprehensive report.

How does the structure of a deep research multi-agent system work in LlamaIndex?

Multi-agent systems use specialized agents with coordinated roles.
A common pattern includes a Question Agent (formulates research queries), Answer Agent (finds answers using tools), and Report Agent (compiles findings into a report). Each agent focuses on its specialty, passing tasks and data along a defined path. This division of labor leads to higher quality outputs, modularity, and easier debugging.

What is the handoff tool in LlamaIndex multi-agent systems?

The handoff tool enables control transfer between agents.
When one agent completes its portion of the workflow, it uses the handoff tool to delegate the next step to another agent. For instance, after gathering research, the Research Agent can hand off to the Report Agent for synthesis, ensuring seamless collaboration and flow of information.

What kinds of Large Language Models (LLMs) does LlamaIndex support?

LlamaIndex supports a wide range of LLMs.
You can use open-source models (like Llama, GPT-Neo), commercial APIs (OpenAI's GPT, Anthropic’s Claude), or even self-hosted models. The framework is designed to be LLM-agnostic, but certain features like Function Agent tool-calling require model support.

How does LlamaIndex handle looping and reflection in workflows?

Custom workflows can implement loops and self-reflection.
By defining steps that can revisit previous outputs (reflection), an agent can evaluate its work and decide whether to revise or continue. For example, if a report agent detects gaps in its summary, it can trigger a new research cycle. This leads to higher quality and more trustworthy results.

Can LlamaIndex workflows support branching and conditional logic?

Yes,branching is achieved through event-based triggers and conditional steps.
Workflow steps can be configured to emit specific events based on logic, which route execution down different branches. For example, if a research result is inconclusive, the workflow can branch into a fallback process for additional data gathering.

How does visualization and streaming output help when developing complex workflows?

Visualization and streaming output improve debugging and user experience.
Streaming provides instant feedback, making long-running processes more transparent. Visualization tools (like event logs or flow diagrams) help developers understand how data and control move through the workflow, identify bottlenecks, and ensure agents are collaborating as intended. This is especially valuable in multi-agent research systems where tracing interactions is critical.

What are some common challenges when building multi-agent workflows with LlamaIndex?

Challenges include managing state, agent coordination, and tool reliability.
Keeping context consistent across agents, handling errors from external tools, and designing smooth handoffs all require attention. It's also important to monitor for bottlenecks in parallel execution and design clear system prompts so agents understand their roles. Using streaming and visualization helps catch issues early and iterate quickly.

What are practical business applications of deep research AI multi-agent systems?

Applications span market research, due diligence, competitive analysis, and more.
For example, a multi-agent system can ingest client requirements, launch targeted web searches, extract relevant data, and automatically generate a detailed competitor report. This drastically reduces time-to-insight and can be tailored for industries like finance, consulting, or legal research.

Why is the agent workflow stateless by default, and when should you enable context?

Stateless execution ensures isolation and reproducibility.
By default, each run starts fresh, which is ideal for single-turn tasks or when privacy demands no data retention. Enable context when you need multi-turn interactions or the agent must remember previous results (e.g., a research assistant that builds on past findings).

What are the key event types in LlamaIndex workflows, and how do they affect execution?

Main event types include InputRequiredEvent, HumanResponseEvent, and StopEvent.
Events are the signals that move execution forward, request user input, or end the workflow. For example, a StopEvent can be emitted to signal completion, while InputRequiredEvent pauses execution for human input. Understanding event flow is crucial for designing robust, interactive agents.

What is a workflow step, and how is it defined in LlamaIndex?

A step is a unit of logic within a workflow, marked by the @step decorator.
Each step is a Python function that processes input events and emits output events. Steps can perform computation, call tools, or manage control flow. For example, a "Summarize" step might aggregate findings, while a "Validate" step checks for completeness before proceeding.

What are potential pitfalls of tool calling in LlamaIndex workflows?

Challenges include tool misfires and unclear documentation.
If function names, type annotations, or docstrings are ambiguous, the LLM may misuse tools or fail to trigger them. Always provide clear, specific metadata and validate tool integration with test cases. For critical business use, add error handling and fallback logic.

What are key security and privacy considerations with LlamaIndex multi-agent workflows?

Protect sensitive data and control tool access.
Ensure that context objects and tool outputs do not leak confidential information. When integrating external APIs, use secure authentication and consider sandboxing agents. Human-in-the-loop steps are also an opportunity to inspect and approve outputs before they’re finalized.

What are best practices for designing prompts and roles for agents in LlamaIndex?

Be explicit and specific in system prompts.
Clearly define each agent’s role, capabilities, and handoff criteria. For example: “You are the Research Agent. Use the search tool to answer the provided question and pass your findings to the Report Agent.” This reduces ambiguity and makes agent collaboration more predictable.

How does LlamaIndex handle scaling for large workloads or many concurrent users?

Scaling relies on workflow design and infrastructure choices.
Use parallel steps and efficient event collection for high-throughput. For heavy workloads, run LlamaIndex workflows on scalable cloud services, and partition tasks across agents or instances. Monitor for bottlenecks at tool APIs or LLM endpoints, and use streaming output to manage user expectations.

Can context be shared between different agents or workflows in LlamaIndex?

Yes, context can be passed and updated across agents.
When designing multi-agent systems, ensure each agent reads from and writes to the shared context object, or pass the context explicitly between workflows. This allows for persistent knowledge, such as shared research notes or progress markers.

How do you troubleshoot errors in LlamaIndex agent workflows?

Use detailed logs, event inspection, and visualization.
Enable verbose logging to track event flow, tool calls, and agent decisions. Review context objects and intermediate outputs. If possible, visualize workflow graphs to pinpoint where execution diverges from expectations. Isolate problematic steps and test them individually using mock inputs.

How do you stay current with improvements or changes in LlamaIndex?

Follow official documentation and the community.
Check the LlamaIndex documentation, GitHub repository, and community forums for new releases, best practices, and sample projects. Many common patterns and troubleshooting tips are shared by other practitioners, accelerating your learning curve.

What’s a concrete example of a deep research multi-agent workflow using LlamaIndex?

Example: Automated competitor analysis for a sales team.
The workflow includes a Research Agent (searches the web and internal CRM), a Summarization Agent (compiles findings), and a Report Agent (generates a formatted PDF). Each agent uses dedicated tools and shares context, delivering a high-quality analysis with minimal manual input.

How should a business professional start building with LlamaIndex?

Begin with a simple agent workflow, then expand as needed.
Start by defining your main goal (e.g., automate research or reporting). Implement a single-agent workflow with basic tools and context. Once validated, add specialized agents and custom tools, and evolve toward a multi-agent system. Use streaming output and visualization to ensure transparency and continuous improvement.