# Core Banking Integration > - Skill: `frank-luongt/core-banking-integration-2` (Agent Skill) - Install (CLI): `npx skillmds@latest add frank-luongt/core-banking-integration-2` - Raw SKILL.md: https://api.skillmd.com/api/skills/frank-luongt/core-banking-integration-2/raw - Safety review: pending (external: skill-scanner PASS, skillspector WARNING) - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Integrations & APIs - Author: frank-luongt (https://skillmd.com/u/frank-luongt) - Updated: 2026-09-21 - Page: https://skillmd.com/skills/frank-luongt/core-banking-integration-2 --- --- 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 | Platform | Architecture | API Style | Strength | |---|---|---|---| | **Temenos Transact** | Monolithic/modular | REST + proprietary | Largest install base (3,000+ banks) | | **Thought Machine Vault** | Cloud-native, event-driven | gRPC + REST | Smart contracts for product config | | **Mambu** | Cloud-native SaaS | REST (composable) | Fastest time-to-market | | **Finastra** | Modular (FusionFabric) | REST (Open API) | Broadest product suite | ## Patterns ### 1. Temenos Transact REST API ```python 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) ```python 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 ```python 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 ```python 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 ```python # 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](https://www.temenos.com/platform/transact/) - [Thought Machine Vault](https://www.thoughtmachine.net/vault) - [Mambu API Documentation](https://api.mambu.com/) - [Finastra FusionFabric.cloud](https://developer.fusionfabric.cloud/)