EUDA Guardian
Benefits, Impact and Outcomes
Back-end: Python

EUDA Guardian: AI-Powered EUDA Intelligence, Governance and Controlled Change Platform

What Inspired Us

In the banking and financial services industry, financial institutions heavily rely on End User Developed Applications (EUDAs), most commonly Microsoft Excel workbooks packed with complex formulas, VBA macros, and external data links. While these workbooks become operationally critical, they are rarely documented properly, making them massive operational and model risk liabilities. New team members frequently update input data mechanically without understanding the underlying logic, creating catastrophic audit and business-continuity concerns.

We were inspired to build EUDA Guardian to provide a transition path from unmanaged, high-risk EUDAs to governed, automated solutions. Our vision wasn't to force an immediate, disruptive rewrite of these spreadsheets, but to convert them into understandable, governed, and safely changeable business applications. We wanted to prove that you can combine the probabilistic reasoning of AI with strict, deterministic guardrails to make financial computing safe.

How We Built It

We built EUDA Guardian by aligning with the UiPath Maestro Case track, structuring our solution to separate AI-driven insights from strict, programmatic file execution.

The Architecture & Component Stack

Orchestration & Workflow: Built on UiPath Maestro Case to dynamically manage case stages, human tasks, and state transitions.
User Interface: Utilized UiPath Apps and Action Center to provide seamless ingestion portals and maker-checker approval screens for business users.
Workbook Ingestion & Parsing: Developed a specialized Python/Coded Agent layer utilizing libraries like openpyxl and oletools to safely extract raw formulas, sheet structures, and VBA macro code without executing them blindly.
Agentic Intelligence: Leveraged UiPath Agent Builder alongside an integrated LLM to power a network of specialized agents:
Discovery & Business Logic Agents to summarize purpose and group repetitive formulas.
Lineage Engine to construct a deterministic mathematical dependency graph.
Risk, Change Impact, and Test Design Agents to flag risks, propose cell-specific edits, and generate test scripts.
Execution & Test Layer: A deterministic UiPath Robot and Python service to apply approved edits exclusively onto cloned workbooks and run rigorous regression testing.

[User Upload via App] ➔ [Maestro Case Creation] ➔ [Python Ingestion & Parsing]
                                                               ⬇
[Deterministic Code Execution] ⬅ [Action Center Approval] ⬅ [Agentic Risk & Logic Analysis]
            ⬇
[Automated Regression Testing] ➔ [Candidate Release & Generated Audit Pack]

The Reference MVP Scenario

To prove our concept, we developed a reference case featuring a fictional Daily Liquidity Threshold Reporting EUDA used by a bank operations team:

Discovery: The system analyzed an .xlsm workbook consisting of raw transaction sheets, calculation tabs, and VBA macros.
Risk Detection: It successfully flagged a series of pre-seeded risks: a hard-coded local file path in the macro, a hidden mapping worksheet, inconsistent formulas, and a stale external reference.
Controlled Change Execution: We submitted a natural-language request to adjust the exception threshold from £100,000 to £150,000 for Corporate customers while keeping it at £100,000 for Retail customers. The Change Impact Agent mapped the exact cells, a human reviewer authorized it via Action Center, and a robot applied the change to a cloned copy without ever touching the original file.

Challenges We Faced

Bridging Probabilistic AI with Deterministic Banking Compliance: Generative AI is naturally probabilistic, but financial regulations demand absolute mathematical certainty. We overcame this by enforcing a core safety control: AI may analyze, recommend, and prepare changes, but it can never directly execute them without deterministic validation. Edits are only performed by an allow-listed, code-driven execution layer.
LLM Context Optimization: Sending enormous, repetitive spreadsheet cells to an LLM is slow and costly. We solved this by implementing an algorithmic Formula Grouping technique. The system clusters similar formula structures, choosing only a representative sample to send to the LLM for translation into business prose.
VBA Sandboxing & Security Risks: Executing arbitrary macro code is a major bank security hazard. We drew a hard line in our MVP architecture, forcing macro analysis to remain strictly static (code text parsing) and confining any test runs to highly controlled, restricted environment setups.

What We Learned

The Power of Agentic Networks: Rather than relying on a single monolith prompt, distributing responsibilities across specialized, micro-focused agents (e.g., separating Test Design from Change Impact) yields drastically higher accuracy and fewer hallucinations.
Grounded AI is Trusted AI: To get Risk and Control Reviewers to trust an AI platform, every explanation must be traceable. We learned that grounding outputs with direct evidence tags (e.g., tying an explanation directly to Liquidity_Calculation!H2:H500) completely changes how stakeholders perceive AI risk.
The Governance Narrative Wins: As our technical direction highlights, the winning narrative for AI in corporate landscapes is not that AI should be given a blank check to freely rewrite spreadsheets. Instead, the true value lies in using AI as a tool to unearth transparency, implement maker-checker boundaries, and provide an automated, audit-ready paper trail.

What's Next for EUDA Guardian

The hackathon MVP successfully proves that we can safely parse, understand, and execute controlled changes on a single critical spreadsheet. Moving forward, our vision is to scale EUDA Guardian into an enterprise-grade ecosystem:

Enterprise-Wide Scale & Analytics

Centralized EUDA Inventory: Implement automated scanning across corporate environments to discover, catalog, and score the criticality of every spreadsheet in use.
Portfolio Concentration Risk: Build an analytical dashboard for Risk and Control officers to visualize concentrations of unsupported macros, broken data links, and key-person dependencies across the entire bank.

Deep Enterprise Integrations

Secure Storage Ecosystems: Integrate directly with corporate document repositories and version control platforms like SharePoint, OneDrive, ServiceNow, and Git.
Model-Risk Platforms: Connect natively with established banking governance and model-risk systems to feed audit and documentation logs directly into institutional workflows.

Institutional Governance & Security

Advanced Maker-Checker Workflows: Deploy strict role-based access control (RBAC), multi-layered segregation of duties, and explicit maker-checker boundaries between corporate revesters and executive approvers.
Continuous Control Monitoring: Automate periodic recertification cycles and evidence retention to ensure continuous compliance with evolving financial regulations.

The Modernization Engine

Strategic Modernization Roadmaps: Expand our AI's capability from simply recommending cell edits to generating high-level architectural roadmaps. The platform will actively advise technical teams on whether a legacy EUDA should be retained, simplified, automated via UiPath, migrated to a secure database, or completely rebuilt as an API-driven application.