Inferensys

Integration

AI Integration for Temenos Core Banking

A practical blueprint for integrating AI into Temenos T24 Transact and Infinity to automate customer service, enhance fraud detection, and streamline back-office operations using APIs and event-driven architecture.
Architect reviewing LLM integration architecture on laptop, system diagrams visible, modern technical office setup.
ARCHITECTURE AND ROLLOUT

Where AI Fits into the Temenos Stack

AI integration for Temenos T24 Transact and Infinity connects to specific APIs, event hooks, and data objects to automate workflows without disrupting core processing.

AI capabilities are layered onto the Temenos stack through its open APIs and event-driven architecture. Key integration points include:

  • Temenos Infinity (Digital Front-End): AI-driven chatbots, personalized offer engines, and automated onboarding workflows interact via the Temenos Composer APIs and customer journey hooks.
  • Temenos T24 Transact (Core Processing): Transaction monitoring, fraud scoring, and back-office automation connect to the T24 Real-Time and Interaction Framework APIs, listening for posting events on accounts, loans, and payments.
  • Temenos Data Hub: AI models for customer insights, risk forecasting, and regulatory reporting are fed by the Data Hub's unified customer and transaction views, avoiding direct query load on the production core.

Implementation follows a sidecar pattern, where AI services run in parallel, consuming events and calling back to the core via approved APIs. For example, a real-time fraud detection agent subscribes to the T24 Payment Order event stream, scores the transaction in milliseconds, and posts a Hold instruction via the Arrangements API if a threshold is breached. This keeps AI logic decoupled, auditable, and scalable independent of the core banking batch cycles. Critical workflows like loan underwriting support or KYC document review are built as microservices that call Temenos APIs to retrieve applicant data, process documents, and update the Customer or Arrangement records with analysis results.

Rollout requires careful governance. AI integrations are first deployed in assistive mode (e.g., providing recommendations to a human agent in Temenos Service Manager) before progressing to supervised automation. All AI-driven updates to master records or financial postings are logged with a distinct audit trail, linking the AI agent ID, prompt/input data, and the resulting API call. This controlled approach allows banks to start with high-impact, low-risk use cases—like automating the categorization of Investigation cases or summarizing customer interaction histories—before expanding to more autonomous processes.

AI WORKFLOW ENTRY POINTS

Key Integration Surfaces in Temenos

Customer Master & Account APIs

AI integration for Temenos T24 Transact and Infinity begins with the customer and account data layer. This includes the CUSTOMER application for profiles and the ACCOUNT application for deposit, loan, and investment accounts.

Key AI Use Cases:

  • Intelligent Onboarding: Use AI to extract and validate KYC documents (IDs, proofs of address) submitted via Infinity, automatically populating the CUSTOMER application and triggering risk scoring workflows.
  • Dynamic Segmentation: Analyze transaction patterns and account balances to update customer segments in real-time, enabling hyper-personalized offers.
  • Proactive Servicing: Build agents that monitor account conditions (e.g., low balance, dormant status) and trigger personalized communications or next-best-action prompts for service reps.

Integration is achieved via Temenos's Infinity Experience APIs for front-end actions and T24 Transact Core Banking APIs (like CustomerService and AccountService) for direct system-of-record updates, ensuring AI-driven insights become actionable records.

PRODUCTION INTEGRATION PATTERNS

High-Value AI Use Cases for Temenos

Integrate AI directly into Temenos T24 Transact and Infinity workflows to automate high-volume tasks, enhance decision-making, and improve customer service. These patterns connect via APIs, event-driven triggers, and data pipelines.

01

Intelligent Transaction Monitoring & Fraud Triage

Deploy real-time AI models on the Temenos transaction posting engine (TPH) to score transactions for fraud and AML risk. High-risk items are flagged for immediate review in the compliance dashboard, while low-risk items post without delay. Integrates via Temenos Event Framework or API hooks.

