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. That usually means it stays manual by default. A computer-use agent operates the application's own screen the way a person would, reading what's displayed and clicking and typing in response. The process gets automated without touching the legacy system's internals.
Why “no API” keeps work stuck on manual
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’s complicated, but because there’s no clean integration point. A person clicking through the same screens is the only option anyone has tried.
This work also rarely shows up as a priority to fix. “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.
When the one person who knows the legacy system’s quirks is out, the task either waits. Or it gets done by someone less familiar with the screen’s particular traps. That’s exactly where mistakes creep in.
How the agent operates the screen for you
A computer-use agent operates the legacy application’s own screen the way a person would. It reads what’s currently displayed. It decides what to click or type based on the task it’s been given. Then it proceeds through the same steps a human operator follows, with no API or integration into the system’s internals. We script and test the specific task carefully against the real application first. 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 doesn’t recognize or expect, it stops rather than guessing. The task goes to a human queue with the state attached.
Typical use cases: data entry into an old ERP. Status checks on a portal with no API. Report pulls from a desktop application, or repetitive multi-step tasks on internal tools a vendor no longer updates.
What stays with your team
An unexpected screen. An error message it wasn’t built to handle. A task outside its scripted scope. Anything the agent can’t confidently proceed through goes to a person rather than being pushed through on a guess. Deciding which legacy processes are worth automating this way stays with your team, since the scripting effort is real. 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. Where a non-production copy exists, the agent is tested extensively against it before any live run. 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. Add 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, see the factory ERP recovery case study. For operating a multi-agent system, see 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 only 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 goes into 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, or 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 doesn't match what it expects. It 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.