Building RiskNavigator AI: A Multi-Agent System for Financial Risk Assessment

Introduction

Imagine you’re planning to invest in a stock, say Apple (AAPL). You need to:

• Gather current market data (price, volume, trends)
• Analyze the company’s fundamentals (revenue, profit, debt)
• Develop trading strategies (when to buy, how much, at what price)
• Plan the execution (entry/exit points, stop-loss levels)
• Assess risks (market volatility, company-specific risks)
• Synthesize everything into an actionable recommendation

For a human investor, this process takes hours and requires expertise across multiple domains. For a traditional AI system, cramming all this knowledge into a single model leads to inconsistent results and “hallucinations” (making up facts).

What if we could build a team of specialized AI agents, each expert in one domain, working together seamlessly?

That’s exactly what I built with RiskNavigator AI - a multi-agent system built with Google’s Agent Development Kit (ADK) and powered by Gemini 2.5 Pro that orchestrates five specialized AI agents: Data Analyst (retrieving real-time market data via Alpha Vantage’s Model Context Protocol with 60+ financial tools), Trading Analyst (developing investment strategies), Execution Analyst (creating actionable plans), Risk Analyst (evaluating potential risks), and Summary Agent (generating executive reports with PDF export)working sequentially through state-based communication to deliver comprehensive financial analysis and risk assessment for stock investments, all deployed on Google Cloud Run with an interactive web chat interface and RESTful APIs.

Live Demo: https://financial-advisor-r4ixiexwla-ue.a.run.app

Note: The live demo runs on Google Cloud Run’s serverless infrastructure without GPU acceleration, which may result in slower response times (60-90 seconds per analysis). For optimal performance, we recommend running the system locally following the setup guide in the GitHub repository.

GitHub: https://github.com/daddyofadoggy/financial_advisor

In this blog post, I’ll walk you through the entire journey - from understanding what agents are, to designing the architecture, implementing the system, and deploying it to production. No prior knowledge of agents required!

---

What is an AI Agent?

The Simple Explanation

An AI agent is a program that can:

1. Perceive its environment (read inputs, access tools)
2. Reason about what to do (using an LLM like GPT or Gemini)
3. Act autonomously (call functions, use tools, make decisions)
4. Learn from results (iterate and improve)

Think of it like a smart assistant that doesn’t just answer questions, but actually does things for you.

Agent vs. Traditional LLM

Traditional LLM (ChatGPT-style):

User: "What's the current price of AAPL?"
LLM: "I don't have real-time data, but as of my last training..."

AI Agent with Tools:

# Agent has access to tools
agent_tools = [
    get_stock_price,      # Can fetch real-time data
    get_company_info,     # Can retrieve fundamentals
    calculate_metrics     # Can perform computations
]

# Agent workflow
user_query = "What's the current price of AAPL?"
agent_thinks = "I need real-time data. I'll use get_stock_price tool."
agent_action = get_stock_price("AAPL")  # Executes the tool
agent_response = "AAPL is currently trading at $225.50 (as of 2 min ago)"

Key Difference: Agents can take actions and access real-world data, not just generate text.

What is a Multi-Agent System?

Definition

A multi-agent system (MAS) is a computational system where multiple autonomous agents interact and coordinate to solve complex problems that would be difficult or inefficient for a single agent to handle alone. Each agent in the system is a self-contained entity with its own knowledge, goals, and capabilities, capable of perceiving its environment, making decisions, and taking actions.

The Problem Multi-Agent Systems Solve

Traditional monolithic AI systems face a critical challenge: complexity overload. When a single AI model is tasked with handling multiple specialized domains simultaneously (e.g., data gathering, strategy formulation, risk assessment), it often results in:

1. Context Confusion: The model struggles to maintain focus across different expertise areas
2. Inconsistent Quality: Performance varies significantly across different task types
3. Hallucinations: Increased tendency to generate false information when operating outside its strongest capabilities
4. Limited Scalability: Difficult to update or improve specific capabilities without affecting the entire system

Multi-agent systems solve these problems through specialization and coordination. By decomposing complex tasks into smaller, focused sub-tasks handled by specialized agents, MAS architectures achieve:

• Higher Accuracy: Each agent becomes expert in its narrow domain
• Better Reliability: Specialized agents are less prone to errors in their area of expertise
• Easier Maintenance: Individual agents can be updated without system-wide changes
• Natural Parallelization: Independent agents can work simultaneously on different aspects of the problem

Multi-Agent Systems in Practice

A multi-agent system is like a team of specialists working together:

Investment Analysis Team (Human):
├── Data Analyst: Gathers market data
├── Strategy Analyst: Develops trading strategies
├── Execution Planner: Plans trade execution
├── Risk Manager: Assesses risks
└── Portfolio Manager: Synthesizes everything

↓↓↓ TRANSLATES TO ↓↓↓

RiskNavigator AI (Multi-Agent):
├── Data Agent: Fetches real-time financial data
├── Trading Agent: Develops investment strategies
├── Execution Agent: Plans entry/exit points
├── Risk Agent: Evaluates risk factors
├── Summary Agent: Creates final recommendation
└── Coordinator Agent: Orchestrates the entire workflow

Each agent is specialized, focused, and good at one thing. When they work together, they produce better results than a single generalist agent.

---

Motivation: Why I Built This

The Personal Problem

As someone interested in investing, I faced these challenges:

1. Information Overload: Bloomberg, Yahoo Finance, company reports, news articles - too much data scattered everywhere
2. Time Constraint: Analyzing one stock properly takes 2-3 hours
3. Expertise Gap: I’m good at technical analysis but weak at fundamental analysis
4. Inconsistency: My analysis quality varies depending on my mood and energy

The Bigger Picture

The average retail investor underperforms the market by 3-5% annually, largely due to poor decision-making processes. Meanwhile, institutional investors spend millions on teams of analysts.

The Gap: Retail investors need institutional-grade analysis but can’t afford it.

The Opportunity: AI can democratize sophisticated financial analysis.

Why This Project Matters

1. Democratization: Makes institutional-quality analysis accessible to everyone
2. Speed: What takes humans hours takes agents seconds
3. Consistency: Same quality analysis every time, no emotional bias
4. Scalability: Can analyze entire portfolios, not just one stock
5. Learning Opportunity: Perfect project to learn multi-agent systems

---

Problem Statement

The Challenge

Goal: Build an AI system that can analyze any stock and provide comprehensive, actionable investment recommendations including:

• Current market conditions
• Multiple trading strategies (growth, value, momentum)
• Detailed execution plan
• Comprehensive risk assessment
• Executive summary with clear recommendations

Constraints:

• Must use real-time data (not stale training data)
• Must be accurate and reliable (minimize hallucinations)
• Must be fast (under 60 seconds)
• Must be production-ready (99.9% uptime)
• Must be cost-effective (serverless, pay-per-use)

Why It’s Hard:

1. Multi-Domain Knowledge: Requires expertise in technical analysis, fundamental analysis, risk management, portfolio theory
2. Real-Time Data: Needs integration with external financial APIs
3. Complex Reasoning: Must synthesize disparate information into coherent recommendations
4. Reliability: Financial advice requires high accuracy; mistakes are costly

---

Solution: Why Multi-Agent Architecture?

Why Not a Single Large Model?

I experimented with a single LLM approach first:

# Single LLM approach (doesn't work well)
prompt = """
You are a financial advisor. Analyze AAPL stock.
Provide:

1. Current market data
2. Trading strategies
3. Execution plan
4. Risk assessment
5. Summary

Use these tools: [60+ financial API tools]
"""

result = gemini.generate(prompt)

Problems I Encountered:

1. Context Mixing: Model confused data gathering with strategy development
2. Inconsistent Quality: Great at technical analysis, poor at risk assessment
3. Hallucinations: Made up financial metrics when uncertain
4. Tool Overload: Struggled to choose the right tool from 60+ options
5. Poor Structure: Output format varied wildly

Why Multi-Agent is Superior

1. Specialization Through Division of Labor

Like a real investment firm, each agent has a clear job:

# Multi-agent approach (works much better)
agents = {
    "data_analyst": {
        "role": "Gather and validate market data",
        "tools": ["get_quote", "get_fundamentals", "get_news"],
        "expertise": "Data retrieval and validation"
    },
    "trading_analyst": {
        "role": "Develop trading strategies",
        "tools": [],  # Uses data from data_analyst
        "expertise": "Technical and fundamental analysis"
    },
    "execution_analyst": {
        "role": "Plan trade execution",
        "tools": [],
        "expertise": "Order planning and execution timing"
    },
    "risk_analyst": {
        "role": "Assess all risks",
        "tools": [],
        "expertise": "Risk quantification and mitigation"
    },
    "summary_agent": {
        "role": "Synthesize recommendations",
        "tools": ["export_to_pdf"],
        "expertise": "Executive communication"
    }
}

Benefit: Each agent becomes an expert in its domain, leading to higher quality output.

