Crew AI Multi-Agent System for Investment

The CrewAI Financial Researcher is an autonomous agent designed to collect, analyze, and synthesize financial data using large language models (LLMs), custom tools, and structured multi-agent workflows. It supports finance teams, analysts, and product builders by automating high-effort research tasks with high accuracy and speed.

Purpose

The Financial Researcher agent acts as your intelligent analyst, capable of:

• Gathering financial information from APIs, news, internet, etc.

• Performing qualitative and quantitative analysis

• Generating insights for investment, risk, market, and competitive intelligence

• Summarizing complex financial documents

Follwoing five steps need to follow to create Crew AI Project

1. Create the project with: crewai crew financial_research

2. Fill the config yaml files to define the Agents and Tasks.

3. Create crew.py module to create the Agents, Tasks, and Crew, referencing the config.

4. Update main.py to set any inputs

5. Run with: crewai run

Fill the config yaml files to define the Agents and Tasks

agents.yaml file

agents.yaml is a configuration file in CrewAI that defines all agents involved in a multi-agent workflow, including roles, goals, backstories, and the LLM used for all agents.

researcher:
  role: >
    Senior Financial Researcher for {company}
  goal: >
    Research the company, news and potential for {company}
  backstory: >
    You're a seasoned financial researcher with a talent for finding
    the most relevant information about {company}.
    Known for your ability to find the most relevant
    information and present it in a clear and concise manner.
  llm: <LLM>

analyst:
  role: >
    Market Analyst and Report writer focused on {company}
  goal: >
    Analyze company {company} and create a comprehensive, well-structured report
    that presents insights in a clear and engaging way
  backstory: >
    You're a meticulous, skilled analyst with a background in financial analysis
    and company research. You have a talent for identifying patterns and extracting
    meaningful insights from research data, then communicating
    those insights through well crafted reports.
  llm: <LLM>

tasks.yaml file

tasks.yaml is a configuration file where you define all tasks executed by agents in a CrewAI workflow.

Each task describes:

• what needs to be done

• which agent performs it

• what the task should output

• whether the output should be saved for later tasks

# src/research_crew/config/tasks.yaml
research_task:
  description: >
    Conduct thorough research on company {company}. Focus on:
    1. Current company status and health
    2. Historical company performance
    3. Major challenges and opportunities
    4. Recent news and events
    5. Future outlook and potential developments

    Make sure to organize your findings in a structured format with clear sections.
  expected_output: >
    A comprehensive research document with well-organized sections covering
    all the requested aspects of {company}. Include specific facts, figures,
    and examples where relevant.
  agent: researcher

analysis_task:
  description: >
    Analyze the research findings and create a comprehensive report on {company}.
    Your report should:
    1. Begin with an executive summary
    2. Include all key information from the research
    3. Provide insightful analysis of trends and patterns
    4. Offer a market outlook for company, noting that this should not be used for trading decisions
    5. Be formatted in a professional, easy-to-read style with clear headings
  expected_output: >
    A polished, professional report on {company} that presents the research
    findings with added analysis and insights. The report should be well-structured
    with an executive summary, main sections, and conclusion.
  agent: analyst
  context:
    - research_task
  output_file: output/report.md

Create crew.py module to create the Agents, Tasks, and Crew, referencing the config.

# src/financial_researcher/crew.py
from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task


@CrewBase
class ResearchCrew():
    """Research crew for comprehensive topic analysis and reporting"""

    @agent
    def researcher(self) -> Agent:
        return Agent(
            config=self.agents_config['researcher'],
            verbose=True
        )

    @agent
    def analyst(self) -> Agent:
        return Agent(
            config=self.agents_config['analyst'],
            verbose=True
        )

    @task
    def research_task(self) -> Task:
        return Task(
            config=self.tasks_config['research_task']
        )

    @task
    def analysis_task(self) -> Task:
        return Task(
            config=self.tasks_config['analysis_task'],
            output_file='output/report.md'
        )

    @crew
    def crew(self) -> Crew:
        """Creates the research crew"""
        return Crew(
            agents=self.agents,
            tasks=self.tasks,
            process=Process.sequential,
            verbose=True,
        )

Update main.py to set any inputs

#!/usr/bin/env python
# src/financial_researcher/main.py
import os
from financial_researcher.crew import ResearchCrew

