OpenAdapt.AI
LOCAL-FIRST · MIT OPEN SOURCE1.6k stars on OpenAdapt· 258 forks

Compile repeated GUI work. Verify the result. Halt when you can’t.

Demonstrate a repeated GUI task once. OpenAdapt compiles it into a local program that makes no model calls on a healthy run. The same governed loop runs across every interface your work is trapped behind — browser, Windows, macOS, RDP, and Citrix — as one product. When the screen changes, it re-checks its evidence and either repairs the step or stops for a person instead of guessing. See how it runs across every interface.

Purpose-built for repeated, high-stakes GUI work that has no clean API and can be checked against an independent source of truth.

Hosted runs in minutes · or run it entirely on your own machine · zero per-run model cost · deterministic replay you can audit

Read the technical paper

app.openemr — referral-intakeillustrative
BrowserWindowsmacOSRDPCitrixone loop
1.0click'Sign In'template12ms
2.0typeusername8ms
3.0click'Tasks'template9ms
4.0click'Open referral'template11ms
5.0click'Save Encounter'⚠ UI drift detected
re-resolved via geometry — anchor update saved as diff
postconditions verified · run complete
total 2.4s  ·  model calls: 0  ·  cost per run: $0.00VERIFIED · 0 MODEL CALLS
Illustrative — a stylized depiction of a compiled replay, not captured benchmark data. See measured results.

How it works

A demonstration becomes a reviewable program

Three steps, one governed loop. Healthy replay is deterministic; model spend is reserved for compilation or repair.

  1. 1

    Record & compile

    Demonstrate one bounded, repeated instance. OpenAdapt compiles the trace into a reviewable, parameterized program — not a prompt a model reinterprets each run.

  2. 2

    Replay deterministically

    Healthy runs execute the compiled steps locally with zero model calls, so repeat runs are fast and cost nothing per run.

  3. 3

    Resolve, repair, or halt

    Under interface drift, deterministic evidence re-finds the target, an optional model proposes a governed repair, or configured verification halts and preserves a run report.

Real reference workflow

From demonstration to verified Frappe write

Synthetic local data, real Frappe Lending interactions, and an oracle outside the replay path.

Reference workflow

Each reference is a bounded, synthetic fixture with its own honest evidence and caveats.

  1. 1.0

    Demonstrate

    Complete one bounded, synthetic instance while OpenAdapt captures the browser evidence and input events.

    Captured Frappe Lending frames showing a synthetic loan application demonstration being completed and saved.
    Demonstrate — captured Frappe Lending frames · synthetic local fixture
  2. 2.0

    Compile

    Turn the demonstration into a parameterized, inspectable workflow with a declared business effect.

    workflow.jsoncompiled
    workflow
    create-loan-application
    parameters
    email · phone · product · amount · term
    target
    Loan Application form
    effect
    exactly one matching record
    healthy run
    deterministic · zero model calls
    Compile — inspectable task contract derived from the recorded synthetic workflow
  3. 3.0

    Replay

    Execute the compiled steps locally without asking a model to reinterpret the task.

    OpenAdapt deterministically replaying the compiled synthetic loan application workflow in Frappe Lending.
    Replay — real compiled run · local, model-free, independently checked
  4. 4.0

    Verify the write

    Check the saved record through a separately authenticated read-only session and a direct database delta audit.

    independent effect evidenceverified
    • REST readbackexact fields matched
    • SQL delta+1 Loan Application
    • Collateral auditnon-target digest unchanged
    • Execution6/6 compiled trials correct
    0 silent incorrect successes0 over-halts0 model calls
    Verify — three baseline and three cosmetic-drift compiled trials; scoped to the pinned local reference environment.

Frappe Lending v16.2.0, Frappe v16.27.0, and ERPNext v16.27.0 were pinned in a local fixture with fictional values. The six compiled trials cover one task on one environment under baseline and cosmetic-drift conditions. OpenAdapt is unaffiliated with Frappe Technologies Pvt. Ltd.; Frappe is its registered trademark.

Inspect evidence manifest

More reference workflows

Each reference is a bounded, synthetic fixture with its own honest evidence and caveats. Select one to preview it above.

OpenOpenOpen

Want the full method and evidence? Read the technical paper.

OpenAdapt Cloud

From approved workflow to reviewable outcome.

Explore how workflows, runs, evidence, and reports stay connected across three real reference applications.

OpenAdaptCloud
Reference workflows

Healthcare reference

OpenEMR

Patient note entry

Reference workflow

Patient note entry

Compiled

A demonstrated OpenEMR task compiled into an inspectable, governed workflow.

