Personalized AI infrastructure
AI Agents and Legacy Software: Connect Without a Full Rebuild
How to put a controlled connector in front of an older system of record so AI agents get useful, bounded access without a full rebuild.

AI agents can work with legacy software without a full rebuild when a thin, controlled connector sits between the agent and the older system of record. The connector exposes a small set of named operations, such as looking up an order status or drafting a change for approval, and it enforces the permissions, limits and logs that the business defines. The old system keeps doing what it already does well, and the agent receives only the access its role needs.
Key takeaways
- Keep the system of record where it is and place a connector in front of it.
- Expose a few named operations, never raw database access or screen automation by default.
- Give each operation its own permission, approval boundary and log entry.
- Build and test read operations before any write operation, and writes before any autonomous action.
- Review access on a schedule, because legacy systems change slowly and often without announcement.
Why legacy systems block agents, and why a rebuild is often the wrong first move
Most older business systems hold the records a team relies on: orders, invoices, customer histories, inventory counts. The difficulty is access. The software may have no modern interface, its export files arrive in batches, its vendor may no longer update it, and the only practical path to the data may be the screen a person uses every day. Leaders often respond by proposing a replacement project, but a rebuild takes a long time, mixes data migration with new behavior, and leaves the business without the old record during the transition.
An agent does not need the whole system to be modern. It needs a bounded view of specific records and a way to request a small number of actions. That is a narrower problem, and it can be solved in front of the system that already exists.
What a controlled connector actually does
A connector is a small service that receives a request from an agent, checks whether that request is allowed, translates it into the legacy system's own terms, runs the call, and returns a trimmed result. It also records what happened. In practice it handles four jobs: it validates inputs, it applies authorization on every request, it limits how much data and how many calls can pass through, and it writes a log entry that a person can read later.
The Model Context Protocol offers one common way to describe tools to an agent in a consistent format, which makes the connector's operations easier to review. The description matters less than the rule behind it. The OWASP authorization guidance recommends denying access by default and checking permission on each request, not once when a session starts. Apply that rule to every operation the connector exposes.
How do you put a connector in front of an older system, step by step?
The work is easier to control when it follows a sequence. The steps below assume that one team owns the legacy system and one business owner owns the outcome.
- Name the single role the agent will play and the decision or task that role supports.
- List the records and fields that role needs, and mark the fields it must never see, such as payment details or personal data outside its purpose.
- Write each operation as a named function with defined inputs, a defined output and a plain failure message.
- Build the read operations first, then compare their results with the legacy screen for a sample of records that a person has already checked.
- Add write operations only behind an approval step that a named person can accept or reject.
- Set a volume limit and a timeout for each operation so that a faulty loop cannot flood the old system.
- Log every call with the requester, the inputs, the result and the time, so that an incident can be reconstructed afterward.
- Write the success criterion in plain terms before the first live use, for example: the agent answers status questions correctly in the cases a supervisor has sampled.
Illustrative scenario: A distributor runs its order management on software that predates most of its current staff. The customer service team wants an agent to answer delivery questions without interrupting a person. The connector exposes one read operation that returns the status, expected date and last update for an order number. It cannot see prices or bank details, and it cannot change anything. Only after the read version has run cleanly for some time does the team consider a second operation that adds a delivery note, and that note goes through a human approval step first.
Read access first, write access later
Reads are where most of the value starts, and they carry much less risk. Writes deserve more caution because legacy systems often lack the safeguards that modern platforms provide. A retried request can create a duplicate order. A timeout can leave the record half updated. Stripe's documentation on idempotent requests shows the pattern that modern providers use: the caller sends a unique key, and the server returns the original result if the same request arrives again. Many older systems offer nothing comparable, so the connector has to supply that protection itself, with a request key stored in its own log and checked before any write is sent.
For each write, decide who approves it, what information the approver sees, and what happens if no one responds. Changes to what an agent may do should also follow a written process. The guide on how to request and approve changes to a managed AI agent describes a workable format for that.
How do you know the connector is working?
A connector needs evidence, not only a successful demonstration. Track the operations that were called, the number of requests rejected by the permission check, the failures returned by the legacy system, the response times, and the approvals granted or refused by each person. The OpenTelemetry observability primer describes the basic categories, traces, logs and metrics, that make this kind of tracking possible across services. You do not need an elaborate dashboard at the start. You need a weekly view that a manager can read in a few minutes.
Also test the agent's answers against cases with known correct outcomes. The OpenAI evals guide describes the general practice of writing such tests, and Anthropic's note on demystifying evals for agents explains why a small, well-chosen set of cases is more useful than a large, vague one. Keep the test set alongside the connector, and rerun it whenever the legacy system or the agent's instructions change.
What can go wrong with text that the agent reads?
An agent that reads customer emails, tickets or documents will encounter text written by people who may want to manipulate it. A message can contain an instruction such as asking the agent to reveal data or perform an action outside its role. The OWASP prompt injection prevention guidance and the OWASP Top 10 for LLM Applications both treat this as a core risk. The defense is architectural. The connector should never treat the model's output as proof of permission. Each request must be checked against the role, the operation and the record, using an identity that is scoped to the task rather than a broad service account with access to everything.
One practical rule follows from this: if an operation would be harmful when called by someone who should not be calling it, it needs a permission check and, for writes, a human approval step, regardless of how the request was phrased.
Where to start, and how a managed approach helps
Be Human designs and operates personalized AI infrastructure in which agents keep their identity, memory, channels, tools, permissions and operating context under human control. A first engagement defines one useful role, the memory and tools that role needs, the approval boundaries, and an observable success criterion. Managed operations can then cover monitoring, recurring evaluations, integration maintenance, permission review, incident response and controlled improvements, which matters for a connector because the legacy system will change and the connector must change with it. Teams that want to see how the layers fit together can use the one-page architecture map for leaders as a starting point for that discussion.
If you want to find the first task worth handing to an agent, the free Be Human AI diagnostic is a practical place to begin.
Frequently asked questions
Do we have to replace our legacy system before an agent can use it? No. In most cases the system of record stays where it is, and a connector provides the agent with a narrow, controlled view of it. Replacement may still make sense for other reasons, but it should not be the precondition for a first useful agent.
Is it safe to connect an agent to an old system with weak logging? It can be, provided the connector adds the logging, permission checks and volume limits that the old system lacks. Start with read-only operations, so that a mistake cannot change any record while the logs and tests mature.
Who should approve write actions taken by an agent? A named person who owns the outcome should approve them, usually the manager of the process the write affects. The approver should see the proposed change, the reason for it and the source of the request, and the system should record the decision.
How do we know whether the connector is delivering value? Define a success criterion before launch, such as the agent answering a defined set of questions correctly in cases a supervisor has checked. Then review the logs, the failures and the test results on a regular schedule, and keep the connector only where the evidence shows that it helps.
Your next step
See where an AI agent fits in your company first.
Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.
Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.


