BankPilot

An enterprise-grade agentic banking platform that securely turns conversations into intelligent insights, grounded recommendations, and real banking actions

Comment

Inspiration

Banking is increasingly digital, yet many experiences remain fragmented. Customers switch between dashboards, product pages, support channels, and transaction screens, while banking teams spend significant effort navigating dashboards and manually investigating business questions.

We asked: What if AI agents could do more than answer banking questions?

That idea inspired BankPilot—an agentic AI banking platform where customers receive personalized insights and recommendations, securely execute banking workflows, and business stakeholders investigate complex analytical questions using natural language.

We built BankPilot for the All Things Agentic Hackathon to explore how a governed multi-agent architecture can combine banking data, enterprise knowledge, analytics, and secure actions.

What it does

BankPilot provides two primary AI experiences.

🤖 AI Banking Assistant

The AI Banking Assistant helps customers:

  • Analyze transaction and spending patterns.
  • Understand financial behavior.
  • Receive personalized product recommendations.
  • Retrieve grounded product and policy information.
  • Pay credit card bills.
  • Add beneficiaries.
  • Execute secure fund transfers.

Product recommendations are grounded through an enterprise knowledge base using Retrieval-Augmented Generation (RAG).

Sensitive banking actions are executed through a Transaction MCP Server, while deterministic controls such as authorization and OTP verification protect high-value transactions.

📊 Analytics Copilot

The Analytics Copilot enables banking stakeholders to investigate complex business questions using natural language.

It can analyze:

  • Customer acquisition cohorts.
  • Multi-product adoption.
  • Deposit balance growth.
  • CASA growth.
  • Product cross-selling.
  • Customer behavior.

For ambiguous questions, the system uses Human-in-the-Loop (HITL) interaction instead of silently making assumptions. It can also use fan-out execution to investigate multiple hypotheses in parallel before synthesizing the results.

📚 Enterprise Knowledge Base

Bank staff can upload and manage banking product and policy documents.

Documents are processed through the Agent Platform RAG Engine for chunking, embedding, indexing, and retrieval. Access controls determine whether documents are available to:

  • Customers
  • Staff
  • Both

When a new version of a document is uploaded, the previous version can be replaced to help ensure agents retrieve the latest approved information.

This shared knowledge layer powers both the AI Banking Assistant and the Analytics Copilot.

How we built it

BankPilot is built as a modular, enterprise-style agent architecture on Google Cloud.

The platform uses:

  • Gemini 3.7 Flash for AI reasoning.
  • Google ADK for building agent workflows.
  • Google Agent Platform for agent deployment and management.
  • Agent Runtime for running the AI Banking Assistant and Analytics Copilot.
  • Agent Registry for discovering and managing approved agents and capabilities.
  • Agent Gateway for controlled ingress and egress routing.
  • Agent Platform RAG Engine for enterprise knowledge retrieval.
  • Model Context Protocol (MCP) for controlled access to banking actions.
  • Cloud Run for supporting microservices.
  • BigQuery for banking and analytics data.
  • Firebase App Hosting for hosting the application.
  • Firebase Authentication for secure authentication and Google Sign-In.
  • Next.js for the customer and staff experiences.

A Customer Identity Service manages authorization, customer registration, customer context, and access to customer-specific authorized BigQuery views.

The architecture separates:

Identity → Agents → Specialized Sub-Agents → MCP Tools → Knowledge → Data

This separation helps keep responsibilities modular and ensures agents do not directly access sensitive systems without appropriate controls.

BankPilot also includes observability and evaluation capabilities using:

  • Agent Platform tracing and observability
  • OpenTelemetry-based GenAI telemetry
  • Cloud Logging and Cloud Trace
  • BigQuery telemetry pipelines
  • Google ADK Evaluation Suite for automated evaluation, regression testing, and safety benchmarks

Challenges we ran into

One of the biggest challenges was designing the system as a true agentic workflow rather than a collection of chatbots.

We had to carefully separate responsibilities between agents, tools, identity services, knowledge retrieval, and banking data.

