Loan Origination AI Agents for BFSI: Inside a Live System

Editor’s Note: This blog is adapted from a talk by Jawahar Govindaraj, Senior Leader at Tech Mahindra, delivered during the Build with AI meetup hosted by GeekyAnts at NIMHANS. In his session, Jawahar explored the design, architecture, and productionisation of agent-based systems in the BFSI sector. Drawing on decades of experience in automation, enterprise integration, and AI tooling, he presented a real-world roadmap to building GenAI-powered agents using low-code frameworks, orchestration platforms, and reusable eAgent components.

Hi, I am Jawahar Govindaraj. I have been working in the software industry for more than twenty-seven years, currently leading low-code, GenAI, and AgentK practices at Tech Mahindra. Over the years, I have worked across multiple automation and agent frameworks—CrewAI, Microsoft Power Platform, Graph RAG pipelines, and most recently, Laser AI.
In this session, I will walk through how we approach GenAI agent development for the BFSI sector, what constraints are unique to this domain, and how we deploy production-grade systems using low-code platforms, regulatory guardrails, and cost-optimised architectures.

Whenever we meet with CFOs and enterprise leaders, the key asks are clear. They want operational cost reductions, reduced manual effort, faster resolution times, and better customer experiences. The challenge is not in finding use cases—the challenge is in designing scalable, compliant, and efficient agent workflows that can be deployed in real-world financial systems.
Let me start with a common scenario: contact centres. The current state involves high average handling time, repeated manual verification steps, and delays in accessing backend systems. The result is a poor customer experience and inefficient service pipelines. With agents, we can automate the entire workflow—from identity validation to case management and resolution—within minutes.
Another example is trade automation. Wealth managers handle high-volume portfolios and perform complex calculations manually. Agents can streamline these processes through structured risk assessment, rule-based recommendations, and real-time analytics.

The foundation of agent systems rests on four phases: define the goal, plan the path, execute the steps, and correct along the way. But before choosing a tool or model, there are key parameters that must be evaluated.

1. Selecting the Right Use Case

Every agent system starts with a clear purpose. The use case must be well-defined, and the architecture must align with that purpose.

2. Choosing the Right Tools

There are many orchestration and reasoning tools available, but not all of them are cost-effective or compliant. For complex calculations, large vector databases and RAG pipelines may seem tempting, but they come with higher token costs. Select tools that fit the need without overshooting costs.

3. Knowledge Base and Traceability

Agents should be built with clear knowledge and reasoning capabilities. Complex rule calculations—especially scientific or financial rules—must be supported. Traceability and audit logs are essential for post-deployment compliance.

4. Document Processing and Infrastructure

Document extraction, ICR integration, memory handling, and infrastructure scalability must all be considered. The ability to extract structured information from unstructured formats is crucial.

5. Cost, ROI, and Deployment Strategy

It is not enough to build an agent—you must calculate ROI, identify deployment channels, and determine how the agent will integrate with existing workflows. BFSI clients also require strong compliance controls and dashboard-based reporting to measure performance over time.

One of the most exciting transformations is how low-code platforms are enabling rapid development. What used to take weeks can now be achieved in hours. A well-configured low-code platform allows for end-to-end development, integration, testing, and deployment with minimal effort.
This is where the concept of citizen development becomes powerful. With no dependency on Java, Python, or Go, business users can drag, drop, configure, and launch agent workflows. Today, many RPA and low-code platforms come bundled with native agent features—ready for enterprise integration.

Let me walk you through a deployed use case—an end-to-end trade automation and loan origination system we implemented using a modular, agent-driven design.

The flow involves five to six eAgents working in sequence:

1. Query Understanding: Capturing user queries through natural language interfaces.
   
2. Market Analysis: Pulling sentiment and news data to assess market conditions.
   
3. Recommendation Engine: Calculating buy, sell, or hold actions based on real-time data.
   
4. Compliance Agent: Ensuring all decisions meet regulatory criteria.
   
5. Document Validation: Verifying SSN, driving license, payslips, and other inputs using IDP.
   
6. Decision Engine: Recommending EMI plans and issuing approvals within seconds.

This system can process complete loan applications in under three minutes. Tasks that traditionally took twenty to thirty minutes—spread across multiple departments—are now handled autonomously.

Every agent-based system we build follows six key steps:

1. Use Case Identification
   
2. Solution Architecture Design
   
3. Testing and Accuracy Validation
   
4. Integration via APIs and Adapters
   
5. Monitoring, Auditing, and Guardrail Implementation
   
6. Scale and Optimisation
   

This structured approach helps us deliver systems that are fast, compliant, and fully traceable.

The benefits of this system have been substantial. Customer wait times have dropped significantly. Operations that previously required multiple humans and lengthy manual review can now be completed by the system itself.
Return on investment has been fast. Development that once took weeks now takes hours. Agent workflows can be reused, extended, and deployed across similar business units with minor changes. Productivity and data quality have improved, while compliance and traceability have remained intact.
We have also built in advanced analytics. Metrics such as SLA adherence, application statuses, traceability logs, dropout analysis, accuracy measurement, and user satisfaction are all captured and visualised. These dashboards provide business users with continuous insights into agent performance and system efficiency.

For BFSI, governance is non-negotiable. We implement guardrails, compliance checks, and monitoring tools from the start. Whether it is DPDP in India, GDPR in Europe, or other frameworks globally, our systems are built to pass InfoSec audits and platform approvals.
Tools like Appian, Pega, Mendix, OutSystems, and Microsoft Power Platform are evaluated for BFSI compliance before being deployed. InfoSec teams validate and certify each integration. Only after sandbox testing, POC review, and approval does the project go live.
In our view, innovation in BFSI is accelerating—but cautiously. Most enterprise banks still prefer on-premise solutions, while NBFCs have begun embracing cloud-based deployments with more agility.

GenAI and agentic systems are no longer experimental. They are transforming business workflows across domains, especially in regulated sectors like BFSI. With the right architecture, governance, and tooling strategy, these agents can deliver measurable impact within days—not months.
Low-code development is empowering business users, agent orchestration is reducing human load, and smart integrations are making AI agents more accurate and explainable. If built responsibly, these systems are here to stay—and to scale.