Your browser does not support JavaScript! Please enable the settings.
↑

Modernise Without Replacing the Core: Four Patterns for an Agentic Layer Around Legacy Banking Systems

You can add AI agents around an existing banking or fintech core without replacing it, but the safety lives in the boundary. This guide sets out four integration patterns, what tends to fail at the seam and how to sequence them.
November 16, 2026
Innovify Editorial
published on
November 16, 2026
Modernise Without Replacing the Core: Four Patterns for an Agentic Layer Around Legacy Banking Systems

Modernise Without Replacing the Core: Four Patterns for an Agentic Layer Around Legacy Banking Systems

A technology leader in a UK bank or scaling fintech is usually asked two things at once: add AI, and do not break the ledger. Replacing the core answers the second request badly and the first one slowly, so many teams look at a third route: leave the core where it is and build an agentic layer around it. "Wrap it with AI" hides most of the engineering, though. The risk sits at the boundary: what an agent may read, what it may change and who is told when it does. This article sets out four integration patterns in order of risk, the failures that tend to appear at the seam, and a sequence in which each step earns the next.

Why the layer, not the rebuild, is getting the attention

Start with what has been reported, and keep it separate from what we infer from it.

Hyperlayer, reported 20 October 2026. Finextra's standfirst reported that London-based Hyperlayer raised £19.5m at a £195m valuation to help banks modernise without replacing core systems. These are third-party funding figures, and we have only the standfirst, so we do not describe how the company's technology works. The narrow point is that investment is flowing to approaches that leave the core in place.

Starling Bank, reported 20 October 2026. Finextra, FF News and Sifted reported that Starling has deployed an agentic financial-crime investigator inside its core, and that it is training a transactional model on UK sovereign cloud. The speed figure attached to that story is Starling's own claim and we have not used it. What matters here is the stated design principle: data ownership and hosting.

LHV Bank, reported 20 October 2026. Financial IT and FF News reported that LHV Bank has taken an AI agent for customer emails live in the UK. This is trade-press reporting, so we treat it with moderate confidence. The shape is useful: a proof of concept, then production, in a customer workflow rather than in the ledger.

Our reading, which is analysis and not reported fact, is that these stories describe different distances from the core: a funding thesis about leaving it alone, an agent inside a bank's own estate, and an agent on a workflow beside the ledger. None tells you how to do it safely in your estate. That depends on the seam between the agent and the system of record, and that seam is where the engineering effort belongs. If you want to see how Innovify approaches that engineering, our AI and machine learning engineering page is the place to start.

This is deliberately not a rebuild-versus-buy debate, nor a guide to where AI sits across a whole transformation. Here the core stays, and the question is narrower: which pattern lets an agent do useful work against a system that was never designed for one?

What an agent needs from a core that was never built for it

An agent, in this context, is software that uses a language model to decide which of several tools to call in order to complete a task. A conventional integration calls a known endpoint with known inputs. An agent chooses its calls at run time, sometimes in an order nobody scripted. Legacy cores tend to cause friction in four places.

  • Interfaces designed for batch. Many cores expose overnight files, queues or screen-driven interfaces, so an agent expecting a clean request and response meets latency and partial state.
  • Meaning buried in fields. Status codes and memo fields often carry business rules known only to long-serving staff. A model can misread them with confidence.
  • Coarse permissions. Service accounts on older systems are often broad, because they were issued for a trusted batch job and not for a decision-making component.
  • Weak event visibility. If the core cannot say promptly that something changed, the agent works from a stale picture.

Each is a reason to put a deliberate layer between the agent and the core. The four patterns below are ordered by how much authority the agent is given.

Four integration patterns, in order of risk

Pattern one: read-only access to a governed copy

The lowest-risk start is to let the agent read, and only read, from a governed copy of the data rather than from the core. That copy might be a reporting replica, a data platform fed by change data capture, or curated APIs that return approved views. The agent summarises, classifies, drafts and recommends. It changes nothing.

