Inferensys

Integration

AI Integration for Core Banking Platforms in Legacy System Integration

A practical guide to adding AI capabilities to older core banking systems like Temenos T24, Oracle FLEXCUBE, and Finacle using middleware, screen scraping, and data replication strategies for servicing automation, fraud detection, and compliance workflows.
Operations team reviewing AI workflow automation on laptop, workflow builder visible, casual office setup.
LEGACY SYSTEM INTEGRATION

Adding AI to Legacy Core Banking Without a Full Rip-and-Replace

A practical guide to layering AI onto older Temenos T24, Oracle FLEXCUBE, and Finacle systems using middleware and data replication.

Legacy core banking platforms like Temenos T24 Transact, Oracle FLEXCUBE, and Infosys Finacle often lack native AI hooks. The integration strategy focuses on three key surfaces: batch file interfaces for nightly data extracts, screen scraping or API gateways for real-time transaction events, and message queues (IBM MQ, TIBCO) for posting AI-generated decisions back. The goal is to treat the legacy core as a system of record, while building AI smarts in a modern analytics layer that consumes its data.

High-impact workflows start with data replication. Extract customer, account, and transaction data via scheduled batch jobs or CDC tools into a cloud data warehouse or lakehouse. This creates an AI-ready data fabric for building models for fraud detection, next-best-offer, or collections prioritization. For real-time use cases like instant loan decisions, deploy an API orchestration layer that intercepts application requests, calls AI services for scoring, and then routes the enriched payload to the core's existing loan origination module.

Rollout requires a phased, workflow-first approach. Begin with read-only analytics, such as AI-driven customer segmentation or predictive cash flow dashboards, which carry no operational risk. Next, implement human-in-the-loop automations, like AI-triggered alerts for AML investigators or suggested payment plans for collectors, where a core banking user approves the action. Finally, deploy fully automated, low-risk writes, such as AI-categorized transaction memos or automated response drafting for customer service cases. Governance is critical: all AI-driven writes to the core must be logged, auditable, and reversible, with clear fallback procedures to legacy manual processes.

AI INTEGRATION FOR CORE BANKING PLATFORMS IN LEGACY SYSTEM INTEGRATION

Integration Touchpoints for Legacy Core Systems

Connecting AI to Legacy Data Stores

Legacy core banking systems like Temenos T24, Oracle FLEXCUBE, and Finacle often store critical data in monolithic databases or proprietary formats. AI integration typically begins at the middleware layer, where data is replicated, transformed, and made available for intelligent processing.

Key touchpoints include:

  • Batch Extract Pipelines: Scheduled jobs that pull customer, account, and transaction data from core banking tables into modern data lakes or warehouses for AI model training and batch inference.
  • Event Streams: Using message queues (e.g., Kafka) or change data capture (CDC) tools to stream real-time transaction events, customer updates, or payment postings to AI services for immediate fraud scoring or personalization.
  • API Gateways: Building RESTful or GraphQL facades over legacy SOAP or host-based APIs to provide a clean, secure interface for AI agents to retrieve balances, post transactions, or update customer records.

This layer is crucial for creating an AI-ready data foundation without destabilizing the core processing engine.

LEGACY SYSTEM INTEGRATION

High-Value AI Use Cases for Legacy Core Banking

Integrating AI into legacy core banking systems (Temenos T24, Oracle FLEXCUBE, Finacle) requires a pragmatic, data-first approach. These use cases focus on extracting value from existing workflows via middleware, screen scraping, and data replication to modern analytics layers, without a risky core replacement.

01

Automated Transaction Exception Handling

Legacy batch processing often halts on mismatched references or missing fields. An AI layer can intercept failed transactions from the core's exception queue, analyze the error and source document (e.g., SWIFT MT103), suggest corrections, and either auto-repair or route to the correct operations team. This turns multi-day manual reviews into same-day resolution.

Days -> Hours
Resolution time
02

Legacy Report Data Extraction & Enrichment

