Building a Multi-Agent Financial News System with Agno and Agent UI

Want to build a powerful AI-powered financial assistant that fetches the latest news, analyzes sentiment, and provides stock information—all through a sleek, modern interface? This guide will show you how to create exactly that using Agno and Agent UI, combining specialized agents into a comprehensive system that gives you actionable market insights.

What Are Agents and Why They Matter for Traders

Agents are intelligent programs that solve problems autonomously. Unlike traditional programs that follow predefined execution paths, agents dynamically adapt their approach based on context and available tools.

For traders and investors, AI agents represent a paradigm shift in how market information is processed and analyzed. Imagine having a team of specialized assistants working for you 24/7:

• A news analyst monitoring global headlines and rating their sentiment
• A financial data specialist tracking stock movements and key metrics
• A research assistant connecting market events with historical patterns

LLM agents generally consist of four core components:

1. Agent/Brain: The central decision-maker (the LLM itself)
2. Planning: The strategic component determining how to approach a task
3. Memory: Stores conversation history and important context
4. Tool Use: Enables interactions with external systems like stock APIs or web search

Why Build Your Trading Agents with Agno?

Agno stands out as a framework specifically designed for creating powerful, flexible agents:

• Open Source & Independent: No vendor lock-in, full control over your data
• Lightning Fast: Agent creation is 10,000x faster than alternatives like LangGraph
• Multimodal Capabilities: Support for text, image, audio, and video inputs
• Extensive Tooling: Access to 80+ toolkits with thousands of tools
• Model Flexibility: Works with 23+ model providers (OpenAI, Groq, Anthropic, etc.)
• Knowledge Management: Integration with 12+ vector databases for RAG
• Team Orchestration: Build teams of specialized agents working together

For traders specifically, Agno’s combination of speed, flexibility, and specialized financial tools makes it ideal for creating market intelligence systems that can process information at machine speed while providing human-like analysis.

What We’re Building

We’ll create a comprehensive multi-agent financial system powered by Agno:

1. A News Sentiment Agent that analyzes financial news articles and rates sentiment
2. A Finance Agent for retrieving stock prices and company information
3. A Web Agent for general search capabilities
4. A Combined Agent that integrates all these capabilities

By leveraging Agno’s agent architecture and connecting to the elegant Agent UI interface, we’ll build a system that allows traders to:

• Monitor market sentiment across multiple news sources
• Track stock performance with real-time data
• Correlate news events with market movements
• Get plain-language explanations of market dynamics

The best part? This entire setup is open-source and self-hostable, giving you complete control over your trading intelligence system with no ongoing subscription costs or API limits.

How to Build Your Financial Multi-Agent System Effortlessly

One of the most powerful aspects of Agno is how it simplifies agent creation and orchestration. Rather than wrestling with complex frameworks or building everything from scratch, Agno lets you create sophisticated agents with just a few lines of code.

Prerequisites

• Basic knowledge of Python
• Python 3.8+ installed
• Node.js and npm installed
• OpenAI API key or Groq API key (we’ll be using Groq with the Qwen 2.5 32B model)

Step 1: Setting Up the Backend with Agno

First, let’s create our agent system using Agno, a Python framework for building LLM-powered agents.

Installation

pip install agno openai groq duckduckgo-search yfinance python-dotenv fastapi  sqlalchemy 'fastapi[standard]'

Create Your Agent Configuration

Let’s take advantage of Agno’s extensive tool ecosystem. Create a file named playground.py with the following code:

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.playground import Playground, serve_playground_app
from agno.storage.agent.sqlite import SqliteAgentStorage
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.tools.yfinance import YFinanceTools
from agno.models.groq import Groq

import os
from dotenv import load_dotenv
load_dotenv()

# Load environment variables
os.environ["GROQ_API_KEY"] = os.getenv("GROQ_API_KEY")
# Uncomment if using OpenAI models
# os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")

agent_storage: str = "tmp/agents.db"

# News Sentiment Agent
news_sentiment_agent = Agent(
    name="News Sentiment Agent",
    model=Groq(id="qwen-2.5-32b"),
    description="You are a News Sentiment Decoding Assistant. Decode the news and provide the sentiment ranging from +10 to -10 in table format with the following columns Date, Time, News, Source and Score. Also provide reasoning explanation point by point after the Table",
    tools=[DuckDuckGoTools(fixed_max_results=10)],
    storage=SqliteAgentStorage(table_name="news_sentiment_agent", db_file=agent_storage),
    add_datetime_to_instructions=True,
    add_history_to_messages=True,
    num_history_responses=5,
    markdown=True,
)