This suits investigation support, case summarisation and drafting. It also gives you a record of what the agent saw and said, which you can review before anyone grants it more authority. Its weakness is staleness: a replica that lags the core by hours can make an agent confidently wrong about a customer's current position. Label every answer with the data's timestamp, and be explicit about which questions the agent must not answer from a lagging copy.

Pattern two: event hooks that let the agent react

The second pattern lets the agent listen. Events from the core, such as a new alert, a failed payment or a customer complaint, are published to a stream, and the agent picks up the ones it is meant to handle. It still does not write to the core. It produces a recommendation, a ticket or a drafted message for a person or another system.

The agent now starts work before a human has to ask, which is where visible value tends to appear. It is also where volume becomes a design concern: a burst of events creates a burst of model calls, so you need rate limits and a rule for what happens when the agent falls behind. Silent dropping is the failure to avoid, because nobody notices work that never arrived.

Pattern three: constrained write paths

The third pattern lets the agent cause a change, but never by touching the core directly. It calls a narrow, named action exposed by a service you control, for example "place a temporary hold" or "request a document from the customer". The service validates the request, applies business rules, enforces limits and writes to the core using its own tightly scoped credentials.

This is the anti-corruption layer idea applied to agents: the agent never sees the core's native interface, so it cannot discover and misuse an operation nobody meant to offer. Three properties make it workable:

  1. Each action is small, named and reversible where possible. An agent that can only request a hold is safer than one that can edit an account.
  2. Each action is idempotent. If the agent retries, or the network repeats the call, the outcome must match a single call. Legacy systems are often unforgiving about duplicates.
  3. Each action carries identity. The audit trail should show which agent, acting on whose behalf, under which version of its instructions, made the request.

Pattern four: human approval on the actions that matter

The fourth pattern is less a technical option than a control that sits across the other three. For actions with financial, legal or customer-harm consequences, the agent prepares the action and a named person approves it. The approval screen should show what the agent proposes, why and which data it relied on, so the human is reviewing evidence and not rubber-stamping.

Approval need not be permanent. As the record builds, a firm may decide that some low-impact actions no longer need a person in the loop, while others never will. That decision belongs to the people accountable for the outcome, not to the team that built the agent.

What fails at the seam

As analysis rather than reported fact, we expect the same handful of failure modes to recur where the agent meets the core.

Stale or partial reads. The agent answers correctly from yesterday's data. Mitigation: timestamps on every answer, freshness checks before any action, and refusal rules for questions the copy cannot support.

Misread business rules. A flag means one thing in one product and another elsewhere. Mitigation: a maintained glossary of fields owned by someone in the business, and tests built from edge cases that the people who know the system supply.

Over-broad credentials. The agent inherits a service account that can do far more than its task requires. Mitigation: a separate identity per agent and per action class, least privilege, and no direct credentials to the core.

Prompt injection through data. Text in a customer message, a memo field or an uploaded document can contain instructions the model treats as commands. Mitigation: treat retrieved content as untrusted data, keep tools narrow so injected instructions have little to reach, and test with hostile inputs before launch.

Duplicate and runaway actions. An agent retries, loops or fans out. Mitigation: idempotent actions, per-agent rate limits, volume caps and a kill switch that can be used without a deployment.

Ownership gaps. The agent works, but nobody owns it after the project team moves on. Mitigation: name an accountable owner and a support route before launch.

Invisible degradation. Quality drifts and nobody has a measure. Mitigation: sample outputs for human review, track overrides, and define in advance what triggers a rollback.

Few of these are about the model. They are about permissions, data meaning and operations, which is why the work looks like platform engineering as much as AI.

Controls a UK regulated firm should expect to evidence

This section is an outline and not legal or compliance advice. The detail depends on your firm, your permissions and your regulators.

Our reading is that a regulated firm adding agents around a core should be able to show five things on request: what the agent is for and who is accountable for it; what data it can read and where that data is hosted; what it can change and through which controlled actions; how a human can intervene; and how its behaviour is monitored over time.