Critical risk and regulatory reports (e.g., liquidity, large exposures) are often generated as static PDFs or fixed-format text files from the legacy core. An AI agent can scrape, parse, and validate these reports, extract key figures into a structured data lake, and enrich them with external market data for advanced analytics and automated regulatory submission.

Manual -> Automated
Data pipeline
03

Screen Scraping for Teller & Service Desk Copilots

Where APIs are limited, a secure RPA+AI layer can perform controlled 'screen scraping' of green-screen or client-server teller applications. This enables a modern copilot interface that can answer customer questions (e.g., 'Why was my check held?') by retrieving and summarizing data from multiple legacy screens in real-time, boosting frontline staff productivity.

5 Screens -> 1 Query
Staff efficiency
04

Batch Processing Intelligence & Failure Prediction

Overnight batch cycles (EOD processing, interest accrual) are black boxes. By streaming batch job logs and system metrics to an AI monitoring layer, you can predict job failures, identify performance bottlenecks, and provide prescriptive remediation steps before the morning operations team logs in, ensuring SLA adherence.

Reactive -> Proactive
Operations mode
05

Customer Data Consolidation & Golden Record Creation

Legacy cores often have fragmented customer data across multiple product silos (loans, deposits). An AI-driven process can replicate and reconcile customer records from disparate legacy tables, resolving entities, merging duplicates, and creating a single 'golden record' in a downstream MDM or data warehouse. This clean customer view powers hyper-personalization and compliance.

Fragmented -> Unified
Customer view
06

Mainframe Log Analysis for Fraud & Anomaly Detection

Security-relevant events are buried in mainframe system logs (SMF, RACF). An AI model can continuously ingest and analyze these logs alongside application transaction data, detecting anomalous patterns indicative of insider threats, credential misuse, or fraudulent financial activity that legacy rules engines miss.

Rules -> Behavioral AI
Detection method
LEGACY SYSTEM INTEGRATION PATTERNS

Example AI Automation Workflows

These workflows illustrate how to layer AI onto legacy core banking platforms (Temenos T24, Oracle FLEXCUBE, Finacle) using middleware, data replication, and event-driven patterns. Each example addresses a high-friction, manual process common in older systems.

Trigger: A nightly ACH/SEPA batch job in the core banking system fails or generates exceptions (e.g., invalid account numbers, insufficient funds).

Context/Data Pulled:

  1. The middleware layer (e.g., MuleSoft, Apache NiFi) monitoring the core banking batch interface captures the exception file or error log.
  2. An AI service is invoked, which extracts the failed transaction details and queries a replicated data store for:
    • Customer master data (contact info, recent transactions).
    • Historical exception patterns for this customer/account.
    • Available balance from a near-real-time data feed.

Model or Agent Action:

  • A classification model categorizes the exception (data error vs. funds error).
  • For data errors (wrong account), an LLM-powered agent suggests corrections by matching payee names against a cleansed directory.
  • For funds errors, a rules engine combined with a predictive model assesses the likelihood of funds arriving same-day (based on historical patterns) and recommends holding or rejecting the item.

System Update or Next Step:

  • The AI workflow generates a resolution file (corrected account details, hold instructions) and posts it back to the core banking system's exception handling queue via a middleware API.
  • For high-confidence corrections, the transaction is automatically reprocessed. Low-confidence items are routed to a human queue in a modern case management tool with the AI's analysis pre-attached.

Human Review Point: All suggested account number corrections are flagged for a 5% random sample audit. Any item where the predictive model's confidence score is below 85% is automatically routed for manual review.

LEGACY SYSTEM INTEGRATION

Implementation Architecture: The AI Middleware Layer

A practical blueprint for adding AI to legacy core banking systems without a risky, full-scale replacement.

