Review the workflow before repeat use
Compilation turns the recording into explicit steps and checks that your team can inspect before governed replay.
Compared with Playwright, Power Automate, UiPath, and Claude computer use
OpenAdapt vs Playwright vs Power Automate vs UiPath vs Claude computer use
Use this when the repeating GUI write has to stay on your computer: secrets, PHI, credentials, or a delivery you must prove. OpenAdapt compiles a demonstration into a program. The program reports VERIFIED only if an independent check agrees. Later healthy runs make no generative-model API calls. In a 90-run injected-fault study, screen-only checking accepted 54 of 90 wrong results. One out-of-band read of the record cut that to 9 of 90. Read the study
Keep OpenAdapt when the GUI job repeats, the app has no usable API, and the write still needs an independent check. Playwright owns developer-written browser tests. Power Automate owns Microsoft-connected work. UiPath owns a large robot fleet. Claude computer use owns novel tasks that should be re-planned each run. If an API already does the write, use the API.
pip install openadapt
openadapt flow tutorial
A halt looks like this: the screen paints Saved, the independent read disagrees, and the program stops instead of reporting VERIFIED. openadapt quickstart --break-it is that case on a synthetic backend.
Where OpenAdapt fits
Built for consequential work trapped behind a GUI.
The strongest fit is a GUI workflow your team repeats, where the business intent stays stable, a wrong action matters, and a direct integration is not practical.
Keep a reviewed repair
Review a proposed change once. The next healthy run reuses the approved workflow version.
Prove the result
Configured identity and effect checks decide whether the run can report VERIFIED.
Choose the execution boundary
Run locally, in a managed browser, or inside a customer-controlled environment, including on-prem.
Side by side
How each approach behaves once the task is known.
Scroll horizontally to compare all approaches.
| Decision point | OpenAdapt | Traditional RPA | Computer-use agents | Browser recorders |
|---|---|---|---|---|
| Best fit | Repeated, consequential GUI workflows without a practical API | Broad enterprise automation with mature connectors and orchestration | Novel or changing tasks that benefit from reasoning each time | Simple browser workflows and test automation |
| Authoring | Record a task; compile the demonstration | Build selectors, rules, and flowcharts | Describe the goal and configure tools and guardrails | Record steps or write a script or prompt |
| Healthy repeat run | Default deterministic replay; no generative-model API call | Deterministic replay; platform licensing applies | A model plans and acts during agent-mode runs | Fixed or model-driven replay, depending on the tool |
| When the interface changes | Re-resolve from evidence, propose or teach a repair, or halt | Repair selectors and workflow logic | Reason through the changed interface | Repair selectors or let a model re-infer |
| Result contract | Configured identity and effect checks can halt and preserve a report | Depends on configured platform controls | Depends on the agent platform and its guardrails | Depends on the tool and script |
| Execution boundary | Local, managed browser, or customer-controlled, including on-prem | Customer infrastructure or vendor cloud | Local or cloud, depending on the provider | Browser with local or cloud services |
| Interface coverage | Record-compile-verify loop on browser, Windows, macOS, Linux, and RDP. Citrix/VDI needs exact-environment qualification | Mature desktop, browser, and remote-application coverage | Provider-specific browser and screen coverage | Browser only |
Governed failure
Re-resolve, repair, teach, or halt.
OpenAdapt first tries retained evidence. If the interface moved beyond that evidence, it can create a repair candidate or accept a taught correction. Neither becomes active until the required review and checks pass. A failed pre-action identity check halts the run. If delivery might have occurred and the effect cannot be proved, the run returns RECONCILIATION_REQUIRED without a blind retry.
Re-resolve
Find the current target from retained evidence.
Repair
Propose a reusable workflow change for review.
Teach
Record a guarded correction at the halted step.
Halt
Preserve a report when verification fails.
Measured comparison
Screen-only checking accepted 54 of 90 wrong results. One out-of-band record read cut that to 9 of 90.
That is the current method result: a 90-run injected-fault study through the real replayer, graded by a read that bypasses the acting session. A third arm that read every table in the store reached 0 of 90, and that arm is the most instrumented case. The middle rung is the number a deployment ships. Read the study · Method notes
Historical MockMed rows, measured 2026-07-08
On MockMed, compiled replay had a 4.9s median versus 37.5s for the agent. The records include 100 compiled replays and 20 agent runs. Its OCR check marked 100/100 compiled replays and 20/20 agent runs as passes. The final frames were not retained for rescoring under the current stricter verifier. Compiled replay recorded 0 model API calls and incurred $0.00 in estimated model API charges per run. The agent made 13 calls and incurred $0.27 in estimated model API charges per run under the documented pricing basis. Treat these latency and OCR rows as historical. They do not lead this comparison.
Measured 2026-07-08; source checkout declared Flow 0.1.0
The benchmark notes describe a pre-v0.2.0 development checkout. The exact runtime HEAD wasn't retained, so the saved results commit below doesn't identify the source revision used for the run. These figures haven't been re-measured on a later release. Open results commit cbec44c.
7.6× faster
median run: 4.9s compiled vs 37.5s agent
$0 vs $0.27
estimated model API charges per run
0 vs ~13
model calls per run
Compiled $0 in estimated model API charges per run; agent $0.27 per run.
A separate historical field cross-check used the public OpenEMR demo and the corrected saved-row OCR oracle. It counted compiled replay at 19/20 and the agent at 10/10. The field oracle inspected retained final frames. It did not read the stored OpenEMR record. These historical rows do not measure the current engine or production reliability.
MockMed method and rerun instructionsMockMed benchmark recordsOpenEMR field methodOpenEMR benchmark recordsDrift and repair evidence
Use the simplest tool that proves the result.
If an API exists, use the API. Choose traditional RPA when connector breadth and enterprise orchestration matter most. Choose a computer-use agent for novel or exploratory work. Choose OpenAdapt when the GUI workflow repeats and you need a program you can inspect, an independent effect check, and a halt when the check cannot prove the result.
The signed ledger has seven active target admissions. The admitted runtimes include Flow 1.34.0. Evidence class is remote-safe-synthetic. A Production run still needs an admission for the exact workflow version. The public workflow ledger lists seven active synthetic admissions (bundle_version 0.0.0-synthetic, remote-safe-synthetic). That isn't a customer workflow. Native Mac installers stay ad-hoc 0.15.0; use pip. Start locallyStart a sprintSee the ledger
Review execution and deployment optionsRead the practical guide
Specific alternatives
Compare the tool you already use.
Each page starts with the alternative's strengths and compares authoring, verification, outcomes, deployment, and source access.
FAQ
Frequently asked questions
- What is OpenAdapt?
- OpenAdapt compiles a repeating GUI task into a local program so secrets, PHI, and credentials stay on your computer. Use it when you need proof the write landed, later runs should not call a model, or the app has no usable API. You demonstrate a task; it compiles a deterministic local program. VERIFIED means an independent check of the write passed. The default healthy replay makes no generative-model API calls.
- Why not just use the API?
- Use it. If a supported API exposes the operation, that is the right answer, and our own fit checklist says so. OpenAdapt is for the work that only happens through the screen: a legacy desktop or Citrix-delivered application with no API, an API that does not cover the fields this workflow writes, or an API your licensing tier, vendor agreement, or IT approval will not give you. Verification is separate from that. OpenAdapt proves the effect through whichever channel the target system exposes: a read-only API, a database query, a file check, a second session, or reacquiring the persisted state through the interface itself. Proof does not depend on an API either.
- How is OpenAdapt different from RPA tools like UiPath?
- Conventional RPA is broad and mature, especially on Windows, but workflows are usually built around selectors and integrations. OpenAdapt targets the narrower case where work is repetitive and consequential but the interface is visual, variable, or integration-hostile. It compiles a demonstration and uses a resolution ladder under drift instead of asking a model to re-plan every run.
- How is OpenAdapt different from AI computer-use agents?
- A computer-use agent is appropriate for novel work because it can re-plan each run. OpenAdapt is for repeated work: the default healthy replay follows the compiled program locally and makes no generative-model API calls. Under drift, deterministic structure, template, OCR, and geometry evidence run first. An optional model can propose a repair, but it does not make unsupported drift safe and stays subject to configured verification and policy.
- Does “repair” mean every UI change is handled automatically?
- No. A target may be re-resolved deterministically, an optional model may propose a repair, an operator may teach a correction, or the run may halt as unsupported. Available evidence, identity coverage, postconditions, policy, and verifier configuration determine which outcome is allowed. OpenAdapt does not claim general adaptation to arbitrary application changes.
- Does my data leave my machines?
- Self-hosted runs remain local by default. Hosted upload accepts an approved sanitized copy, not the original recording and not an assumption that compilation removed sensitive data. Live screenshots can contain sensitive data again, so they stay inside the declared managed, customer-controlled, or on-prem runtime boundary. See the security page for the exact upload and review controls.
- Can I run locally without paying?
- Yes. Local is $0. No account. Tell the AI you already talk to, "Use OpenAdapt to do this task."
- Do I have to use your hosting?
- No. You don't. Run it on your machine. Desktop, RDP, and Citrix stay on a self-hosted or customer-controlled runtime. Hosted is optional if you want us to run the machine.
- What do I pay for on Hosted?
- The machine. Hosted is $29 / month. The runner is ours. The Seal still comes from the verified run.
- What is Qualification?
- A review that gets a workflow into Enterprise. You send one workflow, one app, and one environment. We reply go or no-go. Start on /qualify.
- Is OpenAdapt in Production?
- You can run the compile-and-prove loop today. Demonstrate the task, compile it, check the effect independently, and get VERIFIED or a halt. The signed ledger has seven active target admissions. Evidence class is remote-safe-synthetic. A Production run still needs an admission for the exact workflow version. The public workflow ledger lists seven active synthetic admissions (bundle_version 0.0.0-synthetic, remote-safe-synthetic). That isn't a customer workflow. Native Mac installers stay ad-hoc 0.15.0; use pip. Start locally, or with a qualification sprint.
- What software does OpenAdapt work with?
- OpenAdapt targets repeated workflows across browser applications, Windows UI Automation, native macOS Accessibility, Linux AT-SPI, RDP, Citrix, and other remote desktop environments. Choose managed browser execution or connect a local, self-hosted, or customer-controlled runtime for desktop, remote, private-system, and regulated workflows.
Test one real workflow.
Measure authoring time, run time, intervention rate, and incorrect-success rate on work your team already repeats.