[ Computer-Use AI ]
Automate the Systems That Never Got an API
We build agents that read the screen, click, type and navigate legacy portals and desktop apps the way a trained operator would. They run in isolated virtual machines, ask before risky steps and record every action.

- Needed from the target system
- No API
- Needed from the target system
- Isolated sandbox per agent session
- 1 VM
- Isolated sandbox per agent session
- Certified security practices
- ISO 27001
- Certified security practices
- Of hypercare after launch
- 30 days
- Of hypercare after launch
Work Trapped Behind a Screen
Computer use fits when the only way into a system is its user interface and the work is too varied for brittle scripts.
01Payer and insurance portals
Agents log into payer websites, submit prior authorizations, check claim status and download remittances, then write results back to your practice system.
Staff stop retyping data between portals
02Government and tax filings
Form-heavy public portals with no integration options are filled from your records, with a screenshot of every confirmation page saved as evidence.
Filings done on time with a receipt for each
03Legacy desktop software
Older ERP, accounting or green-screen terminals driven through a virtual desktop, so data moves in and out without a costly rewrite.
Old systems join modern workflows
04Carrier and supplier sites
Agents check shipment status, book pickups and download invoices across dozens of carrier and supplier portals that each look different.
One status view across every partner site
05RPA bot replacement
Selector-based bots that break whenever a page changes are replaced by agents that understand the screen and adapt to small layout updates.
Fewer broken bots after every UI release
06QA and acceptance testing
Agents follow written test cases in plain language, explore your app like a new user and report bugs with screenshots and steps to reproduce.
Broader test coverage without more scripts
Nine Requests, One Pause, Eight Receipts
The agent observes, acts and checks its own work, and it stops when the screen asks for a person. This is an example run on a payer portal, modeled on real work.
- TaskSubmit the 9 pending prior authorization requests in the payer portal.
- ObserveOpens a sandboxed browser and loads the saved portal session from the vault.
- ObserveReads the New Request form through the accessibility tree and finds all 14 fields.
- ActFills the member ID, procedure and diagnosis codes, then checks the form shows no errors.
- PauseRequest 6 shows a CAPTCHA, so the agent stops and a person steps into the live session.
- VerifySaves a screenshot of each confirmation page as the receipt for that request.
- 07Result8 submitted with receipts and 1 waiting for you in the review queue.
What Makes a Computer-Use Agent Reliable
Seeing a screen is the easy part. Acting on it safely, repeatedly and at scale is where the engineering goes.

- 01Screen understandingScreenshots combined with accessibility trees and DOM data, so the agent finds the right field even when labels or positions shift.
- 02Sandboxed virtual machinesEach session runs in a disposable VM or container with only the apps and network routes the task needs.
- 03Hybrid browser controlDeterministic Playwright steps for stable pages and model-driven actions for the parts that change, which cuts cost and errors.
- 04Credential vaultingLogins and MFA tokens are injected from a vault at run time and never appear in prompts, logs or screenshots.
- 05Human takeoverWhen the agent hits a CAPTCHA, an unexpected dialog or a high-value submit button, it pauses and a person can step into the live session.
- 06Session recordingVideo, screenshots and an action log for every run, so you can replay exactly what the agent saw and did.
- 07Queues and schedulingWork items are queued, retried on failure and spread across parallel VMs, with run windows that respect portal limits.
How a Computer-Use Agent Runs
The model decides what to do next. Everything around it controls where it can act and what gets recorded.
- 01
Work intake
Where tasks come from and where results go.
- Task queue
- Review dashboard
- Email and CSV inputs
- API trigger
- 02
Agent loop
Observes the screen, plans the next action and checks the result.
- Action planner
- Step verifier
- Takeover handler
- Retry policy
- 03
Perception and control
How the agent sees and operates the interface.
- Screenshots
- Accessibility tree
- Playwright
- Mouse and keyboard driver
- 04
Sandbox runtime
Isolated environments created and destroyed per session.
- Virtual desktops
- Headless browsers
- Network allowlist
- Secrets vault
- 05
Evidence and monitoring
Proof of every action and alerts when runs drift.
- Session video
- Action log
- Success rate dashboard
- Cost per task

Two to three weeks
One Portal, Shadow Runs First
We pick the portal that costs your team the most hours, run the agent beside your staff without submitting anything, then switch it on with approvals in place.
Pick Your First PortalWhere Screens Still Run the Work
Every industry has a portal nobody will build an API for. These are the ones we see most.

Healthcare
Payer portals, eligibility checks and practice systems that only open through a browser, worked by agents that stop for a person on anything clinical.
- Prior authorizations
- Claim status checks
- Remittance downloads

