Retrofitting AI into a legacy system

Meet "Continental Insurance" — a representative composite. Its claims platform is 20 years old: a monolith on an older stack, a database that is the undisputed system of record, batch jobs no one wants to touch, and a business that processes thousands of claims a day on top of it. Leadership wants AI to triage incoming claims and draft adjuster summaries. What they cannot have is a rewrite, a multi-quarter freeze, or any risk to the system of record. This is the most common enterprise AI job that isn't a greenfield demo, and it is dominated by three forces a new project never feels: you must not break what works, you must not couple to legacy internals, and you must be able to roll back in seconds.

1 · Framing the retrofit — the constraints that rule out a rewrite

The instinct is "let's just rebuild the claims flow with AI in it." In a real enterprise that is how you spend two years and ship nothing. Start by writing the constraints that make a rewrite a non-starter, because they also point straight at the pattern you should use instead.

2 · Integration patterns — how the AI touches the legacy system

The core decision is how the new AI capability connects to the old system without becoming welded to it. Four patterns cover almost every case; you usually combine them. The unifying idea is an anti-corruption layer (ACL): a translation boundary so the AI speaks a clean domain model and never learns the legacy schema's 20 years of quirks.

3 · The strangler-fig architecture

The strangler-fig pattern (a well-known, publicly documented approach to legacy modernization) is the backbone: put a façade in front of the legacy system, route a slice of traffic through the new AI path, and grow that slice only as it earns trust — while the legacy path stays authoritative the entire time. Read the diagram as one claim's journey: it enters the façade, which decides whether this slice is AI-enabled; the AI path reads legacy data through the ACL, produces an advisory output, and the legacy system remains the system of record.

4 · Data plumbing — reading legacy data safely

The AI needs current claims data, but the write path to the system of record is exactly what you promised not to touch. The answer is to read, never reach in: capture changes as a stream and build a purpose-shaped read model the AI queries, translated through the ACL. The legacy DB stays authoritative and untouched; the AI works off a derived, eventually-consistent view.

The read-side data flow

1. Change-data-capture (CDC) taps the legacy DB's change log and emits events — no code changes to legacy writes.
2. An ACL transform maps legacy rows into a clean domain event (stable names, resolved enums, no nulls-as-flags).
3. A read model (a separate store shaped for the AI's queries) is built from those events.
4. The AI path queries the read model, never the legacy DB directly — decoupling load and schema.
5. Any AI output is written to an advisory queue, never back into the system of record without human/legacy validation.

5 · Risk containment — flags, shadow mode & the kill switch

A retrofit lives or dies on containment: the blast radius of any AI mistake must be small and reversible. Four mechanisms, layered, give you that. Notice they're the same mechanisms a mature deployment uses everywhere — the retrofit just makes them non-negotiable because the legacy system is unforgiving.

6 · Incremental rollout — one slice at a time

Now sequence the actual rollout. The strangler-fig only works if you grow the AI slice deliberately, measure each step against the legacy baseline, and keep the rollback one config away the whole time. Never enable a slice you couldn't instantly disable.

7 · Failure modes & the containment that hardens each

A retrofit "designed for production" is one where every failure mode maps to a containment mechanism already in the architecture. If a row points at something you'd bolt on after an incident, that is your next incident.

route(request):
  if KILL_SWITCH_ON:                 return legacy(request)        # instant, config-only
  slice = classify_slice(request)
  if not flag_on(slice):             return legacy(request)        # slice not enabled
  try:
     ai = ai_path(request)                                          # reads via ACL/read model
     if SHADOW_MODE:  log_compare(ai, legacy(request)); return legacy(request)
     return ai
  except (Timeout, Error):           return legacy(request)        # circuit-breaker fallback