Core Banking Integration

<!-- AUTO-GENERATED by export-skills.py — DO NOT EDIT -->
---
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]
---

> **Platform Note:** This skill was designed for multi-agent execution. Perplexity Computer handles orchestration automatically — treat sub-agent instructions as sequential steps to complete thoroughly.

# 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/)

<!-- Source: .faos/custom/skills/integrations/core-banking-integration/SKILL.md -->