Teams That Handed Over the Clicking
“I had the pleasure of working with Sajal Tech on a travel website, and it was an incredible experience from start to finish. They demonstrated professionalism, clear understanding of requirements, and excellent communication throughout.”
Safe Agents on Real Screens
An agent with a mouse can do anything a person can. We narrow that down on purpose.
- Rule 1
Isolation by default
Sessions run in disposable VMs with an outbound allowlist, so the agent can reach the target portal and nothing else.
- Rule 2
Approval on irreversible steps
Payments, submissions and deletions above a threshold wait for a person to confirm in the live session or the review queue.
- Rule 3
Prompt injection defense
Text found on web pages is treated as untrusted data, and instructions that appear on screen cannot change the agent's task or permissions.
- Rule 4
Replayable audit trail
Video, screenshots and action logs are retained per your policy, with sensitive fields masked before storage.
Models and Tooling for Computer Use
We benchmark computer-use models on your actual screens, then pair them with deterministic automation where pages are stable.
Computer-use models
- Claude computer use
- OpenAI computer-use agents
- Gemini
- Meta Muse Spark 1.1
- Qwen Omni
Browser and desktop control
- Playwright
- Chrome DevTools Protocol
- Puppeteer
- xdotool
- Windows UI Automation
Sandboxes
- Docker
- Firecracker microVMs
- AWS WorkSpaces
- Kasm
Orchestration and ops
- LangGraph
- Temporal
- LangSmith
- OpenTelemetry
From Manual Clicks to Supervised Agents
We prove reliability on a small batch of real tasks before the agent handles volume.
3 to 5 days
Screen walkthrough
Record your team doing the task, list every screen and edge case, and decide which steps need approval.
- Task map
- Risk and approval list
- Fixed quote
2 to 3 weeks
Shadow runs
The agent performs real tasks in a sandbox or test account while a person checks each result against the manual process.
- Working agent
- Success rate baseline
2 to 3 weeks
Supervised production
Live tasks with human takeover enabled, queueing, vaulted credentials and alerts on failures or layout changes.
- Live agent
- Review dashboard
- Runbooks
Ongoing
Scale out
Add portals and parallel VMs, move stable steps to deterministic scripts and lower cost per task.
- New portals
- Monthly success report
What Computer-Use Automation Costs
Indicative starting prices. Model and VM usage are estimated per task during scoping, so you can compare against manual effort.
Single-portal agent
One agent automating one repetitive task in one web portal.
From
$2,500
2 to 3 weeks
- Screen walkthrough
- Sandboxed browser agent
- Session recording
- 30 days of support
Multi-system operator
Agents across several web and desktop apps with queues and takeover.
From
$12,000
5 to 8 weeks
- Up to 4 target systems
- Credential vault
- Human takeover and review queue
- Success rate dashboard
RPA migration program
Replace an existing bot estate with supervised computer-use agents.
From
$30,000
3 to 5 months
- Bot inventory and prioritization
- Parallel VM fleet
- Hybrid scripted and AI steps
- Ongoing tuning
Computer-Use AI Questions
It is an AI agent that operates software through its user interface. It looks at screenshots and accessibility data, then clicks, types and scrolls like a person. It is useful when a system has no API or the API does not cover what you need.
RPA bots follow fixed selectors and break when a button moves or a label changes. A computer-use agent understands what is on the screen and can handle small layout changes, new pop-ups and varied inputs. We still use scripted steps where pages are stable because they are faster and cheaper.
For well-scoped tasks, yes, with supervision. We measure task success rate during shadow runs before going live, route uncertain steps to a person and alert on drops in success rate. We do not recommend fully unattended runs for irreversible actions.
Yes. A screen-driven step takes seconds rather than milliseconds, and each step costs model tokens. That is why we use it for systems without APIs and move to an API or scripted step wherever one exists.
Credentials and MFA secrets live in a vault and are injected at run time. Sessions are reused where the portal allows it. When a CAPTCHA or unusual verification appears, the agent pauses and a person completes it in the live session.
That is a real risk called prompt injection. We treat all on-screen text as untrusted, restrict network access to allowlisted domains, keep task instructions separate from page content and require approval for sensitive actions.
We test Claude computer use, OpenAI operator-style agents and Gemini against your real screens and pick per task on success rate and cost. Some workflows use a cheaper model for navigation and a stronger one for reading complex forms.
In your cloud account or a dedicated environment we manage, in the region you choose. Each session uses a fresh VM or container that is destroyed after the run, with recordings stored under your retention policy.
It depends on the number of steps and screens. During shadow runs we measure model and VM cost per completed task, so you can compare it with the time your team spends today before scaling up.
Let's build your next product together
Book a free strategy call and leave with a clear plan and estimate. No commitment.
- 01Pick a time that suits you
- 0230 minutes on scope, stack, timeline and budget
- 03Fixed-price proposal, NDA on request