Batch -> Real-time
Alerting speed
02

Customer Service Agent Copilot

Embed an AI assistant within the Temenos Infinity service console. It pulls customer history, open products, and recent transactions via T24 APIs to provide agents with instant summaries, next-best-action suggestions, and draft responses for common inquiries, reducing handle time.

Hours -> Minutes
Case resolution
03

Automated Loan Application Review

Connect AI to the Temenos Loan Origination module. For incoming applications, the system extracts and validates data from uploaded documents (bank statements, tax forms), performs an initial credit assessment using internal and external data, and routes complete packages to underwriters with a summary.

1-2 Days
Initial review cycle
04

Smart KYC & Onboarding Workflow

Automate the initial stages of customer onboarding in Temenos. AI processes ID documents, performs PEP/sanctions screening matches, and extracts beneficial ownership data. Results populate the Customer Master and trigger manual review only for exceptions, accelerating account opening.

Same day
Onboarding SLA
05

Personalized Product Recommendation Engine

Leverage transaction and customer profile data from Temenos to power a real-time recommendation API. Use AI to analyze spending patterns, life events, and product holdings to surface personalized offers for loans, deposits, or cards within digital banking channels and advisor scripts.

Real-time
Offer triggers
06

Regulatory Report Generation & Validation

Automate the extraction and consolidation of data from Temenos general ledgers and risk modules for reports like Basel III, IFRS 9, or liquidity coverage ratio (LCR). AI validates figures against source transactions, flags anomalies for review, and generates draft narratives, reducing manual compilation effort.

Weeks -> Days
Report preparation
TEMENOS T24 & INFINITY INTEGRATION PATTERNS

Example AI Automation Workflows

These workflows illustrate how AI agents and automations connect to Temenos T24 Transact and Infinity APIs, event hooks, and data models to drive specific business outcomes. Each pattern includes the trigger, data context, AI action, and resulting system update.

Trigger: A new customer application is submitted via Temenos Infinity's digital front-end and creates a pending CUSTOMER record in T24.

Context/Data Pulled: The integration retrieves:

  • The application payload and attached documents (ID, proof of address) from the Infinity application event.
  • The nascent CUSTOMER record and its CUSTOMER.STATUS from T24 via the CUSTOMER API.
  • Relevant watchlist and PEP data from external compliance feeds.

AI Agent Action: An AI agent orchestrated by a workflow engine:

  1. Extracts and validates data from uploaded documents using vision/OCR models.
  2. Performs a risk assessment by cross-referencing extracted data against watchlists and analyzing application patterns.
  3. Generates a summary and recommendation (e.g., APPROVE, REVIEW, DECLINE) with cited reasons.

System Update/Next Step: Based on the agent's confidence score and recommendation:

  • High-confidence Approve/Decline: The workflow automatically updates the CUSTOMER.STATUS via the T24 API and triggers the next step (e.g., account creation or rejection communication).
  • Requires Review: The case, along with the AI summary and extracted data, is routed to a human reviewer's queue in Infinity or a connected case management system.

Human Review Point: All REVIEW recommendations and any low-confidence decisions are escalated. The agent's reasoning is presented to the human to accelerate final judgment.

CONNECTING AI TO T24 TRANSACT & INFINITY

Implementation Architecture & Data Flow

A production-ready AI integration for Temenos connects to its APIs and event streams, injecting intelligence into servicing, monitoring, and support workflows without disrupting core processing.

The integration architecture is event-driven, anchored on Temenos's T24 Transact APIs for account and transaction data and Infinity's engagement APIs for digital channel context. AI services are deployed as containerized microservices that subscribe to key business events—such as a high-value payment posting, a customer service case creation, or a loan application submission—via message queues or webhooks. For retrieval-augmented generation (RAG) use cases, a dedicated pipeline syncs relevant customer, product, and policy documents from T24's database to a vector store, enabling agents to answer questions with grounded, up-to-date context.