Workflow
openemr-browser-reference
Inputs
Workflow-defined parameters
Target
Bounded OpenEMR browser task
Effect contract
One matching note persisted
The OpenAdapt Cloud workflows list opening the synthetic OpenEMR workflow: approved bundle versions and run history in the real dashboard.Real OpenAdapt Cloud app · synthetic OpenEMR workflow
Interactive product preview · no live backend dependencyReference workflows using synthetic records

UI drift

What “repair” means, and where it stops

OpenAdapt is not an unconstrained agent. Drift ends in one of four explicit outcomes, each visible in the run report.

Automatic

Deterministic re-resolution

Structure, templates, OCR, and geometry try to re-find the recorded target. No model is required. A changed anchor is saved as an auditable bundle diff.

Optional

AI-assisted proposal

If deterministic evidence is insufficient and a model is configured, it can propose a target or confirm limited visual state. The model can be wrong; identity, policy, and postcondition gates still decide whether execution continues.

Operator path

Human teaching and resume

A halt produces evidence for an operator. The CLI can teach a correction, and durable mode can checkpoint verified progress for authenticated approval and resume.

Unsupported drift

Refuse instead of improvise

If no configured path can establish the target or expected result, the workflow stops. OpenAdapt does not claim general adaptation to arbitrary application changes.

Availability and refusal depend on retained evidence and configuration. Identity checks cover armed steps only; system-of-record verification requires declared effects and a configured verifier. Read the measured limits.

From demonstration to operation

One governed workflow, end to end

OpenAdapt turns a demonstration into an inspectable workflow that moves from local development to governed operation without changing the workflow model.

  1. 01

    Capture the workflow

    Demonstrate a bounded, repeated task, including the evidence OpenAdapt needs to identify targets and verify outcomes.

  2. 02

    Compile and policy-check

    Turn the demonstration into an inspectable program with parameters, target evidence, postconditions, and an explicit OpenAdapt certification policy.

  3. 03

    Run through the governed gate

    The fail-closed run gate rechecks the exact bundle and selected policy. Healthy replay makes no model calls and produces structured evidence.

  4. 04

    Resolve change under governance

    Re-resolve from retained evidence, propose a reviewable repair when needed, and stop when configured verification fails.

One execution model across your stack

Built for the interfaces your work depends on

From modern browser apps to legacy Windows and remote desktops, workflows stay inspectable, policy-bound, and governed by explicit verification.

Web applications

Compile DOM, accessibility, visual, and interaction evidence into deterministic browser workflows.

Windows applications

Use structured UI Automation with retained visual evidence to operate legacy desktop applications.

RDP, Citrix & VDI

Carry the same policy, verification, repair, and audit model into remote application environments.

Every interface, first-class

One governed loop across every surface

Every surface below runs the same governed loop, with its label read directly from a single machine-readable status manifest so the website, docs, launcher, and packages stay in lockstep.

  • Browser

    Supported

    Record, compile, and replay browser workflows end to end. Healthy runs make no model calls, and identity, effect, and policy coverage are enforced per bundle before anything executes.

  • Windows / macOS / RDP

    Supported

    Operate native Windows, macOS, and RDP applications under the same governed loop: structured UI Automation and accessibility evidence, effect verification against an independent oracle, and fail-closed halting when verification does not pass.

  • Citrix / VDI

    Supported

    Run the governed loop across Citrix and VDI environments with a pixel-and-evidence safety floor. Identity, effect, and policy checks and halt-on-uncertainty carry into remote application delivery.

  • Hosted Cloud

    Supported

    The managed control plane runs your approved workflows across every substrate with run history, reporting, usage, and governed updates, backed by live billing. Runtime data handling and customer-controlled boundaries are configured per deployment.

Current components: launcher openadapt 1.7.1 · openadapt-flow 1.19.0 · desktop 0.6.2

Choose the execution boundary

Local engine

Build, inspect, and run qualified workflows on your own infrastructure with the MIT-licensed engine.

View the engine

Managed cloud execution

Operate approved workflows across every substrate through the managed control plane with run history, reports, usage, and governed updates.

See hosted options

Customer-controlled deployment

Keep runtime data inside a qualified customer boundary when the workflow involves regulated data, private systems, or deployment-specific effect checks.

Review the security boundary

Every production workflow is qualified against its target application and environment. Technical teams can review the qualification evidence, engine limits and hosted architecture.

Ways to start

Run it yourself, subscribe, or start a pilot

Run the MIT-licensed engine yourself for free. Subscribe to OpenAdapt Cloud — the managed control plane that runs your approved workflows across every substrate with assisted onboarding. Or start a scoped paid pilot to bring regulated data and customer-controlled deployments under the same governance.

Open Source

FreeMIT

For builders and self-hosters who want it running on their own machines.

  • Browser artifacts stay local unless you explicitly push
  • Deterministic re-resolution with auditable diffs
  • Policy certification, fail-closed run gate, and reports
  • MIT-licensed engine and CLI