# Create output directory if it doesn't exist
os.makedirs('output', exist_ok=True)

def run():
    """
    Run the research crew.
    """
    inputs = {
        'company': 'Google'
    }

    # Create and run the crew
    result = ResearchCrew().crew().kickoff(inputs=inputs)

    # Print the result
    print("\n\n=== FINAL REPORT ===\n\n")
    print(result.raw)

    print("\n\nReport has been saved to output/report.md")

if __name__ == "__main__":
    run()

Execute the code with the command: crewai run

Here is the sample output Comprehensive Report on Google

Executive Summary Google, under the umbrella of Alphabet Inc., has demonstrated robust financial growth, with a 14% year-over-year increase in services revenue reaching $87.1 billion in Q3 2025. The company's operating margins and return on assets have also shown significant improvement. Historically, Google has exhibited consistent growth, with annual revenues forecasted to reach $305.63 billion in 2025. Despite facing challenges such as antitrust legal issues, market competition, and regulatory scrutiny, Google is poised for future growth through advancements in artificial intelligence, expansion of cloud solutions, and commitment to sustainability. This report provides a detailed analysis of Google's current status, historical performance, challenges, opportunities, recent news, and future outlook.

1. Introduction to Google Google, founded in 1998, has evolved into a multinational technology company specializing in Internet-related services and products. Under the parent company Alphabet Inc., Google's primary sources of revenue include advertising, cloud computing, hardware, and software.

2. Current Company Status and Health As of 2025, Google maintains a strong financial position. Key financial metrics include:

• Services revenue: $87.1 billion in Q3 2025, reflecting a 14% year-over-year increase.

• Operating margins: 32.19%.

• Return on assets (ROA): Improved to 25.71%.

• Stock price performance: Rebounded significantly since the lows of 2022, with a 60.25% increase over the past year.

3. Historical Company Performance Google's historical performance has been consistently strong, with significant annual revenue growth:

• 2021: $256.74 billion.

• 2022: $279.8 billion.

• 2025: Forecasted at $305.63 billion. The company's stock has seen fluctuations, including a peak of $291.31 in November 2025, following a recovery from a low of $140.53 earlier in 2025.

4. Major Challenges and Opportunities

Challenges:

• Antitrust Legal Issues: Google faces a significant antitrust lawsuit initiated by the U.S. DOJ in January 2025, targeting its dominance in online advertising.

• Market Competition: The rise of AI technologies increases competition, particularly from newer companies leveraging generative AI in search and advertising.

• Regulatory Scrutiny: Concerns about privacy, market monopolization, and data security continue to challenge Google's operational practices.

Opportunities:

• AI Advancements: Integrating artificial intelligence across services promises to enhance user engagement and retention.

• Cloud Solutions Expansion: Google Cloud's growth is a significant opportunity for long-term profits, with innovative product offerings like Vertex AI.

• Sustainable Initiatives: Commitment to sustainability and social impact through initiatives like the Google.org Impact Challenge enhances community relations and corporate responsibility.

5. Recent News and Events Recent updates from Google include:

• Generative AI Developments: Numerous announcements at Google I/O 2025 regarding AI-driven capabilities across services.

• AI in Healthcare: Innovations focusing on healthcare data analysis and support systems, including new AI infrastructure.

• Algorithm Updates: Series of algorithm changes in 2025 aimed at combating spam and enhancing content originality.

6. Analysis of Trends and Patterns Google's consistent growth trajectory indicates a strong position in the tech industry. However, the company must navigate antitrust legal issues, market competition, and regulatory scrutiny. The integration of AI across services and the expansion of cloud solutions present significant opportunities for future growth.

7. Market Outlook Looking ahead, Google's strategies will likely center on:

• AI Implementation: Continued expansion of AI technologies into every facet of their business.

• Regulatory Adaptation: Adjustments to strategies in response to ongoing legal pressures and public scrutiny.

• Diversification into New Markets: Exploration into hardware innovations and enhanced cloud computing solutions, aiming for leadership in new and emerging sectors. This outlook is based on publicly available information and should not be used for trading decisions.

8. Conclusion Google's ability to innovate and adapt will play a critical role in shaping its future position in the tech landscape. With a strong financial foundation, historical growth, and a commitment to advancements in AI and sustainability, Google is poised for continued success. However, navigating the challenges of antitrust issues, market competition, and regulatory scrutiny will be essential to the company's long-term health and growth.