2. Sequential Reasoning

Financial analysis naturally follows a workflow:

Step 1: Gather Data
   ↓
Step 2: Analyze Data → Develop Strategies
   ↓
Step 3: Plan Execution
   ↓
Step 4: Assess Risks
   ↓
Step 5: Synthesize Recommendation

Multi-agent systems excel at sequential workflows where each step builds on the previous.

3. Reduced Hallucinations

Single Model Problem:

Prompt: "Analyze AAPL's debt-to-equity ratio"
Output: "AAPL has a debt-to-equity ratio of 1.8" ← HALLUCINATED!
(Actual: 1.96)

Multi-Agent Solution:

# Data Agent with strict validation
data = data_agent.get_fundamental("AAPL", "debt_to_equity")
# Returns: {"value": 1.96, "source": "Alpha Vantage", "timestamp": "2025-01-28"}

# Other agents receive validated data
# No chance to hallucinate numbers

Benefit: Separation of data retrieval from analysis prevents hallucination.

4. Better Reliability Through Cross-Validation

# Risk agent can verify trading agent's assumptions
if risk_agent.volatility == "HIGH":
    if "aggressive" in trading_agent.strategy:
        flag_inconsistency()  # Catch logical errors

Benefit: Multiple perspectives catch errors.

5. Easier Debugging and Maintenance

Single Model:

Output is wrong → ???
Need to debug one giant prompt → nightmare

Multi-Agent:

Output is wrong → Which agent failed?
  - Data Agent output looks good ✓
  - Trading Agent output looks good ✓
  - Risk Agent output is wrong ✗
    → Fix Risk Agent prompt only

Benefit: Isolate and fix issues quickly.

---

Understanding Agent Design Patterns

Before diving into our implementation, let’s understand the landscape of agent design patterns available for building agentic AI systems. Google Cloud’s architecture guide identifies 12 fundamental patterns for designing multi-agent systems, each suited for different use cases.

Overview of All Agent Design Patterns

1. Single-Agent System

The simplest pattern - one AI model with tools that autonomously handles requests.

When to Use: Early-stage development, straightforward tasks with multiple steps

Example: Customer support chatbot querying databases

2. Multi-Agent Sequential Pattern ⭐ (Our Choice)

Executes specialized agents in a predefined, linear order where each agent’s output feeds the next.

When to Use: Highly structured, repeatable processes with unchanging sequences

Example: Data processing pipelines, assembly-line workflows

3. Multi-Agent Parallel Pattern

Multiple specialized agents work simultaneously, then outputs are synthesized.

When to Use: Sub-tasks can execute concurrently, gathering diverse perspectives

Example: Customer feedback analysis (sentiment + keywords + categorization + urgency)

4. Multi-Agent Loop Pattern

Repeatedly executes a sequence until a termination condition is met.

When to Use: Iterative refinement, self-correction tasks

Example: Content generation with critic review until quality standards met

5. Multi-Agent Review and Critique Pattern

Generator creates output, critic evaluates, and approves/rejects/returns for revision.

When to Use: Tasks requiring high accuracy or strict compliance

Example: Code generation with security auditing

6. Multi-Agent Iterative Refinement Pattern

Agents work within loops modifying stored results across iterations.

When to Use: Complex generation tasks difficult to achieve in single steps

Example: Blog post writing and revision, code development and debugging

7. Multi-Agent Coordinator Pattern

Central agent dynamically directs workflow by decomposing requests and dispatching to specialized agents.

When to Use: Structured business processes requiring adaptive routing

Example: Customer service routing to appropriate specialized agents

8. Multi-Agent Hierarchical Task Decomposition Pattern

Multi-level agent hierarchy decomposes complex tasks through progressive levels.

When to Use: Ambiguous, open-ended problems requiring extensive planning

Example: Complex research projects decomposed into gathering, analysis, synthesis

9. Multi-Agent Swarm Pattern

Multiple specialized agents collaborate iteratively through all-to-all communication.

When to Use: Ambiguous problems benefiting from debate and iterative refinement

Example: New product design involving market researchers, engineers, and financial modelers

10. ReAct (Reason and Act) Pattern

Iterative loop of thought → action → observation until exit condition.

When to Use: Complex, dynamic tasks requiring continuous planning

Example: Robotics agents generating adaptive paths

11. Human-in-the-Loop Pattern

Agent pauses at predefined checkpoints for human review/approval.

When to Use: High-stakes decisions, subjective judgments, critical approvals

Example: Financial transaction approval, sensitive document validation

12. Custom Logic Pattern

Developers implement specific orchestration logic with conditional code.

When to Use: Complex branching logic beyond linear sequences

Example: Refund process combining parallel verification with conditional routing

Why We Chose the Sequential Pattern

For RiskNavigator AI, we selected the Multi-Agent Sequential Pattern. Here’s our reasoning:

1. Natural Financial Analysis Workflow

Financial analysis follows a logical, sequential process:

Step 1: Data Gathering (Data Agent)
  ↓ Output: Market data, fundamentals, news

Step 2: Strategy Development (Trading Agent)
  ↓ Input: Market data | Output: Trading strategies

Step 3: Execution Planning (Execution Agent)
  ↓ Input: Strategies | Output: Entry/exit points, position sizing

Step 4: Risk Assessment (Risk Agent)
  ↓ Input: Data + Strategies + Execution | Output: Risk analysis

Step 5: Synthesis (Summary Agent)
  ↓ Input: All previous outputs | Output: Final recommendation

Each step depends on the previous step’s output - this is a perfect fit for the sequential pattern.

Visual Architecture: Sequential Design with MCP Integration

The diagram below illustrates the complete sequential architecture, showing how the Financial Coordinator orchestrates the agent workflow and how the Model Context Protocol (MCP) integrates with the Data Analyst Agent to access real-time financial data:

Key Components in the Diagram:

1. Financial Coordinator (Top)

   • Central orchestrator managing the sequential workflow
   • Uses Google ADK’s AgentTool to invoke each specialized agent
   • Maintains shared state across all agents

2. Sequential Agent Pipeline (Left to Right)

   • Data Analyst Agent → Fetches real-time market data
   • Trading Analyst Agent → Develops investment strategies
   • Execution Analyst Agent → Plans trade execution
   • Risk Analyst Agent → Assesses risks
   • Summary Agent → Synthesizes final recommendation

3. MCP Integration (Bottom)

   • Alpha Vantage MCP Server provides 60+ financial tools
   • Connected exclusively to Data Analyst Agent
   • Enables real-time data access without embedding API keys in code
   • Tools include: stock quotes, fundamentals, news sentiment, technical indicators

4. Shared State (Arrows)

   • Each agent writes output to specific state keys
   • Subsequent agents read from previous outputs
   • Creates cumulative context flow: Data → Trading → Execution → Risk → Summary

5. Sequential Flow Benefits

   • No branching: Linear execution path
   • Deterministic: Same inputs produce same outputs
   • Debuggable: Easy to trace which agent produced which output
   • Efficient: No orchestration overhead from LLM decision-making

This visual representation shows why the sequential pattern is optimal: the workflow is a straight pipeline where each agent builds upon the previous agent’s work, exactly like a financial analysis team in a traditional investment firm.

2. Predictable and Reliable

Unlike dynamic workflows (coordinator/swarm patterns), our sequence is:

• Fixed: Same order every time
• Deterministic: Reproducible results
• Testable: Easy to validate each stage
• Debuggable: Clear failure points

This predictability is crucial for financial applications where consistency matters.

3. Optimal Information Flow

The sequential pattern ensures complete context at each stage:

# Each agent has access to ALL previous outputs via shared state
class SharedState:
    market_data_analysis_output: str      # From Data Agent
    proposed_trading_strategies_output: str  # From Trading Agent
    execution_plan_output: str            # From Execution Agent
    final_risk_assessment_output: str     # From Risk Agent
    executive_summary_output: str         # From Summary Agent

# Example: Risk Agent can see everything
risk_agent_input = {
    "market_data": state.market_data_analysis_output,
    "strategies": state.proposed_trading_strategies_output,
    "execution": state.execution_plan_output,
    "user_risk_attitude": user_input.risk_level
}

This cumulative context allows later agents to make holistic decisions.

4. No Orchestration Overhead

Sequential pattern doesn’t require:

• ❌ AI model to decide which agent to call next (coordinator pattern)
• ❌ Complex synchronization logic (parallel pattern)
• ❌ Termination condition checks (loop pattern)

Instead, we have a simple, hard-coded workflow:

# Simple, linear execution
def execute_workflow(user_query, risk_attitude):
    # Step 1
    market_data = data_agent.run(ticker=user_query)

    # Step 2
    strategies = trading_agent.run(
        market_data=market_data,
        risk_attitude=risk_attitude
    )

    # Step 3
    execution = execution_agent.run(
        market_data=market_data,
        strategies=strategies
    )

    # Step 4
    risks = risk_agent.run(
        market_data=market_data,
        strategies=strategies,
        execution=execution
    )

    # Step 5
    summary = summary_agent.run(
        market_data=market_data,
        strategies=strategies,
        execution=execution,
        risks=risks
    )

    return summary

