Core Banking Integration

name: core-banking-integration description: Core banking system integration patterns for AI agents connecting to Temenos Transact, Thought Machine Vault, Mambu, and Finastra. Use when building agents that interact with core banking APIs for account management, payments, lending, and customer data. tags: [banking, temenos, thought-machine, mambu, finastra, core-banking]

Core Banking System Integration

Connect AI agents to core banking platforms (Temenos Transact, Thought Machine Vault, Mambu, Finastra) for account management, payments, lending, and customer data access.

When to Use

• Building AI agents that query or manage bank accounts, transactions, and balances
• Integrating with modern cloud-native core banking (Thought Machine, Mambu) or legacy (Temenos, Finastra)
• Implementing conversational banking assistants with real account access
• Automating lending workflows, KYC checks, or payment processing via agent tools

Platform Comparison

Patterns

1. Temenos Transact REST API

import requests
from typing import Optional

class TemenosClient:
    def __init__(self, base_url: str, token: str):
        self.base_url = base_url.rstrip("/")
        self.headers = {
            "Authorization": f"Bearer {token}",
            "Content-Type": "application/json",
        }

    def get_account(self, account_id: str) -> dict:
        """Get account details from Temenos Transact."""
        resp = requests.get(
            f"{self.base_url}/api/v1/holdings/accounts/{account_id}",
            headers=self.headers,
        )
        resp.raise_for_status()
        return resp.json()

    def get_transactions(self, account_id: str, from_date: str, to_date: str) -> list[dict]:
        """Get account transactions for a date range."""
        resp = requests.get(
            f"{self.base_url}/api/v1/holdings/accounts/{account_id}/transactions",
            headers=self.headers,
            params={"fromDate": from_date, "toDate": to_date},
        )
        resp.raise_for_status()
        return resp.json().get("body", [])

    def get_customer(self, customer_id: str) -> dict:
        """Get customer profile."""
        resp = requests.get(
            f"{self.base_url}/api/v1/party/customers/{customer_id}",
            headers=self.headers,
        )
        resp.raise_for_status()
        return resp.json()

2. Thought Machine Vault (gRPC + Smart Contracts)

import requests

class VaultClient:
    def __init__(self, base_url: str, token: str):
        self.base_url = base_url.rstrip("/")
        self.headers = {
            "X-Auth-Token": token,
            "Content-Type": "application/json",
        }

    def get_account(self, account_id: str) -> dict:
        """Get account from Vault core."""
        resp = requests.get(
            f"{self.base_url}/v1/accounts/{account_id}",
            headers=self.headers,
        )
        resp.raise_for_status()
        return resp.json()

    def get_balances(self, account_id: str) -> dict:
        """Get live account balances (Vault computes from postings)."""
        resp = requests.get(
            f"{self.base_url}/v1/balances/live",
            headers=self.headers,
            params={"account_ids": account_id},
        )
        resp.raise_for_status()
        return resp.json()

    def create_posting(self, debit_account: str, credit_account: str, amount: str, denomination: str) -> dict:
        """Create a posting instruction batch (payment/transfer)."""
        payload = {
            "posting_instruction_batch": {
                "posting_instructions": [{
                    "custom_instruction": {
                        "postings": [
                            {"credit": False, "amount": amount, "denomination": denomination, "account_id": debit_account},
                            {"credit": True, "amount": amount, "denomination": denomination, "account_id": credit_account},
                        ]
                    }
                }]
            }
        }
        resp = requests.post(
            f"{self.base_url}/v1/posting-instruction-batches:asyncCreate",
            headers=self.headers,
            json=payload,
        )
        resp.raise_for_status()
        return resp.json()

3. Mambu Composable Banking API

import requests

