Financial institutions have long embraced technology, especially when it delivers operational efficiency or a clear strategic edge. They invest heavily in digital infrastructure, but once a system stabilizes, they often become slow to adopt the next wave, particularly if it appears incremental. That pattern is about to shift. We’re entering a new era, one where finance becomes a playground for intelligent systems that can learn, reason, and act with increasing autonomy. The idea that an AI agent could onboard customers, monitor risk, recommend investments, or even collaborate with other agents, with little to no human oversight, is no longer science fiction. It’s already unfolding. Widespread adoption remains limited due to several unresolved challenges, which I’ll explore in this article. But make no mistake: this transformation is coming. And over the next decade, it could reshape financial services more profoundly than any previous wave of technological change.

This blog is based on the lecture I delivered in the series of “The future of finance” and explores how AI agents and agentic workflows are reshaping financial services. We’ll unpack the technical frameworks behind them, explore how real-world companies are deploying them, and highlight what engineers and students can do today to stay ahead of the curve. While this article is self-sufficient, if you are interested in first one in this series, it can be found at: https://akshaykunkulol.me/blogs/the-future-of-finance-embracing-ai-in-financial-services/

In 2024, we crossed a tipping point. The conversation moved beyond “What can AI Agents do?” to “How can we build systems around it that solve real problems?” In finance, this could mean using LLMs to improve process to automate onboarding, interpret regulatory documents, assess creditworthiness, generate personalized advice, and even execute trades with minimal human oversight.

What makes this leap possible is the rise of agentic workflows: AI-driven processes that are goal-directed, multi-step, and increasingly autonomous.

“Just like cloud computing became the backbone of modern apps, agentic AI is becoming the backbone of modern financial operations.”

Understanding AI Agents & Agentic Workflows

What is an AI Agent?

An AI agent is more than a chatbot. It’s an autonomous system that can:

• Perceive its environment (through inputs like text, documents, APIs)
• Reason over data or context
• Choose the right tool (or API) for the task
• Take action and learn from the outcome

These agents are not hardcoded. They adapt, learn, and decide dynamically. Think of them as interns who get smarter with every task.

What is an Agentic Workflow?

An agentic workflow is a process where one or more AI agents handle a multi-step task with minimal supervision. This could involve querying databases, validating inputs, looping over documents, or collaborating with other agents.

In practical terms, an agentic workflow in finance might involve a lead agent that breaks down a high-level task (e.g. “optimize this investment portfolio”) into sub-tasks. The lead agent could invoke a data-retrieval agent to fetch the latest financial reports (tool use), consult a risk-analysis agent to evaluate market volatility (analysis), and even communicate with a compliance agent to ensure any strategy adheres to regulations (coordination). Each agent operates semi-independently, yet their interactions follow a shared plan to meet the overall objective. This multi-agent, tool-using paradigm is what makes the workflow agentic. It contrasts with a static workflow where every step is pre-defined by developers. In an agentic system, the AI itself can figure out which steps to take and in what order, often by iteratively reasoning about the task – a capability enabled by advances in large language models (LLMs) and new AI frameworks.

Crucially, agentic AI systems remain under human oversight even as they automate tasks. While they can initiate actions, organizations typically implement human-in-the-loop checkpoints or policy constraints to ensure safety and compliance. As these agents become more sophisticated, robust governance (ethical guidelines, transparency, audit trails) will be needed to address concerns about errors, biases, or unintended behavior. Nonetheless, the potential benefits in efficiency and capability are enormous – from 24/7 monitoring of financial markets to personalized client interactions at scale. The next sections delve into the technologies making such agentic workflows possible.

Technical Foundations: The Frameworks Powering AI Agents

Today’s intelligent financial systems are built using modular, open-source frameworks that bring reasoning, memory, action, and coordination to life. Let’s explore five of the most relevant tools.

1. LangChain: The Agent Framework