Try locally

pip install openadapt

Supported

OpenAdapt Cloud

$500.00/month

OpenAdapt Cloud

Up to 10,000 workflow runs/month

The managed control plane for governed workflow execution across every substrate. Your approved workflows — browser, Windows, macOS, RDP, and Citrix — run in the managed runner with run history, reporting, and governed updates. Onboarding is assisted: we qualify the first workflow with you.

  • Managed runner for approved workflows across every substrate
  • Deterministic healthy replay with zero model calls
  • Run history, failure reports, usage, and governed updates
  • Sanitized uploads admitted under declared policy
  • Price and billing period confirmed in Stripe
Hosted upload accepts an approved sanitized copy, not the original recording. Live screens can contain sensitive data again; workflows that expose PHI require a separately qualified customer-controlled boundary. Review the security boundary.

By subscribing, you agree to the Terms of Service and acknowledge the Privacy Notice.

Design partner

Scoped pilot

Scoped paid pilot

Priced after qualification

Bring regulated data and customer-controlled deployments under the same governed loop. We qualify the artifact policy, effect oracle, and operating model with you inside your controlled boundary, then scope and price the pilot before production use.

  • Qualify the safety boundary and effect oracle first
  • Scope one workflow and one measurable outcome
  • Execute in the customer-controlled environment
  • Identity and effect checks configured per deployment
  • Sanitized derivatives may cross approved boundaries
  • Runtime PHI remains in the trusted execution environment
  • Deployment, support, and compliance terms documented in scope
Read our security posture: on-prem data handling, what is and isn't certified yet, and how to report a vulnerability.
Evaluate a workflow

The hosted subscription price shown above comes directly from Stripe and is confirmed again at checkout. Regulated deployment and service terms are scoped separately.

Is this the right tool?

Use APIs first. Use OpenAdapt for the UI-only last mile.

OpenAdapt is deliberately narrow. It’s for repeated, high-stakes GUI work that has no real API and can be checked against an independent source of truth.

When OpenAdapt fits

  • The work repeats and the business intent stays stable.
  • A wrong action matters, so a run has to be verified or halted.
  • There's no practical API for the last mile, so it's UI-only.
  • An independent oracle (REST, SQL, export) can confirm the effect.

When work fits that shape, OpenAdapt runs it across every interface it touches — browser, Windows, macOS, RDP, and Citrix — under one governed loop. See how it compares with RPA, computer-use agents, and browser recorders on the comparison page.

Workflow qualification

Book a 30-minute automation fit call

Tell us the substrate, repetition, consequence of error, data boundary, and current verification path. We'll tell you whether it fits managed cloud execution or a customer-controlled deployment, and how we'd qualify it.

You'll hear back from a founder within one business day.

Open source

MIT licensed. Install it and read the code.

pip install openadapt is the stable end-user entry point. The openadapt-flow engine records a workflow, compiles it into a reviewable program, and replays it locally with no model calls on a healthy run.

Install the OpenAdapt workflow CLI

One command installs the OpenAdapt launcher and governed workflow compiler. The same CLI records, compiles, and replays across browser, Windows, macOS, RDP, and Citrix under one governed loop. No account or hosted service is required.

Install
$pip install openadapt
Installs the OpenAdapt launcher and compiler for Python 3.10+ on Windows, macOS, or Linux. Run the engine under openadapt flow. For isolated command-line installs, the docs also cover uv tool. Read docs

The end-to-end workflow loop

Try the whole loop right now against the bundled demo app, which runs in the browser: record, compile, inspect, certify, replay, and induce known test drift. No account or cloud service. Once it is installed, your workflow data stays on your machine. One heads-up on first run: the first demo-record or replay downloads a bundled Chromium (~150 MB) once, so that step takes a few minutes, and on Linux you may need playwright install-deps first.

pip install openadaptInstall OpenAdapt
openadapt flow demo-record --out recRecord yourself doing the task
openadapt flow compile rec --out bundle --name my-taskTurn the recording into a workflow
openadapt flow lint bundleInspect identity, assertion, and risk coverage gaps
openadapt flow certify bundle --policy clinical-writeThe clinical gate refuses this demo bundle and exits non-zero — on purpose. Safeguards refuse instead of guessing. Re-run with --policy permissive to see a clean pass.
openadapt flow replay bundleReplay it locally, with zero AI calls
openadapt flow replay bundle --drift themeExercise deterministic re-resolution on bundled test drift
pip uninstall openadaptRemove the launcher when you are finished

Every replay writes a step-by-step run report: what ran, what it saw, what re-resolved, and what halted. Compiler/runtime source and measured limits are in the openadapt-flow engine. Evaluating a regulated workflow? Evaluate a workflow.

Product updates and hosted launch information. This does not create an account or promise access.