TL;DR
- Banks integrate AI agents with legacy core banking systems through a governed layer between the agent and the core: tool contracts the agent can call, a context layer it reads from, an authorization check on every write, and connectors and event streams that reach the core.
- An agent should never hold direct credentials to the core, because the core can't tell an agent from a teller, and the model shouldn't be the one deciding whether an action is allowed.
- Reads and writes need different paths: reads come from a live customer view built above the core, and writes go through a banking capability that checks entitlements, carries an idempotency key, and waits for the core to confirm.
- Batch and mainframe cores work with agents when the agent knows which data is real time and which posts overnight, and tells the customer the truth about timing.
- Start with one read-heavy use case, wrap the core capabilities it needs as governed tools, and add writes only once tracing, approvals, and a stop path are in place.
Most AI agents in banking can talk, and far fewer can act. In our conversations with leading banks across the globe, the agent that looked great in the demo stalls at the same point every time: it needs to read a balance from a 30-year-old core, place a hold, or open a dispute, and nobody can say safely how it gets there.
This post sets out the integration architecture that answers that question: the layers between an agent and the core, how reads and writes differ, what changes when the core runs in batch on a mainframe, and a step-by-step plan to get the first agent into production.
How do banks connect AI agents to legacy core banking systems?
Banks connect AI agents to legacy cores through a governed layer that sits between the agent and every system of record. The agent calls a small set of named tools, each tool maps to a banking capability such as "place card hold" or "get recent transactions", and that capability reaches the core through connectors or event streams the bank already controls.
Protocols for the agent side now exist. The Model Context Protocol lets servers expose tools that can be invoked by language models, such as querying databases or calling APIs, and its specification expects servers to validate every tool input, enforce access controls, and rate limit tool calls. A protocol standardizes how the agent asks, while the bank still has to decide what each tool is allowed to do once it's asked.
That's the work the layer does, and it's also where agent projects differ from core banking integration for digital channels. A mobile app calls the same APIs in the same order every time, but an agent chooses its next call at runtime, so the controls have to sit around every call it might make.
Why shouldn't an AI agent call the core directly?
An agent shouldn't call the core directly because it would inherit permissions it can't be trusted to use and a ledger that can't tell it apart from a human. The OWASP Top 10 for LLM applications names this risk Excessive Agency and traces it to excessive functionality, excessive permissions, and excessive autonomy, with the example of a read-only extension that connects with an identity that can also update and delete records.
The same guidance asks teams to implement authorization in downstream systems rather than relying on the model to decide whether an action is allowed, and to run each action in the context of the specific user with the minimum privileges needed. A legacy core typically knows service accounts and branch users, so our conviction is that the bank needs a layer in front of it that understands agents, customers, and policies, and gives each agent a verified identity with its own limits.
What does the integration architecture look like?
The architecture has six layers, and each one answers a question a risk or architecture team will ask before any agent goes live.
| Layer | What it does | What breaks without it |
|---|---|---|
| Agent | Understands intent, plans steps, and chooses which tool to call | Nothing to integrate yet |
| Tool contracts | A short list of named tools with typed inputs and outputs, scoped to the agent's role | The agent improvises calls against raw APIs |
| Authorization | Checks identity, entitlement, policy, and limits before any write runs | The model decides what it's allowed to do |
| Banking capabilities | Reusable services for account opening, payments, holds, disputes, and KYC checks, shared by agents, apps, and employees | Each agent rebuilds business rules its own way |
| Context | A live view of each customer, assembled from the core, cards, CRM, and documents | The agent answers from partial or stale data |
| Connectivity | Connectors, APIs, and event streams into the core and other systems of record | Point-to-point integrations for every use case |
The agent loop of plan, tool call, and observation runs on top of this stack, and every tool call passes down through it. The point of the layering is reuse: when an agent places a card hold, it uses the same capability and the same eligibility rules as the mobile app and the contact center.
How should reads and writes to the core differ?
Reads and writes need separate paths, because a wrong read gives a bad answer while a wrong write moves money.
The read path
Reads should come from the context layer above the core. A banking semantic layer defines what "customer", "account", and "available balance" mean across systems, so the agent gets one consistent record instead of stitching core, card, and KYC data together on every turn. It also keeps the agent's repeated lookups off the core.
The write path
Writes should go through a banking capability with four controls in front of the core:
- Entitlement check. The capability confirms the customer, the agent, and the policy allow this action at this amount before anything executes.
- Idempotency key. Agents retry when a call times out, and the IETF's draft Idempotency-Key header exists because a timed-out POST leaves the client unsure whether the resource was created, so a retried payment without a key can post twice.
- Human approval where the risk calls for it. The MCP specification says there should always be a human in the loop with the ability to deny tool invocations, and banks apply that per action, with approvals for high-value or irreversible writes and humans in the loop on exceptions.
- Confirmation from the system of record. The agent tells the customer an action is done only once the core confirms it, and the trace links the request, the approval, and the posting.
How do you connect agents to batch cores and mainframes?
You connect agents to batch and mainframe cores by exposing what's real time as APIs, streaming what changes as events, and being honest about what only updates overnight. IBM already supports the first step with tooling to create RESTful APIs to and from an IBM Z mainframe, so mainframe transactions can sit behind a governed tool.
For data that changes outside the agent's own calls, change data capture keeps the context layer current. Open-source connectors such as Debezium capture changes in source databases and send them as records into Kafka, and the context layer subscribes to those events.
Where the core posts in a nightly batch, the agent needs to know it. In our experience, the fastest way to lose a customer's trust is an agent that says a payment is complete when the core will post it at 2am, so every capability should return a status the agent can explain in plain words, such as "accepted" or "posted". When new and legacy systems run side by side, bi-directional data synchronization becomes the hardest problem, and it needs clear ownership of each data domain from day one.
How do you integrate the first AI agent with your core?
You integrate the first agent by starting narrow, wrapping only the capabilities it needs, and adding writes once you can trace and stop them.
- Pick one read-heavy use case. Balance and transaction questions, card status, or dispute status give real value without moving money.
- Inventory the core capabilities it needs. List every read and write, the system that owns it, and whether it's real time, near real time, or batch.
- Wrap each capability as a governed tool. Give it a clear name, typed inputs and outputs, and a scope tied to the agent's role, and expose only those tools to that agent.
- Build the context layer before the second use case. A shared customer view stops each new agent from creating its own integrations.
- Put authorization in front of every write. Check entitlement and policy in the capability, never in the prompt, and store the result with the trace.
- Add idempotency, timeouts, and status codes. Every write carries a key, every call has a timeout, and every result says whether the core has confirmed it.
- Trace, rehearse the stop path, then grade autonomy. Run AgentOps for every agent and move each action from assistive to delegated to autonomous as the evidence earns it.
How does Backbase connect AI agents to existing cores?
The Backbase AI-native Banking OS sits above the systems of record and leaves the bank's cores, CRMs, and data platforms in place. Its connectivity layer uses connectors and event streams to reach core banking, card management, payment processors, CRM, and document management, and banking capabilities expose domain logic such as account opening, credit decisioning, payment initiation, and KYC checks as standard endpoints that any workflow or agent can call.
Deterministic workflows govern the process while agents handle the tasks inside it that need judgment, and no action executes, by any actor, until it has been authorized. Agentic Banking integrates with any existing installation, Backbase or not, so a bank can put its first governed agent into production on top of the core it already runs.
Frequently asked questions
How do banks integrate AI agents with legacy core banking systems?
They put a governed layer between the agent and the core. The agent calls named tools, each tool maps to a banking capability that checks entitlements and policy, and connectors or event streams carry the request to the core and the confirmation back.
Can AI agents work with mainframe core banking systems?
Yes. Mainframe transactions can be exposed as REST APIs behind governed tools, change data capture can stream updates into a context layer, and the agent can explain to customers which actions post in real time and which post in the nightly batch.
Why isn't our AI agent talking to our core banking system properly?
The usual causes are raw APIs exposed without tool contracts, inconsistent data definitions across core, card, and CRM systems, and missing status handling for batch postings or timeouts. A context layer and capability-level tools fix most of them.
Is the Model Context Protocol safe to use with a core banking system?
MCP standardizes how agents discover and call tools, and its specification asks servers to validate inputs, control access, and rate limit calls. The bank still has to put authorization, idempotency, and approvals in the capabilities behind each tool.
Do banks need to replace the core before deploying AI agents?
No. Agents can run on top of an existing core through a layer that adds context, authorization, and reusable banking capabilities, and banks can modernize the core journey by journey while agents are already in production.