5. Performance Benefits

• Lower Latency: No extra LLM calls for orchestration
• Lower Cost: Fewer API calls to the model
• Faster Debugging: Linear trace through execution
• Easier Testing: Test each agent in isolation

6. When Sequential Pattern Works Best

Our use case is ideal because:

✅ Fixed Sequence: Analysis steps don’t change based on input

✅ No Branching: No conditional logic like “if high risk, skip execution planning”

✅ No Iteration: No need to re-run agents based on validation

✅ Clear Dependencies: Each step builds on previous steps

Comparison: Why NOT Other Patterns?

Pattern	Why We Didn’t Choose It
Parallel	Steps can’t run concurrently - strategies need market data first
Coordinator	Overhead of LLM orchestration unnecessary for fixed workflow
Loop/Iterative	No need for refinement - one pass produces final output
Swarm	Too complex for our structured process
ReAct	Overkill - we know exactly what tools each agent needs

Real-World Performance

Here’s proof the sequential pattern works for our use case:

Execution Time Breakdown:

Data Agent:      12s  (API calls to Alpha Vantage)
Trading Agent:   8s   (Strategy generation)
Execution Agent: 6s   (Planning calculations)
Risk Agent:      9s   (Risk analysis)
Summary Agent:   5s   (Final synthesis)
Total:          40s  ✅ Under 60s target

The linear execution allows us to optimize each stage independently without coordination overhead.

---

Architecture Overview

System Design

                    ┌─────────────────────────────┐
                    │   Financial Coordinator     │
                    │   (Orchestrator Agent)      │
                    └──────────┬──────────────────┘
                               │
                    ┌──────────┴──────────┐
                    │  Agent-to-Agent     │
                    │  Communication      │
                    │  (A2A Protocol)     │
                    └──────────┬──────────┘
                               │
         ┌─────────────────────┼─────────────────────┐
         │                     │                     │
    ┌────▼────┐          ┌────▼────┐          ┌────▼────┐
    │  Data   │──────────▶ Trading │──────────▶Execution│
    │ Agent   │          │ Agent   │          │ Agent   │
    └─────────┘          └─────────┘          └─────────┘
         │                     │                     │
         │                     └──────────┬──────────┘
         │                                │
    ┌────▼────────────────────────────────▼────┐
    │          Risk Agent                      │
    └──────────────────┬───────────────────────┘
                       │
                  ┌────▼────┐
                  │ Summary │
                  │ Agent   │
                  └─────────┘
                       │
                  ┌────▼────┐
                  │   PDF   │
                  │  Report │
                  └─────────┘

Key Components

1. Google Agent Development Kit (ADK)

ADK is Google’s framework for building multi-agent systems. It provides:

• Agent orchestration
• State management
• Tool integration
• Built-in web UI

2. Gemini 2.5 Pro

Latest Google LLM powering all agents. Why Gemini?

• Advanced reasoning capabilities
• Large context window (2M tokens)
• Native tool calling
• Fast inference

3. Model Context Protocol (MCP)

The Model Context Protocol (MCP) is an open standard introduced by Anthropic for connecting large language models (LLMs) to external data sources and tools. It provides a universal, standardized way for AI models to securely access context from various systems—databases, APIs, file systems, web services—without requiring custom integration code for each connection.

Before MCP, integrating LLMs with external tools faced significant challenges:

1. Fragmented Integration: Each tool required custom integration code, leading to maintenance nightmares
2. Security Risks: API keys and credentials were often hard-coded into applications
3. Limited Reusability: Tool integrations were tightly coupled to specific LLM providers
4. Scalability Issues: Adding new tools required extensive development work
5. Context Isolation: LLMs couldn’t seamlessly access relevant context across multiple systems

MCP addresses these problems by establishing a standardized communication protocol between AI models and external resources. It defines:

• Uniform Interface: Consistent API for tool discovery and invocation
• Security Model: Secure credential management and access control
• Interoperability: Works across different LLM providers (Claude, Gemini, GPT, etc.)
• Composability: Easily combine multiple MCP servers for complex workflows

As described in Anthropic’s paper introducing MCP (Anthropic, 2024), the protocol enables “a new paradigm of AI-system integration where models can securely and reliably access the context they need from any source, without fragmented implementations.” This standardization is critical for building production-grade multi-agent systems that require robust, maintainable tool integrations.

MCP in RiskNavigator AI: Our Use Case

In our financial advisor system, we use MCP to connect the Data Analyst Agent to Alpha Vantage’s comprehensive suite of financial APIs:

# MCP makes tool integration simple
from mcp import MCPToolset

# Alpha Vantage provides 60+ financial tools via MCP
alpha_vantage_mcp = MCPToolset(
    server="alpha-vantage",
    tools=[
        "get_global_quote",        # Real-time stock prices
        "get_company_overview",     # Fundamentals
        "get_time_series_daily",    # Historical data
        "get_news_sentiment",       # News analysis
        # ... 56 more tools
    ]
)

# Data Agent can now access all these tools
data_agent = Agent(
    model="gemini-2.5-pro",
    tools=alpha_vantage_mcp
)

Benefits in Our Implementation:

• Simplified Integration: One MCP connection provides access to 60+ financial tools
• Security: API keys managed by MCP server, not embedded in agent code
• Flexibility: Can easily swap MCP servers (e.g., switch from Alpha Vantage to Bloomberg)
• Reliability: Standardized error handling and retry logic built into the protocol

4. Agent-to-Agent Communication (A2A)

Agent-to-Agent Communication (A2A) refers to the mechanisms and protocols that enable autonomous agents within a multi-agent system to exchange information, coordinate actions, and share knowledge. A2A is fundamental to collaborative problem-solving in distributed AI systems, allowing specialized agents to work together seamlessly without requiring centralized control.

In multi-agent systems, agents need to collaborate to solve complex problems, but face several challenges:

1. Information Silos: Without communication, each agent operates with limited local knowledge
2. Coordination Overhead: Agents need to synchronize their actions without explicit programming
3. Context Loss: Downstream agents lose valuable insights generated by upstream agents
4. Redundant Work: Agents may duplicate efforts without awareness of others’ activities
5. Inconsistent State: Different agents may operate on different versions of shared data

A2A protocols solve these problems by establishing standardized methods for:

• Message Passing: Structured communication between agents
• State Sharing: Common memory spaces accessible to all agents
• Event Notification: Alerting agents when relevant changes occur
• Negotiation: Resolving conflicts and coordinating joint actions

In the context of modern agent frameworks, A2A enables seamless information flow across the agent pipeline, ensuring each agent has access to the cumulative knowledge generated by all previous agents.

Google’s Agent Development Kit provides built-in support for agent-to-agent communication through its tool abstraction layer. As documented in Google’s ADK technical specifications and the “5-Day AI Agents Intensive Course” (Google Cloud, 2024), ADK implements A2A using an AgentTool pattern where:

• Each agent can be wrapped as a tool callable by other agents
• The coordinator agent invokes sub-agents through standardized tool interfaces
• Communication occurs through shared state objects managed by the framework
• The system automatically handles message serialization and state synchronization

This approach, described in the ADK documentation, enables “composable agent architectures where specialized agents can be orchestrated without tight coupling, supporting both sequential and hierarchical agent workflows” (Google Cloud ADK Documentation, 2024).

A2A in RiskNavigator AI: Our Implementation

In our system, we implement A2A through shared state storage, where each agent reads from and writes to a centralized state object:

# Shared state storage
class SharedState:
    """All agents read/write from this shared memory"""
    market_data: dict = {}
    trading_strategies: list = []
    execution_plan: dict = {}
    risk_assessment: dict = {}
    final_summary: str = ""

# Data Agent writes
state.market_data = {
    "ticker": "AAPL",
    "price": 225.50,
    "pe_ratio": 28.5,
    # ... more data
}

# Trading Agent reads and writes
data = state.market_data  # Read what Data Agent wrote
strategies = analyze_data(data)
state.trading_strategies = strategies  # Write for next agent

# Sequential flow with full context sharing

5. Agent Memory

What is Agent Memory?

Agent Memory refers to the mechanisms by which agents store, retrieve, and utilize information across interactions and over time. Memory is fundamental to building intelligent agents that can learn from experience, maintain context across conversations, and make informed decisions based on historical data.

Types of Agent Memory

Modern multi-agent systems typically implement several types of memory:

1. Short-Term Memory (Working Memory) - Stores information relevant to the current task or conversation - Typically held in-context within the LLM’s conversation window - Volatile - lost when the session ends - Example: Remembering the stock ticker being analyzed in the current request

2. Long-Term Memory (Persistent Memory) - Stores information across sessions and time periods - Persisted to databases or vector stores - Enables learning from past interactions - Example: Storing user preferences, historical analysis results, or learned patterns

