[DMP 2026]: Agentic AI for Proactive Portfolio Management with Explainable Autonomy

[DavidH-1]

Ticket Contents

Description

Overview and Objectives: Design and build a prototype "Portfolio Health Agent" that autonomously monitors loan portfolios, identifies at-risk accounts, and takes pre-approved actions (e.g., sending reminders, scheduling follow-ups) while escalating complex cases to human loan officers. The project explores how to balance AI autonomy with explainability and human oversight in a regulated financial context.

Description (Glance): Develop an agentic AI framework using LangChain and a local LLM to proactively manage loan portfolios. The agent fetches data from Mifos X, applies risk scoring, and executes configurable actions with human-readable explanations. A dashboard in the Mifos X Web App allows loan officers to review agent decisions, provide feedback, and adjust autonomy levels. The project includes a user study to evaluate trust and usability.

Goals & Mid-Point Milestone

Goals

• [1] [Design and Build Prototype Health Agent]
• [2] [Develop agentic AI Framework using LangChain]
• [3] [integration into Mifos X]
• [4] [Documentation to support extensibility]

Setup/Installation

This is a new project but you should investigate Mifos X and previous AI contributions
LangChain for agent building: https://www.langchain.com/

FINRA guidance on agentic AI: https://www.investmentnews.com/regulation-legal-compliance/finra-flags-rise-of-agentic-ai-seeks-member-firms-feedback/264996

Anthropic's research on interpretability: https://www.anthropic.com/research

Mifos X API: https://demo.mifos.io/api-docs/apiLive.htm

Mifos Repositories: openMF/mifos-x, openMF/web-app,

New repo for solution: openMF/mifos-x-ai-agentic-framework

Expected Outcome

Design and build a prototype "Portfolio Health Agent" that autonomously monitors loan portfolios, identifies at-risk accounts, and takes pre-approved actions (e.g., sending reminders, scheduling follow-ups) while escalating complex cases to human loan officers.

Acceptance Criteria

Portfolio Health Agent created
documentation for maintainability in place
documentation for extensibility in place
Participation in Mid term and Final presentation to Mifos Community
Documented Project Report in Blog post shared to the Mifos Community

Implementation Details

Python, LangChain, Prompt Engineering, Agentic AI concepts, Explainable AI, Basic frontend (React/Angular), Research methodology.

Mockups/Wireframes

n/a

Product Name

Mifos X

Organisation Name

The Mifos Initiative

Domain

Financial Inclusion

Tech Skills Needed

Artificial Intelligence

Mentor(s)

@rahulg963 @PRIYANSHU2026 @Akshat111111

Category

AI

[DavidH-1]

This ticket will be assigned to the successful C4GT DMP2026 applicant

[RudraDudhat2509]

Hey, went through the Mifos X API docs and the FINRA guidance you linked. A few thoughts on approach:
For data layer:- the /loans and /loans/{loanId}/repaymentschedule endpoints have enough to build a basic risk scorer (days overdue, repayment ratio). That's a good starting point before adding anything agentic.
For the agent itself:- LangGraph fits well because the graph stays explicit and auditable, which directly maps to what FINRA flags as the core concern with agentic AI in financial contexts: traceability of multi-step decisions. Each node (assess → act → escalate) can log its reasoning independently.
The HITL layer feels like the most important part to get right here. Not just an override button but showing the loan officer why the agent decided what it did.
Happy to put together a more detailed design doc. Should I open a GitHub Discussion or is Discord preferred?

[RudraDudhat2509]

Also, I noticed openMF/mifos-x-ai-agentic-framework is a new repo. Would it be appropriate to open a draft PR with an initial project structure / README as part of the application process, or is that better saved for after selection?

[DavidH-1]

HI All C4GT Hopefuls. If you are reading this you have found one of our projects we have listed this year. If would like to discuss about this project, as well as find our general guidance on what to include in your applications and how to stand our please ensure you join our Mifos Slack channel at:
https://join.slack.com/t/mifos/shared_invite/zt-3m6x47dgj-iX0Oqv8KS0VGgouNnuJrAg
channel: #c4gt-discussion

[DavidH-1]

HI All C4GT Hopefuls. If you are reading this you have found one of our projects we have listed this year. If would like to discuss about this project, as well as find our general guidance on what to include in your applications and how to stand our please ensure you join our Mifos Slack channel at:
https://join.slack.com/t/mifos/shared_invite/zt-3m6x47dgj-iX0Oqv8KS0VGgouNnuJrAg
channel: #c4gt-discussion