High-value implementation patterns include:

  • Servicing Automation: An AI agent listens for service requests in Infinity, retrieves the customer's full relationship history from T24 via APIs, and either auto-resolves common inquiries or drafts a detailed summary for a human agent.
  • Transaction Monitoring: A real-time scoring service intercepts payment messages before final posting, evaluates them against behavioral models and watchlists, and routes suspicious transactions to a dedicated investigation queue with a reasoning audit trail.
  • Underwriting Support: For commercial lending workflows, an AI service extracts and cross-checks data from uploaded financial statements against T24 customer records, flagging discrepancies and populating credit memo templates for loan officers.

Rollout is phased, starting with read-only APIs and non-critical workflows to validate data accuracy and performance. Governance is enforced through Temenos's existing Role-Based Access Control (RBAC) for data access, with all AI tool calls logged to the same audit trails used for core banking transactions. This approach ensures compliance, maintains system stability, and allows the bank to scale AI use cases from a single department to the enterprise.

Temenos T24 & Infinity Integration Patterns

Code & Payload Examples

Triggering AI on Core Banking Events

Temenos T24 Transact can publish transaction events via its Event Engine or Integration Framework. A common pattern is to deploy a webhook listener that receives these events, enriches them with customer context, and calls an AI service for real-time analysis, such as fraud scoring or next-best-action.

python
# Example: Flask webhook for T24 transaction events
from flask import Flask, request
import requests

app = Flask(__name__)

@app.route('/webhook/t24-transaction', methods=['POST'])
def handle_transaction():
    event = request.json
    # Enrich with customer data from T24 Customer API
    customer_id = event.get('customerId')
    customer_profile = get_customer_profile(customer_id)  # Call T24 API
    
    # Prepare payload for AI scoring service
    ai_payload = {
        "transaction": event,
        "customer": customer_profile,
        "timestamp": event.get('timestamp')
    }
    
    # Call AI service for fraud risk score
    ai_response = requests.post(
        'https://ai-service/inference/fraud',
        json=ai_payload,
        headers={'Authorization': 'Bearer YOUR_API_KEY'}
    )
    
    # Log high-risk scores back to T24 for alerting
    if ai_response.json().get('riskScore') > 0.8:
        log_alert_to_t24(event['id'], ai_response.json())
    
    return {'status': 'processed'}, 200

This pattern enables sub-second AI decisioning integrated directly into the transaction posting flow.

T24 TRANSACT & INFINITY WORKFLOWS

Realistic Operational Impact & Time Savings

This table illustrates the tangible operational improvements achievable by integrating AI agents and copilots into key Temenos workflows, focusing on time savings, manual effort reduction, and improved decision velocity.

Workflow / MetricBefore AI IntegrationAfter AI IntegrationImplementation Notes

Customer Onboarding (KYC/AML Review)

Manual document review: 2-4 hours per case

AI-assisted extraction & screening: 20-30 minutes per case

AI pre-fills customer master, flags anomalies for human review; reduces drop-offs

Transaction Monitoring (Fraud Alert Triage)

Analyst reviews 50-100 alerts daily, 5-10 minutes each

AI prioritizes high-risk alerts, provides summaries: 1-2 minutes each

Focuses analyst effort; reduces false positives; integrates with T24 posting engine

Loan Application Underwriting Support

Manual data collection from statements & reports: 3-5 hours

AI aggregates & analyzes financials, generates summary: 30-45 minutes

Pulls data via APIs; provides risk memo; underwriter makes final decision

Customer Service Inquiry Resolution

Agent searches across multiple T24 screens: 8-12 minutes

AI copilot surfaces unified customer profile & history: <1 minute

Integrates with Infinity service desk; reduces average handle time

Regulatory Report Generation (e.g., Large Exposure)

Manual data extraction, validation, formatting: 1-2 days monthly

AI automates data pull & draft generation: 2-4 hours monthly

Connects to T24 GL & risk modules; human validates final figures