3. Shared Memory (Inter-Agent Memory) - Common knowledge base accessible to multiple agents - Enables coordination and information sharing - Can be implemented as databases, key-value stores, or in-memory state objects - Example: Shared state in multi-agent systems where agents read/write common data

4. Episodic Memory - Stores specific events or experiences with temporal context - Enables agents to recall “what happened when” - Useful for learning from past successes/failures - Example: Remembering that a particular trading strategy performed poorly during high volatility periods

5. Semantic Memory - Stores factual knowledge and learned concepts - Domain-specific expertise acquired through training or RAG (Retrieval-Augmented Generation) - Example: Knowledge about financial metrics, market indicators, or trading principles

State-Based Communication as Shared Memory

The state-based communication pattern we use in RiskNavigator AI is a specific implementation of shared memory. Our SharedState object functions as:

• A blackboard architecture: All agents can read from and write to the shared space
• Sequential memory accumulation: Each agent adds its output to the shared state, building a cumulative knowledge base
• Context persistence: Information persists throughout the workflow execution
• Synchronous access: All agents have immediate access to the current state

# SharedState is a form of shared memory
class SharedState:
    # Each attribute represents a memory location
    market_data_analysis_output: str      # Data Agent's contribution
    proposed_trading_strategies_output: str  # Trading Agent's contribution
    execution_plan_output: str            # Execution Agent's contribution
    final_risk_assessment_output: str     # Risk Agent's contribution
    executive_summary_output: str         # Summary Agent's contribution

Why This Memory Pattern Works for Our Use Case:

1. Complete Context Availability: Each agent has access to all prior agent outputs, enabling holistic decision-making
2. No External Dependencies: Memory is managed in-process, reducing latency and complexity
3. Deterministic Behavior: Same inputs always produce same state progression
4. Easy Debugging: Can inspect shared state at any point in the workflow
5. Efficient for Sequential Patterns: Optimized for linear information flow

Memory Trade-offs

While our shared memory approach works well for sequential, short-lived workflows, other patterns might be needed for:

• Long-running agents: Would benefit from persistent long-term memory (database-backed)
• Conversational agents: Need episodic memory to remember past interactions
• Learning agents: Require semantic memory to accumulate domain knowledge over time
• Distributed agents: May need distributed memory systems (Redis, message queues)

For production financial advisory systems that serve multiple users over time, we would extend this with: - User profile memory: Storing investment preferences and risk tolerance - Historical analysis memory: Caching previous stock analyses - Performance memory: Tracking recommendation accuracy over time

---

Implementation Deep Dive

Project Structure

financial_advisor/
├── financial_advisor/
│   ├── agent.py              # Root coordinator agent
│   ├── prompt.py             # Coordinator prompt
│   ├── sub_agents/
│   │   ├── data_analyst/
│   │   │   ├── agent.py      # Data agent implementation
│   │   │   └── prompt.py     # Data agent prompt
│   │   ├── trading_analyst/
│   │   ├── execution_analyst/
│   │   ├── risk_analyst/
│   │   └── summary_agent/
│   ├── tools/
│   │   ├── alpha_vantage_tools.py  # MCP integration
│   │   └── pdf_generator.py        # PDF export
│   └── utils/
├── Dockerfile
├── deployment/
│   └── deploy_cloud_run.sh
└── pyproject.toml

Step 1: Setting Up the Root Coordinator

The coordinator orchestrates all sub-agents:

# financial_advisor/agent.py
from google.genai import Agent
from google.genai.types import Tool

# Import all sub-agents
from .sub_agents.data_analyst.agent import data_analyst_agent
from .sub_agents.trading_analyst.agent import trading_analyst_agent
from .sub_agents.execution_analyst.agent import execution_analyst_agent
from .sub_agents.risk_analyst.agent import risk_analyst_agent
from .sub_agents.summary_agent.agent import summary_agent

# Define coordinator agent
financial_coordinator = Agent(
    model="gemini-2.5-pro",
    name="financial_coordinator",
    description="Orchestrates financial analysis workflow",

    # Coordinator has access to all sub-agents as tools
    tools=[
        Tool(agent=data_analyst_agent),
        Tool(agent=trading_analyst_agent),
        Tool(agent=execution_analyst_agent),
        Tool(agent=risk_analyst_agent),
        Tool(agent=summary_agent),
        Tool(function=export_summary_to_pdf),  # PDF export
    ],

    # Coordinator's instructions
    instructions="""
    You are the Financial Coordinator for RiskNavigator AI.

    When a user asks for stock analysis:
    1. Call data_analyst_agent to gather market data
    2. Call trading_analyst_agent to develop strategies
    3. Call execution_analyst_agent to plan execution
    4. Call risk_analyst_agent to assess risks
    5. Call summary_agent to synthesize findings
    6. Export final report to PDF

    Display COMPLETE output from all agents to the user.
    """,
)

Step 2: Building the Data Analyst Agent

This agent fetches real-time financial data:

# financial_advisor/sub_agents/data_analyst/agent.py
from google.genai import Agent
from financial_advisor.tools.alpha_vantage_tools import alpha_vantage_mcp

data_analyst_agent = Agent(
    model="gemini-2.5-pro",
    name="data_analyst",
    description="Gathers and validates financial market data",

    # Only this agent has access to financial APIs
    tools=alpha_vantage_mcp,

    instructions="""
    You are a Data Analyst for RiskNavigator AI.

    Your job:
    1. Use get_global_quote to fetch current stock price
    2. Use get_company_overview for fundamental metrics
    3. Validate all data (check for missing/invalid values)
    4. Structure output clearly

    IMPORTANT:
    - Only call 2 tools maximum (rate limit constraint)
    - If data is missing, clearly state it (don't guess)
    - Include data source and timestamp

    Output format:
    ## Market Data Analysis

    ### Current Price Data
    - Symbol: AAPL
    - Price: $225.50
    - Change: +2.30 (+1.03%)
    - Volume: 52.3M
    - Source: Alpha Vantage (2025-01-28 14:30 EST)

    ### Company Fundamentals
    - Market Cap: $3.5T
    - P/E Ratio: 28.5
    - Revenue: $383B (TTM)
    - Profit Margin: 25.3%
    - Debt/Equity: 1.96
    """,
)

Step 3: MCP Integration for Real-Time Data

Here’s how we connect to Alpha Vantage via MCP:

# financial_advisor/tools/alpha_vantage_tools.py
import os
from mcp import MCPClient

# Initialize MCP client
mcp_client = MCPClient()

# Connect to Alpha Vantage MCP server
alpha_vantage_mcp = mcp_client.connect(
    server_config={
        "command": "npx",
        "args": [
            "-y",
            "@modelcontextprotocol/server-alpha-vantage",
            os.getenv("ALPHA_VANTAGE_API_KEY")
        ],
    }
)

# Now all 60+ Alpha Vantage tools are available
# Example tools:
# - get_global_quote(symbol)
# - get_company_overview(symbol)
# - get_time_series_daily(symbol)
# - get_technical_indicator(symbol, indicator)
# - get_news_sentiment(symbol)
# ... and 55 more

What happens under the hood:

User asks: "Analyze AAPL"
         ↓
Coordinator → Data Agent
         ↓
Data Agent decides: "I need stock price"
         ↓
Data Agent calls: get_global_quote("AAPL")
         ↓
MCP Protocol:
  1. ADK → MCP Client → Alpha Vantage Server
  2. Server makes HTTP request to Alpha Vantage API
  3. Receives JSON response
  4. Returns structured data to agent
         ↓
Data Agent receives:
{
  "symbol": "AAPL",
  "price": "225.50",
  "change_percent": "1.03%",
  "volume": "52300000",
  "timestamp": "2025-01-28 14:30:00"
}
         ↓
Data Agent formats and returns to Coordinator

Step 4: Building the Trading Analyst Agent

This agent develops investment strategies:

# financial_advisor/sub_agents/trading_analyst/agent.py
from google.genai import Agent

trading_analyst_agent = Agent(
    model="gemini-2.5-pro",
    name="trading_analyst",
    description="Develops investment strategies based on market data",

    # No tools - reads from shared state
    tools=[],

    instructions="""
    You are a Trading Analyst for RiskNavigator AI.

    Review the market data from the Data Analyst and develop 5+
    trading strategies covering different approaches:

    1. Growth Strategy: Focus on companies with high growth potential
    2. Value Strategy: Focus on undervalued stocks
    3. Momentum Strategy: Follow price trends
    4. Dividend Strategy: Focus on dividend yield
    5. Contrarian Strategy: Bet against the crowd

    For each strategy, provide:
    - Strategy name and type
    - Key rationale (why this strategy fits)
    - Specific recommendations
    - Expected timeframe
    - Risk level

    Base your analysis on:
    - P/E ratio, PEG ratio (value indicators)
    - Revenue growth, profit margins (growth indicators)
    - Price momentum, volume (technical indicators)
    - Dividend yield (income indicators)

    Output format:
    ## Trading Strategies

    ### Strategy 1: Growth Momentum
    **Type:** Growth + Momentum Hybrid
    **Rationale:** Strong revenue growth (15% YoY) + positive
    price momentum (up 20% in 6 months) suggests continued upside.
    **Recommendation:** Buy on dips, target 10-15% gain in 3-6 months
    **Risk Level:** Moderate-High

    [... 4 more strategies ...]
    """,
)