This comprehensive report provides insights into Google's current status, historical performance, challenges, opportunities, and future outlook. As a leading technology company, Google's continued innovation and adaptation will be crucial in maintaining its position in the ever-evolving tech industry.

Build MCP Server with Tools

An MCP server is a service that exposes structured data or functionality (like a database, API, or knowledge base) to be consumed by an MCP client and then used by an LLM.

Here’s the basic flow:

1. MCP Server provides access to data or tools (for example, a CRM database, internal documentation, API, SharePoint, etc.).It exposes this through MCP-compatible APIs or endpoints.

2. MCP Client connects to one or more MCP servers. It sends structured queries or requests (like “get weather info” or “fetch math calculation”) to the MCP server.

3. LLM (Language Model) The client then takes the data returned from the server and passes it to the LLM, which uses that information to generate natural-language output or take further actions.

User Case

Step 1: The user sends a prompt → The chatbot receives it.

Step 2: According to the prompt MCP client decides which MCP server to call(Weather or Custom Math server).

Step 3: The MCP client interacts with one or more MCP servers to retrieve or perform actions, and then uses a Large Language Model (LLM) to generate a reasoning-based output based on the server’s response.

Step 4: Response sent back to the client.

Custom Math MCP server

We have built a custom Math MCP server that supports addition, subtraction, multiplication, and division operations. The MCP server communicates using the stdio transport.

from mcp.server.fastmcp import FastMCP

mcp=FastMCP("Math")

@mcp.tool()
def add(a:int,b:int)->int:
    """_summary_
    Add to numbers
    """
    return a+b

@mcp.tool()
def subtract(a:int,b:int)-> int:
    """Subtract two numbers"""
    return a-b

@mcp.tool()
def multiple(a:int,b:int)-> int:
    """Multiply two numbers"""
    return a*b

@mcp.tool()
def division(a:int,b:int)-> int:
    """Division two numbers"""
    return a/b


#Use standard input/output (stdin and stdout) to receive and respond to tool function calls.
if __name__=="__main__":
    mcp.run(transport="stdio")

Weather MCP Server

A Weather MCP server is a custom MCP server designed to handle weather data requests. It provides tools for retrieving current weather conditions and forecasts for a given state code (e.g., CA, NJ, etc.), using the streamable-http transport protocol to exchange messages with the MCP client.

from mcp.server.fastmcp import FastMCP
from typing import Any
import httpx
# Initialize FastMCP server
mcp = FastMCP("weather")

# Constants
WEATHER_API_BASE = "https://api.weather.gov"
USER_AGENT = "weather-app/1.0"


async def make_nws_request(url: str) -> dict[str, Any] | None:
    """Make a request to the NWS API with proper error handling."""
    headers = {
        "User-Agent": USER_AGENT,
        "Accept": "application/geo+json"
    }
    async with httpx.AsyncClient() as client:
        try:
            response = await client.get(url, headers=headers, timeout=30.0)
            response.raise_for_status()
            return response.json()
        except Exception:
            return None
        
def format_alert(feature: dict) -> str:
    """Format an alert feature into a readable string."""
    props = feature["properties"]
    return f"""
        Event: {props.get('event', 'Unknown')}
        Area: {props.get('areaDesc', 'Unknown')}
        Severity: {props.get('severity', 'Unknown')}
        Description: {props.get('description', 'No description available')}
        Instructions: {props.get('instruction', 'No specific instructions provided')}
        """

@mcp.tool()
async def get_alerts(state: str) -> str:
    """Get weather alerts for a US state.

    Args:
        state: Two-letter US state code (e.g. CA, NY)
    """
    url = f"{WEATHER_API_BASE}/alerts/active/area/{state}"
    data = await make_nws_request(url)

    if not data or "features" not in data:
        return "Unable to fetch alerts or no alerts found."

    if not data["features"]:
        return "No active alerts for this state."

    alerts = [format_alert(feature) for feature in data["features"]]
    return "\n---\n".join(alerts)

if __name__=="__main__":
    mcp.run(transport="streamable-http")

MCP Client

