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

Show it once. It runs forever. On your premises.

OpenAdapt compiles a recorded demonstration into a self-healing automation. Certified workflows halt when identity or effects cannot be verified. It's open source and auditable, and it runs entirely on your own machines.

Every automation tool assumes an API. The systems that actually run your business don't: legacy EMRs, Citrix desktops, the internal apps your team still works by hand. OpenAdapt learns them from one demonstration and runs them where your data already lives. Web workflows are supported today. Windows and Citrix workflows are being validated with design partners.

referral-intake · compiled replaylocal
1.0click'Sign In'template12ms
2.0typeusername8ms
3.0click'Tasks'template9ms
4.0click'Open referral'template11ms
5.0click'Save Encounter'⚠ UI drift detected
healed via geometry — fix saved as reviewable diff
postconditions verified · run complete
total 2.4s  ·  model calls: 0  ·  cost per run: $0.00VERIFIED · 0 MODEL CALLS
Show it once. It runs forever. On your premises.
Compiled replay. Zero per-run model cost.
Self-healing: UI drift becomes a reviewable diff.
On the default path, nothing leaves your machine.

Process

How it works

Record a task once, and get an automation you can run, review, and audit.

  1. 1.0

    Record

    Do the task once. OpenAdapt watches your screen and your clicks.

    OpenAdapt's recorder capturing a real session in a live OpenEMR electronic health record: signing in and opening the patient workflow while every screen and input is captured.
    Record — real footage · driving a live OpenEMR instance
  2. 2.0

    Compile

    Your recording becomes a script you can read, edit, and reuse.

    The recorded demonstration compiled into an editable script: visual anchor targets, a per-step assertion, and a parameter.
    Compile — crafted annotation over a real recorded frame
  3. 3.0

    Run

    It replays in milliseconds on your own machine, with no AI cost per run.

    OpenAdapt replaying a compiled workflow against a live OpenEMR electronic health record, locally and with no per-run model calls.
    Run — real footage · driving a live OpenEMR instance
  4. 4.0

    Self-heal

    When the app changes, it finds the button again and shows you the fix to approve.

    OpenAdapt replaying against a drifted UI: the fallback ladder still finds each target and proposes the anchor fix as a reviewable diff.
    Self-heal — real footage · driving our MockMed demo app
  5. 5.0

    Audit

    Every run leaves a step-by-step report: what it did, what it saw, what changed.

    The illustrated run report OpenAdapt produces for every run: what ran, what it saw, and what changed, with per-step screenshots.
    Audit — real footage · driving our MockMed demo app

MockMed benchmark · reproducible · cost and latency

5s vs 37s
typical run: OpenAdapt vs an AI agent
$0 vs $0.27
AI cost per run (agent priced at list rate)
0 vs 24
AI calls per run: none on a healthy OpenAdapt run

The same clinical task, run both ways on MockMed, the demo app that ships with openadapt-flow so anyone can reproduce these numbers exactly (100 OpenAdapt replays vs 20 agent runs). Both passed the same independent check every time. So this is a gap in cost and speed, not in reliability. The agent cost is list price; an introductory rate lowers it through 2026-08-31.

We also ran it on the live OpenEMR public demo (N=10 agent runs, both passed 100%). It runs on a shared instance that resets daily, so you cannot reproduce it exactly. Treat it as cost and speed only. It says nothing about reliability on a real EMR.

Safety

Certified workflows halt instead of guessing.

Certified workflows halt when identity or effects can't be verified, flagging a person rather than writing to the wrong record. We built an adversarial test suite to measure how often it could still pick the wrong target, put our own engine through seven rounds of it, and publish every result, including what it gets wrong today.

Featured on There's An AI For That

Industries

Built for regulated back-offices

Record the workflow once and OpenAdapt turns it into an automation your team can run, review, and audit, all on your own machines. Nothing brittle to hand-build. No AI cost per run.
Built-in PII/PHI scrubbing keeps your sensitive data safe.

Healthcare clinics

Healthcare clinics

  • Referral and fax intake, EMR data entry and extraction; web EMRs today, desktop and VDI EMRs on the roadmap. PHI handling stays fully local.
Mortgage & lending ops

Mortgage & lending ops

  • Loan-file data extraction and entry; desktop LOS like Encompass on the roadmap. Borrower data stays in your environment.
Other regulated back-offices

Other regulated back-offices

  • Document-heavy, compliance-bound workflows. Tell us yours.

Let us build for you

If OpenAdapt doesn't fully automate your workflow out of the box, we'll work with you to fix that.

Start Intake

Running the same workflow hundreds of times on software you can't API into?

We're taking a small number of healthcare and lending pilots. OpenAdapt v1 is open source and under active development.

Book a pilot →

Pricing

Priced on the outcome, not the click

The engine is open source and free. When you need it in production, the AI is included in the price: no per-step, per-seat, or per-call metering. On-premises keeps your data in your building.

Open Source

FreeMIT

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

  • Record → compile → replay, fully local
  • Self-healing scripts, reviewable as diffs
  • Self-host for full auditability
  • The engine is MIT and always will be