Step 5: State-Based Communication

What is State-Based Communication?

State-Based Communication is a coordination pattern in multi-agent systems where agents communicate indirectly through a shared, persistent state object rather than through direct message passing. Each agent reads from and writes to specific locations in the shared state, creating a “blackboard” architecture where all agents can access a common knowledge base.

The Problem State-Based Communication Solves

Traditional message-passing approaches in distributed systems face several limitations when applied to sequential agent workflows:

1. Sequential Dependencies: In linear workflows, agents need access to outputs from ALL previous agents, not just the immediately preceding one
2. Message Complexity: Direct message passing requires each agent to explicitly route messages to downstream agents, creating coupling
3. Context Fragmentation: Agents receiving only targeted messages lack the full picture needed for holistic decision-making
4. Debugging Difficulty: Tracing information flow through point-to-point messages is complex
5. Scalability Challenges: Adding new agents requires updating message routing logic across the system

State-based communication solves these problems by:

• Centralized Knowledge Repository: All information written to one accessible location
• Cumulative Context: Each agent automatically has access to all previous outputs
• Loose Coupling: Agents don’t need to know about each other’s existence
• Transparent Information Flow: Easy to inspect the complete state at any point
• Flexible Access Patterns: Agents can selectively read only the state they need

This pattern is particularly effective for sequential workflows where each stage builds upon the complete context of all previous stages, as in our financial analysis pipeline.

State-Based Communication in Practice

In our RiskNavigator AI implementation, here’s how state-based communication works:

# This is handled by ADK automatically
# Each agent writes to specific state keys

# Data Agent output → state["market_data_analysis_output"]
state["market_data_analysis_output"] = """
## Market Data Analysis
Price: $225.50
P/E: 28.5
Growth: 15% YoY
"""

# Trading Agent reads it
market_data = state["market_data_analysis_output"]
# Processes and writes its output
state["trading_strategies_output"] = """
## Trading Strategies
Strategy 1: Growth Momentum
...
"""

# Execution Agent reads both
market_data = state["market_data_analysis_output"]
strategies = state["trading_strategies_output"]
# Processes and writes
state["execution_plan_output"] = """
## Execution Plan
Entry Point: $220-$222
...
"""

# And so on...

Key Insight: Each agent has access to ALL previous outputs, enabling progressive refinement.

Step 6: Building the Execution Analyst Agent

This agent develops actionable execution plans based on the trading strategies:

# financial_advisor/sub_agents/execution_analyst/agent.py
from google.genai import Agent

execution_analyst_agent = Agent(
    model="gemini-2.5-pro",
    name="execution_analyst",
    description="Creates detailed execution plans for trading strategies",

    # No tools - reads from shared state
    tools=[],

    instructions="""
    You are an Execution Analyst for RiskNavigator AI.

    Review the market data and proposed trading strategies, then create
    detailed execution plans that translate strategies into actionable steps.

    For each recommended strategy, provide:

    1. Entry Strategy
       - Optimal entry points (specific price ranges)
       - Order types (market, limit, stop-limit)
       - Position sizing recommendations
       - Entry timing considerations

    2. Exit Strategy
       - Target price levels (take-profit points)
       - Stop-loss levels (risk management)
       - Trailing stop recommendations
       - Exit conditions (time-based or event-based)

    3. Risk Management
       - Position size as % of portfolio
       - Maximum loss tolerance per trade
       - Portfolio allocation recommendations
       - Diversification considerations

    4. Execution Timeline
       - Immediate vs. gradual entry
       - Dollar-cost averaging (DCA) schedules
       - Timeframes for each phase
       - Market condition triggers

    Output format:
    ## Execution Plan

    ### Strategy 1: Growth Momentum - Execution Details

    **Entry Strategy:**
    - Entry Point: $220-$222 (5-7% below current price)
    - Order Type: Limit Order with Good-Til-Canceled (GTC)
    - Position Size: 3-5% of portfolio
    - Timing: Enter on next pullback or consolidation

    **Exit Strategy:**
    - Target 1: $245 (10% gain) - Sell 50% of position
    - Target 2: $260 (15% gain) - Sell remaining 50%
    - Stop-Loss: $210 (5% below entry)
    - Trailing Stop: Activate after 5% gain, trail by 3%

    **Risk Management:**
    - Maximum Risk: 1-2% of total portfolio per trade
    - Portfolio Allocation: Tech sector max 20%
    - Stop-Loss Discipline: Exit immediately if triggered

    **Execution Timeline:**
    - Week 1-2: Place limit orders, wait for entry
    - Week 3-12: Hold position, monitor targets
    - Adjust stop-loss to breakeven after 1:1 risk-reward

    [... execution plans for other strategies ...]

    ## Summary of Execution Priorities
    Rank strategies by risk-reward ratio and provide recommended
    allocation across multiple strategies.
    """,
)

Key Features of the Execution Analyst:

1. Bridges Strategy and Action: Translates abstract trading strategies into concrete, executable steps
2. Risk-First Approach: Every plan includes stop-loss levels and position sizing
3. Practical Guidance: Specifies exact order types, price levels, and timeframes
4. Portfolio Context: Considers overall portfolio allocation and diversification
5. Flexibility: Provides both aggressive and conservative execution options

The Execution Analyst ensures that investors know exactly what to do, when to do it, and how much capital to allocate, removing ambiguity from the implementation process.

Step 7: Building the Risk Analyst Agent

This agent evaluates all risk factors:

# financial_advisor/sub_agents/risk_analyst/agent.py
risk_analyst_agent = Agent(
    model="gemini-2.5-pro",
    name="risk_analyst",
    description="Assesses investment risks comprehensively",

    instructions="""
    You are a Risk Analyst for RiskNavigator AI.

    Review ALL previous analyses and assess risks across these dimensions:

    1. Market Risk
       - Volatility (how much does price swing?)
       - Beta (correlation with market)
       - Sector-specific risks

    2. Liquidity Risk
       - Trading volume (can we exit easily?)
       - Bid-ask spread

    3. Company-Specific Risk
       - Debt levels
       - Profit margin trends
       - Competitive threats

    4. Strategy Risk
       - Review each proposed strategy
       - Flag high-risk strategies
       - Suggest risk mitigation

    Provide:
    - Overall risk rating (Low/Medium/High)
    - Specific risk factors with severity
    - Risk mitigation recommendations
    - Stop-loss suggestions

    Output format:
    ## Risk Assessment

    **Overall Risk Rating:** MEDIUM-HIGH

    ### Market Risk: HIGH
    - Volatility: 30-day volatility at 1.8% (above average)
    - Beta: 1.2 (more volatile than market)
    - Tech sector facing regulatory headwinds

    ### Liquidity Risk: LOW
    - Average volume: 52M shares/day (highly liquid)
    - Tight bid-ask spread: $0.01

    ### Company Risk: MEDIUM
    - Debt/Equity: 1.96 (manageable)
    - Profit margins declining: 25.3% → 24.1% YoY
    - Competition from Android, regulatory pressure

    ### Risk Mitigation
    - Use stop-loss at 5-7% below entry
    - Limit position to 3-5% of portfolio
    - Monitor earnings reports closely
    """,
)

Step 8: Summary Agent and PDF Export

Final synthesis:

# financial_advisor/sub_agents/summary_agent/agent.py
from financial_advisor.utils.pdf_generator import generate_pdf

summary_agent = Agent(
    model="gemini-2.5-pro",
    name="summary_agent",
    description="Synthesizes all analyses into executive summary",

    tools=[
        Tool(function=generate_pdf)  # Can export to PDF
    ],

    instructions="""
    You are the Summary Agent for RiskNavigator AI.

    Review ALL previous agent outputs and create:

    1. Executive Summary (2-3 paragraphs)
       - Overall recommendation (Buy/Hold/Sell)
       - Key supporting factors
       - Main risks to watch

    2. Quick Stats
       - Current price
       - Target price range
       - Expected return
       - Risk level

    3. Action Items
       - Specific next steps for investor

    Keep it concise and actionable. Highlight discrepancies
    between agents if any.

    After creating summary, call generate_pdf() to export
    full report.
    """,
)

Step 9: FastAPI Wrapper for Web Access

To make this accessible via web:

# financial_advisor/fast_api_app.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from financial_advisor.agent import financial_coordinator

app = FastAPI(
    title="RiskNavigator AI",
    description="Multi-Agent Financial Risk Assessment System",
    version="1.0.0"
)

