Systems too old for an API:
automated through the screen anyway
Some of the most tedious work in a business runs on a system too old, too locked-down, or too fragile to offer an API, which usually means it stays manual by default. A computer-use agent operates the application's own screen the way a person would, reading what is displayed and clicking and typing in response, so the process gets automated without touching the legacy system's internals.
The process today
Every business eventually runs into a system nobody wants to touch: an old ERP, a vendor tool with no API, a government or industry portal that only offers a web form. The work that depends on it, entering data, pulling a report, checking a status, stays manual by default, not because it is complicated, but because there is no clean integration point, and a person clicking through the same screens is the only option anyone has tried.
The second cost is that this work rarely shows up as a priority to fix, since “there’s no API” sounds like a dead end rather than a solvable problem, so the manual process just continues indefinitely, absorbing hours that could go elsewhere.
The third is that when the one person who knows the legacy system’s quirks is out, the task either waits or gets done by someone less familiar with the screen’s particular traps, which is where mistakes creep in.
What the agent does
A computer-use agent operates the legacy application’s own screen the way a person would: it reads what is currently displayed, decides what to click or type based on the task it has been given, and proceeds through the same steps a human operator follows, without any API or integration into the system’s internals. We script and test the specific task carefully against the real application, since legacy screens often have quirks, a modal that appears inconsistently, a field that needs a specific format, that the agent needs to be built around.
Every action is logged with a screen recording, so any run can be reviewed step by step after the fact. Where the screen shows something the agent does not recognize or expect, it stops rather than guessing, and the task goes to a human queue with the state attached.
Typical use: data entry into an old ERP, status checks on a portal with no API, report pulls from a desktop application, repetitive multi-step tasks on internal tools a vendor no longer updates.
What stays with humans
Anything the agent cannot confidently proceed through, an unexpected screen, an error message it was not built to handle, a task outside its scripted scope, goes to a person rather than being pushed through on a guess. Decisions about which legacy processes are worth automating this way, since the scripting effort is real, stay with your team. Any change to the legacy system itself, a version update, a new screen layout, needs a review of the agent’s script before it runs live again.
Guards
Every run is logged with a screen recording and the exact sequence of actions taken, so nothing the agent does on your legacy system is a black box. Rate limits are matched to what the legacy system can actually handle without triggering lockouts or performance issues, learned from our own experience automating fragile systems. The agent is tested extensively against a non-production copy where one exists before any live run, and a kill switch stops it mid-task in one message if something looks wrong.
Price and timeline
| Option | Price | What it covers | Timeline |
|---|---|---|---|
| Single automation | from $1,200 | One task, one legacy system, full testing and action log | 2 to 3 weeks |
| Department package | from $4,000 | Multiple tasks across one or more legacy systems, shared monitoring dashboard | 4 to 8 weeks |
Running cost is usually $40 to $150 a month in model usage depending on task frequency and complexity, with a budget cap set before launch.
Related
This pairs well with MCP integrations for internal tools for systems that do offer some form of programmatic access worth exposing properly, and with data migration between systems for the one-time version of a similar problem. See the AI agents service page and the automation-everything overview for full package details. For a real build on recovering a self-hosted legacy ERP and operating a multi-agent system, see the factory ERP recovery case study and the ProBay own marketplace AI agent team case study.
Stuck with a system too old for a real integration? Get in touch and we will look at what the screen actually requires.
Tired of doing this by hand? We can take the whole routine off your team, not just this step: Routine takeover, from $400 →
FAQ
How much does it cost to automate a legacy system with a computer-use agent?
From $1,200 for one well-defined, repeatable task on one system, live in 2 to 3 weeks. Multi-step workflows across more than one legacy screen usually run $2,500 to $4,500.
How long before it is live?
2 to 3 weeks, most of it spent carefully scripting and testing against the real application so the agent handles the screen's quirks reliably before going live.
What kind of systems can this work on?
Any application with a screen a person currently operates manually: old desktop software, a terminal-based system, a web app with no usable API, internal tools from a vendor who no longer supports integration.
What happens if the legacy system's screen changes or behaves unexpectedly?
The agent is built to detect when what it sees does not match what it expects, and stops and flags the task for a human rather than guessing and taking a wrong action on a system that may not be easy to undo.
Is this safe to run against a system we cannot afford to break?
Yes, with guards: rate limits matched to what the system can handle, a full action log with screen recording, and a kill switch. We test extensively in a non-production copy of the system before any live run where one is available.