An MCP client (Model Context Protocol client) is the component that connects to one or more MCP servers (like weather and custom math MCP servers) to request specialized data, tools, or computations, and then uses the results (often through an LLM, like llama, ChatGPT, etc.) to generate contextually aware outputs.

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_groq import ChatGroq
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
from fastapi import FastAPI, Query
import uvicorn
from pydantic import BaseModel

load_dotenv()

app = FastAPI(title='MCP AI Agent')

class ChatRequest(BaseModel):
    user_input: str

@app.post("/chat")
async def main(request: ChatRequest):
    client=MultiServerMCPClient(
        {
            "math":{
                "command":"python",
                "args":["mathserver.py"], ## Ensure correct absolute path
                "transport":"stdio",
            
            },
            "weather": {
                "url": "http://localhost:8000/mcp",  # Ensure server is running here
                "transport": "streamable_http",
            }

        }
    )

    import os
    os.environ["GROQ_API_KEY"]=os.getenv("GROQ_API_KEY") # Groq and Llama


    tools=await client.get_tools()
    model=ChatGroq(model="llama-3.3-70b-versatile")  # Groq and Llama

    agent=create_react_agent(
        model,tools
    )

    result = await agent.ainvoke({"messages": [{"role": "user", "content": request.user_input}]})
    return result

uvicorn.run(app, host='127.0.0.1', port=8002)

Now time to build the UI with streamlit

import streamlit as st
import requests

# Streamlit App Configuration
st.set_page_config(page_title="MCP MultiAgent UI", layout="centered")

# Define API endpoint
API_URL = "http://127.0.0.1:8002/chat"

# Streamlit UI Elements
st.title("MCP Chatbot Agent")
st.write("Interact with the MCP using this interface.")


# Input box for user messages
user_input = st.text_area("Enter your prompt:", height=150, placeholder="Please type your prompt here...")


# Button to send the query
if st.button("Submit"):
    if user_input.strip():
        try:

            with st.spinner("wait...", show_time=True):
                # Send the input to the FastAPI backend
                payload = {"user_input": user_input}
                response = requests.post(API_URL, json=payload)

            # Display the response
            if response.status_code == 200:
                response_data = response.json()
                if "error" in response_data:
                    st.error(response_data["error"])
                else:
                    ai_responses = [
                        message.get("content", "")
                        for message in response_data.get("messages", [])
                        if message.get("type") == "ai"
                    ]

                    if ai_responses:
                        st.subheader("Agent Response:")
                        for i, response_text in enumerate(ai_responses, 1):
                            st.markdown(f"{response_text}")
                    else:
                        st.warning("No AI response found in the agent output.")
            else:
                st.error(f"Request failed with status code {response.status_code}.")
        except Exception as e:
            st.error(f"An error occurred: {e}")
    else:
        st.warning("Please enter a message before clicking 'Send Query'.")

Output of the agent when using the Math MCP server

Output of the agent when using the weather MCP server

Conclusion

By separating logic and computation from the client, the MCP server enables modularity, scalability, and reusability across different applications. Whether it’s a math server performing calculations or a weather server providing forecasts, MCP servers enhance the capability of AI-driven systems by integrating external tools and data sources seamlessly.

Researcher & Analyst AI App (All-Purpose) using LangGraph

This app is a comprehensive research and analysis platform designed for professionals and academics. It enables users to collect, organize, and analyze data efficiently. With built-in tools for literature review management, data visualization, and AI-assisted insights, This agent helps researchers make evidence-based decisions faster.

Key Features:

• AI-powered data summarization and trend detection

• Integration with Tavily search and OpenAI Model.

• Real-time market data aggregation

• Predictive modeling for sales and growth trends

• Write executive summary after research and analysis.

Technical Overview

• LangGraph — for orchestrating multi-agent workflows and reasoning chains

• Python / FastAPI — backend service for agent coordination

• OpenAI — for LLM-based analysis and report generation

• Streamlit — for UI and interactive visualization

• LangChain Tools — for data ingestion and retrieval-augmented generation (RAG)

Architecture Summary:

The app uses a LangGraph-based agent graph, where:

• A Supervisor Agent assigning tasks to other agents.

• A Research Agent gathers the research content.

1. Key facts and background 2. Current trends or developments 3. Important statistics or data points 4. Notable examples or case studies

• An Analysis Agent performs comparative and statistical reasoning. 1. Key insights and patterns

  2. Strategic implications

  3. Risks and opportunities

  4. Recommendations