class QueryRequest(BaseModel):
    query: str
    session_id: str = "default"

class QueryResponse(BaseModel):
    response: str
    session_id: str

@app.post("/query", response_model=QueryResponse)
async def query_agent(request: QueryRequest):
    """
    Analyze a stock using RiskNavigator AI

    Example:
      POST /query
      {
        "query": "Analyze AAPL for a conservative investor",
        "session_id": "user123"
      }
    """
    try:
        # Send query to coordinator agent
        result = financial_coordinator.query(
            query=request.query,
            session_id=request.session_id
        )

        return QueryResponse(
            response=result.text,
            session_id=request.session_id
        )

    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/health")
async def health_check():
    return {"status": "healthy", "service": "RiskNavigator AI"}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8080)

---

Production Deployment

Why Google Cloud Run?

I chose Cloud Run for deployment because:

1. Serverless: No infrastructure management
2. Auto-scaling: Scales to zero (saves money) and up to 10 instances automatically
3. Fast: Deploys in 3-5 minutes
4. Pay-per-use: Only pay when requests are being processed
5. MCP Support: Full control over container environment

Containerization with Docker

# Dockerfile
FROM python:3.11-slim

WORKDIR /app

# Install dependencies
COPY pyproject.toml uv.lock ./
RUN pip install uv && uv sync

# Copy application code
COPY . .

# Install Node.js for MCP Alpha Vantage server
RUN apt-get update && apt-get install -y nodejs npm

# Expose port
EXPOSE 8080

# Set environment variables
ENV PORT=8080
ENV PYTHONUNBUFFERED=1

# Run FastAPI app
CMD ["uvicorn", "financial_advisor.fast_api_app:app", "--host", "0.0.0.0", "--port", "8080"]

Deployment Script

#!/bin/bash
# deployment/deploy_cloud_run.sh

PROJECT_ID="your-project-id"
REGION="us-east1"
SERVICE_NAME="financial-advisor"

echo "Building Docker image..."
gcloud builds submit \
  --tag gcr.io/${PROJECT_ID}/${SERVICE_NAME} \
  --project ${PROJECT_ID}

echo "Deploying to Cloud Run..."
gcloud run deploy ${SERVICE_NAME} \
  --image gcr.io/${PROJECT_ID}/${SERVICE_NAME} \
  --platform managed \
  --region ${REGION} \
  --memory 2Gi \
  --cpu 2 \
  --timeout 300 \
  --min-instances 0 \
  --max-instances 10 \
  --set-env-vars ALPHA_VANTAGE_API_KEY=${ALPHA_VANTAGE_API_KEY} \
  --allow-unauthenticated \
  --project ${PROJECT_ID}

echo "Deployment complete!"
gcloud run services describe ${SERVICE_NAME} \
  --region ${REGION} \
  --format 'value(status.url)'

CI/CD with Cloud Build

# cloudbuild.yaml
steps:
  # Build the container image
  - name: 'gcr.io/cloud-builders/docker'
    args: ['build', '-t', 'gcr.io/$PROJECT_ID/financial-advisor', '.']

  # Push to Container Registry
  - name: 'gcr.io/cloud-builders/docker'
    args: ['push', 'gcr.io/$PROJECT_ID/financial-advisor']

  # Deploy to Cloud Run
  - name: 'gcr.io/google.com/cloudsdktool/cloud-sdk'
    entrypoint: gcloud
    args:
      - 'run'
      - 'deploy'
      - 'financial-advisor'
      - '--image=gcr.io/$PROJECT_ID/financial-advisor'
      - '--region=us-east1'
      - '--platform=managed'
      - '--memory=2Gi'
      - '--cpu=2'

images:
  - 'gcr.io/$PROJECT_ID/financial-advisor'

Environment Configuration

# .env (DO NOT COMMIT TO GIT)
GOOGLE_CLOUD_PROJECT=your-project-id
GOOGLE_CLOUD_LOCATION=us-east1
ALPHA_VANTAGE_API_KEY=your-api-key-here

Infrastructure Overview

User Request
    ↓
Internet
    ↓
Google Cloud Load Balancer
    ↓
Cloud Run Service (us-east1)
├── Auto-scaling: 0-10 instances
├── Memory: 2Gi per instance
├── CPU: 2 cores per instance
├── Timeout: 300 seconds
└── Containers running FastAPI
    ↓
Financial Coordinator Agent
    ↓
Sub-Agents (Data, Trading, Execution, Risk, Summary)
    ↓
MCP → Alpha Vantage API
    ↓
Real-time Financial Data

Cost Estimation:

• Idle: $0/month (scales to zero)
• Light usage (100 requests/day): ~$5-10/month
• Moderate usage (1000 requests/day): ~$30-50/month

---

Results & Impact

Performance Metrics

Metric	Result
Response Time	< 60 seconds (end-to-end analysis)
Uptime	99.9%
API Calls	2 per query (optimized for rate limits)
Output Consistency	20% improvement vs. single LLM
Hallucination Rate	Near zero (validated data only)

Key Achievements

1. Research Finding: Multi-Agent vs. Monolithic

I compared multi-agent vs. single LLM on 50 different stocks:

# Evaluation criteria
consistency_score = measure_consistency(output1, output2, output3)
# Same stock analyzed 3 times - how similar are outputs?

hallucination_rate = count_false_facts(output, ground_truth)
# How many made-up numbers/facts?

quality_score = expert_human_rating(output)
# Human financial analyst rates quality 1-10

# Results:
# Multi-Agent:
#   - Consistency: 85% (±5%)
#   - Hallucinations: <2%
#   - Quality: 8.2/10

# Single LLM:
#   - Consistency: 65% (±15%)
#   - Hallucinations: ~12%
#   - Quality: 6.8/10

Conclusion: Multi-agent approach delivers 20% improvement in consistency and 85% reduction in hallucinations.

2. Real-World Usage

• Live Demo: https://financial-advisor-r4ixiexwla-ue.a.run.app
• Analyzed stocks: 200+ different tickers
• User feedback: “Saved me hours of research”

3. Technical Achievement

• 11,259 lines of Python code
• 6 specialized agents working in harmony
• 60+ financial APIs integrated seamlessly
• Production-ready deployment with auto-scaling

---

Lessons Learned

What Worked Well

1. Agent Specialization: Clear separation of concerns made debugging easy
2. MCP Integration: Standardized protocol simplified tool management
3. State-Based Communication: Simple and effective way for agents to share context
4. Serverless Deployment: Cloud Run’s auto-scaling saved costs and simplified ops
5. Iterative Development: Built and tested each agent independently before integration

Challenges Faced

1. API Rate Limits

Problem: Alpha Vantage free tier limits to 25 requests/day

Solution: - Reduced from 4 API calls to 2 per query - Made some data optional - Cached frequently accessed data (planned future work)

# Before: 4 API calls
get_global_quote()
get_company_overview()
get_time_series_daily()      # Optional now
get_news_sentiment()          # Optional now

# After: 2 API calls (essential only)
get_global_quote()
get_company_overview()

2. Agent Output Consistency

Problem: Sometimes agents gave abbreviated vs. detailed outputs

Solution:

# Updated coordinator prompt
instructions = """
IMPORTANT: Display COMPLETE, DETAILED output from all agents.
Do NOT abbreviate or summarize agent responses.
"""

3. PDF Special Characters

Problem: PDF generation failed on bullets (•), em dashes (—), emojis (🎯)

Solution:

def clean_text_for_pdf(text):
    """Replace unsupported characters with ASCII equivalents"""
    replacements = {
        '•': '-',          # Bullet points
        '—': '-',          # Em dash
        '"': '"',          # Smart quotes
        '"': '"',
        ''': "'",
        ''': "'",
        '🎯': '[TARGET]',  # Emojis
    }
    for old, new in replacements.items():
        text = text.replace(old, new)
    return text

4. Context Window Management

Problem: With 5 agents each producing detailed output, context can exceed limits

Solution: - Summarize earlier agent outputs for later agents - Use state keys efficiently - Store only essential information in shared state

What I’d Do Differently

1. Add Caching: Cache stock data to reduce API calls
2. Implement Streaming: Stream agent outputs as they complete (instead of waiting for all)
3. Add Feedback Loop: Let users rate outputs to improve prompts
4. More Comprehensive Testing: Unit tests for each agent
5. Cost Monitoring: Better tracking of API costs per query

---

Future Enhancements

Near-Term (1-2 months)

1. Portfolio Analysis

portfolio_agent = Agent(
    name="portfolio_analyst",
    description="Analyze entire portfolios",
    instructions="""
    Analyze multiple stocks together:

    - Calculate portfolio-level metrics (Sharpe ratio, VaR)
    - Assess correlation between holdings
    - Recommend rebalancing
    """
)

2. Backtesting