# Finance Agent
finance_agent = Agent(
    name="Finance Agent",
    model=Groq(id="qwen-2.5-32b"),
    tools=[YFinanceTools(stock_price=True, analyst_recommendations=True, company_info=True, company_news=True)],
    instructions=["Always use tables to display data. If the stock is related to Indian Stock use .NS to the symbol for example if the stock symbol is SBIN then add SBIN.NS to it"],
    storage=SqliteAgentStorage(table_name="finance_agent", db_file=agent_storage),
    add_datetime_to_instructions=True,
    add_history_to_messages=True,
    num_history_responses=5,
    markdown=True,
)

# Web Agent (keeping this from your original playground)
web_agent = Agent(
    name="Web Agent",
    model=Groq(id="qwen-2.5-32b"),
    tools=[DuckDuckGoTools()],
    instructions=["Always include sources"],
    storage=SqliteAgentStorage(table_name="web_agent", db_file=agent_storage),
    add_datetime_to_instructions=True,
    add_history_to_messages=True,
    num_history_responses=5,
    markdown=True,
)

# Combined Agent - integrates both news sentiment and stock price functionality
combined_agent = Agent(
    name="Financial News & Stock Agent",
    model=OpenAIChat(id="gpt-4o"),  # Using GPT-4o for better reasoning with combined tasks
    tools=[DuckDuckGoTools(), YFinanceTools(stock_price=True, analyst_recommendations=True, company_info=True, company_news=True)],
    instructions=[
        "You are a Financial News and Stock Analysis Assistant.",
        "For news queries, decode the news sentiment ranging from +10 to -10 in table format with columns: Date, Time, News, Source and Score.",
        "Include the current stock price, key metrics, and recent price movement when a company is mentioned.",
        "Always provide reasoning for sentiment scores point by point after the tables.",
        "Always present financial data in tables for clarity.",
        "Always use tables to display data. If the stock is related to Indian Stock use .NS to the symbol for example if the stock symbol is SBIN then add SBIN.NS to it"
    ],
    storage=SqliteAgentStorage(table_name="combined_agent", db_file=agent_storage),
    add_datetime_to_instructions=True,
    add_history_to_messages=True,
    num_history_responses=5,
    markdown=True,
)

# Setting up the playground with all agents
app = Playground(agents=[combined_agent, news_sentiment_agent, finance_agent, web_agent]).get_app()

if __name__ == "__main__":
    serve_playground_app("playground:app", reload=True)

This script defines four distinct agents:

1. News Sentiment Agent: Specializes in analyzing news articles and rating their sentiment from +10 to -10
2. Finance Agent: Retrieves stock information using YFinance
3. Web Agent: A general-purpose web search agent
4. Combined Agent: An integrated agent that combines news analysis and financial data capabilities

Create an Environment File

Create a .env file in the same directory:

GROQ_API_KEY=your_groq_api_key_here
OPENAI_API_KEY=your_openai_api_key_here

Run the Playground

Now, let’s run the playground to test our agents:

python playground.py

This will start a FastAPI server at http://localhost:8000 where you can test your agents directly.

Step 2: Setting Up Agent UI

Now that our backend is ready, let’s set up the beautiful Agent UI frontend to interact with our agents.

Clone the Agent UI Repository

npx create-agent-ui@latest
cd agent-ui

Configure Agent UI

One of the advantages of using Agent UI with Agno is that they’re designed to work together out of the box. By default, Agent UI connects to port 7777, which is the same port that our Agno playground runs on, so no additional configuration is needed.

Run the Agent UI

npm run dev

This will start Agent UI at http://localhost:3000.

Step 3: Using Agent UI with Your Agents

Once both services are running:

1. Open Agent UI at http://localhost:3000
2. You’ll see the Endpoint section is already set to http://localhost:7777 by default
3. Select one of your agents from the dropdown (e.g., “Financial News & Stock Agent”)
4. Start chatting!

Using Your Multi-Agent System for Market Insights

Once your system is up and running, you can interact with your agents through the elegant Agent UI interface to gain valuable market insights. Here are some examples specific to trading and investing:

News Sentiment Analysis for Trading Signals

Try asking:

• “What is the latest news about Tesla and how might it affect the stock?”
• “Analyze the sentiment of recent Fed announcements on interest rates”
• “Compare the sentiment of news about NVIDIA versus AMD”

The News Sentiment Agent will search for recent articles and provide a sentiment score for each, highlighting potential trading opportunities based on media coverage.

Real-Time Financial Data

Try asking:

• “What is the current price, PE ratio, and market cap of Apple?”
• “Show me the 52-week high/low for major banking stocks”
• “What are analyst price targets for RELIANCE.NS?”

The Finance Agent will retrieve detailed financial metrics, helping you make data-driven investment decisions.

Market Research and Analysis

Try asking:

• “What factors are driving oil prices this week?”
• “Search for recent insider trading activity at Microsoft”
• “Find the latest earnings reports for Zomato (ZOMATO.NS)”

The Web Agent will gather information and compile research that can inform your trading strategy.

Combined Financial Intelligence

Try asking:

• “Is there a correlation between recent Tesla news sentiment and stock price movements?”
• “What impact did the latest Apple product announcement have on their stock?”
• “Analyze semiconductor industry news and stock performance over the past week”

The Combined Agent will integrate news sentiment analysis with financial data to provide a comprehensive market view that could reveal potential trading edges.

Customizing Your Agents

The real power of this setup is how easily you can customize the agents. Here are some ideas:

Add More Tools and Expand Your Agents

As your needs grow, Agno makes it easy to enhance your agents with additional capabilities. The framework supports a vast ecosystem of tools that can be combined for powerful market analysis.

For traders and investors looking to build more sophisticated systems, consider these extensions:

• Add Website Tools to scrape specific financial websites and reports directly
• Integrate Google Search for broader market research beyond DuckDuckGo
• Use Newspaper Tools to extract and analyze content from financial publications
• Add Pandas Tools to process, transform, and visualize financial datasets
• Include Telegram Tools to receive market alerts and communicate with your team

To add a new tool, simply import it and include it in your agent definition:

# Example of adding Website and Newspaper tools for better financial research
from agno.tools.website import WebsiteTools
from agno.tools.newspaper import NewspaperTools

# Create an enhanced research agent
enhanced_research_agent = Agent(
    name="Market Research Agent",
    model=Groq(id="qwen-2.5-32b"),
    tools=[
        DuckDuckGoTools(), 
        WebsiteTools(),
        NewspaperTools()
    ],
    instructions=["Extract detailed information from financial news sites and include all sources"],
    storage=SqliteAgentStorage(table_name="research_agent", db_file=agent_storage),
    markdown=True,
)

As you become more familiar with Agno, you can experiment with different tool combinations to create more specialized agents tailored to your trading style.

Create Industry-Specific Agents for Trading

You can create agents specialized for different trading strategies and market segments:

• Commodities Market Agent: With specific instructions for energy, metals, and agricultural markets
• Technical Analysis Agent: Focused on chart patterns, indicators, and historical price movements
• Fundamental Analysis Agent: Specializing in financial statements, valuation metrics, and company performance
• Macroeconomic Agent: Monitoring global economic indicators, central bank policies, and geopolitical events
• Forex Trading Agent: Tracking currency pairs, interest rate differentials, and international trade data

For institutional investors, you can also build agents that assist with:

• Portfolio optimization and risk management
• Regulatory compliance monitoring
• ESG (Environmental, Social, Governance) analysis

The key is to provide clear instructions and select tools that match your trading objectives.

Customize the UI

Agent UI is built with Next.js and can be customized to match your brand or preferences:

• Edit the color scheme in the Tailwind configuration
• Add custom components or features
• Implement authentication for multi-user access

Conclusion: The Future of Financial Analysis

With Agno and Agent UI, you’ve created a powerful multi-agent system for financial news analysis and stock information in just a few steps. The system offers several advantages that traditional financial tools can’t match:

• Contextual Understanding: Unlike rule-based systems, your agents understand the nuances of financial news and market movements
• Integration Capabilities: Easily expand your system by adding new tools and data sources
• Conversational Interface: Interact with complex financial data through natural language
• Full Ownership: No dependence on third-party services that might change pricing or shut down
• Customizability: Tailor every aspect of your agents to your specific trading strategy

For traders and investors, this approach represents a new paradigm in financial intelligence. Instead of juggling multiple tools, data sources, and news feeds, you can create a unified interface that combines the best of AI language understanding with specialized financial knowledge.

As AI agent technology continues to evolve, traders who learn to build and customize these systems will have a significant edge in processing information, spotting trends, and making better-informed decisions.

Whether you’re a day trader looking for sentiment signals, a long-term investor tracking company performance, or a financial analyst preparing reports, the combination of Agno and Agent UI provides a foundation for building sophisticated AI assistants tailored to your specific needs.

Start small, experiment with different agent configurations, and gradually integrate more sophisticated tools and data sources. The most powerful aspect of this approach is that it grows and evolves with your requirements.

Happy building and trading with your new AI-powered financial assistant!