class MambuClient:
    def __init__(self, base_url: str, api_key: str):
        self.base_url = base_url.rstrip("/")
        self.headers = {
            "apiKey": api_key,
            "Accept": "application/vnd.mambu.v2+json",
            "Content-Type": "application/json",
        }

    def get_client(self, client_id: str) -> dict:
        """Get client (customer) details."""
        resp = requests.get(f"{self.base_url}/api/clients/{client_id}", headers=self.headers)
        resp.raise_for_status()
        return resp.json()

    def get_deposit_account(self, account_id: str) -> dict:
        """Get deposit account with balance."""
        resp = requests.get(f"{self.base_url}/api/deposits/{account_id}", headers=self.headers)
        resp.raise_for_status()
        return resp.json()

    def get_loan_account(self, loan_id: str) -> dict:
        """Get loan account with schedule."""
        resp = requests.get(f"{self.base_url}/api/loans/{loan_id}", headers=self.headers)
        resp.raise_for_status()
        return resp.json()

    def search_transactions(self, account_id: str, from_date: str, to_date: str) -> list[dict]:
        """Search transactions with filter criteria."""
        payload = {
            "filterCriteria": [
                {"field": "parentAccountKey", "operator": "EQUALS", "value": account_id},
                {"field": "creationDate", "operator": "BETWEEN", "value": from_date, "secondValue": to_date},
            ],
            "sortingCriteria": {"field": "creationDate", "order": "DESC"},
        }
        resp = requests.post(f"{self.base_url}/api/deposits/transactions:search", headers=self.headers, json=payload)
        resp.raise_for_status()
        return resp.json()

4. Finastra FusionFabric.cloud

import requests

class FinastraClient:
    def __init__(self, base_url: str, token: str):
        self.base_url = base_url.rstrip("/")
        self.headers = {
            "Authorization": f"Bearer {token}",
            "Content-Type": "application/json",
        }

    def get_accounts(self, customer_id: str) -> list[dict]:
        """Get customer accounts from Finastra core."""
        resp = requests.get(
            f"{self.base_url}/retail-banking/accounts/v1/accounts",
            headers=self.headers,
            params={"customerId": customer_id},
        )
        resp.raise_for_status()
        return resp.json().get("accounts", [])

    def initiate_payment(self, debtor_account: str, creditor_account: str, amount: float, currency: str) -> dict:
        """Initiate a payment via Finastra Payment Hub."""
        payload = {
            "debtorAccount": {"identification": debtor_account},
            "creditorAccount": {"identification": creditor_account},
            "instructedAmount": {"amount": str(amount), "currency": currency},
        }
        resp = requests.post(
            f"{self.base_url}/payments/v1/payment-initiations",
            headers=self.headers,
            json=payload,
        )
        resp.raise_for_status()
        return resp.json()

Agent Tool Pattern

# Wrap core banking calls as AI agent tools
def check_balance(account_id: str) -> str:
    """Check the current balance for a bank account.

    Args:
        account_id: The bank account identifier
    """
    client = MambuClient(base_url=MAMBU_URL, api_key=MAMBU_KEY)
    account = client.get_deposit_account(account_id)
    balance = account.get("balances", {}).get("availableBalance", 0)
    currency = account.get("currencyCode", "USD")
    return f"Account {account_id} available balance: {currency} {balance:,.2f}"

def get_recent_transactions(account_id: str, days: int = 30) -> str:
    """Get recent transactions for a bank account.

    Args:
        account_id: The bank account identifier
        days: Number of days to look back (default 30)
    """
    from datetime import datetime, timedelta
    to_date = datetime.now().strftime("%Y-%m-%d")
    from_date = (datetime.now() - timedelta(days=days)).strftime("%Y-%m-%d")

    client = MambuClient(base_url=MAMBU_URL, api_key=MAMBU_KEY)
    txns = client.search_transactions(account_id, from_date, to_date)
    return f"Found {len(txns)} transactions in the last {days} days."

Anti-Patterns

• Exposing raw account numbers to LLMs -- mask sensitive data before passing to models
• Direct database queries bypassing core banking APIs -- always use the platform's REST/gRPC APIs
• Caching account balances -- always fetch live balances (stale data = compliance risk)
• Skipping idempotency keys on payment/posting APIs -- duplicate payments are catastrophic
• Not implementing rate limiting -- core banking APIs have strict throughput limits

References

• Temenos Transact API
• Thought Machine Vault
• Mambu API Documentation
• Finastra FusionFabric.cloud