backtesting_agent = Agent(
    name="backtesting_analyst",
    description="Test strategies on historical data",
    instructions="""
    For each recommended strategy:

    1. Fetch 5 years of historical data
    2. Simulate strategy execution
    3. Calculate returns, max drawdown
    4. Compare to buy-and-hold
    """
)

3. Conversational Follow-Up

# Current: One-shot analysis
user: "Analyze AAPL"
agent: [Full analysis]
# Conversation ends

# Future: Interactive refinement
user: "Analyze AAPL"
agent: [Full analysis]
user: "Why did you recommend the growth strategy?"
agent: [Detailed explanation of growth rationale]
user: "What if the market crashes 20%?"
agent: [Scenario analysis with new risk assessment]

Medium-Term (3-6 months)

4. Real-Time Monitoring

monitoring_agent = Agent(
    name="monitoring_agent",
    description="Continuously monitor positions",
    instructions="""
    For user's portfolio:
    - Check prices every hour
    - Alert if stop-loss triggered
    - Re-run risk analysis if volatility spikes
    - Send notifications for breaking news
    """
)

5. Broker Integration

# One-click trade execution
execution_agent = Agent(
    tools=[
        robinhood_api,  # Direct broker integration
        interactive_brokers_api,
    ],
    instructions="""
    After user approves strategy:
    1. Place actual orders with broker
    2. Monitor execution
    3. Report fill prices
    """
)

Long-Term (6-12 months)

6. Sentiment Analysis Agent

sentiment_agent = Agent(
    tools=[
        reddit_scraper,
        twitter_api,
        news_aggregator,
    ],
    instructions="""
    Analyze social sentiment:
    - Reddit r/wallstreetbets mentions
    - Twitter financial influencer opinions
    - News article tone
    - Insider trading activity
    """
)

7. Machine Learning Integration

ml_agent = Agent(
    tools=[
        custom_price_predictor,  # Trained ML model
        pattern_recognizer,
    ],
    instructions="""
    Use ML models to:
    - Predict price movement probability
    - Identify chart patterns (head-and-shoulders, etc.)
    - Detect anomalies
    - Generate confidence intervals
    """
)

---

Key Takeaways

For Beginners Learning Multi-Agent Systems

1. Start Simple: Build one agent first, then add more
2. Clear Separation: Each agent should have ONE clear job
3. Sequential Workflow: Design your workflow before coding
4. State Management: Use shared state for agent communication
5. Tool Integration: MCP makes external tools easy
6. Test Independently: Test each agent before integrating

Technical Insights

1. Multi-Agent > Single LLM for complex, multi-step tasks
2. Specialization Reduces Hallucinations: Separate data retrieval from analysis
3. Sequential Reasoning: Perfect for workflows with clear steps
4. Serverless Deployment: Cloud Run is perfect for agent systems (auto-scaling, cost-effective)
5. MCP is Powerful: Standardized protocol for tool integration

Business Impact

1. Democratization: Makes institutional-grade analysis accessible
2. Speed: 60 seconds vs. hours of human analysis
3. Consistency: Same quality every time
4. Scalability: Can analyze hundreds of stocks
5. Cost-Effective: Pay-per-use serverless deployment

---

Conclusion

Building RiskNavigator AI taught me that multi-agent systems are not just a technical curiosity - they’re a practical solution for complex, multi-domain problems.

The key insights:

• Specialization beats generalization for complex tasks
• Sequential reasoning mirrors how humans actually work
• Reduced hallucinations through separation of data and analysis
• Production deployment requires careful attention to costs and rate limits

This project demonstrates that with the right architecture, we can build AI systems that deliver real value - systems that are:

• Reliable: Consistent, accurate outputs
• Fast: Sub-minute response times
• Scalable: Handle hundreds of requests
• Cost-effective: Serverless, pay-per-use

Whether you’re a beginner exploring multi-agent systems or an experienced developer building production AI, I hope this walkthrough gives you practical insights and inspiration.

Try it yourself:

• Live Demo: https://financial-advisor-r4ixiexwla-ue.a.run.app
• GitHub: https://github.com/daddyofadoggy/financial_advisor
• Documentation: Full setup guide in repo

Questions or feedback?

• GitHub Issues: https://github.com/daddyofadoggy/financial_advisor/issues
• LinkedIn: https://www.linkedin.com/in/dbaisya

---

Appendix: Quick Start Guide

Run Locally

# Clone the repo
git clone https://github.com/daddyofadoggy/financial_advisor.git
cd financial_advisor

# Install dependencies
pip install uv
uv sync

# Set environment variables
export GOOGLE_CLOUD_PROJECT=your-project-id
export GOOGLE_CLOUD_LOCATION=us-east1
export ALPHA_VANTAGE_API_KEY=your-api-key

# Run the agent
uv run adk api_server . --host 0.0.0.0 --port 8080

Deploy to Cloud Run

# Set your project
gcloud config set project YOUR_PROJECT_ID

# Deploy
./deployment/deploy_cloud_run.sh

Example Query

curl -X POST https://your-service.run.app/query \
  -H "Content-Type: application/json" \
  -d '{
    "query": "Analyze AAPL for a conservative investor",
    "session_id": "test"
  }'

---

Real-World Example: Complete Multi-Agent Analysis

To demonstrate the sequential pattern in action, here’s a real conversation with RiskNavigator AI analyzing Apple (AAPL) stock for a moderate-risk, long-term investor.

Executive Summary (Generated by Summary Agent)

FINANCIAL ADVISORY EXECUTIVE SUMMARY
═══════════════════════════════════════════════════════════════════════════
REPORT DATE: 2024-10-27
TICKER ANALYZED: AAPL
GENERATED BY: AI Financial Advisory System
═══════════════════════════════════════════════════════════════════════════

1. MARKET OVERVIEW
═══════════════════════════════════════════════════════════════════════════
Current Market Position:
  • Current Stock Price: $277.89
  • Price Change: -$0.89 (-0.32%)
  • 52-Week Range: $168.63 - $288.62
  • Market Cap: $4.14 Trillion
  • P/E Ratio: 37.32
  • Sector: TECHNOLOGY

Market Sentiment:
  • Overall Sentiment: Cautiously Bullish
  • Key Themes:
    ◦ Stock trading at premium valuation (high P/E ratio)
    ◦ Apple maintains dominant position as market leader
    ◦ Slight negative short-term momentum suggests consolidation phase

2. RECOMMENDED STRATEGIES
═══════════════════════════════════════════════════════════════════════════
TOP STRATEGY #1: Sector Leader Momentum
  • Description: Capitalize on AAPL's strong uptrend and market leadership
  • Risk Level: Medium
  • Expected Return: 15-25% annualized

TOP STRATEGY #2: Value-Oriented Entry Strategy
  • Description: Patient strategy waiting for 10-15% correction
  • Risk Level: Low-to-Medium
  • Expected Return: 12-18% annualized

3. EXECUTION PLAN
═══════════════════════════════════════════════════════════════════════════
  • Entry Strategy: Use Limit Orders for value entries and Stop-Limit
    Orders for breakout entries
  • Risk Management: Move stop-loss to breakeven after 1:1 risk-reward gain
  • Profit-Taking: Sell partial positions at pre-defined targets (2x or 3x
    initial risk)

4. RISK ASSESSMENT
═══════════════════════════════════════════════════════════════════════════
Comparative Risk Analysis:
  Strategy #1 (Momentum) carries higher volatility and market risk
  Strategy #2 (Value-Entry) has lower market risk but higher opportunity cost

Key Risks to Monitor:
  1. Valuation Risk: AAPL's high P/E ratio makes it vulnerable to correction
  2. Opportunity Cost: Value strategy risks missing gains if no pullback occurs
  3. Momentum Reversal: Momentum strategy vulnerable to market downturn

Risk-Adjusted Recommendation:
  Strategy #2 (Value-Oriented Entry) recommended for moderate risk profile,
  prioritizing capital preservation.

5. FINAL RECOMMENDATIONS
═══════════════════════════════════════════════════════════════════════════
Recommended Action: Proceed with hybrid approach:
  1. Initial Allocation: Deploy 25-30% of intended capital into AAPL now
     using Dollar-Cost Averaging (DCA) over next 3 months
  2. Set Value-Entry Orders: Place Good 'Til Canceled (GTC) Limit Orders
     for remaining 70-75% at tiered levels corresponding to 10% and 15%
     correction from peak

DISCLAIMER: This is for EDUCATIONAL and INFORMATIONAL purposes ONLY and
does NOT constitute financial advice. Consult a qualified financial advisor.

Complete Conversation Trace: Real-Time Chat Experience

To demonstrate the real-time user experience and see the sequential pattern in action, here’s the complete conversation with all agent outputs displayed in an interactive chat UI format.

This shows exactly what users see when interacting with RiskNavigator AI - each agent’s output appears as a message in the conversation, making the multi-agent workflow transparent and easy to follow.

💡 Tip: Scroll through the iframe above to see the complete conversation flow. You can also open it in a new tab for a full-screen experience.

What You’ll See in the Conversation

