Building Banking Agents with LangGraph

Why Banking Needs Multi-Agent Systems

Banking is one of the most complex domains for AI. A single customer interaction might touch:

• Account inquiries (read-only, low risk)
• Fund transfers (write operations, medium risk)
• Loan applications (multi-step, high risk)
• Compliance checks (regulatory, critical)

A monolithic chatbot can't handle this well. Each of these domains has different risk profiles, different data sources, and different approval workflows. The answer is multi-agent orchestration — specialised agents that collaborate to serve the customer.

Why LangGraph

We chose LangGraph for banking orchestration because of its core design principles:

Stateful graph execution. Banking workflows are inherently stateful. A customer might start a balance inquiry, pivot to a transfer, then ask about fees. LangGraph's graph-based state machine handles these transitions naturally.

Human-in-the-loop. High-risk operations (transfers above a threshold, loan approvals) need human oversight. LangGraph supports interrupt points where the workflow pauses for human review before continuing.

Persistence. Conversations can span hours or days (e.g., loan applications). LangGraph's checkpointing means you can resume a conversation exactly where it left off, even after a server restart.

Architecture Overview

Our banking agent system uses a supervisor pattern:

Supervisor Agent — Routes incoming messages to the appropriate specialist based on intent classification. Manages conversation state and handles handoffs between agents.

Account Agent — Handles balance inquiries, transaction history, account details. Read-only access to core banking systems.

Transfer Agent — Processes fund transfers with multi-step verification. Applies business rules (daily limits, recipient validation) before executing.

Compliance Agent — Runs in parallel with other agents. Monitors all interactions for regulatory requirements (AML, KYC). Can halt transactions that trigger compliance rules.

Fallback Agent — Handles out-of-scope queries gracefully. Escalates to human agents when confidence is low.

Key Design Decisions

Typed State with Pydantic

Every agent operates on a well-defined state schema using Pydantic models. This gives us:

• Runtime validation of all data flowing between agents
• Clear contracts between agent boundaries
• Automatic documentation of the state shape

class BankingState(BaseModel):
    customer_id: str
    intent: str | None = None
    risk_level: str = "low"
    requires_human_review: bool = False
    transaction_context: TransactionContext | None = None
    compliance_flags: list[str] = []

Parallel Compliance Checking

The compliance agent runs as a parallel branch in the graph. While the account or transfer agent processes the customer's request, compliance checks execute simultaneously. If a flag is raised, the graph conditionally routes to a human review node.

Graceful Degradation

If any specialist agent fails or times out, the supervisor routes to the fallback agent rather than showing an error. The fallback can:

• Provide a helpful response from cached FAQ data
• Offer to escalate to a human agent
• Save the conversation state for retry

Deployment Considerations

Banking infrastructure has strict requirements. Our deployment pattern uses:

• Kubernetes for orchestration with strict network policies
• Redis for session state and agent communication
• Dedicated compliance logging with immutable audit trails
• Circuit breakers on all core banking system integrations

The LangGraph application runs as a stateless service with state persisted externally, allowing horizontal scaling during peak hours.

Lessons Learned

Start with the happy path. Don't try to handle every edge case in V1. Get the core account inquiry and simple transfer flows working end-to-end first, then expand.

Invest in observability early. Multi-agent systems are hard to debug. We instrument every agent decision, every state transition, and every external API call from day one.

Compliance is not an afterthought. In banking, compliance is a first-class requirement. Building it as a parallel agent from the start is far easier than bolting it on later.

What's Next

We're exploring Temporal for long-running banking workflows (loan origination, dispute resolution) where processes span days or weeks. The combination of LangGraph for real-time conversation and Temporal for background orchestration is a powerful pattern for financial services.

If you're building conversational AI for banking or financial services, let's talk.