Team: 
We've built a comprehensive financial intelligence system that transforms how users interact with their finances through three specialized AI agents. Our solution combines the power of Google's latest AI models with robust financial algorithms to deliver trustworthy, actionable insights that users can rely on for their most important financial decisions.
Our architecture demonstrates a critical insight: Trust through hybrid intelligence. By combining AI agents for interaction and understanding with deterministic algorithms for financial calculations, we ensure users get both the conversational intelligence they desire and the mathematical precision they demand.
The Google AI Agent Bake-off challenged teams to build innovative AI agent solutions using Google's technology stack. Within the financial services vertical, the core challenge was clear:
How do you build AI agents that users can trust with their money?
Financial services require a unique balance:
- 🤖 Intelligence: Understanding complex financial situations
- 🔢 Precision: Accurate calculations without hallucination
- 🛡️ Security: Production-grade authentication and data protection
- 🎨 Engagement: Delightful user experiences that drive adoption
Your conversational financial companion
- Purpose: Provides real-time spending insights through natural conversation
- Core Features:
- Analyzes transaction patterns across all accounts
- Identifies spending trends and anomalies
- Offers personalized budgeting suggestions
- Tracks progress toward financial goals
- User Experience: Natural language queries like "How much did I spend on dining this month?" or "Am I on track with my budget?"
The architectural centerpiece - Where AI meets algorithmic precision
- Purpose: Plans major purchases while ensuring financial stability
- Innovation: Hybrid architecture combining:
- AI Layer: Understanding purchase intent and context
- Algorithmic Layer: Deterministic financial calculations
- Core Algorithm:
- Analyzes cash flow patterns
- Projects future savings capacity
- Calculates optimal savings timeline
- Ensures emergency fund preservation
- Provides guaranteed mathematical accuracy
- Trust Factor: Users can verify every calculation, building confidence in AI-assisted financial planning
Bringing dreams to life with visual intelligence
- Purpose: Comprehensive travel planning with financial awareness
- Powered by: Google's Nano Banana (Gemini 2.5 Flash) for generative imagery
- Features:
- Generates personalized travel itineraries
- Creates visual destination previews
- Calculates total trip costs
- Integrates with Big Purchases Agent for savings plans
- Provides real-time budget tracking during trips
- Visual Innovation: Generates custom imagery for destinations, helping users visualize and emotionally connect with their savings goals
graph TB
subgraph "Frontend Layer"
UI[Next.js Application]
AUTH[Firebase Authentication]
end
subgraph "Agent Layer"
DS[Daily Spending Agent]
BP[Big Purchases Agent]
TP[Travel Planning Agent]
end
subgraph "Intelligence Layer"
AI[AI Processing Engine]
ALGO[Algorithmic Tools]
VIS[Nano Banana Visual Gen]
end
subgraph "Data Layer"
API[FastAPI Backend]
DB[(JSON Data Store)]
end
subgraph "Infrastructure"
CR[Cloud Run]
GCP[Google Cloud Platform]
end
UI -->|Secured by| AUTH
AUTH -->|Requests| DS
AUTH -->|Requests| BP
AUTH -->|Requests| TP
DS -->|Queries| AI
BP -->|Orchestrates| AI
BP -->|Validates| ALGO
TP -->|Generates| VIS
TP -->|Consults| BP
AI -->|Fetches| API
ALGO -->|Fetches| API
API -->|Reads/Writes| DB
UI -.->|Hosted on| CR
API -.->|Deployed on| CR
CR -.->|Runs on| GCP
sequenceDiagram
participant User
participant Frontend
participant Auth as Firebase Auth
participant Agent
participant AI as AI Engine
participant Tool as Financial Tools
participant API as Backend API
User->>Frontend: Request (e.g., "Plan vacation")
Frontend->>Auth: Validate session
Auth-->>Frontend: Token
Frontend->>Agent: Authenticated request
Agent->>AI: Process intent
AI->>API: Get user data
API-->>AI: Financial context
alt Complex Calculation Required
Agent->>Tool: Execute algorithm
Tool->>API: Get financial data
API-->>Tool: Data
Tool-->>Agent: Precise calculation
end
Agent->>AI: Generate response
AI-->>Agent: Formatted response
Agent-->>Frontend: Result
Frontend-->>User: Display
-
Authentication Layer
- Firebase Authentication for user identity
- JWT tokens for session management
- Role-based access control
-
API Security
- Google Cloud ID tokens for service-to-service auth
- CORS configuration for frontend protection
- Request validation and sanitization
-
Infrastructure Security
- Cloud Run managed TLS
- VPC Service Controls
- Secret Manager for sensitive configuration
-
Data Protection
- User data isolation
- Encrypted data transmission
- Audit logging for compliance
The Big Purchases Agent exemplifies our core innovation:
class BigPurchaseAgent:
def plan_purchase(self, purchase_request):
# AI understands the request
context = ai_engine.understand_intent(purchase_request)
# Algorithm provides precision
calculation = financial_algorithm.calculate_savings_plan(
amount=context.amount,
timeline=context.desired_date,
cash_flow=user.get_cash_flow(),
emergency_fund=user.get_emergency_minimum()
)
# AI generates human-friendly response
response = ai_engine.format_response(calculation)
return response # Best of both worldsUsing Nano Banana (Gemini 2.5 Flash) to generate destination imagery:
- Creates emotional connection to savings goals
- Increases user engagement and motivation
- Personalizes the financial planning experience
Full Google Cloud Stack implementation:
- Frontend: Next.js on Cloud Run
- Authentication: Firebase Auth
- Backend: FastAPI on Cloud Run
- AI Services: Vertex AI integration
- Monitoring: Cloud Logging & Monitoring
- Every calculation is verifiable
- AI explains its reasoning
- Users can audit recommendations
- Agents handle interaction and understanding
- Tools ensure mathematical accuracy
- Clear boundaries prevent hallucination in critical calculations
- Not just a prototype - fully deployed solution
- Real authentication and security
- Scalable architecture on Google Cloud
- Conversational interfaces for accessibility
- Visual elements for emotional connection
- Personalized insights that drive action
# Core agent structure demonstrating our architectural principles
class FinancialAgent:
def __init__(self, ai_model, tools):
self.ai_model = ai_model
self.tools = tools # Deterministic algorithms
def process_request(self, user_request):
# AI for understanding
intent = self.ai_model.extract_intent(user_request)
# Tools for precision
if intent.requires_calculation:
result = self.tools.execute(intent)
else:
result = self.ai_model.generate_response(intent)
return self.format_response(result)class SavingsCalculator:
@staticmethod
def calculate_savings_timeline(
target_amount: float,
monthly_income: float,
monthly_expenses: float,
current_savings: float,
emergency_fund_minimum: float
) -> dict:
"""
Deterministic calculation ensuring mathematical accuracy
"""
available_monthly = monthly_income - monthly_expenses
# Ensure emergency fund is maintained
if current_savings < emergency_fund_minimum:
months_to_emergency = (
(emergency_fund_minimum - current_savings) /
available_monthly
)
remaining_monthly = available_monthly
else:
months_to_emergency = 0
remaining_monthly = available_monthly
months_to_target = (
target_amount / remaining_monthly
) + months_to_emergency
return {
"monthly_savings": remaining_monthly,
"total_months": int(months_to_target),
"completion_date": calculate_date(months_to_target),
"maintains_emergency_fund": True
}- Clarity: Complex financial situations explained simply
- Confidence: Verifiable calculations build trust
- Motivation: Visual goals increase savings rates
- Accessibility: Natural language removes barriers
- Zero Hallucination: Critical calculations always accurate
- Sub-second Response: Optimized for real-time interaction
- 100% Uptime: Production deployment on Cloud Run
- Full Security: Enterprise-grade authentication and authorization
- Investment Planning Agent: Portfolio optimization with risk assessment
- Tax Optimization Agent: Real-time tax impact analysis
- Family Finance Agent: Multi-user household budgeting
- Predictive Analytics: ML-based spending predictions
- Integration with real banking APIs
- Blockchain transaction verification
- Advanced fraud detection
- Voice interface support
- Gemini 2.5 Flash (Nano Banana): Visual generation
- Vertex AI: Agent orchestration
- Custom Algorithms: Financial calculations
- FastAPI: High-performance API
- Python 3.11: Core language
- Pydantic: Data validation
- Next.js 14: React framework
- TypeScript: Type safety
- Tailwind CSS: Styling
- Google Cloud Run: Serverless containers
- Firebase: Authentication & hosting
- Cloud Storage: Data persistence
- Firebase Auth: User authentication
- Cloud IAM: Service authorization
- Secret Manager: Credential management
Our solution represents a paradigm shift in financial AI agents. By combining conversational AI with algorithmic precision, we've created a system that users can trust with their most important financial decisions. The deployment on Google Cloud's full stack demonstrates not just technical capability, but a production-ready solution that could be launched tomorrow.
The key insight - that financial services require hybrid intelligence rather than pure AI - sets our solution apart and provides a blueprint for the future of AI in finance.
Ayo Adedeji - Architecture & Backend Development Adrian Osorio - Sous Chef, Frontend & Agent Design
Built for the Google AI Agent Bake-off Competition
Competition Submission - Google AI Agent Bake-off 2025