Exception Handling (Payment Repair Queue)

Manual investigation of mismatched fields: 15-30 minutes per item

AI suggests corrections & routing: 5-10 minutes per item

Leverages payment hub events; learns from past repair actions

Static Data Maintenance (Product Catalog Updates)

Manual entry & validation for bulk updates: 4-8 hours

AI-assisted data cleansing & bulk upload prep: 1-2 hours

Reduces errors in T24 product parameterization; audit trail maintained

ARCHITECTING CONTROLLED AI OPERATIONS FOR TEMENOS

Governance, Security & Phased Rollout

A practical framework for deploying AI in Temenos T24 Transact and Infinity with built-in controls, auditability, and incremental value delivery.

Integrating AI into Temenos requires a policy-aware architecture that respects the platform's data model and operational boundaries. Key surfaces include the Temenos API Framework (TAF) for secure customer and transaction data access, the Temenos Process Manager (TPH) for orchestrating AI-enhanced approval workflows, and the Infinity Interaction Framework for powering customer-facing agents. All AI tool calls should be routed through a dedicated middleware layer that enforces role-based access control (RBAC) aligned with Temenos user groups, logs all prompts and completions to an immutable audit trail, and applies data masking for sensitive fields like account numbers or PII before sending payloads to external LLMs.

A phased rollout mitigates risk and demonstrates quick wins. Phase 1 typically targets a single, high-volume workflow with a clear manual burden, such as using AI to categorize and summarize customer service inquiries from Infinity into T24 Transact cases, reducing manual triage time. Phase 2 expands to transaction monitoring, where AI analyzes posting entries in near-real-time via event listeners to flag anomalies for fraud review, integrating findings back into the Temenos Financial Crime Investigation (FCI) module. Phase 3 introduces more complex, multi-step agents, such as an underwriting copilot that retrieves customer financial history from T24, analyzes uploaded bank statements, and drafts a risk assessment for a loan officer's review within the Temenos Credit Risk workflow.

Governance is non-negotiable. Establish a model registry to track all deployed AI models (e.g., for classification, summarization, scoring) and their linkage to specific Temenos modules. Implement human-in-the-loop (HITL) gates for any AI-driven action that modifies core records (e.g., updating a customer risk score) or triggers financial transactions. Use Temenos's own audit log tables (e.g., H_AT_* tables) to correlate AI actions with system changes. Finally, design for regulatory readiness by ensuring all AI-driven decisions for credit, fraud, or AML can be explained and that data lineage from the Temenos general ledger to the AI model input is fully traceable, supporting compliance with frameworks like IFRS 9 and Basel III.

IMPLEMENTATION AND WORKFLOW DETAILS

Frequently Asked Questions

Practical questions about integrating AI agents and workflows with Temenos T24 Transact and Infinity, covering architecture, data access, and production rollout.

AI integrations connect primarily through Temenos's Open API framework and Event-Driven Architecture (EDA). The standard pattern involves:

  1. Trigger: An event in T24 (e.g., a high-value transaction posting, a new customer complaint case in Infinity) publishes a message to a Kafka topic or triggers a webhook.

  2. Context Retrieval: An AI agent or microservice consumes the event, then uses T24's APIs to fetch relevant context. For a transaction monitoring workflow, this might include:

    • Customer profile and risk rating from the CUSTOMER application.
    • Recent transaction history from FT or TT records.
    • Account details from ACCOUNT application.
  3. AI Action: The enriched payload is sent to an LLM or a specialized model for analysis (e.g., fraud scoring, summarization, classification).

  4. System Update: The result is written back to T24. This could be:

    • Updating a flag field in the transaction record (FT.LOCAL.REF field).
    • Creating a new alert record in the AML.ALERT or monitoring application.
    • Posting a note to the customer's interaction history in Infinity.

This ensures the core ledger remains the system of record, with AI acting as an intelligent, event-driven layer.

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.