• A Writer Agent generates final insights, executive summary and recommendations. 1. Executive Summary

  2. Key Findings

  3. Analysis & Insights

  4. Recommendations

  5. Conclusion

Python code details # State Definition

class SupervisorState(MessagesState):
    """State for the multi-agent system"""
    next_agent: str = ""
    research_data: str = ""
    analysis: str = ""
    final_report: str = ""
    task_complete: bool = False
    current_task: str = ""

# Define tools

@tool
def search_web(query: str) -> str:
    """Search the web for information."""
    # Using Tavily for web search
    search = TavilySearchResults(max_results=3)
    results = search.invoke(query)
    return str(results)

@tool
def write_summary(content: str) -> str:
    """Write a summary of the provided content."""
    # Simple summary generation
    summary = f"Summary of findings:\n\n{content[:600]}..."
    return summary

# Define tools

@tool
def search_web(query: str) -> str:
    """Search the web for information."""
    # Using Tavily for web search
    search = TavilySearchResults(max_results=3)
    results = search.invoke(query)
    return str(results)

@tool
def write_summary(content: str) -> str:
    """Write a summary of the provided content."""
    # Simple summary generation
    summary = f"Summary of findings:\n\n{content[:600]}..."
    return summary

# Call Open AI LLM

llm = ChatOpenAI(model="gpt-4o-mini")

# Define tools

def supervisor_agent(state: SupervisorState) -> Dict:
    """Supervisor decides next agent using OpenAI LLM"""
	.....
     .....
         # Determine next agent
    if "done" in decision_text or has_report:
        next_agent = "end"
        supervisor_msg = f"**Supervisor:** All tasks complete! Great work team."
    elif "researcher" in decision_text or not has_research:
        next_agent = "researcher"
        supervisor_msg = f"**Supervisor:** Let's start with research. Assigning to Researcher..."
    elif "analyst" in decision_text or (has_research and not has_analysis):
        next_agent = "analyst"
        supervisor_msg = f"**Supervisor:** Research done. Time for analysis. Assigning to Analyst..."
    elif "writer" in decision_text or (has_analysis and not has_report):
        next_agent = "writer"
        supervisor_msg = f"**Supervisor:** Analysis complete. Let's create the report. Assigning to Writer..."
    else:
        next_agent = "end"
        supervisor_msg = f"**Supervisor:** Task seems complete."
    return {
        "messages": [AIMessage(content=supervisor_msg)],
        "next_agent": next_agent,
        "current_task": task
    }

# Agent 1: Researcher (using Open AI)

def researcher_agent(state: SupervisorState) -> Dict:
    """Researcher uses Open AI to gather information"""
    task = state.get("current_task", "research topic")
    
    # Create research prompt
    research_prompt = f"""As a research specialist, provide comprehensive information about: {task}
    # Create agent message
    agent_message = f"**Researcher:** I've completed the research on '{task}'.\n\nKey findings:\n{research_data[:600]}..."
    return {
        "messages": [AIMessage(content=agent_message)],
        "research_data": research_data,
        "next_agent": "supervisor"
    }

# Agent 2: Analyst (using OPen AI)

def analyst_agent(state: SupervisorState) -> Dict:
    """Analyst uses Open AI to analyze the research"""
    research_data = state.get("research_data", "")
    task = state.get("current_task", "")
    
    # Create analysis prompt
    analysis_prompt = f"""As a data analyst, analyze this research data and provide insights"
    # Get analysis from LLM
    analysis_response = llm.invoke([HumanMessage(content=analysis_prompt)])
    analysis = analysis_response.content
    
    # Create agent message
    agent_message = f"**Analyst:** I've completed the analysis.\n\nTop insights:\n{analysis[:600]}..."
    
    return {
        "messages": [AIMessage(content=agent_message)],
        "analysis": analysis,
        "next_agent": "supervisor"
    }

# Agent 3: Writer (using Open AI)