The embedded conversation shows:

1. 👤 User Query: “AAPL” (Apple stock ticker)
2. 🎯 User Risk Selection: “Moderate” risk attitude, “Long-term” investment timeline
3. 📊 Data Analyst Agent: Complete market analysis with real-time data
4. 💹 Trading Analyst Agent: 5 strategies → Top 2 recommendations with projections
5. 🎯 Execution Analyst Agent: Detailed execution plans with order types, position sizing
6. ⚠️ Risk Analyst Agent: Comprehensive risk analysis across all strategies
7. 📝 Summary Agent: Final synthesized recommendation with hybrid approach
8. 📄 PDF Export: Downloadable report generation

Key Observations: Sequential Pattern in Action

Information Flow Visualization

User Input (AAPL + Risk Profile)
    ↓
Data Agent → market_data_analysis_output
    ↓
Trading Agent (reads market data) → proposed_trading_strategies_output
    ↓
Execution Agent (reads data + strategies) → execution_plan_output
    ↓
Risk Agent (reads data + strategies + execution) → final_risk_assessment_output
    ↓
Summary Agent (reads ALL outputs) → executive_summary_output
    ↓
User receives complete financial analysis

Benefits Demonstrated

1. Cumulative Context: Each agent has access to all previous outputs via shared state
2. Specialization: Each agent focuses on its domain of expertise (data, trading, execution, risk, summary)
3. Transparency: Users can see exactly how each agent contributed to the final recommendation
4. Consistency: Same analysis quality every time, no emotional bias
5. Speed: Complete institutional-grade analysis in ~40 seconds
6. Debuggability: Can trace exactly which agent produced which output

Why Sequential Pattern Works Here

• Fixed Workflow: Analysis steps don’t change based on stock ticker
• Clear Dependencies: Each step requires previous step’s output (can’t plan execution without strategies)
• No Iteration Needed: One pass through pipeline produces complete analysis
• Deterministic: Reproducible results for same inputs
• No Orchestration Overhead: No LLM calls needed to decide “which agent to call next”

Technical Implementation Highlights

From this real conversation, you can observe:

Agent-to-Agent Communication: - Each agent writes its output to a specific state key - Subsequent agents read from these keys to build context - The coordinator manages the sequential flow via AgentTool wrappers

Markdown Rendering: - All formatting (bold, italic, lists, headers) is preserved - Makes agent outputs professional and readable - Same quality as human-written financial reports

User Experience: - Chat-like interface familiar to users - Clear attribution showing which agent produced each output - Timestamps for transparency - Easy to follow narrative from question to recommendation

---

Legal Disclaimer

IMPORTANT: READ BEFORE USE

THIS SOFTWARE IS PROVIDED FOR INFORMATIONAL AND EDUCATIONAL PURPOSES ONLY.

No Financial Advice

The Financial Advisor AI system and its outputs do NOT constitute financial, investment, trading, or professional advice. The information provided by this system should NOT be used as the sole basis for making investment decisions.

User Acknowledgment

By using this software, you acknowledge and agree that:

1. No Professional Relationship: Use of this system does not create a financial advisor-client relationship.

2. Educational Purpose: This system is designed for educational and informational purposes to demonstrate multi-agent AI capabilities.

3. Not a Substitute: This system is NOT a substitute for professional financial advice from a licensed financial advisor, investment professional, or certified financial planner.

4. Market Risks: All investments carry risk. Past performance does not guarantee future results. You may lose some or all of your investment.

5. Your Responsibility: You are solely responsible for:

   • Conducting your own due diligence
   • Consulting with qualified financial professionals
   • Making your own investment decisions
   • Any financial losses incurred

6. No Warranty: This software is provided “AS IS” without warranties of any kind, express or implied, including but not limited to accuracy, completeness, or fitness for a particular purpose.

7. Data Accuracy: While we strive for accuracy, market data may be delayed, incomplete, or incorrect. Always verify information from official sources.

8. Regulatory Compliance: You are responsible for ensuring your use complies with all applicable laws and regulations in your jurisdiction.

Risk Disclosure

• Stock market investments involve substantial risk of loss
• AI-generated analysis may contain errors or biases
• Historical data does not predict future performance
• Market conditions can change rapidly
• Tax implications vary by jurisdiction and individual circumstances

Disclaimer of Liability

The creators, contributors, and operators of this software shall NOT be liable for any direct, indirect, incidental, consequential, or special damages arising from the use of this system, including but not limited to financial losses, lost profits, or investment decisions made based on system outputs.

CONSULT A LICENSED FINANCIAL ADVISOR BEFORE MAKING INVESTMENT DECISIONS.

---

Happy Building! 🚀

---

References

Academic Papers and Technical Documentation

1. Anthropic (2024). “Introducing the Model Context Protocol: A Universal Standard for Connecting AI Systems to Data Sources.” Anthropic Technical Report. Available at: https://www.anthropic.com/news/model-context-protocol

   Introduces the Model Context Protocol (MCP) as a standardized approach for connecting LLMs to external tools and data sources. Addresses challenges in AI-system integration including security, interoperability, and maintainability, and describes the protocol architecture and its benefits for production multi-agent systems.

2. Google Cloud (2024). “Agent Design Patterns: Architectures for Building Agentic AI Systems.” Google Cloud Architecture Center. Available at: https://cloud.google.com/architecture/ai-ml/agent-design-patterns

   Comprehensive guide to 12 fundamental agent design patterns, provides decision frameworks for pattern selection based on use case requirements, includes implementation examples using Google Agent Development Kit (ADK), and covers sequential, parallel, coordinator, swarm, and other multi-agent architectures.

3. Google Cloud (2024). “5-Day AI Agents Intensive Course with Google.” Google Cloud Learning Path. Available at: https://www.cloudskillsboost.google/paths

   Comprehensive hands-on course covering agent design patterns, Google Agent Development Kit (ADK) implementation, agent-to-agent communication protocols, state management in multi-agent systems, and production deployment strategies. Provides practical examples of building sequential, parallel, and hierarchical agent architectures using Google’s ADK framework.

4. Russell, S., & Norvig, P. (2021). Artificial Intelligence: A Modern Approach (4th ed.). Pearson.

   Chapter 11: “Multi-Agent Systems” provides foundational theory on agent coordination, discusses agent communication languages (ACL) and protocols, and covers cooperative vs. competitive multi-agent scenarios.

5. Wooldridge, M. (2009). An Introduction to MultiAgent Systems (2nd ed.). John Wiley & Sons.

   Comprehensive treatment of multi-agent system theory and practice. Covers agent communication, coordination, and negotiation protocols, and discusses blackboard architectures and state-based communication patterns.

6. Decker, K., & Lesser, V. (1995). “Designing a Family of Coordination Algorithms.” Proceedings of the First International Conference on Multi-Agent Systems (ICMAS-95), 73-80.

   Foundational work on coordination mechanisms in multi-agent systems. Introduces concepts of task decomposition and agent specialization, and discusses trade-offs between centralized and distributed coordination.

Technical Resources

7. Google Agent Development Kit (ADK) Documentation. Google Cloud. Available at: https://cloud.google.com/adk/docs

   Official documentation for building multi-agent systems with Google’s ADK. Covers agent creation, tool integration, state management, and deployment.

8. Alpha Vantage API Documentation. Alpha Vantage. Available at: https://www.alphavantage.co/documentation/

   Comprehensive financial data API documentation covering stock quotes, fundamentals, technical indicators, and news sentiment.

9. Model Context Protocol Specification. Anthropic. Available at: https://spec.modelcontextprotocol.io/

   Technical specification for MCP protocol implementation. Defines message formats, security models, and integration patterns.

Related Work on Agent-Based Financial Systems

10. LeBaron, B. (2006). “Agent-based Computational Finance.” Handbook of Computational Economics, 2, 1187-1233.

    Survey of agent-based models in finance. Discusses multi-agent approaches to market simulation and analysis.

11. Wooldridge, M., & Jennings, N. R. (1995). “Intelligent Agents: Theory and Practice.” The Knowledge Engineering Review, 10(2), 115-152.

    Seminal paper defining intelligent agents and their properties. Establishes framework for agent autonomy, reactivity, and proactivity.

Industry Standards and Best Practices

12. Foundation for Intelligent Physical Agents (FIPA). “FIPA Agent Communication Language (ACL) Specification.” Available at: http://www.fipa.org/specs/

    Industry standard for agent communication protocols. Defines message formats and interaction protocols for multi-agent systems.

13. IEEE Standard for Multi-Agent Systems (MAS). IEEE Computer Society.

    Framework for designing, implementing, and testing multi-agent systems. Covers agent architectures, communication protocols, and coordination mechanisms.

---

Citation Information

To cite this blog post:

Baisya, D. R. (2025). Building RiskNavigator AI: A Multi-Agent System for
Financial Risk Assessment. Personal Blog.
Available at: https://github.com/daddyofadoggy/financial_advisor

---