uvx --python 3.12 openadapt quickstart --break-it

No account or API key. uv
fetches Python 3.12 if you need it; with Python 3.10 to 3.12 already installed,
python -m pip install --upgrade openadapt then openadapt quickstart --break-it
does the same.

What the quickstart shows

The command runs a synthetic clinic task twice on your computer. The first run
saves an entry and confirms it through the app's read-only API. For the second
run, the test server is set up to reject the save, so it never reaches the
record. This is the output from openadapt 1.17.0, with the break-it lines in
the current wording:

[1/5] Record the demonstration against a real persistence boundary
[2/5] Compile and propose a fixture-specific effect contract
[3/5] Certify against the clinical-write policy
[4/5] Admit and execute under the standard profile
      VERIFIED in 5.6s; 0 model calls; the system of record holds 1 record(s)
[5/5] Emit the local run receipt
...
--- break-it: the same certified bundle, with the save set to fail ---

  Injected fault:      'optimistic' -- the server rejects the write
  On screen:           every on-screen check passed, including the saved message
  The verifier found:  1/2 declared effect(s) REFUTED by an independent
                       read of the system of record, which holds 0 record(s)
  The engine did:      HALTED at the consequential step instead of claiming
                       success (transaction: RECONCILIATION_REQUIRED, billable: no)
  Result:              Check the record. A save may have gone through. A person checks the record before anything is retried.

The quickstart tutorial walks through every line.

How it compares

An agent and OpenAdapt also work together: the agent decides what to enter,
and OpenAdapt makes the entry and checks it.

How it works

flowchart LR
    S["Show the task"] --> C["Compile"] --> Q["Certify and qualify"] --> A["Admit"] --> R["Run with checks"]
    R -.->|"stopped: show the fix"| C

OpenAdapt works from the screen, so it runs where there's no usable API: web
apps, native Windows, macOS and Linux apps, and RDP and Citrix windows. A
person or an agent shows the task. The compiler turns one or more
demonstrations into a program, and qualification runs it against your normal
and fault cases before an admission lets that exact version run. At each save
the program checks that the right record is on screen, makes the entry, and
reads the record back.

Run outcomes

The console's last line can read HALTED for both the second and third rows.
transaction_outcome in report.json tells them apart, so base every rerun on
it. Run outcomes lists every value.

Automate your own workflow

python -m pip install --upgrade openadapt
openadapt flow record --url https://staging.your-app.example --out rec
openadapt flow compile rec --out bundle --name my-first-workflow
openadapt flow replay bundle --url https://staging.your-app.example --run-dir run

replay drives the app at --url and performs every recorded action,
including saves you can't undo. It doesn't ask first and doesn't check the
saved record. Point it at a test or staging copy, never at production data.

A program that writes to a real system also needs record checks, a deployment
file, certification, qualification, and an admission; then openadapt flow run
runs it. The operator sets each run's approval mode: by default the run waits
for a person to approve each save in OpenAdapt Desktop, and with not_gated it
doesn't pause and the report says so. Your first workflow walks through it.

To record a desktop app, install the recorder and your operating system's
adapter, for example python -m pip install "openadapt[capture,windows]", or
use OpenAdapt Desktop. An agent can record
too, through the MCP server's recording tools; on Windows, RDP and Citrix that
support is on main and not yet released.

Give a workflow to an AI agent

claude mcp add openadapt -- uvx --python 3.12 openadapt-agent serve

With no bundles, the server offers a synthetic sandbox workflow that returns
every outcome. To serve your own compiled workflows, run
openadapt agent serve --mode production --bundles ./bundles; without
--mode production the agent can list them but not run them. Each workflow is
one tool call, and the agent gets an outcome back instead of driving the
screen. Connect an agent covers other clients.

Measured so far

On a local OpenEMR 8.0.0.3 test copy with synthetic referrals (14 and
15 October 2026), OpenAdapt and a Claude computer-use agent each entered
referrals in 62 timed runs. Median time was 29.7 seconds for OpenAdapt and 36.5
seconds for the agent. OpenAdapt made no model calls; the agent cost about
$0.08 a run at list price. Both saved 62 of 63 normal referrals correctly,
judged by the same database read-back, and the agent matched or beat OpenAdapt
in three other tests. Every result
is published. OpenAdapt isn't affiliated with the OpenEMR project.

In a fault test through the real replayer, 72 of 90 runs left a wrong record
behind a success screen. A check of the success banner reported success on 54
of those 72; a full read of the database caught all 72. How a save is checked has the method.

Each application on each surface needs its own qualification.
Surfaces and Limits
have the details.

Packages

pip install openadapt installs the openadapt command, the engine, and the
MCP server. The product packages live in this repository:

Research on GUI agents lives in separate repositories:
openadapt-evals (benchmarks)
and openadapt-ml (model
training). The packages map has the full list.

Security and procurement

Screens, typed values, and recordings stay on the computer or runner that runs
OpenAdapt. The shareable receipt and the Cloud dashboard hold counts, digests,
and closed values. A sanitized copy leaves only after a person approves it, and
screenshots go to a model host only if you turn on model grounding.
Security & procurement covers data handling, deployment
boundaries, evidence, subprocessors, and release integrity. Plans are on the
pricing page.

The block below is generated from the signed public lifecycle record.

The signed ledger has seven active target admissions. Their evidence class
is remote-safe-synthetic, not MockMed production_acceptance. They remain
valid until revoked; there's no expiry date. pip install openadapt is the
admitted runtime (launcher 1.16.0, Flow 1.35.1). Desktop's admitted artifact
is the 0.16.0 wheel. Native Mac DMGs stay ad-hoc signed 0.15.0; don't treat
those as admitted. A Production run still needs a workflow admission for the
exact compiled bundle, application, and environment.
Check the live signed Production record.

Earlier versions

The pre-1.0 version (v0.46.0) is frozen under
legacy/.
docs/LEGACY_FREEZE.md
explains how to install it and how to migrate.

Contributing

Launcher, engine, MCP server, and contract changes all belong in this
repository; engine changes go in packages/flow/.
Contribution guide ·
Issues ·
Discussions ·
Report a vulnerability

Maintained by OpenAdaptAI under the
MIT License.