[Siddhi-sahu]

hello @DavidH-1 👋, this project directly aligns with my skills and interests👀(like langchain and anything AI!!) excited to explore more!

[deepakm0003]

Hey @DavidH-1, I have so much expreinced in this filed and also win so much hackathon and explored this project also that aligns so much my tech stack to explore more.

[amanvaibhav162]

Hello @DavidH-1 Sir,
As I have an experience in working on using llms in my project I will be able to contribute with greater interest and much more clarity.So sir, I’m interested in building the Portfolio Health Agent for The Mifos Initiative Mifos X, focusing on combining agentic AI with explainability and human oversight.
As I have an experience in working on using llms in my project I will be able to contribute with greater interest and much more clarity.

Approach:
Use LangChain with a local LLM to design an agent that monitors loan data via Mifos X APIs.
Implement a risk scoring system to identify at-risk accounts.
Enable automated actions (reminders, follow-ups) with clear, human-readable explanations.
Integrate a feedback loop where loan officers can review, override, and guide agent decisions.

Initial Plan:
Set up basic agent pipeline (data fetch → risk scoring → action trigger).
Build core integration with Mifos X APIs.
Add explainability layer for every decision.

Key Focus:
Maintain transparency and auditability of AI decisions
Ensure safe autonomy with human-in-the-loop design
Keep the system modular and extensible for future improvements

I’ll share my design before implementation and iterate based on mentor feedback.

[vandit98]

Hi @DavidH-1, I’m interested in prioritizing this project for DMP 2026.

I started with a small working prototype so my proposal can be grounded in something reviewable: #3

The prototype focuses on the safety core first:

• transparent risk scoring for loan accounts
• explainable feature-level contributions
• policy-bound autonomy levels
• proposed actions for reminders, follow-ups, and escalation
• human-readable decision explanations
• audit metadata for future loan-officer review

I kept the first pass dependency-light and deterministic so the risk/action boundary can be reviewed before adding LangChain/LangGraph, local LLMs, or live Mifos X API adapters.

A few questions I would like to validate before extending it:

1. Which Mifos X endpoints should be treated as the first integration target for portfolio health: loans, repayment schedules, transactions, or client notes?
2. Should the first dashboard workflow be “recommend only” by default, with all actions requiring officer approval?
3. Are there existing sample/demo loan datasets that applicants should use for risk-scoring validation?
4. Would LangGraph be acceptable for the first agent orchestration layer if each node logs its input, output, and explanation?

I’ll also join the Mifos #c4gt-discussion Slack channel as suggested.

[A-Chronicle]

Status Update: Portfolio Health Agent Implementation

Hi maintainers,

I've analyzed the requirements in this issue and have built a working foundation for the Portfolio Health Agent. Here's what I've accomplished and my plan going forward.