The FCA's speech of 19 October 2026 was reported as applying existing frameworks, including Consumer Duty and senior-manager accountability, to AI rather than creating new rules for agents. If that holds, an agent sits inside the accountability you already have. Read the speech and the current FCA and PRA pages before relying on any summary, including this one, and ask your compliance and legal advisers how they apply to your permissions. Innovify is a technology partner, not a regulated financial institution, so decisions about your regulatory position remain with you and your advisers.

A sequence you can defend to a risk committee

The patterns give a natural order: an agent earns each step from the evidence the previous one produced. This is a ladder to apply one workflow at a time, not a programme-wide plan.

  1. Pick a workflow with a clear owner and contained consequences. Alert triage suits this better than anything touching balances.
  2. Build the governed read path. Decide the data copy, its freshness, its hosting and the access rules. Log every read.
  3. Run the agent read-only in shadow. Measure how often it agrees with the people doing the work now, and why it differs.
  4. Add event hooks. Test volume, failure handling and behaviour when it falls behind.
  5. Introduce one constrained write action behind human approval. Choose the smallest useful action and record approvals and rejections.
  6. Review with the accountable owner. Decide whether to widen, hold or reverse before picking the next action.
  7. Keep the exit open. The layer should be removable without touching the core, so a failed experiment costs a deployment and not a migration.

Where Innovify fits

Innovify is a technology partner with deep expertise in banking, financial services, fintech and insurance, and we help mid to large businesses build AI-native products and modernise their technology stack. For a team in this position, that means helping you design the boundary: the governed read path, the event and action layer, the approval flow and the monitoring. We design compliance in from day one, which means agreeing the controls above with your risk and compliance colleagues before any agent can write.

That is Innovify's stated approach, and the right starting point depends on your estate. If you are weighing where an agent could safely begin work against your own core, our AI / ML development team can talk it through with you.

FAQ

Can we add AI agents to a legacy core without replacing it?

Yes, in many cases, but the agent should not touch the core directly. Put a governed layer between them: read from a controlled copy, react to events, and make changes only through narrow, validated actions with human approval where the consequences warrant it. Whether it suits your estate depends on the core's interfaces, your data freshness needs and your regulatory position.

What is the safest first use of an agentic layer on a banking system?

A read-only workflow with a clear owner and contained consequences, such as case summarisation or alert triage. The agent reads from a governed copy and recommends, and people act on the recommendation.

How do we stop an agent making unintended changes to the core?

Never give it direct credentials to the core. Expose a small set of named, idempotent actions through a service you control, with limits, validation, per-agent identity and a kill switch, and require approval from a named person for high-impact actions.

Is wrapping a legacy system a substitute for core replacement?

Not necessarily. A layer can extend the useful life of a core and clarify what a later replacement must do, but it does not remove the core's constraints. Reported activity, such as Hyperlayer's October 2026 raise, shows interest in the approach without proving it suits any given estate.

What should a UK firm check before putting an AI agent near its core?

Check who is accountable for the agent, where its data is hosted, what it can read and change, how a human can intervene and how its behaviour is monitored. Then read the FCA speech of 19 October 2026 and the current FCA and PRA primary pages, and take legal and compliance advice. This article is not legal or compliance advice.

Conclusion

Adding an agentic layer around a legacy core is a boundary-design problem more than a model problem. The October 2026 reporting shows UK investors and banks paying attention to the idea, but not how to make it safe in your own estate. Start read-only, add events, allow only narrow and reversible actions, keep humans on the decisions that matter, and let each step earn the next. If the layer works, you have modernised without a migration. If it does not, you will know what a replacement must provide.

Related reading

Explore next: AI and ML development

Connect With Us

Let’s Build Something Exceptional

Innovify transforms ideas into scalable, impactful products by integrating user centered design, AI-native engineering, data-back growth and lean agile methodologies. Our close client collaboration complemented with on-shore and nearshore delivery creates speed, clarity, and success at scale.
Discuss your project