View on GitHub

pip install openadapt

Managed onboarding

Hosted

$500/mo · up to 10,000 runs

For teams without on-prem hardware who want a managed cloud runner. We onboard you personally to start; the self-serve runner is rolling out.

  • We set you up personally, nothing for you to run
  • Up to 10,000 workflow runs a month
  • Hosted inference included at no extra cost
  • No per-step or per-seat billing, no surprise charges
Working with PHI or PII? Enterprise runs OpenAdapt inside your own environment, so regulated data never enters our infrastructure.
Recommended

Enterprise

Talk to us

For regulated teams in healthcare, lending, and other compliance-bound back-offices.

  • On-prem, or managed by us inside your own cloud (single-tenant), so PHI never enters our infrastructure
  • Inference runs on your hardware at zero metered cost
  • Pilot first, then an annual platform license
  • On-prem architecture built for BAA and SOC 2 requirements; formal attestation in progress
  • Audit trail: every run writes an illustrated report
  • Self-healing and fleet management included
Read our security posture: on-prem data handling, what is and isn't certified yet, and how to report a vulnerability.
Book a demo

Pilot

Start with one workflow, live in 30 days.

Pick one high-value, repetitive task. You demonstrate it once and OpenAdapt compiles it, so it is live in days, not a multi-week integration project. We agree one success measure up front and get it running end to end with checks that confirm it did the right thing. If it doesn't hit that measure, you pay nothing.

$10,000$15,000
Founding pricing, for our first design partners
credited toward your first-year license
Book a call to scope a pilot

Scope and price are confirmed before we begin. Full refund if the success criteria we agree up front aren't met.

We price the outcome and the compliance, and include the AI in that price. No per-step, per-seat, or per-call charges anywhere.

Open source

MIT licensed. Install it and read the code.

OpenAdapt is open source. Record a workflow once and it becomes a self-healing automation that runs on your own machines, with no AI cost per run.

Install in 30 seconds

One command installs everything you need. No Python setup required.

Install
$curl -fsSL https://openadapt.ai/install.sh | sh
Installs uv and OpenAdapt, then you run openadapt. Intel and Apple Silicon Macs. View the script

The full loop, in five commands

Try the whole loop right now against the bundled demo app: record, compile, replay, heal. No account, no 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.

curl -fsSL https://openadapt.ai/install.sh | shInstall 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 replay bundleReplay it locally, with zero AI calls
openadapt flow replay bundle --drift themeChange the UI and watch it heal itself

Every replay writes a step-by-step run report: what ran, what it saw, what healed. Source on GitHub. Running this on your own desktop workflows in a regulated environment? Book a demo.

PyPI Download Trends

Historical download statistics for OpenAdapt packages

8Packages
View:
Range:
Loading statistics...
Data sourced from PyPI OpenAdapt packages via pypistats.org API (data retained for ~180 days)

FAQ

Frequently asked questions

What is OpenAdapt?
OpenAdapt is an open-source tool for automating desktop work. You do a task once while it records you, and it turns that recording into a script that runs on your own machines and repairs itself when the screen changes. A healthy run makes no cloud AI calls, so it costs nothing to run.
How is OpenAdapt different from RPA tools like UiPath?
With traditional RPA, someone hand-builds the automation, and it breaks when the screen changes. With OpenAdapt you just record the task once. When the screen changes, it fixes itself and shows you the change to approve. And it runs entirely on your own machines.
How is OpenAdapt different from AI computer-use agents?
An AI agent works out your task from scratch on every run, so it is slow, unpredictable, and charges you each time. OpenAdapt learns the task once and replays it locally for free. Healthy replay makes zero model calls. When the screen changes, deterministic fallbacks (template, OCR, geometry) handle many UI changes, and an optional local model assists the rest.
Does my data leave my machines?
In a self-hosted or bring-your-own-cloud deployment, no. Recordings, scripts, and replays all live on your own machines, and healthy replay makes zero model calls. When the screen changes, deterministic fallbacks (template, OCR, geometry) handle many UI changes; an optional model can assist the rest, and you can run that model on your own hardware inside your network, so PHI never enters our infrastructure. Tools for scrubbing PII and PHI are included, so you can clean captured data before anyone or anything sees it.
Is OpenAdapt free?
Yes. OpenAdapt is MIT-licensed open source, free to use and modify. For regulated teams in healthcare and lending, we also run paid pilots with hands-on support: we help build your first workflows, set up review, and keep the automations running. Book a demo to talk about a pilot.
What software does OpenAdapt work with?
OpenAdapt works from what is on the screen, not from an API or browser internals. Today it handles web apps, including web EMRs. Because it works from the screen, the same approach can reach desktop apps and software delivered over Citrix or remote desktop. Those adapters are in progress. The goal is to automate the desktop EMRs and loan systems that cloud tools can't touch, with no API integration project.

Book

Book a 15-minute automation fit call

Tell us your highest-friction workflow and we'll map what can be automated first.

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

Register for updates (we promise not to spam)