Give your agent a program, not a mouse.

Your agent, or a person, does a task once in an app. OpenAdapt compiles that run into a program your agent can call. A healthy run of the program makes no model calls. The program checks the record before it saves, reads it back afterward, and stops when a check fails.

OpenEMR test copy · Referral 40 model calls
OpenEMR during referral 4, step 28: Click Create New Patient
Stopped before savingOpenEMR listed a possible duplicate where the recording had none. No chart was created.Open its Seal

The program29 steps, compiled from one recording

Name

Date of birth and sex

Address

Phone, email and country

Create the chart

  1. Saved and checked 11 of 11 fields read back
  2. Saved and checked 11 of 11 fields read back
  3. Saved and checked 11 of 11 fields read back
  4. Stopped before saving Possible duplicate patient
Screenshot of each step from four real runs on a test copy of OpenEMR with synthetic patients, 20 Oct 2026, sped up. Select a referral or a step to jump to it; select an outcome to open that run’s signed Seal.

The program stopped before saving
a possible duplicate patient

The program expects the screen it saw when it was recorded. On referral 4, OpenEMR listed a patient who might be the same person, so the program created no chart and left the decision to a person.

OpenEMR after referral 1: the new patient's chart, created by the program
Screenshot · referral 1 · synthetic patientSaved, then read back from OpenEMR11 of 11 fields match the referral.Open its Seal
OpenEMR during referral 4: a possible-duplicate list with one matching patient, and the button to confirm a new chart, which the program did not press
Screenshot · referral 4 · synthetic patientStopped before savingAt “Click Create New Patient”, OpenEMR found a matching chart. No duplicate was created.Open its Seal

The same kind of stop on an earlier run of the referral program, filmed.

Real recordings, sped up. Synthetic patients.

The program it compiled

OpenAdapt compiled a recorded referral into 29 fixed steps that run once per referral. Watch four runs go through them; the fourth stops at a possible duplicate.

Compiled programNew patient from a referral · OpenEMR test copy
Run trace bound · 4 referrals, recorded
Ready
Compiled topology31 nodes · 31 exact edges · 7 cards
declared loopnot confirmed
  • For each referral in the list to Name (loop body: declared loop)
  • Name to Date of birth and sex (sequence)
  • Date of birth and sex to Address (sequence)
  • Address to Phone, email and country (sequence)
  • Phone, email and country to Create the chart (sequence)
  • Create the chart to For each referral in the list, returns to an earlier step (sequence)
  • For each referral in the list to Every referral done (sequence)
  • Create the chart to Stop the run (exception: not confirmed)

The map follows the emitted edge targets. It keeps each loop and exception route visible.

Recorded on a test copy of OpenEMR with synthetic patients. This public view of the program leaves out the recorded values.

It reads the saved record back

On a test copy of OpenEMR, Claude Sonnet 5.5 entered referrals on its own with computer use while we made some of the saves fail in the database. The agent reported each failed save as done. Reading the records back from the database caught 25 of the 30 failed saves, and it confirmed the 5 that saved correctly. The table shows each kind of failure.

30 of 30
bad saves the agent reported as done
25 of 30
caught by reading the record back
0
false alarms on clean saves
Injected fault, 5 times eachThe agent saidThe read-back found
A field blanked
A value changed
A duplicate chart
The save never landed
Another chart deleted
Another chart edited
Clean saves

Reported as done Caught as a bad save Confirmed as saved correctly Not caught

The 5 it missed edited a different patient’s chart. A later version of the check caught all 5 on rebuilt runs. Claude Sonnet 5.5 computer use alone, synthetic patients, faults injected only in the test database, 19 Oct 2026. See the runs

$0 in model fees per run. The compiled program calls no model and sends no screens anywhere.

Watch it catch a bad save on your computer

This command takes about a minute. It runs a clinic app with synthetic records on your computer, makes an entry that saves, then a second whose save fails on purpose, and shows you OpenAdapt stopping. You don’t need an account, and the records aren’t uploaded.

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

For teams building AI agents

Your agent supplies the values, and the program enters them in the app

Your agent picks a compiled program by name. The program types the values into the app and reads the record back. The outcome it returns is done and checked, stopped before saving, check the record, or didn’t run.

YouEnter today’s 25 referrals.

AI agent

Ready