Completed: Core Agent Framework (PR #4)

I've implemented the fundamental architecture described in the issue:

Agent Components:

• LangChain-based Agent using React pattern for autonomous decision-making
• Risk Assessment Engine with 5-factor weighted model (arrears 50%, repayment 25%, account age 10%, loan ratio 10%, missed payments 5%)
• Mifos X API Client with full integration layer (get clients, accounts, send reminders, schedule follow-ups, escalate cases)
• REST Dashboard API with 9 endpoints for loan officer oversight
• Test Suite with 6/6 unit tests passing and proper risk calibration

Key Features Working:

• Autonomous portfolio monitoring with risk classification (HIGH/MEDIUM/LOW)
• Explainable AI decisions with transparent reasoning
• Pre-approved action execution (reminders, follow-ups, escalations)
• Human-in-the-loop approval workflow
• Decision logging for audit trails
• Comprehensive documentation (API reference, risk methodology, agent behavior)

Phased Roadmap (4-month program)

Phase 1: Integration and Intelligence (Issues #5-6)

• Issue Integration with real Mifos X instance #5: Real Mifos X instance integration with end-to-end testing
• Issue Set up local LLM for agent reasoning #6: Local LLM setup (Ollama/LM Studio) for autonomous reasoning

Phase 2: User Experience and Production (Issues #7-9)

• Issue Build dashboard UI for loan officer oversight #7: Dashboard UI for loan officer oversight (React/Vue)
• Issue Production deployment and scaling #8: Production deployment (Docker, K8s, monitoring, logging)
• Issue Testing, validation, and performance optimization #9: Comprehensive testing, UAT, performance optimization

Phase 3: Launch and Community (Issue #10)

• Issue Documentation, community engagement, and project report #10: Documentation, community presentation, final project report

How This Addresses Issue Requirements

Requirement	Implementation	Status
Monitor loan portfolios autonomously	Agent scans accounts, calculates risk scores	Complete
Identify accounts at risk	5-factor risk model with classification	Complete
Execute pre-approved actions	Reminders, follow-ups, escalations via API	Complete
Escalate complex cases	Loan officer approval workflow implemented	Complete
Provide explainable decisions	Transparent reasoning with decision logging	Complete
User study ready	Decision log structure for trust/usability analysis	Complete

Next Immediate Steps

1. Real Mifos X Testing - Test agent against actual portfolio data
2. LLM Integration - Enable autonomous reasoning beyond rule-based decisions
3. UI Development - Loan officers need intuitive interface for approvals
4. Production Hardening - Reliability, monitoring, scaling for deployment

Repository Structure

mifos-x-ai-agentic-framework/
├── src/agent/              # LangChain agent orchestration
├── src/api/                # Mifos X API client
├── src/risk_scorer/        # Risk assessment engine
├── src/dashboard/          # Flask REST API
├── docs/                   # Complete documentation
├── tests/                  # Unit tests (6/6 passing)
└── requirements.txt        # Dependencies

Technical Highlights

• Modular Design: Easy to extend risk factors, add new tools, integrate new data sources
• Production Ready: Error handling, logging, validation throughout
• Well Documented: API reference, risk methodology, agent behavior guides
• Tested Foundation: Risk scoring calibrated and validated
• Scalable: REST API design supports high-volume requests

Looking Forward

I'm committed to:

• Maintaining code quality and test coverage above 80%
• Regular progress updates and transparent communication
• Gathering loan officer feedback for UI/UX
• Writing comprehensive documentation
• Presenting findings to the Mifos community

I'm ready to dive into Phase 1 and would appreciate guidance on:

1. Preferred Mifos X test instance setup
2. Community preferences for LLM choice
3. Any specific risk factors the community wants prioritized

PR: #4
Issues: #5-10 created for phased implementation

[Meghali54]

Hi @rahulg963, @PRIYANSHU2026, and @Akshat111111,

I am highly interested in the Portfolio Health Agent project. My background in developing deep learning models for gait recognition and architecting "SlothOps" (an autonomous first-responder for crashes) has prepared me to build robust, agentic frameworks. I am particularly excited about implementing the "Human-in-the-loop" oversight required for financial inclusion. Below is my proposed technical roadmap. The goal is to move from reactive loan management to a proactive, autonomous Agentic Framework. I propose building an agent using LangChain that not only identifies at-risk loans via the Mifos X API but also justifies its decisions using Explainable AI (XAI) patterns, ensuring every action (from reminders to escalations) is auditable by human loan officers.

2. Proposed Tech Stack
   Orchestration: LangChain (Agentic Workflows) & LangGraph (for stateful multi-turn logic).
   Reasoning: Local LLM (e.g., Llama 3 or Mistral via Ollama) to ensure data privacy.
   Data Ingestion: Python-based integration with Mifos X REST APIs.
   Explainability: Implementation of Chain-of-Thought (CoT) prompting and structured log exports for the Mifos X Dashboard.
   The Data & Risk Layer (Weeks 1-3)
   API Wrapper: Develop a robust Python client to fetch loan schedules and repayment history from Mifos X.

Scoring Engine: Instead of a "black box," I will use a hybrid approach: traditional financial logic combined with LLM reasoning to identify "soft" risk factors (e.g., shifting payment patterns). Phase 2: Agentic Workflow & Autonomy Levels (Weeks 4-6)
Action Tools: Define specific LangChain "Tools" the agent can call:

send_sms_reminder()

schedule_officer_followup()

flag_for_manual_review()

Autonomy Gates: Implement a "Confidence Threshold" logic. If the AI's risk-certainty is below 80%, it must escalate to a human rather than taking autonomous action.

Phase 3: Explainability & Dashboard Integration (Weeks 7-9)
Decision Logs: Every action will generate a "Reasoning Trace" (e.g., "Account X flagged because 3 consecutive late payments match the pattern of high-risk defaults in Sector Y").

Frontend Integration: Build a React-based monitoring dashboard for loan officers to "Approve" or "Reject" agent suggestions, creating a feedback loop to refine the agent's prompts.

[Naitik120gupta]

Hi @DavidH-1,
I found this project quite interesting and i want to know some details:
Are there any prerequisites and how my proposal can be reviewed, Also what is the evaluation criteria.