LangChain provides the building blocks to create agents that:

• Call LLMs (like GPT-4 or Claude)
• Connect to external tools (APIs, calculators, databases)
• Maintain memory
• Choose actions dynamically

LangChain abstracts away boilerplate, letting developers focus on reasoning and execution.

Use Case Example: Build a portfolio advisor agent that chats with users, pulls market data, evaluates investment fit, and explains choices.

2. LangGraph: Structured Workflows for AI

LangGraph is built on top of LangChain. It lets you structure an agent’s logic as a directed graph:

• Nodes = functions or agent steps
• Edges = conditional transitions

Use Case Example: In a lending application, an agent evaluates income → checks credit → routes to risk model → generates outcome.

3. LlamaIndex: Connecting LLMs to Your Knowledge

Formerly known as GPT Index, LlamaIndex helps LLMs answer questions using external documents. It allows:

• Data ingestion (PDFs, SQL, CSVs)
• Indexing into searchable formats
• RAG (retrieval augmented generation) workflows

Use Case: Compliance teams query massive regulatory documents via natural language.

4. n8n: Low-Code Workflow Automation

n8n is a visual workflow builder that connects apps, APIs, and LLMs. It’s useful for:

• Trigger-based workflows (e.g., new form submission → run AI agent)
• Automation without writing full backend code

Use Case: A form submission triggers n8n to verify documents, send data to an LLM agent, and email a summary.

5. Model Context Protocol (MCP): Memory & Handovers

MCP defines how agents pass context to each other. It helps agents:

• Store state between tasks
• Resume sessions across workflows
• Share memory securely

Use Case Example: A KYC agent finishes onboarding and hands off client data to a portfolio planner agent.

MCP has been likened to “a USB-C port for AI applications”, offering a standardized way for LLM-based agents to plug into content repositories, business applications, development tools, and more.

6. Agent-to-Agent Communication (A2A)

In modern systems, agents often talk to each other directly:

• To negotiate tasks
• To share intermediate results
• To delegate subtasks

This enables collaborative AI systems.

A2A was announced with support from over 50 technology partners – including big names like Salesforce, SAP, Intuit, PayPal, and frameworks like LangChain – indicating industry-wide interest in agent interoperability. The problem it addresses is that without a common protocol, agents built in siloed systems can’t leverage each other’s capabilities, leading to duplication and limited utility. With A2A, an agent could essentially call upon another agent as a service, regardless of the underlying code, as long as both speak A2A.

What does A2A entail? It builds on familiar web protocols (JSON over HTTP, Server-Sent Events for streaming, etc.) so it’s easy to implement on existing infrastructure. It defines a communication pattern between a “client” agent (the one initiating a request) and a “remote” agent (the one performing a requested task). Key features include:

• Agent Discovery: A2A introduces the concept of an Agent Card – a machine-readable description of an agent’s capabilities and APIs. Agents can publish their Agent Card so that others can find who can do what. For example, an investment advisory agent might advertise that it can provide portfolio optimization given certain inputs.
• Task Request & Lifecycle: Agents communicate by sending a Task object which represents a unit of work to be done. The protocol defines a lifecycle for tasks (e.g., pending, in-progress, completed) including support for long-running tasks with progress updates. This is important in workflows like loan processing or fraud investigations that may involve multiple steps or human approvals along the way.
• Secure Context and Messaging: A2A emphasizes enterprise-grade security – authentication and authorization are built-in, aligning with OAuth/OpenAPI auth schemes. Agents exchange messages that can include not just text but structured data or even media (it’s modality-agnostic), negotiating formats as needed. This ensures, for instance, that if Agent A expects a PDF report, and Agent B can provide it, they can agree on that through the protocol.
• Collaboration Patterns: The protocol natively supports multi-turn interactions – a client and remote agent can chat back and forth sharing context, intermediate results (artifacts), or asking for clarifications. In effect, it’s like a structured conversation between two AI systems to get a job done.