0/25
Enter referralTaught · 41 steps
View call
enter_referral(
  fname: "Nadia",
  lname: "Brennan",
  DOB: "1971-04-19",
  …
)

OpenAdapt step 0 of 41

Screens sent to a model
0
Model cost
$0.00

The agent passes the fields and gets back a status. It never sees the screen, and no vision model is called for the clicks.

Sped up, with synthetic patients. Agent + OpenAdapt: one call to the compiled program per referral, $0 and 0 screenshots. Agent alone: Claude Sonnet 5.5’s real runs for the same patients, with each screenshot, click and cost. Both show 7 real runs from 14 Oct, repeated to fill 25.

Start with two commands

Serve your compiled programs to Claude Code or another agent client, where they appear as workflows, or compile your own agent’s run into a program.

Call programs from your agent

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

Adds OpenAdapt to Claude Code. Without your own workflows, it serves a simulated sandbox workflow that returns any of the four outcomes on request.

Compile your agent’s run

from openadapt_flow.jit import compile_agent

jit = compile_agent(my_agent, task=task, app=app, verifier=verifier,
                    policy="clinical-write", cache_dir="jit-cache", model_key=key)
jit.run(note="Follow up in two weeks")    # the agent does it; a draft is saved
# a person reviews, runs the canary, and admits the draft
jit.run(note="Recheck knee in ten days")  # the program runs: 0 model calls, save read back

Your agent does the task once on your own model key, and a person reviews the draft program and admits it for use. After that, the program runs in place of the agent.

For regulated settings, such as healthcare and insurance

OpenAdapt runs on a computer you control

It signs in to your system from that computer and doesn’t send your records anywhere else. It is meant for work where a wrong entry in the system of record is costly, such as a clinic’s charts or an insurer’s claims.

A person decides each save
By default, the program pauses before a save and sends a picture of exactly what will be saved to a phone or the desktop. The person can save it or stop it.
The record is read back
After a save, OpenAdapt checks the saved fields in your system through a separate read-only login that your IT team creates.
The run report is signed
The report lists what the run did, and its signature can be checked in a browser.

Recorded 18 Oct 2026 from OpenAdapt Desktop's phone page. The connection to the computer is simulated for this recording; the picture on the card is a real frame from the referral run at the top of this page.

Describe the task, not a record. Don't enter patient data or personal information, such as names, dates of birth, or phone or record numbers. You get a page with a brief for your AI and the install steps. We keep the job text to see what people ask for.

Our test runs and results, with their evidence

The test runs on this page, the processes we have shown OpenAdapt and our tested results are published with their evidence. They use test systems and synthetic records. Your own runs are private to you.

Each run ends with a signed report you can check

When a run ends, OpenAdapt writes a report of what it did and signs it with a key on the machine that ran it. That signed report is its Seal, and each mark on the Seal is a step or check from the report. If any byte of the report changes afterward, the signature check fails. The Seals shown here come from runs on a test copy of OpenEMR with synthetic patients.

Referral 1 · SealSaved and checked4 runs3 saved and checked1 stopped before savingOpen the Seal and check it in your browser →

The signature comes from the machine that did the work. It shows that the report hasn't changed since the run; it doesn't grade the run.

Pick a data-entry task your team does by hand every day

Local free, on your own computer · Team $499 a month · Enterprise qualification sprints from $15k. Pricing · It runs on a computer you control, and your records stay there. Security

Sources

  1. OpenAdapt scoreboard, the agent's claims versus the read-back, run openemr_referral/2026-10-19-a (SCOREBOARD.md). Claude Sonnet 5.5 did the entry alone with computer use, on a local OpenEMR test copy with synthetic patients. We injected faults only in the test database, in these ways: a field blanked, a value changed, a duplicate chart, a save that never landed, another chart deleted, and another chart edited. Each fault had 5 items, and there were 5 clean items as well. The agent claimed success on all 30 bad saves. verify-run caught 25 of the 30. It confirmed 5 of 5 clean saves, with 0 false alarms. The 5 misses were edits to another chart, and a later version of the check caught those on rebuilt state (5 of 5). The runs weren't timed.
  2. OpenAdapt quickstart with --break-it (openadapt launcher 1.17.0), MockMed synthetic clinic app, 18 Oct 2026 (the run's reports): the normal entry ended Done and checked by a read of the saved note; with the save rejected on purpose, the screen looked the same as the good save, and the run stopped and reported Check the record without retrying.