Integrating AI directly into a legacy core banking platform like Temenos T24 Transact or Oracle FLEXCUBE is often impossible due to closed APIs, monolithic architecture, and stringent change controls. The proven pattern is to deploy an AI middleware layer that acts as a real-time bridge. This layer consumes data from the core system via secure methods—such as transaction log tailing, batch file replication, or screen scraping for green-screen terminals—and surfaces AI capabilities through modern channels. Key integration points include customer master data, general ledger postings, loan account statuses, and payment transaction queues, which are streamed to a separate analytics environment for processing.

The middleware architecture typically involves: 1) Event Ingestion using tools like Apache Kafka or cloud-native queues to capture core banking events; 2) Data Harmonization where legacy data formats (e.g., COBOL copybooks) are transformed into AI-ready schemas; 3) AI Service Mesh where containerized models for fraud scoring, document extraction, or next-best-action run inference; and 4) Action Orchestration where results are fed back into the core system via approved channels like batch API wrappers or by updating auxiliary databases. This keeps the core's integrity intact while enabling use cases like real-time transaction monitoring or automated KYC document review.

Rollout is phased, starting with read-only analytics (e.g., customer churn prediction) to build trust, then progressing to low-risk, human-in-the-loop actions (e.g., triaging AML alerts), and finally to automated write-backs (e.g., updating customer risk scores). Governance is critical: all AI inferences should be logged with full audit trails, and any automated decision impacting financial records must pass through the core's existing approval workflows. This approach de-risks the integration, allowing banks to modernize incrementally. For related patterns, see our guide on AI Integration for Core Banking Platforms in Cloud Migration.

AI INTEGRATION FOR LEGACY CORE BANKING

Code and Payload Patterns

Orchestrating AI Services via Middleware

For legacy systems like older Temenos T24 or Oracle FLEXCUBE versions, a middleware layer (e.g., MuleSoft, Apache Camel) acts as the integration hub. This layer receives events from the core banking system—often via batch file drops, database triggers, or message queues—and orchestrates calls to AI services.

A common pattern is to use the middleware to call an AI service for document classification or data extraction, then transform and push the enriched data back into the core system or a modern data lake.

python
# Example: Middleware service calling an AI extraction API
import requests

def process_loan_application(file_path, core_transaction_id):
    """
    Called by middleware when a new loan document batch is detected.
    """
    # 1. Call AI service for document intelligence
    with open(file_path, 'rb') as f:
        files = {'file': f}
        ai_response = requests.post(
            'https://ai-service.inferencesystems.com/v1/extract',
            files=files,
            headers={'Authorization': 'Bearer API_KEY'}
        )
    
    extracted_data = ai_response.json()
    
    # 2. Map extracted fields to core banking payload
    core_payload = {
        "transactionId": core_transaction_id,
        "customerId": extracted_data.get('customer_number'),
        "loanAmount": extracted_data.get('principal_amount'),
        "productCode": "LN001",
        "extractedFields": extracted_data  # Store raw AI output for audit
    }
    
    # 3. Post to core banking's staging API or update queue
    requests.put(
        'http://core-middleware/loan/staging',
        json=core_payload
    )
LEGACY SYSTEM INTEGRATION

Realistic Time Savings and Operational Impact

This table illustrates the practical impact of layering AI onto legacy core banking platforms via middleware and data replication, focusing on workflows that are typically manual, time-consuming, or error-prone.

Workflow / MetricBefore AI (Legacy Process)After AI (Integrated Layer)Implementation Notes

Customer Onboarding (KYC Review)

Manual document review: 2-4 hours per case

Assisted extraction & scoring: 20-30 minutes per case

AI pre-fills core system screens; human final approval required.

Transaction Exception Handling

Manual investigation of mismatched postings: 1-2 hours

Automated root-cause analysis & routing: 10-15 minutes

AI analyzes logs from middleware; suggests corrective journal entries.

Regulatory Report Data Validation

Manual sampling and cross-checking: 3-5 days per report

Automated anomaly detection & reconciliation: 1 day

AI runs on replicated data lake; flags discrepancies for core ledger review.

Loan Document Processing

Manual data entry from scanned docs: 45-60 minutes per file

Assisted extraction & system pre-population: 10-15 minutes