def writer_agent(state: SupervisorState) -> Dict:
    """Writer uses Open AI to create final report"""
    
    research_data = state.get("research_data", "")
    analysis = state.get("analysis", "")
    task = state.get("current_task", "")
    # Create writing prompt
    writing_prompt = f"""As a professional writer, create an executive report based on:

    Task: {task}

    Research Findings:
    {research_data[:800]}

    Analysis:
    {analysis[:800]}

    Create a well-structured report with:
    1. Executive Summary
    2. Key Findings  
    3. Analysis & Insights
    4. Recommendations
    5. Conclusion

    Keep it professional and concise."""
        
    # Get report from LLM
    report_response = llm.invoke([HumanMessage(content=writing_prompt)])
    report = report_response.content
        # Create final formatted report
    final_report = f"""
    **FINAL REPORT**
    {'\n'}
    {'='*50}
    {'\n'}
    Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}
    {'\n'}
    {'='*50}

    {report}

    {'='*50}
    Report compiled by Multi-Agent AI System powered by Open AI
    """
    
    return {
        #"messages": [AIMessage(content=f"Writer: Report complete! See below for the full document.")],
        "messages": [AIMessage(content=final_report)],
        "final_report": final_report,
        "next_agent": "supervisor",
        "task_complete": True
    }

# Router Function(decide based on the state)

def router(state: SupervisorState) -> Literal["supervisor", "researcher", "analyst", "writer", "__end__"]:
    """Routes to next agent based on state"""
    
    next_agent = state.get("next_agent", "supervisor")
    
    if next_agent == "end" or state.get("task_complete", False):
        return END
        
    if next_agent in ["supervisor", "researcher", "analyst", "writer"]:
        return next_agent
        
    return "supervisor"

# Create LangGraph workflow and compile

workflow = StateGraph(SupervisorState)

# Add nodes
workflow.add_node("supervisor", supervisor_agent)
workflow.add_node("researcher", researcher_agent)
workflow.add_node("analyst", analyst_agent)
workflow.add_node("writer", writer_agent)

# Set entry point
workflow.set_entry_point("supervisor")

# Add routing
for node in ["supervisor", "researcher", "analyst", "writer"]:
    workflow.add_conditional_edges(
        node,
        router,
        {
            "supervisor": "supervisor",
            "researcher": "researcher",
            "analyst": "analyst",
            "writer": "writer",
            END: END
        }
    )

graph=workflow.compile()

# Chat API endpoint that receives user input, processes it through an AI workflow, and returns the generated result.

@app.post("/chat")
def chat(request: ChatRequest):
    result = graph.invoke({"messages": [{"role": "user", "content": request.user_input}]})
    return result

# Starts the FastAPI server when the Python file is run directly

if __name__ == '__main__':
    uvicorn.run(app, host='127.0.0.1', port=8000)

# Now time to build the UI with streamlit

import streamlit as st
import requests

# Streamlit App Configuration
st.set_page_config(page_title="LangGraph MultiAgent UI", layout="centered")

# Define API endpoint
API_URL = "http://127.0.0.1:8000/chat"

# Streamlit UI Elements
st.title("Research and Analysis Chatbot Agent")
st.write("Interact with the LangGraph-based agent using this interface.")

# Finally ready for the build the final UI(textbox, submit button, result, etc.)

# Input box for user messages
user_input = st.text_area("Enter your prompt:", height=150, placeholder="Please type your prompt here...")


# Button to send the query
if st.button("Submit"):
    if user_input.strip():
        try:

            with st.spinner("wait...", show_time=True):
                # Send the input to the FastAPI backend
                payload = {"user_input": user_input}
                response = requests.post(API_URL, json=payload)

            # Display the response
            if response.status_code == 200:
                response_data = response.json()
                if "error" in response_data:
                    st.error(response_data["error"])
                else:
                    ai_responses = [
                        message.get("content", "")
                        for message in response_data.get("messages", [])
                        if message.get("type") == "ai"
                    ]

                    if ai_responses:
                        st.subheader("Agent Response:")
                        #st.markdown(f"**Final Response:** {ai_responses[-1]}")
                        for i, response_text in enumerate(ai_responses, 1):
                            st.markdown(f"{response_text}")
                            #st.markdown(f"**Response {i}:** {response_text}")
                    else:
                        st.warning("No AI response found in the agent output.")
            else:
                st.error(f"Request failed with status code {response.status_code}.")
        except Exception as e:
            st.error(f"An error occurred: {e}")
    else:
        st.warning("Please enter a message before clicking 'Send Query'.")

Finally, it’s time to enter the prompt and get the desired output