Use Case: Google gives a scenario of candidate sourcing in HR: one agent is tasked to find job candidates, which then consults specialized recruiter agents and scheduling agents to handle different pieces, all within a unified interface. This showcases how, with A2A, complex workflows can be distributed among expert agents, each contributing their part. For financial services, we can imagine A2A enabling, say, a compliance agent to query a trading surveillance agent about a suspicious trade, or a personal finance coach agent to delegate a tax question to a specialized tax advisor agent – all seamlessly, unbeknownst to the end-user who just sees their query answered holistically.

Making It Work: Putting the Stack Together

These tools are not competing. They’re puzzle pieces that fit into a broader picture. Let’s look at how they work together in a modern AI-powered financial system.

A Typical Flow:

1. User submits financial data (via form or API)
2. n8n triggers a workflow
3. LangChain agent processes intent and chooses tools
4. LlamaIndex retrieves context from policy, investment docs
5. LangGraph drives flow through income check → product fit → risk alert
6. MCP stores session for audit trail or future steps
7. A2A allows another agent (e.g. compliance) to take over if needed

Each of these tools complements the others. The real power comes when you chain them into a single adaptive system.

Skills for the AI-Driven Financial Future

With agentic systems gaining ground, what should engineers, especially students and early-career professionals, learn to stay ahead?

Core Technical Skills:

• Python & APIs: Still the bedrock of AI systems
• Data literacy: SQL, Pandas, NumPy to clean and move financial data
• LLM Integration: Prompt engineering, API usage (OpenAI, Anthropic, etc.)
• LangChain / LangGraph / LlamaIndex: Practical agent building
• n8n: Low-code automation for rapid prototyping
• Cloud & DevOps: For scalable deployment

Agentic Design Thinking:

• Understand how to build modular agents that reason
• Structure workflows with decision points and context flow
• Know when to let agents hand off to humans (human-in-the-loop)

Human Skills:

• Ethical judgment: When not to automate
• Collaboration: With cross-functional teams and with AI itself
• Communication: Explaining system decisions and boundaries

Next: we’ll explore use cases where these systems are already live from robo-advisors to compliance copilots and what’s coming next in agentic finance.

Real-World Use Cases in Finance

The frameworks we’ve discussed are not theoretical. They’re already powering tools inside banks, fintech startups, and regulatory tech platforms. Here are some examples of where AI agents and workflows are making a difference:

1. Robo-Advisors with Personalized Planning

Modern robo-advisors are evolving beyond rule-based questionnaires. They now:

• Understand nuanced investor preferences
• Pull real-time market data
• Simulate different investment strategies
• Adapt to changing life goals or risk appetite

Example: A LangChain-based advisor uses LlamaIndex to read client docs, pulls NAVs from APIs, and generates strategy briefs.

2. Compliance Copilots

Financial firms face growing complexity in regulations. AI agents:

• Parse lengthy compliance documents
• Flag potential violations
• Generate audit-ready reports
• Coordinate with other agents (e.g., fraud, legal)

Example: An n8n-triggered agent reads RBI circulars daily, summarizes updates using GPT-4, and notifies the compliance team.

3. Customer Support with Deep Reasoning

LLM agents handle:

• KYC verification
• Password resets
• Product recommendation
• Contextual support across chat/email/voice

By integrating with CRM tools via LangGraph, the support agent can “remember” context across sessions and escalate when needed.

4. Internal Risk Monitors

Risk management agents:

• Monitor transactions in real-time
• Cross-check suspicious patterns against internal thresholds and policy documents
• Trigger human review workflows

5. Insurance Underwriting

Agents can:

• Read scanned documents (OCR)
• Evaluate claim history
• Suggest underwriting decisions
• Explain rationale in plain language

Why is adoption slow?

1. Engineering Complexity

It’s not plug-and-play, it requires deep system design.