Some key challenges included:

  • Designing secure access to customer-specific banking data.
  • Preventing agents from directly accessing sensitive transactional systems.
  • Implementing access-controlled RAG retrieval for customers and staff.
  • Managing document updates so outdated knowledge does not remain available.
  • Designing multi-agent workflows without unnecessary complexity.
  • Handling ambiguous analytical questions through Human-in-the-Loop interactions.
  • Running multiple analytical hypotheses efficiently through fan-out execution.
  • Adding deterministic controls such as OTP verification around sensitive AI-driven actions.
  • Maintaining observability across the frontend, microservices, agents, and AI inference.

These challenges reinforced the importance of treating AI agents as part of a broader enterprise system rather than simply connecting an LLM to a database.

Accomplishments that we're proud of

We are particularly proud that BankPilot goes beyond a traditional banking chatbot.

Some of our favorite accomplishments include:

  • Building an AI Banking Assistant that combines personalized analysis, RAG-powered recommendations, and secure banking actions.
  • Implementing a Transaction MCP Server to isolate banking operations from agent reasoning.
  • Adding deterministic security controls, including OTP verification for sensitive transactions.
  • Building an Analytics Copilot capable of investigating complex banking questions.
  • Implementing Human-in-the-Loop interaction for ambiguous analytical questions.
  • Using fan-out execution to investigate multiple hypotheses in parallel.
  • Creating a shared enterprise knowledge layer for both customer and staff agents.
  • Implementing access controls for knowledge documents.
  • Designing a modular multi-agent architecture around Google Agent Platform.
  • Using customer-specific BigQuery Authorized Views to enforce data isolation.
  • Adding observability, telemetry, evaluation, and safety testing capabilities.

Most importantly, BankPilot demonstrates a complete agentic workflow—from understanding a question to retrieving knowledge, analyzing data, delegating tasks, and securely taking action.

What we learned

Building BankPilot taught us that enterprise agentic AI is fundamentally an architecture and systems design challenge, not just a model integration exercise.

Some of our key learnings were:

  • Multi-agent systems should have clear separation of responsibilities.
  • Agents should not directly access sensitive systems without controlled tools.
  • MCP is useful for isolating and governing transactional capabilities.
  • RAG requires lifecycle management, access controls, and document versioning.
  • Customer-specific data access should be enforced at the data layer, not only through prompts.
  • Human-in-the-Loop workflows are valuable when business questions are ambiguous.
  • Parallel execution can make complex analytical investigations more effective.
  • Deterministic security controls remain essential even when AI agents initiate workflows.
  • Observability and evaluation are critical for understanding how agents behave in complex systems.
  • The most useful AI agents are not just conversational—they can investigate, coordinate, and take controlled action.

What's next for BankPilot

BankPilot is a prototype, but the architecture opens several possibilities for future development.

Next, we would like to explore:

  • More autonomous background banking workflows.
  • Persistent agent memory for long-running customer and business interactions.
  • Expanded specialized agents for fraud analysis, financial wellness, and customer servicing.
  • More advanced recommendation and personalization capabilities.
  • Additional enterprise governance and policy controls.
  • Deeper integration with Agent Registry and enterprise agent discovery.
  • Enhanced evaluation datasets based on real-world banking scenarios.
  • Improved multimodal experiences for customer interactions.
  • Additional Google AI model integrations such as Gemma, Veo, or Lyria.
  • Production-grade integrations with real banking infrastructure.

Our long-term vision is for BankPilot to become an enterprise agent platform for banking—where AI agents securely understand customers, investigate business problems, retrieve trusted knowledge, and take meaningful action.

BankPilot demonstrates that the future of banking AI is not just better conversations—it is governed intelligence that can reason, investigate, and act.

Disclosures

BankPilot was built as a new project during the All Things Agentic Hackathon submission period. To accelerate development, I reused portions of my pre-existing code and infrastructure patterns for setting up the BigQuery infrastructure and supporting frontend development. These reused components were adapted and integrated into BankPilot, while the agentic AI architecture, multi-agent workflows, AI Banking Assistant, Analytics Copilot, MCP integration, RAG pipeline, access controls, and Google Agent Platform integrations were developed specifically for this project during the submission period.

Built With

Share this project:

Updates

Submission history