Start with the prompt "What will be the future of quantum computing in the year 2026?"

Here is the Response Agent Response:

Supervisor: Let's start with research. Assigning to Researcher...

Researcher: I've completed the research on 'What will be the future of quantum computing in the year 2026?'.

Key findings:

Future of Quantum Computing in 2026

1. Key Facts and Background

Quantum computing leverages quantum mechanics principles to process information in fundamentally different ways than classical computing. Unlike classical bits that represent either a 0 or 1, quantum bits (qubits) can represent both simultaneously due to a phenomenon known as superposition. Quantum entanglement further allows qubits to be interconnected, exponentially increasing computational power for specific types of pr...

Supervisor: Research done. Time for analysis. Assigning to Analyst...

Analyst: I've completed the analysis.

Top insights:

Insights and Analysis of the Research Data on Quantum Computing in 2026

1. Key Insights and Patterns

• Technological Shift: Quantum computing is set to fundamentally disrupt traditional computing paradigms, with significant advancements anticipated in hardware sophistication, algorithm development, and real-world application capabilities. The integration of quantum computing in vari...

Supervisor: Analysis complete. Let's create the report. Assigning to Writer...

FINAL REPORT

==================================================
Generated: 2025-10-26 13:06
==================================================
# Executive Report: Insights and Analysis of Quantum Computing in 2026

Executive Summary

As quantum computing approaches a transformative threshold by 2026, this report compiles critical insights from the latest research data. The foundational technology is poised to disrupt conventional computing paradigms through advancements in hardware and algorithms, leading to real-world applications across various sectors. Investment trends indicate growing confidence in quantum technologies, with financial projections reaching 24billionandamarketsizeexpectedtogrowto24billionandamarketsizeexpectedtogrowto8 billion at a compound annual growth rate (CAGR) of over 30%. This report provides an analysis of the current state of quantum computing, future trends, and strategic recommendations for stakeholders in the industry.

Key Findings

1. Technological Shift:

   • Quantum computing is anticipated to revolutionize traditional computing, promising substantial enhancements in computational capabilities and efficiency.

2. Investment Trends:

   • Global financial investment in quantum technologies is projected to reach $24 billion by 2026, demonstrating increasing confidence from governmental and private sectors.

3. Market Dynamics:

   • The quantum computing market is expected to grow to approximately $8 billion by 2026, with a CAGR exceeding 30%, indicating broad interest and adoption across industries.

4. Hardware Advancements:

   • Significant development in qubit technologies—including superconducting qubits, trapped ions, and topological qubits—is being pursued by leading companies to improve system stability and reduce error rates.

Analysis & Insights

The analysis of the current quantum computing landscape reveals several key patterns and trends:

• Disruption of Existing Paradigms: Quantum computing's ability to perform complex calculations far surpasses classical systems, paving the way for new applications in fields such as cryptography, drug discovery, and optimization problems.

• Ecosystem Development: The expanding ecosystem encompassing hardware manufacturers, software developers, and research institutions signifies a collective effort to enhance the practical implementation of quantum technologies.

• Skill Gap and Workforce Development: As the industry grows, the need for skilled professionals in quantum computing is becoming critical. Investments in education and training programs are necessary to cultivate a workforce capable of leveraging these technologies.

Recommendations

1. Increased Collaboration: Encourage collaboration between academia, industry, and government to accelerate research, share knowledge, and develop best practices in quantum computing.

2. Focus on Real-World Applications: Identify and prioritize specific applications with immediate potential benefits, such as optimization in logistics, materials science, and pharmaceuticals, to stimulate early adoption.

3. Investment in Talent Development: Launch initiatives aimed at educating and training the next generation of quantum computing professionals to address the skill gap and support industry growth.

4. Monitor Regulatory Developments: Stay abreast of regulatory changes that may impact the development and implementation of quantum technologies to ensure compliance and strategic alignment.

Conclusion

The landscape of quantum computing is rapidly evolving, with significant advancements anticipated by 2026. The convergence of technological developments, investment growth, and market dynamics presents considerable opportunities for businesses and researchers alike. By understanding these trends and aligning strategies accordingly, stakeholders can position themselves at the forefront of this groundbreaking field, harnessing its potential to drive innovation and efficiency across various sectors.

===========================================================
Report compiled by Multi-Agent AI System powered by Open AI