• Multi-layered architecture: Agentic systems require orchestration between LLMs, vector databases, APIs, memory, decision logic, and sometimes multiple agents.
• State management is hard: Keeping context across steps (MCP) or between agents (A2A) is non-trivial.
• Error handling is messy: Unlike deterministic systems, AI agents can hallucinate, misroute flows, or produce ambiguous results.

2. Cognitive Leap for Teams

The learning curve is steep and lacks structured onboarding pathways.

• Many teams are still adjusting to prompt engineering, let alone multi-agent orchestration.
• The mental model shift from linear automation → autonomous agents is substantial.
• Most dev teams are trained in CRUD and API flows, not goal-driven dynamic systems.

3. Lack of Business Confidence

Enterprises fear reputational and regulatory fallout.

• Unpredictability: Agents don’t behave the same way twice; this freaks out compliance, risk, and product heads.
• Explainability: Businesses need to explain to customers and regulators why the agent did what it did.
• Liability: Who is responsible when an autonomous agent makes a financial error?

 4. Governance, Privacy, and Safety Concerns

Trust and control mechanisms aren’t mature yet.

• Financial data is sensitive; building with LLMs requires extra layers of sandboxing and monitoring.
• Regulations like GDPR, DPDP (India), and PCI-DSS limit how data is stored, shared, and processed.
• Agent systems often lack built-in audit trails or red-teaming features.

5. Tooling Ecosystem Still Evolving

The tech isn’t mature/stable enough for risk-averse industries like finance.

• LangChain, LangGraph, LlamaIndex, and n8n are improving fast but still in active development.
• There’s no clear “gold standard” stack for production-ready agentic systems.
• Developer experience (DX) for debugging agent workflows is limited.

6. Misaligned Incentives

Agents need strategic vision + budget support which is often missing.

• Many enterprises prioritize short-term ROI. Agentic workflows are a long-term capability play that can spur innovation.
• Most AI investment is still in surface-level chatbots or analytics dashboards not deep automation.

7. Missing Standards

It’s like early days of the internet, lots of islands, few bridges.

• There’s no clear protocol (yet) for agent communication, security, or handoffs though efforts like MCP, AutoGen, and Open Agents are emerging.
• Interoperability between agents built by different vendors is still theoretical.

What’s Coming Next?

The future of finance is moving toward collaborative AI ecosystems. Here’s where we’re headed:

1. Agent Mesh Networks

Agents won’t just work in isolation. They’ll form networks:

• Portfolio advisor talks to compliance agent
• Risk agent negotiates with pricing engine
• Autonomous trading bot communicates with market data agent

2. AI-Native Financial Products

Expect new products designed from scratch to be:

• Adaptive (personalized in real-time)
• Transparent (with explainable AI logic)
• Modular (easily configurable by advisors or clients)

3. Regulation-Aware AI Systems

With increasing scrutiny on AI, new norms are likely to emerge:

• Agentic actions may need audit trails
• RAG pipelines may need validation stamps
• Ethics and fairness evaluations will be expected

4. India-Specific Opportunities

For Indian fintechs, the opportunity is massive:

• Vernacular AI agents for rural investors
• Regulatory copilots for SEBI and RBI compliance
• Low-cost, high-efficiency AI advisory tools

We are entering an era where financial intelligence is no longer just human. It’s distributed, modular, and increasingly agentic. The winners in this new world will be those who:

• Master the technical frameworks
• Understand domain-specific needs, break them down with clarity
• Build with empathy and ethics

Whether you’re a student, a developer, or a fintech founder – now is the time to learn, build, and participate in this transformation.

Let’s be honest: agentic systems will replace certain jobs and workflows, especially ones rooted in repetition, not judgment. But that doesn’t mean they’re here to replace us. They’re here to replace how we work, scale our decision-making, and challenge us to evolve. Let’s be the generation that shapes this future with clarity, courage, and care.