AI extracts fields to staging table; loan officer verifies before core posting.

Batch Job Failure Triage

Manual log review and escalation: 2-3 hours per incident

Predictive alerting & suggested remediation: <30 minutes

AI monitors middleware ETL logs; predicts failures before core processing window.

Static Data Maintenance

Manual updates via green screens: prone to inconsistencies

Assisted change validation & bulk update scripts: 75% faster

AI validates change requests against business rules before core submission.

Customer Service Case Summarization

Agent reads through multiple core system screens: 5-10 minutes

Automated case summary at login: <1 minute

AI aggregates data from core & call logs into a unified narrative for the agent.

LEGACY SYSTEM INTEGRATION

Governance, Security, and Phased Rollout

A practical framework for deploying AI in legacy core banking environments with control and confidence.

Integrating AI with a legacy core banking system like Temenos T24, Oracle FLEXCUBE, or Finacle requires a middleware-first strategy to avoid destabilizing the core ledger. The architecture typically involves a real-time data replication layer (e.g., using change data capture or batch extracts) that feeds a modern analytics database or data lake. AI services—for fraud scoring, document extraction, or customer support agents—then operate on this replicated data, calling back to the core via secure, idempotent APIs for actions like posting a transaction hold or updating a customer risk score. This pattern isolates AI experimentation from the mission-critical posting engine and allows for rigorous data validation and fallback logic.

Governance is non-negotiable. Every AI-driven decision or action must be logged with a full audit trail, linking back to the source core banking transaction ID, customer account, and the specific AI model and prompt version used. Implement role-based access controls (RBAC) to ensure AI tools can only call core banking APIs (e.g., for payment reversals or note updates) that are permitted for the initiating user's role. For high-stakes workflows like loan underwriting or fraud block, design a human-in-the-loop approval step where the AI's recommendation and supporting evidence are presented in a case management interface before the core banking system is updated.

A phased rollout is critical for risk management and organizational adoption. Start with a read-only intelligence phase, such as using AI to summarize customer interaction history from the core system for service agents, which has no operational risk. Next, move to assistive workflows, like AI-powered anomaly detection that flags transactions for manual review within the existing fraud module. Finally, progress to controlled automation, such as AI auto-categorizing and routing inbound customer service inquiries, where you can implement circuit breakers and daily volume limits. Each phase should have clear success metrics, fallback procedures to manual processes, and involve the platform's operations team in the design to ensure the integration respects the core system's batch windows, reconciliation processes, and data governance rules.

LEGACY SYSTEM INTEGRATION

Frequently Asked Questions

Integrating AI with legacy core banking platforms (Temenos T24, Oracle FLEXCUBE, Finacle) requires specific architectural patterns. Below are answers to common technical and strategic questions.

We use a multi-layered integration approach that avoids direct, risky modifications to the legacy core.

  1. Data Replication Layer: Establish a secure, one-way data pipeline from the legacy system's database (often Oracle, DB2) or flat-file exports to a modern analytics layer (e.g., cloud data warehouse). Tools like Fivetran, Informatica, or custom CDC (Change Data Capture) streams are used.
  2. Event Capture via Middleware: If a middleware layer (IBM MQ, TIBCO) exists, we instrument it to publish transaction and customer events to a message broker (Kafka, RabbitMQ). These events become triggers for AI workflows.
  3. Screen Scraping & RPA for Write-Backs: For actions requiring updates back to the legacy system (e.g., updating a customer risk score), we use Robotic Process Automation (RPA) tools like UiPath or Automation Anywhere to execute pre-defined scripts via the legacy green-screen or GUI interface. This is a last-resort, controlled method.
  4. AI Service Layer: The AI models and agents operate in this modern layer, consuming the replicated data and event streams. Decisions and insights are stored in a side-car database or pushed back via the controlled RPA/middleware channel.

This pattern keeps the legacy system stable while enabling AI capabilities.

Prasad Kumkar

About the author

Prasad Kumkar

CEO & MD, Inference Systems

Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.

His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.